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;*/ } }