private IEnumerator SetRandomDestination()
{
State = KeeperState.ConstructingPath;
Vector3?randomDestination = null;
int grace = 0;
while (!randomDestination.HasValue)
{
var area = Mathf.Clamp(RandomDestinationArea - grace, Transform.localScale.magnitude, Mathf.Infinity);
var randomPoint = Random.insideUnitSphere * area + Transform.position;
NavMeshHit hit;
NavMesh.SamplePosition(randomPoint, out hit, area, 1);
var path = new NavMeshPath();
navAgent.CalculatePath(hit.position, path);
if (path.status == NavMeshPathStatus.PathComplete)
{
randomDestination = hit.position;
}
grace += (int)Transform.localScale.magnitude;
yield return(null);
}
currentDestination = randomDestination.Value;
navAgent.SetDestination(randomDestination.Value);
_state = State = KeeperState.Stalking;
}
public bool WaitForKeeperState(KeeperState keeperState, TimeSpan timeOut)
{
if (_zookeeperEventThread != null && Thread.CurrentThread == _zookeeperEventThread)
{
throw new Exception("Must not be done in the zookeeper event thread.");
}
LOG.Info("Waiting for keeper state " + keeperState);
try
{
bool stillWaiting = true;
while (_currentState != keeperState)
{
if (!stillWaiting)
{
return(false);
}
stillWaiting = _stateChangedCondition.WaitOne(timeOut);
// Throw an exception in the case authorization fails
}
LOG.Debug("State is " + _currentState);
return(true);
}
catch (ThreadInterruptedException e)
{
throw new ZKInterruptedException(e);
}
finally
{
}
}
public bool WaitForKeeperState(KeeperState keeperState, TimeSpan timeout)
{
if (_zookeeperEventThread != null && Thread.CurrentThread == _zookeeperEventThread)
{
throw new Exception("Must not be done in the zookeeper event thread.");
}
Logger.Debug("Waiting for keeper state " + keeperState);
this.AcquireEventLock();
try
{
bool stillWaiting = true;
while (CurrentState != keeperState)
{
if (!stillWaiting)
{
return(false);
}
stillWaiting = EventLock.StateChangedCondition.Await(timeout);
}
Logger.Debug("State is " + CurrentState);
return(true);
}
catch (ThreadInterruptedException e)
{
throw new ZkInterruptedException(e);
}
finally
{
EventLock.Unlock();
}
}
//MethodImpl(MethodImplOptions.Synchronized)]
private void SetCurrentState(KeeperState state)
{
lock (this)
{
_currentState = state;
}
}
/// <summary>
///
/// </summary>
/// <param name="state"></param>
/// <param name="type"></param>
/// <param name="clientPath"></param>
/// <returns></returns>
public IEnumerable <IWatcher> Materialize(KeeperState state, EventType type, string clientPath)
{
HashSet <IWatcher> result = new HashSet <IWatcher>();
switch (type)
{
case EventType.None:
result.Add(defaultWatcher);
foreach (var ws in dataWatches.Values)
{
result.UnionWith(ws);
}
foreach (var ws in existWatches.Values)
{
result.UnionWith(ws);
}
foreach (var ws in childWatches.Values)
{
result.UnionWith(ws);
}
// clear the watches if auto watch reset is not enabled
if (ClientConnection.DisableAutoWatchReset &&
state != KeeperState.SyncConnected)
{
dataWatches.Clear();
existWatches.Clear();
childWatches.Clear();
}
return(result);
case EventType.NodeDataChanged:
case EventType.NodeCreated:
AddTo(dataWatches.GetAndRemove(clientPath), result);
AddTo(existWatches.GetAndRemove(clientPath), result);
break;
case EventType.NodeChildrenChanged:
AddTo(childWatches.GetAndRemove(clientPath), result);
break;
case EventType.NodeDeleted:
AddTo(dataWatches.GetAndRemove(clientPath), result);
//XXX This shouldn't be needed, but just in case
HashSet <IWatcher> list = existWatches.GetAndRemove(clientPath);
if (list != null)
{
AddTo(existWatches.GetAndRemove(clientPath), result);
log.Warn("We are triggering an exists watch for delete! Shouldn't happen!");
}
AddTo(childWatches.GetAndRemove(clientPath), result);
break;
default:
var msg = new StringBuilder("Unhandled watch event type ").Append(type).Append(" with state ").Append(state).Append(" on path ").Append(clientPath).ToString();
log.Error(msg);
throw new InvalidOperationException(msg);
}
return(result);
}
public void HandleStateChanged(KeeperState state)
{
if (state == KeeperState.Expired)
{
expiredEvents++;
}
}
/// <summary>
/// Waits untill ZooKeeper connection is established
/// </summary>
/// <param name="connectionTimeout">
/// The connection timeout.
/// </param>
/// <returns>
/// Status
/// </returns>
public bool WaitUntilConnected(int connectionTimeout)
{
Guard.Greater(connectionTimeout, 0, "connectionTimeout");
EnsuresNotDisposed();
if (eventWorker != null && eventWorker == Thread.CurrentThread)
{
throw new InvalidOperationException("Must not be done in the ZooKeeper event thread.");
}
Logger.Debug("Waiting for keeper state: " + KeeperState.SyncConnected + " time out: " +
connectionTimeout); //.SyncConnected);
var stillWaiting = true;
lock (stateChangedLock)
{
currentState = connection.ClientState;
if (currentState == KeeperState.SyncConnected)
{
return(true);
}
Logger.DebugFormat("Current state:{0} in the lib:{1}", currentState,
connection.GetInternalZKClient().State);
var stopWatch = Stopwatch.StartNew();
while (currentState != KeeperState.SyncConnected)
{
if (!stillWaiting)
{
return(false);
}
stillWaiting = Monitor.Wait(stateChangedLock, connectionTimeout);
Logger.DebugFormat("Current state:{0} in the lib:{1}", currentState,
connection.GetInternalZKClient().State);
currentState = connection.ClientState;
if (currentState == KeeperState.SyncConnected)
{
return(true);
}
if (stopWatch.Elapsed.TotalMilliseconds > connectionTimeout)
{
break;
}
Thread.Sleep(1000);
}
Logger.DebugFormat("Current state:{0} in the lib:{1}", currentState,
connection.GetInternalZKClient().State);
currentState = connection.ClientState;
if (currentState == KeeperState.SyncConnected)
{
return(true);
}
return(false);
}
}
public IEnumerable<IWatcher> Materialize(KeeperState state, EventType type, string clientPath)
{
HashSet<IWatcher> result = new HashSet<IWatcher>();
switch (type) {
case EventType.None:
result.Add(defaultWatcher);
foreach (var ws in dataWatches.Values) {
result.UnionWith(ws);
}
foreach (var ws in existWatches.Values) {
result.UnionWith(ws);
}
foreach(var ws in childWatches.Values) {
result.UnionWith(ws);
}
// clear the watches if auto watch reset is not enabled
if (ClientConnection.DisableAutoWatchReset &&
state != KeeperState.SyncConnected)
{
dataWatches.Clear();
existWatches.Clear();
childWatches.Clear();
}
return result;
case EventType.NodeDataChanged:
case EventType.NodeCreated:
AddTo(dataWatches.GetAndRemove(clientPath), result);
AddTo(existWatches.GetAndRemove(clientPath), result);
break;
case EventType.NodeChildrenChanged:
AddTo(childWatches.GetAndRemove(clientPath), result);
break;
case EventType.NodeDeleted:
AddTo(dataWatches.GetAndRemove(clientPath), result);
// XXX This shouldn't be needed, but just in case
HashSet<IWatcher> list = existWatches.GetAndRemove(clientPath);
if (list != null) {
AddTo(existWatches.GetAndRemove(clientPath), result);
#if !NET_CORE
LOG.Warn("We are triggering an exists watch for delete! Shouldn't happen!");
#endif
}
AddTo(childWatches.GetAndRemove(clientPath), result);
break;
default:
var msg = new StringBuilder("Unhandled watch event type ").Append(type).Append(" with state ").Append(state).Append(" on path ").Append(clientPath).ToString();
#if !NET_CORE
LOG.Error(msg);
#endif
throw new InvalidOperationException(msg);
}
return result;
}
private void FireStateChangedEvent(KeeperState state)
{
foreach (var listener in _stateListeners)
{
Action <ZooKeeperEvent> handler = e => listener.OnStateChanged(state);
var description = string.Format("KeeperState changed to {0}, send to {1}", state, listener);
var @event = new ZooKeeperEvent(description, handler);
_eventExecutor.Add(@event);
}
}
private void FireStateChangedEvent(KeeperState state)
{
foreach (var s in this._stateListener)
{
var stateListener = s;
_eventThread.Send(new ZkEvent("State changed to " + state + " sent to " + stateListener)
{
RunAction = () => stateListener.HandleStateChanged(state)
});
}
}
public override void OnStateChanged(KeeperState state)
{
System.Console.WriteLine("Zookeeper connection state changed to {0}", state);
if (state == KeeperState.Disconnected)
{
this.DisconnectedHandle();
}
else if (state == KeeperState.SyncConnected)
{
this.ConnectedHandle();
}
}
private void FireStateChangedEvent(KeeperState state)
{
foreach (IZKStateListener stateListener in _stateListener)
{
_eventTask.Send(new ZKTask.ZKEvent("State changed to " + Convert.ToString(state) + " sent to " + nameof(stateListener))
{
Run = () =>
{
stateListener.HandleStateChanged(state);
}
});
}
}
private bool CheckState(KeeperState state, bool wasConnected)
{
bool isConnected = wasConnected;
bool checkNewConnectionString = true;
switch (state)
{
default:
case KeeperState.Disconnected:
{
isConnected = false;
break;
}
case KeeperState.SyncConnected:
{
isConnected = true;
break;
}
// case KeeperState.AuthFailed:
// {
// isConnected = false;
// log.error("Authentication failed");
// break;
// }
case KeeperState.Expired:
{
isConnected = false;
checkNewConnectionString = false;
HandleExpiredSession();
break;
}
// case KeeperState.SaslAuthenticated:
// {
// // NOP
// break;
// }
}
if (checkNewConnectionString && zooKeeper.HasNewConnectionString())
{
HandleNewConnectionString();
}
return(isConnected);
}
public void QueueEvent(WatchedEvent @event)
{
if (@event.Type == EventType.None && sessionState == @event.State)
{
return;
}
sessionState = @event.State;
// materialize the watchers based on the event
var pair = new ClientConnection.WatcherSetEventPair(conn.watcher.Materialize(@event.State, @event.Type, @event.Path), @event);
// queue the pair (watch set & event) for later processing
AppendToQueue(pair);
}
private void FireStateChangedEvent(KeeperState state)
{
foreach (var stateListener in _stateListeners)
{
_eventTask.Send(new ZKTask.ZKEvent($"State changed to {Convert.ToString(state)} sent to {(stateListener)}")
{
Run = async() =>
{
if (stateListener.StateChangedHandler != null)
{
await stateListener.StateChangedHandler(state);
}
}
});
}
}
private void FireStateChangedEvent(KeeperState state)
{
foreach (var stateListener in _stateListeners)
{
_eventTask.Send(new ZKTask.ZKEvent()
{
Run = async() =>
{
if (stateListener.StateChangedHandler != null)
{
await stateListener.StateChangedHandler(state);
}
}
});
}
}
public void ProcessResult(int rc, String path, Object ctx, KeeperState stat)
{
bool exists;
switch ((KeeperException.Code)rc)
{
case KeeperException.Code.OK:
exists = true;
break;
case KeeperException.Code.NONODE:
exists = false;
break;
case KeeperException.Code.SESSIONEXPIRED:
case KeeperException.Code.NOAUTH:
dead = true;
listener.Closing(rc);
return;
default:
// Retry errors
zk.Exists(znode, true);
return;
}
byte[] b = null;
if (exists)
{
try
{
b = zk.GetData(znode, false, null);
}
catch (KeeperException e)
{
// We don't need to worry about recovering now. The watch
// callbacks will kick off any exception handling
Console.WriteLine(e.ToString());
}
}
if ((b == null && b != prevData) ||
(b != null && !Array.Equals(prevData, b)))
{
listener.Exists(b);
prevData = b;
}
}
public bool WaitForKeeperState(KeeperState keeperState, TimeSpan timeOut)
{
LOG.Info($"Waiting for keeper state {Convert.ToString(keeperState)}");
bool stillWaiting = true;
while (_currentState != keeperState)
{
if (!stillWaiting)
{
return(false);
}
stillWaiting = _stateChangedCondition.WaitOne(timeOut);
// Throw an exception in the case authorization fails
}
LOG.Debug($"State is {Convert.ToString(_currentState)}");
return(true);
}
private bool WaitUntilKeeperState(KeeperState keeperState)
{
lock (WAIT_KEEPER_STATE_LOCK)
{
var elapsed = 0;
while (_connectionState.Value != keeperState)
{
Thread.Sleep(1000);
elapsed += 1000;
if (elapsed >= _connectTimeoutMs)
{
return(false);
}
}
return(true);
}
}
private void ProcessZkConnectEvent(KeeperState state)
{
if (state == KeeperState.SyncConnected)
{
_isDisconnected = false;
}
if (state == KeeperState.Disconnected)
{
_isDisconnected = true;
}
if (state == KeeperState.Expired)
{
_isDisconnected = true;
_zkElectionClient.Reconnect();
}
}
public void QueueEvent(WatchedEvent @event)
{
if (@event.Type == EventType.None && sessionState == @event.State)
{
return;
}
if (waitingEvents.IsAddingCompleted)
{
throw new InvalidOperationException("consumer has been disposed");
}
sessionState = @event.State;
// materialize the watchers based on the event
var pair = new ClientConnection.WatcherSetEventPair(conn.watcher.Materialize(@event.State, @event.Type, @event.Path), @event);
// queue the pair (watch set & event) for later processing
waitingEvents.Add(pair);
}
public void Process(WatchedEvent wEvent)
{
string path = wEvent.Path.ToString();
log("zooWatcher.Process Called");
log("path: " + path);
if (wEvent.GetType().Equals(EventType.None))
{
// We are are being told that the state of the connection has changed
switch (wEvent.State)
{
case KeeperState.SyncConnected:
// In this particular example we don't need to do anything
// here - watches are automatically re-registered with
// server and any watches triggered while the client was
// disconnected will be delivered (in order of course)
break;
case KeeperState.Expired:
// It's all over
// dead = true;
// listener.closing(KeeperException.Code.SessionExpired);
break;
}
}
else
{
if (!String.IsNullOrEmpty(path))
{
OnChange(new CollectionChangeEventArgs(path));
}
}
KeeperState state = wEvent.State;
EventType eType = wEvent.Type;
string ewPath = wEvent.Wrapper.Path;
int ewState = wEvent.Wrapper.State;
int ewType = wEvent.Wrapper.Type;
}
private IEnumerator SetRandomDestination()
{
State = KeeperState.ConstructingPath;
Vector3? randomDestination = null;
int grace = 0;
while (!randomDestination.HasValue)
{
var area = Mathf.Clamp(RandomDestinationArea - grace, Transform.localScale.magnitude, Mathf.Infinity);
var randomPoint = Random.insideUnitSphere * area + Transform.position;
NavMeshHit hit;
NavMesh.SamplePosition(randomPoint, out hit, area, 1);
var path = new NavMeshPath();
navAgent.CalculatePath(hit.position, path);
if (path.status == NavMeshPathStatus.PathComplete) randomDestination = hit.position;
grace += (int)Transform.localScale.magnitude;
yield return null;
}
currentDestination = randomDestination.Value;
navAgent.SetDestination(randomDestination.Value);
_state = State = KeeperState.Stalking;
}
public HashSet <IWatcher> Materialize(KeeperState state, EventType type, string clientPath)
{
HashSet <IWatcher> result = new HashSet <IWatcher>();
switch (type)
{
case EventType.None:
result.Add(defaultWatcher);
foreach (var ws in dataWatches.Values)
{
result.UnionWith(ws);
}
foreach (var ws in existWatches.Values)
{
result.UnionWith(ws);
}
foreach (var ws in childWatches.Values)
{
result.UnionWith(ws);
}
// clear the watches if auto watch reset is not enabled
if (ClientConnection.disableAutoWatchReset &&
state != KeeperState.SyncConnected)
{
lock (dataWatches) {
dataWatches.Clear();
}
lock (existWatches) {
existWatches.Clear();
}
lock (childWatches) {
childWatches.Clear();
}
}
return(result);
case EventType.NodeDataChanged:
case EventType.NodeCreated:
lock (dataWatches) {
AddTo(dataWatches.GetAndRemove(clientPath), result);
}
lock (existWatches) {
AddTo(existWatches.GetAndRemove(clientPath), result);
}
break;
case EventType.NodeChildrenChanged:
lock (childWatches) {
AddTo(childWatches.GetAndRemove(clientPath), result);
}
break;
case EventType.NodeDeleted:
lock (dataWatches) {
AddTo(dataWatches.GetAndRemove(clientPath), result);
}
// XXX This shouldn't be needed, but just in case
lock (existWatches) {
HashSet <IWatcher> list = existWatches.GetAndRemove(clientPath);
if (list != null)
{
AddTo(existWatches.GetAndRemove(clientPath), result);
LOG.Warn("We are triggering an exists watch for delete! Shouldn't happen!");
}
}
lock (childWatches) {
AddTo(childWatches.GetAndRemove(clientPath), result);
}
break;
default:
var msg = string.Format("Unhandled watch event type {0} with state {1} on path {2}", type, state, clientPath);
LOG.Error(msg);
throw new InvalidOperationException(msg);
}
return(result);
}
private void Update()
{
State = Vector3.Distance(Transform.position, drone.Transform.position) < PursuitRange ? KeeperState.Pursuiting : KeeperState.Stalking;
distortion.LookAt(drone.transform);
}
public WatchedEvent(WatcherEvent eventMessage)
{
state = (KeeperState)Enum.ToObject(typeof(KeeperState), eventMessage.State);
type = (EventType)Enum.ToObject(typeof(EventType), eventMessage.Type);
path = eventMessage.Path;
}
private void SetCurrentState(KeeperState state)
{
_currentState = state;
}
public void HandleStateChanged(KeeperState state)
{
}
public WatchedEvent(KeeperState state, EventType type, string path)
{
this.state = state;
this.type = type;
this.path = path;
}
/// <summary>
/// 状态改变的回调函数
/// </summary>
/// <param name="state"></param>
public void HandleStateChanged(KeeperState state)
{
stateChangedEvent(state);
}
/// <summary>
/// Initializes a new instance of the <see cref="ZooKeeperStateChangedEventArgs"/> class.
/// </summary>
/// <param name="state">
/// The current ZooKeeper state.
/// </param>
public ZooKeeperStateChangedEventArgs(KeeperState state)
: base("State changed to " + state)
{
this.State = state;
}
public void HandleStateChanged(KeeperState state)
{
// do nothing, since zkclient will do reconnect for us.
}
// fetches phrases from server
// we pull double the limit
private IEnumerator FetchCoroutine()
{
keeperState = KeeperState.Fetching;
isFetchedReady = false;
// prepare the pre-queue list with needed filters
IDictionary<string, object> fetchInfo = new Dictionary<string, object>
{
{ "requestLimit", PHRASE_REQUEST_LIMIT }
};
var fetchTask = ParseCloud.CallFunctionAsync<IList<ParsePhrase>> ("FetchPhrases", fetchInfo);
while (!fetchTask.IsCompleted) yield return null;
if (fetchTask.IsFaulted || fetchTask.IsCanceled)
{
using (IEnumerator<System.Exception> enumerator = fetchTask.Exception.InnerExceptions.GetEnumerator())
{
if (enumerator.MoveNext ())
{
ParseException exception = (ParseException)enumerator.Current;
errorInfo = new ErrorInfo(ErrorType.ParseException, exception.Code);
}
else
{
errorInfo = new ErrorInfo(ErrorType.ParseInternal);
}
}
keeperState = KeeperState.Error;
yield break;
}
else
{
IList<ParsePhrase> result = fetchTask.Result;
if(result != null)
{
foreach(ParsePhrase phrase in result)
{
phraseCollection.Add (new Phrase() { CorrectMessage = phrase.CorrectMessage });
}
}
else
{
errorInfo = new ErrorInfo(ErrorType.ParseInternal);
keeperState = KeeperState.Error;
yield break;
}
}
keeperState = KeeperState.Neutral;
isFetchedReady = true;
fetchCoroutine = null;
}
private void Update()
{
State = Vector3.Distance(Transform.position, drone.Transform.position) < PursuitRange ? KeeperState.Pursuiting : KeeperState.Stalking;
distortion.LookAt(drone.transform);
}
public WatchedEvent(KeeperState state, EventType type, string path)
{
this.state = state;
this.type = type;
this.path = path;
}
public WatchedEvent(WatcherEvent eventMessage)
{
state = (KeeperState)Enum.ToObject(typeof(KeeperState), eventMessage.State);
type = (EventType)Enum.ToObject(typeof (EventType), eventMessage.Type);
path = eventMessage.Path;
}
/// <summary>
/// new
/// </summary>
/// <param name="type"></param>
/// <param name="state"></param>
/// <param name="path"></param>
public WatchedEvent(EventType type, KeeperState state, string path)
{
this.Type = type;
this.State = state;
this.Path = path;
}
private void Start()
{
State = KeeperState.Stalking;
}
public void QueueEvent(WatchedEvent @event)
{
if (@event.Type == EventType.None && sessionState == @event.State) return;
if (waitingEvents.IsAddingCompleted)
throw new InvalidOperationException("consumer has been disposed");
sessionState = @event.State;
// materialize the watchers based on the event
var pair = new ClientConnection.WatcherSetEventPair(conn.watcher.Materialize(@event.State, @event.Type,@event.Path), @event);
// queue the pair (watch set & event) for later processing
waitingEvents.Add(pair);
}
public HashSet<IWatcher> Materialize(KeeperState state, EventType type, string clientPath)
{
HashSet<IWatcher> result = new HashSet<IWatcher>();
switch (type) {
case EventType.None:
result.Add(defaultWatcher);
foreach (var ws in dataWatches.Values) {
result.UnionWith(ws);
}
foreach (var ws in existWatches.Values) {
result.UnionWith(ws);
}
foreach(var ws in childWatches.Values) {
result.UnionWith(ws);
}
// clear the watches if auto watch reset is not enabled
if (ClientConnection.disableAutoWatchReset &&
state != KeeperState.SyncConnected)
{
lock(dataWatches) {
dataWatches.Clear();
}
lock(existWatches) {
existWatches.Clear();
}
lock(childWatches) {
childWatches.Clear();
}
}
return result;
case EventType.NodeDataChanged:
case EventType.NodeCreated:
lock (dataWatches) {
AddTo(dataWatches.GetAndRemove(clientPath), result);
}
lock (existWatches) {
AddTo(existWatches.GetAndRemove(clientPath), result);
}
break;
case EventType.NodeChildrenChanged:
lock (childWatches) {
AddTo(childWatches.GetAndRemove(clientPath), result);
}
break;
case EventType.NodeDeleted:
lock (dataWatches) {
AddTo(dataWatches.GetAndRemove(clientPath), result);
}
// XXX This shouldn't be needed, but just in case
lock (existWatches) {
HashSet<IWatcher> list = existWatches.GetAndRemove(clientPath);
if (list != null) {
AddTo(existWatches.GetAndRemove(clientPath), result);
LOG.Warn("We are triggering an exists watch for delete! Shouldn't happen!");
}
}
lock (childWatches) {
AddTo(childWatches.GetAndRemove(clientPath), result);
}
break;
default:
var msg = string.Format("Unhandled watch event type {0} with state {1} on path {2}", type, state, clientPath);
LOG.Error(msg);
throw new InvalidOperationException(msg);
}
return result;
}
/// <summary>
/// new
/// </summary>
/// <param name="type"></param>
/// <param name="state"></param>
/// <param name="path"></param>
public WatchedEvent(EventType type, KeeperState state, string path)
{
this.Type = type;
this.State = state;
this.Path = path;
}
public void QueueEvent(WatchedEvent @event)
{
if (@event.Type == EventType.None && sessionState == @event.State) return;
sessionState = @event.State;
// materialize the watchers based on the event
var pair = new ClientConnection.WatcherSetEventPair(conn.watcher.Materialize(@event.State, @event.Type,@event.Path), @event);
// queue the pair (watch set & event) for later processing
AppendToQueue(pair);
}
private void Start()
{
State = KeeperState.Stalking;
}
private bool CheckState(KeeperState state, bool wasConnected)
{
bool isConnected = wasConnected;
bool checkNewConnectionString = true;
switch ( state )
{
default:
case KeeperState.Disconnected:
{
isConnected = false;
break;
}
case KeeperState.SyncConnected:
{
isConnected = true;
break;
}
// case KeeperState.AuthFailed:
// {
// isConnected = false;
// log.error("Authentication failed");
// break;
// }
case KeeperState.Expired:
{
isConnected = false;
checkNewConnectionString = false;
HandleExpiredSession();
break;
}
// case KeeperState.SaslAuthenticated:
// {
// // NOP
// break;
// }
}
if ( checkNewConnectionString && zooKeeper.HasNewConnectionString() )
{
HandleNewConnectionString();
}
return isConnected;
}