internal CuratorEventImpl(CuratorFrameworkImpl client,
CuratorEventType type,
int resultCode,
String path,
String name,
Object context,
Stat stat,
byte[] data,
List<String> children,
WatchedEvent watchedEvent,
List<ACL> aclList)
{
this.type = type;
this.resultCode = resultCode;
this.path = client.unfixForNamespace(path);
this.name = name;
this.context = context;
this.stat = stat;
this.data = data;
this.children = children;
this.watchedEvent = (watchedEvent != null)
? new NamespaceWatchedEvent(client, watchedEvent)
: watchedEvent;
this.aclList = (aclList != null)
? new ReadOnlyCollectionBuilder<ACL>(aclList).ToReadOnlyCollection()
: null;
}
public void Process(WatchedEvent watchedEvent)
{
if (watchedEvent.State != KeeperState.SyncConnected || watchedEvent.Path != Path)
{
return;
}
ProcessImpl(watchedEvent);
}
public override void process(WatchedEvent @event)
{ // Watcher interface
if (@event.State == Watcher.Event.KeeperState.SyncConnected)
{
connectedSignal.countDown();
}
}
public override async Task process(WatchedEvent watchedEvent)
{
if (watchedEvent.getState() != Event.KeeperState.SyncConnected || watchedEvent.getPath() != Path)
{
return;
}
await ProcessImpl(watchedEvent);
}
public override Task process(WatchedEvent @event)
{
if (logger.IsEnabled(LogLevel.Debug))
{
logger.Debug(@event.ToString());
}
return(Task.CompletedTask);
}
public override async Task process(WatchedEvent watchedEvent)
{
var status = watchedEvent.getState();
await this._status_changed.Invoke(status);
await Task.FromResult(1);
}
public override Task process(WatchedEvent @event)
{
if (@event.get_Type() != Event.EventType.None)
{
events.Add(@event);
}
return(CompletedTask);
}
public void Process(WatchedEvent @event)
{
LOG.Debug(@event);
if (@event.Type == EventType.NodeCreated || @event.Type == EventType.NodeDataChanged)
{
Interlocked.Increment(ref processCount);
}
}
public override Task process(WatchedEvent @event)
{
var state = @event.getState();
var type = @event.get_Type();
return(Task.CompletedTask);
// nada
}
public override Task process(WatchedEvent @event)
{
if (@event.getState() == Watcher.Event.KeeperState.SyncConnected)
{
Barrier.SignalAndWait(1);
}
return(Task.FromResult <object>(null));
}
public override async Task process(WatchedEvent @event)
{
var type = @event.get_Type();
if (type != Event.EventType.None)
{
await _zookeeperService.RefreshAsync();
}
}
public void Process(WatchedEvent @event)
{
string result = System.Text.Encoding.Default.GetString(ZkConnector.Instance.GetData("/clients/" + client.client_uuid, false,
ZkConnector.Instance.Exists("/clients/" + client.client_uuid, false)));
//Console.WriteLine(result);
ZkConnector.Instance.Delete("/clients/" + client.client_uuid, -1);
}
/// <summary>
/// zookeeper节点的监视器
/// </summary>
public virtual void Process(WatchedEvent @event)
{
if (this._autoevent != null)
{
//将事件状态设置为终止状态，允许一个或多个等待线程继续；如果该操作成功，则返回true；否则，返回false
this._autoevent.Set();
}
}
public void Process(WatchedEvent evt)
{
var watcherCall = new WatcherCall();
watcherCall.WatcherId = this.Id;
watcherCall.Kind = this.Kind;
watcherCall.WatcherEvt = evt;
this.session.SendWatcherNotification(watcherCall);
}
public void testConvertingToEventWrapper()
{
WatchedEvent we = new WatchedEvent(Watcher.Event.EventType.NodeCreated, Watcher.Event.KeeperState.Expired, "blah");
WatcherEvent wew = we.getWrapper();
Assert.assertEquals((int)Watcher.Event.EventType.NodeCreated, wew.get_Type());
Assert.assertEquals((int)Watcher.Event.KeeperState.Expired, wew.getState());
Assert.assertEquals("blah", wew.getPath());
}
public override async Task process(WatchedEvent @event)
{
var state = @event.getState();
var path = @event.getPath();
var type = @event.get_Type();
OnChange?.Invoke(path, state, type);
await Task.CompletedTask;
}
public void Process(WatchedEvent @event)
{
//Console.WriteLine("["+Address+"] Event : " + @event.Type + " on " + @event.Path);
if (@event.State == KeeperState.SyncConnected && @event.Type == EventType.None)
{
isDisposed = false;
this.connected.Set();
}
}
public override Task process(WatchedEvent @event)
{
if (@event.getState() == Event.KeeperState.Expired)
{
Console.WriteLine("Session expired event received");
Barrier.SignalAndWait(0);
}
return Task.FromResult<object>(null);
}
public override Task process(WatchedEvent @event)
{
if (@event.getState() == Event.KeeperState.SyncConnected)
{
SyncConnectedEvent?.Invoke();
}
return(Task.CompletedTask);
}
public override Task process(WatchedEvent @event)
{
if (@event.getState() == Event.KeeperState.Expired)
{
Console.WriteLine("Session expired event received");
Barrier.SignalAndWait(0);
}
return(Task.FromResult <object>(null));
}
public void Process(WatchedEvent @event)
{
Console.WriteLine("Received watched event: {0}", @event);
if (@event.State == KeeperState.SyncConnected)
{
manualWaitHandler.Set();
}
}
public void Process(WatchedEvent @event)
{
if (@event.State == KeeperState.SyncConnected)
{
log.Info(String.Format("An event of state {0} arrived", @event.State));
ResetEvent.Set();
}
BasicEventListner.GetData("/", true, new Stat());
}
/// <summary>
/// Processes the specified watched event.
/// </summary>
/// <param name="watchedEvent">The watched event.</param>
public void Process(WatchedEvent watchedEvent)
{
try
{
byte[] _nodeData = null;
switch (watchedEvent.Type)
{
case EventType.None:
break;
case EventType.NodeCreated:
ZooKeeper.GetChildren(watchedEvent.Path, this, null);
_nodeData = ZooKeeper.GetData(watchedEvent.Path, this, null);
if (OnNodeChangeEvent != null)
{
OnNodeChangeEvent(watchedEvent, _nodeData);
}
break;
case EventType.NodeDeleted:
ZooKeeper.Exists(watchedEvent.Path, this);
if (OnNodeChangeEvent != null)
{
OnNodeChangeEvent(watchedEvent, null);
}
break;
case EventType.NodeChildrenChanged:
var _chlidrenNode = ZooKeeper.GetChildren(watchedEvent.Path, this, null);
if (OnNodeChildrenChangeEvent != null)
{
OnNodeChildrenChangeEvent(watchedEvent, _chlidrenNode.ToArray());
}
break;
default:
_nodeData = ZooKeeper.GetData(watchedEvent.Path, this, null);
if (OnNodeChangeEvent != null)
{
OnNodeChangeEvent(watchedEvent, _nodeData);
}
break;
}
}
catch (NoNodeException ex)
{
if (OnNodeExceptionEvent != null)
{
OnNodeExceptionEvent(ex, Path);
}
}
}
public override async Task process(WatchedEvent watchedEvent)
{
var event_type = watchedEvent.get_Type();
var zk_status = watchedEvent.getState();
var path = watchedEvent.getPath();
if (watchedEvent.getState() != Event.KeeperState.SyncConnected || watchedEvent.getPath() != Path)
{
$"{watchedEvent.ToJson()}".AddBusinessInfoLog();
return;
}
await ProcessImpl(watchedEvent);
/*
* switch (zk_status)
* {
* case Event.KeeperState.AuthFailed:
* Console.WriteLine(nameof(Event.KeeperState.AuthFailed));
* break;
* case Event.KeeperState.ConnectedReadOnly:
* Console.WriteLine(nameof(Event.KeeperState.ConnectedReadOnly));
* break;
* case Event.KeeperState.Disconnected:
* Console.WriteLine(nameof(Event.KeeperState.Disconnected));
* this.ReConnect();
* break;
* case Event.KeeperState.Expired:
* Console.WriteLine(nameof(Event.KeeperState.Expired));
* this.ReConnect();
* break;
* case Event.KeeperState.SyncConnected:
* break;
* default:
* break;
* }
*
* switch (event_type)
* {
* case Event.EventType.NodeChildrenChanged:
* //注册节点发生改变
* await this.NodeChildrenChanged(path);
* break;
* case Event.EventType.NodeCreated:
* break;
* case Event.EventType.NodeDataChanged:
* break;
* case Event.EventType.NodeDeleted:
* break;
* case Event.EventType.None:
* break;
* default:
* break;
* }
*/
}
public override Task process(WatchedEvent @event)
{
// only care about connected state events; the ConnectionLostToken takes care of the other states for us
if (@event.getState() == Event.KeeperState.SyncConnected)
{
this._watchedEventHandler?.Invoke(@event, this.TaskCompletionSource);
}
return(Task.CompletedTask);
}
async Task WatcherCallback(WatchedEvent @event)
{
#if DEBUG
this.logger.LogInformation("watch callback");
#endif
if (@event.get_Type() == org.apache.zookeeper.Watcher.Event.EventType.NodeDeleted)
{
await this.__get_lock_or_watch_previous_node__();
}
}
public override Task process(WatchedEvent @event)
{
// only care about connected state events; the ConnectionLostToken takes care of the other states for us
if (@event.getState() == Event.KeeperState.SyncConnected)
{
this._waitCompletionSource.TrySetResult(true);
}
return(Task.CompletedTask);
}
/// <summary>
/// Process a watcher notification.
/// </summary>
/// <param name="watchedEvent">Information about the watcher notification</param>
/// <remarks>
/// Releases the watcher semaphore when a notification is received. This will allow
/// the test to set more watchers.
/// </remarks>
public void Process(WatchedEvent watchedEvent)
{
if (watchedEvent == null)
{
throw new ArgumentNullException(nameof(watchedEvent));
}
this.lifetime.Stop();
this.instrumentation?.WatcherNotified(Enum.GetName(typeof(WatchedEvent.WatchedEventType), watchedEvent.EventType), this.lifetime.Elapsed);
}
public override Task process(WatchedEvent @event)
{
if (@event.get_Type() == EventType.NodeDeleted)
{
Logger.GetLogger(service.BaseUrl).Error("leader offline, run for leader");
service.RunForLeaderNode();
}
return(Task.CompletedTask);
}
public void Process(WatchedEvent @event)
{
Console.WriteLine("Received watched event: {0}, ThreadId:{1}", @event, Thread.CurrentThread.ManagedThreadId);
if (@event.State == KeeperState.SyncConnected)
{
Console.WriteLine("to set signal");
manualWaitHandler.Set();
}
}
public void Process(WatchedEvent @event)
{
if (@event.Type == EventType.NodeDataChanged)
{
Log.Info("Process path:{0}", @event.Path);
var ret3 = Handle.GetData(@event.Path, this, null);
DataChangedHandler(@event.Path, ret3);
}
}
/// <summary>
/// Watcher for zookeeper events
/// </summary>
/// <param name="event">zookeeper event</param>
public override async Task process(WatchedEvent @event)
{
if (@event.get_Type() != Event.EventType.None && !string.IsNullOrEmpty(@event.getPath()))
{
await SynchronizedUpdateAsync().ConfigureAwait(false);
}
else if (@event.get_Type() == Event.EventType.None && @event.getState() == Event.KeeperState.Disconnected)
{
await SynchronizedUpdateAsync(cleanZookeeperConnection : true).ConfigureAwait(false);
}
}
public override async Task process(WatchedEvent @event)
{
Console.WriteLine($"Zookeeper链接成功:{@event.getState() == KeeperState.SyncConnected}");
if (@event.get_Type() == EventType.NodeDataChanged)
{
var data = await _cs.ReadConfigDataAsync();
Console.WriteLine("{0}收到修改此节点【{1}】值的通知，其值已被改为【{2}】。", Environment.NewLine, _cs.QueryPath, data);
}
}
public override void process(WatchedEvent @event)
{
if (@event.Type == Watcher.Event.EventType.NodeDataChanged)
{
try
{
displayConfig();
}
catch (InterruptedException)
{
Console.Error.WriteLine("Interrupted. Exiting.");
Thread.CurrentThread.Interrupt();
}
catch (KeeperException e)
{
System.err.printf("KeeperException: %s. Exiting.\n", e);
}
}
}
/// <summary>
/// 当连接成功时调用的
/// </summary>
public override void process(WatchedEvent @event)
{
if (@event.State == Watcher.Event.KeeperState.SyncConnected)
{
LOGGER.info("zk SyncConnected");
connectedSignal.countDown();
}
else if (@event.State.Equals(Watcher.Event.KeeperState.Disconnected))
{
// 这时收到断开连接的消息，这里其实无能为力，因为这时已经和ZK断开连接了，只能等ZK再次开启了
LOGGER.warn("zk Disconnected");
}
else if (@event.State.Equals(Watcher.Event.KeeperState.Expired))
{
if (!debug)
{
// 这时收到这个信息，表示，ZK已经重新连接上了，但是会话丢失了，这时需要重新建立会话。
LOGGER.error("zk Expired");
// just reconnect forever
reconnect();
}
else
{
LOGGER.info("zk Expired");
}
}
else if (@event.State.Equals(Watcher.Event.KeeperState.AuthFailed))
{
LOGGER.error("zk AuthFailed");
}
}
public override Task process(WatchedEvent @event)
{
if (client != null)
{
if (actualWatcher != null)
{
actualWatcher.process(new NamespaceWatchedEvent(client, @event));
}
else if (curatorWatcher != null)
{
try
{
curatorWatcher.process(new NamespaceWatchedEvent(client, @event));
}
catch (Exception e)
{
ThreadUtils.checkInterrupted(e);
client.logError("Watcher exception", e);
}
}
}
}
public virtual void process(WatchedEvent @event)
{
// lets either become the leader or watch the new/updated node
LOG.debug("Watcher fired on path: " + @event.Path + " state: " + @event.State + " type " + @event.Type);
try
{
outerInstance.@lock();
}
catch (Exception e)
{
LOG.warn("Failed to acquire lock: " + e, e);
}
}
public override Task process(WatchedEvent @event)
{
if (LOG_EVENTS)
{
log.Debug("ConnectState watcher: " + @event);
}
if ( @event.get_Type() == Watcher.Event.EventType.None )
{
bool wasConnected = _isConnected.get();
bool newIsConnected = checkState(@event.getState(), wasConnected);
if ( newIsConnected != wasConnected )
{
_isConnected.set(newIsConnected);
Volatile.Write(ref connectionStartMs, CurrentMillis);
}
}
foreach ( Watcher parentWatcher in parentWatchers )
{
TimeTrace timeTrace = new TimeTrace("connection-state-parent-process", tracer.Get());
parentWatcher.process(@event);
timeTrace.commit();
}
return Task.FromResult<object>(null);
}
/// <summary>Processes the specified event.</summary>
/// <param name="watchedEvent">The event.</param>
/// <returns></returns>
public override async Task process(WatchedEvent watchedEvent)
{
if (watchedEvent.getState() == Event.KeeperState.SyncConnected)
{
_connectioned();
}
else
{
_disconnect();
}
#if NET45||NET451
await Task.FromResult(1);
#else
await Task.CompletedTask;
#endif
}
public override async Task process(WatchedEvent watchedEvent)
{
if (watchedEvent.getState() != Event.KeeperState.SyncConnected || watchedEvent.getPath() != Path)
return;
await ProcessImpl(watchedEvent);
}
public void Process(WatchedEvent @event)
{
LOG.Debug(string.Format("Watcher fired on path: {0} state: {1} type {2}", @event.Path, @event.State, @event.Type));
reset.Set();
}
public override Task process(WatchedEvent @event)
{
Console.WriteLine($"[{DateTime.Now.ToString("HH:mm:ss")}] Status: {@event.getState()}, Type: {@event.get_Type()}, Path: {@event.getPath()}");
if (@event.getState() == Event.KeeperState.Expired)
{
if (_startTask?.IsCompleted == true)
_startTask = Start();
}
switch (@event.get_Type())
{
case Event.EventType.NodeChildrenChanged:
break;
}
return Task.FromResult<object>(null);
}
protected abstract Task ProcessImpl(WatchedEvent watchedEvent);
/// <summary>
/// 回调函数
/// </summary>
public override void process(WatchedEvent @event)
{
//
// 结点更新时
//
if (@event.Type == Watcher.Event.EventType.NodeDataChanged)
{
try
{
LOGGER.info("============GOT UPDATE EVENT " + @event.ToString() + ": (" + monitorPath + "," + keyName + "," + disConfigTypeEnum.ModelName + ")======================");
// 调用回调函数, 回调函数里会重新进行监控
callback();
}
catch (Exception e)
{
LOGGER.error("monitor node exception. " + monitorPath, e);
}
}
//
// 结点断开连接，这时不要进行处理
//
if (@event.State == Watcher.Event.KeeperState.Disconnected)
{
if (!debug)
{
LOGGER.warn("============GOT Disconnected EVENT " + @event.ToString() + ": (" + monitorPath + "," + keyName + "," + disConfigTypeEnum.ModelName + ")======================");
}
else
{
LOGGER.debug("============DEBUG MODE: GOT Disconnected EVENT " + @event.ToString() + ": (" + monitorPath + "," + keyName + "," + disConfigTypeEnum.ModelName + ")======================");
}
}
//
// session expired，需要重新关注哦
//
if (@event.State == Watcher.Event.KeeperState.Expired)
{
if (!debug)
{
LOGGER.error("============GOT Expired " + @event.ToString() + ": (" + monitorPath + "," + keyName + "," + disConfigTypeEnum.ModelName + ")======================");
// 重新连接
ZookeeperMgr.Instance.reconnect();
callback();
}
else
{
LOGGER.debug("============DEBUG MODE: GOT Expired " + @event.ToString() + ": (" + monitorPath + "," + "" + keyName + "," + disConfigTypeEnum.ModelName + ")======================");
}
}
}
protected override async Task ProcessImpl(WatchedEvent watchedEvent)
{
var path = Path;
Func<ChildrenMonitorWatcher> getWatcher = () => new ChildrenMonitorWatcher(_zooKeeper, path, _action);
switch (watchedEvent.get_Type())
{
//创建之后开始监视下面的子节点情况。
case Event.EventType.NodeCreated:
await _zooKeeper.getChildrenAsync(path, getWatcher());
break;
//子节点修改则继续监控子节点信息并通知客户端数据变更。
case Event.EventType.NodeChildrenChanged:
try
{
var watcher = getWatcher();
var result = await _zooKeeper.getChildrenAsync(path, watcher);
var childrens = result.Children.ToArray();
_action(_currentData, childrens);
watcher.SetCurrentData(childrens);
}
catch (KeeperException.NoNodeException)
{
_action(_currentData, new string[0]);
}
break;
//删除之后开始监控自身节点，并通知客户端数据被清空。
case Event.EventType.NodeDeleted:
{
var watcher = getWatcher();
await _zooKeeper.existsAsync(path, watcher);
_action(_currentData, new string[0]);
watcher.SetCurrentData(new string[0]);
}
break;
}
}
internal NamespaceWatchedEvent(CuratorFrameworkImpl client, WatchedEvent @event)
: base(@event.get_Type(), @event.getState(), client.unfixForNamespace(@event.getPath()))
{
}
public override Task process(WatchedEvent @event)
{
return Task.FromResult<object>(null);
}
public override Task process(WatchedEvent @event)
{
if ( @event.getState() == Watcher.Event.KeeperState.SyncConnected )
{
Barrier.SignalAndWait(1);
}
return Task.FromResult<object>(null);
}
public void Process(WatchedEvent @event)
{
if (LOG.IsDebugEnabled)
LOG.Debug(string.Format("Watcher fired on path: {0} state: {1} type {2}", @event.Path, @event.State, @event.Type));
try
{
writeLock.Lock();
}
catch (Exception e)
{
LOG.Warn("Failed to acquire lock: " + e, e);
}
}
public void Process(WatchedEvent @event)
{
Console.WriteLine(string.Format("latch:{0} {1}-{2}", name, path, @event.Path));
Debug.WriteLine(string.Format("latch:{0} {1}-{2}", name, path, @event.Path));
eventPath = @event.Path;
latch.CountDown();
}
public override Task process(WatchedEvent @event)
{
if (LOG_EVENTS)
{
log.debug("ConnectState watcher: " + @event);
}
if (@event.get_Type() == Event.EventType.None)
{
bool wasConnected = isConnected_Renamed.get();
var newIsConnected = checkState(@event.getState(), wasConnected);
if (newIsConnected != wasConnected)
{
isConnected_Renamed.set(newIsConnected);
connectionStartMs.Value = TimeHelper.ElapsedMiliseconds;
}
}
foreach (var parentWatcher in parentWatchers)
{
var timeTrace = new TimeTrace("connection-state-parent-process", tracer.get());
parentWatcher.process(@event);
timeTrace.commit();
}
}
public override Task process(WatchedEvent @event)
{
_barrier.SignalAndWait(0);
return Task.FromResult<object>(null);
}
public virtual void Process(WatchedEvent @event)
{
if (@event.State == KeeperState.SyncConnected)
{
connected = true;
lock (sync)
{
Monitor.PulseAll(sync);
}
resetEvent.Set();
}
else
{
connected = false;
lock (sync)
{
Monitor.PulseAll(sync);
}
}
}
protected override async Task ProcessImpl(WatchedEvent watchedEvent)
{
var path = Path;
var watcher = new ChildrenMonitorWatcher(_zooKeeper, path, _action);
switch (watchedEvent.get_Type())
{
case Event.EventType.NodeCreated:
case Event.EventType.NodeChildrenChanged:
if (await _zooKeeper.existsAsync(path, watcher) != null)
{
var result = await _zooKeeper.getChildrenAsync(path, watcher);
var childrens = result.Children;
_action(childrens);
}
else
{
_action(null);
}
break;
case Event.EventType.NodeDeleted:
await _zooKeeper.existsAsync(path, watcher);
_action(null);
break;
}
}
public override void process(WatchedEvent @event)
{
latch.countDown();
}
protected override async Task ProcessImpl(WatchedEvent watchedEvent)
{
var path = Path;
switch (watchedEvent.get_Type())
{
case Event.EventType.NodeDataChanged:
var data = await _zooKeeper.getDataAsync(path, new NodeMonitorWatcher(_zooKeeper, path, _action));
_action(data.Data);
break;
case Event.EventType.NodeDeleted:
_action(null);
break;
}
}
public override Task process(WatchedEvent @event)
{
}
public override Task process(WatchedEvent watchedEvent)
{
string unfixForNs = _curatorFrameworkImpl.unfixForNamespace(watchedEvent.getPath());
ICuratorEvent @event = new CuratorEventImpl(_curatorFrameworkImpl,
CuratorEventType.WATCHED,
(int) watchedEvent.getState(),
unfixForNs,
null,
null,
null,
null,
null,
watchedEvent,
null);
processEvent(@event);
return Task.FromResult<object>(null);
}
public override void Process(WatchedEvent @event)
{
base.Process(@event);
if (@event.Type != EventType.None)
{
try
{
events.TryAdd(@event, TimeSpan.FromMilliseconds(10000));
}
catch (ThreadInterruptedException)
{
LOG.Warn("ignoring interrupt during @event.put");
}
}
}
protected override async Task ProcessImpl(WatchedEvent watchedEvent)
{
var path = Path;
switch (watchedEvent.get_Type())
{
case Event.EventType.NodeDataChanged:
var watcher = new NodeMonitorWatcher(_zooKeeper, path, _action);
var data = await _zooKeeper.getDataAsync(path, watcher);
var newData = data.Data;
_action(_currentData, newData);
watcher.SetCurrentData(newData);
break;
/*case Event.EventType.NodeDeleted:
_action(_currentData, null);
break;*/
}
}
