public override Task process(WatchedEvent @event)
{
LOG.debug("latch:" + path + " " + @event.getPath());
eventPath = @event.getPath();
asyncManualResetEvent.Set();
return(CompletedTask);
}
public async Task testWatcherCorrectness()
{
ZooKeeper zk = null;
MyWatcher watcher = new MyWatcher();
zk = await createClient(watcher);
string[] names = new string[10];
for (int i = 0; i < names.Length; i++)
{
string name = await zk.createAsync("/tc-", "initialvalue".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
names[i] = name;
Stat stat = (await zk.getDataAsync(name, watcher)).Stat;
await zk.setDataAsync(name, "new".UTF8getBytes(), stat.getVersion());
stat = await zk.existsAsync(name, watcher);
await zk.deleteAsync(name, stat.getVersion());
}
for (int i = 0; i < names.Length; i++)
{
string name = names[i];
WatchedEvent @event = watcher.events.poll(10 * 1000);
Assert.assertEquals(name, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDataChanged, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
@event = watcher.events.poll(10 * 1000);
Assert.assertEquals(name, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDeleted, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
}
}
public override Task process(WatchedEvent @event)
{
LOG.debug("latch:" + path + " " + @event.getPath());
eventPath = @event.getPath();
taskCompletionSource.TrySetResult(true);
return(Task.CompletedTask);
}
private void ProcessDataOrChildChanged(WatchedEvent @event)
{
string path = @event.getPath();
if (@event.get_Type() == Event.EventType.NodeChildrenChanged ||
@event.get_Type() == Event.EventType.NodeCreated ||
@event.get_Type() == Event.EventType.NodeDeleted)
{
_childListeners.TryGetValue(path, out ConcurrentHashSet <IZKChildNodeListener> childListeners);
if (childListeners != null && !childListeners.IsEmpty)
{
HandleChildChangedEvents(path, childListeners, @event.get_Type());
}
}
if (@event.get_Type() == Event.EventType.NodeDataChanged ||
@event.get_Type() == Event.EventType.NodeDeleted ||
@event.get_Type() == Event.EventType.NodeCreated)
{
this._nodeListeners.TryGetValue(path, out ConcurrentHashSet <IZKNodeListener> listeners);
if (listeners != null && !listeners.IsEmpty)
{
HandleNodeChanged(@event.getPath(), listeners, @event.get_Type());
}
}
}
public override Task process(WatchedEvent @event)
{
Console.WriteLine("latch:" + path + " " + @event.getPath());
eventPath = @event.getPath();
latch.Set();
return(CompletedTask);
}
public override Task process(WatchedEvent @event)
{
if (string.IsNullOrEmpty(@event.getPath()))
{
return(Task.CompletedTask);
}
var baseUrl = @event.getPath().Split('/')[3];
switch (@event.get_Type())
{
case EventType.NodeDataChanged:
{
var d = node.GetCrawlerConfig(baseUrl);
CrawlerServerManager.Instance.AddServer(baseUrl, d.Ips);
break;
}
case EventType.NodeDeleted:
{
break;
}
}
return(Task.CompletedTask);
}
private void ProcessDataOrChildChange(WatchedEvent @event)
{
string path = @event.getPath();
if (@event.get_Type() == EventType.NodeChildrenChanged ||
@event.get_Type() == EventType.NodeCreated ||
@event.get_Type() == EventType.NodeDeleted)
{
ConcurrentHashSet <IZKChildListener> childListeners;
_childListeners.TryGetValue(path, out childListeners);
if (childListeners != null && !childListeners.IsEmpty)
{
FireChildChangedEvents(path, childListeners, @event.get_Type());
}
}
if (@event.get_Type() == EventType.NodeDataChanged ||
@event.get_Type() == EventType.NodeDeleted ||
@event.get_Type() == EventType.NodeCreated)
{
ConcurrentHashSet <IZKDataListener> listeners;
_dataListeners.TryGetValue(path, out listeners);
if (listeners != null && !listeners.IsEmpty)
{
FireDataChangedEvents(@event.getPath(), listeners, @event.get_Type());
}
}
}
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;
* }
*/
}
// very important that this method does not throw any exceptions as it is called from the zookeeper library
public override async Task process(WatchedEvent @event)
{
if (this.coordinatorToken.IsCancellationRequested || this.ignoreWatches)
return;
if (@event.getPath() != null)
this.logger.Info(this.clientId, $"Coordinator - KEEPER EVENT {@event.getState()} - {@event.get_Type()} - {@event.getPath()}");
else
this.logger.Info(this.clientId, $"Coordinator - KEEPER EVENT {@event.getState()} - {@event.get_Type()}");
switch (@event.getState())
{
case Event.KeeperState.Expired:
this.events.Add(CoordinatorEvent.SessionExpired);
break;
case Event.KeeperState.Disconnected:
if (!this.disconnectedTimer.IsRunning)
this.disconnectedTimer.Start();
break;
case Event.KeeperState.ConnectedReadOnly:
case Event.KeeperState.SyncConnected:
if (this.disconnectedTimer.IsRunning)
this.disconnectedTimer.Reset();
if (@event.getPath() != null)
{
if (@event.get_Type() == Event.EventType.NodeDataChanged)
{
if (@event.getPath().EndsWith("epoch"))
this.events.Add(CoordinatorEvent.NoLongerCoordinator);
}
else if (@event.get_Type() == Event.EventType.NodeChildrenChanged)
{
if (@event.getPath().EndsWith("resources"))
this.events.Add(CoordinatorEvent.RebalancingTriggered);
else if (@event.getPath().EndsWith("clients"))
this.events.Add(CoordinatorEvent.RebalancingTriggered);
}
}
break;
default:
this.logger.Error(this.clientId,
$"Coordinator - Currently this library does not support ZooKeeper state {@event.getState()}");
this.events.Add(CoordinatorEvent.PotentialInconsistentState);
break;
}
await Task.Yield();
}
public override async Task process(WatchedEvent @event)
{
if (@event.get_Type() == Event.EventType.NodeDeleted)
{
var result = await ZkLockerManager.GetClient()
.getChildrenAsync(@event.getPath().Substring(0, @event.getPath().LastIndexOf('/')));
var children = result.Children.OrderBy(item => int.Parse(Regex.Replace(item, @"[a-zA-Z|_]", "0"))).ToList();
if (children.Count > 0)
{
MessageManager <Null> .Publish(
@event.getPath().Substring(0, @event.getPath().LastIndexOf('/') + 1) + children[0], new Null());
}
}
}
public override async Task process(WatchedEvent @event)
{
var path = @event.getPath();
Debug.WriteLine($"ZK event {@event.get_Type()} on {path}");
if (@event.get_Type() == Event.EventType.NodeDeleted)
{
onChange(path, null);
}
if (@event.get_Type() == Event.EventType.NodeDataChanged || @event.get_Type() == Event.EventType.NodeCreated)
{
try
{
var data = await zooKeeper.getDataAsync(path, this);
onChange(path, Encoding.UTF8.GetString(data.Data));
}
catch (KeeperException.NoNodeException)
{
onChange(path, null);
}
}
}
public override async Task process(WatchedEvent @event)
{
if (_isDisposed)
{
return;
}
var stateChanged = @event.getPath() == null;
var dataChanged = @event.get_Type() == Event.EventType.NodeChildrenChanged ||
@event.get_Type() == Event.EventType.NodeCreated ||
@event.get_Type() == Event.EventType.NodeDeleted ||
@event.get_Type() == Event.EventType.NodeDataChanged;
if (stateChanged)
{
await ProcessStateChange(@event);
}
else if (dataChanged)
{
await ProcessDataOrChildChange(@event);
}
else if (@event.getState() == Event.KeeperState.Expired)
{
// If the session expired we have to signal all conditions, because watches might have been removed and
// there is no guarantee that those
// We also have to notify all listeners that something might have changed
Logger.Info("session过期");
await FireAllEvents();
}
}
public override Task process(WatchedEvent @event)
{
Console.WriteLine("Type:" + @event.GetType() + ",EventType:" + @event.get_Type() + ",State:" + @event.getState());
var eventType = @event.get_Type();
if (eventType == EventType.NodeDeleted)
{
return(Task.Run(() =>
{
var leaderPath = @event.getPath();
try
{
_processPathChanged?.Invoke(leaderPath, eventType);
}
catch (KeeperException ex)
{
Console.WriteLine(ex);
}
_electionDataChangedEvent.Set();
}));
}
return(Task.CompletedTask);
}
public override async Task process(WatchedEvent @event)
{
string path = @event.getPath();
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher process : {path} .");
var eventType = @event.get_Type();
if (eventType == Event.EventType.NodeDataChanged)
{
if (!SmartSqlMapConfig.Settings.IsWatchConfigFile)
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap,dot not watch: {path} .");
}
else
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} Starting");
var sqlmap = SmartSqlMapConfig.SmartSqlMaps.FirstOrDefault(m => m.Path == path);
var newSqlmap = await ConfigLoader.LoadSmartSqlMapAsync(path, SmartSqlMapConfig);
sqlmap.Scope = newSqlmap.Scope;
sqlmap.Statements = newSqlmap.Statements;
sqlmap.Caches = newSqlmap.Caches;
SmartSqlMapConfig.ResetMappedStatements();
SmartSqlMapConfig.SmartSqlMapper.CacheManager.ResetMappedCaches();
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} End");
}
}
}
/// <summary>
/// process
/// </summary>
/// <param name="event">event</param>
/// <returns>Task</returns>
public override Task process(WatchedEvent @event)
{
// 写日志
Event.EventType eventType = @event.get_Type();
if (eventType != Event.EventType.None)
{
string path = @event.getPath();
// Event.KeeperState keeperState = @event.getState();
switch (eventType)
{
case Event.EventType.NodeChildrenChanged:
case Event.EventType.NodeCreated:
case Event.EventType.NodeDataChanged:
var tsk = new Task(() => { this.CallBack(path); });
tsk.Start();
return(tsk);
case Event.EventType.NodeDeleted:
// 写日志忽略变更
break;
}
}
return(Task.CompletedTask);
}
public override async Task process(WatchedEvent @event)
{
await base.process(@event);
string path = @event.getPath();
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher process : {path} .");
var eventType = @event.get_Type();
if (eventType == Event.EventType.NodeDataChanged)
{
if (!SmartSqlMapConfig.Settings.IsWatchConfigFile)
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap,dot not watch: {path} .");
}
else
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} Starting");
var sqlmap = SmartSqlMapConfig.SmartSqlMaps.Values.FirstOrDefault(m => m.Path == path);
var newSqlmap = await ConfigLoader.LoadSmartSqlMapAsync(path, SmartSqlMapConfig);
sqlmap.Scope = newSqlmap.Scope;
sqlmap.Statements = newSqlmap.Statements;
sqlmap.Caches = newSqlmap.Caches;
ConfigLoader.TriggerChanged(new Abstractions.Config.OnChangedEventArgs
{
SqlMapConfig = SmartSqlMapConfig,
SqlMap = sqlmap,
EventType = Abstractions.Config.EventType.SqlMapChangeed
});
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} End");
}
}
}
public override async Task process(WatchedEvent @event)
{
await base.process(@event);
string path = @event.getPath();
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher process : {path} .");
var eventType = @event.get_Type();
if (eventType == Event.EventType.NodeDataChanged)
{
var config = ConfigLoader.SqlMapConfig;
if (!config.Settings.IsWatchConfigFile)
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher Changed ,dot not watch: {path} .");
}
else
{
#region SmartSqlMapConfig File Watch
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher Changed ReloadConfig: {path} Starting");
var newConfig = await ConfigLoader.LoadAsync();
ConfigLoader.TriggerChanged(new Abstractions.Config.OnChangedEventArgs
{
SqlMapConfig = newConfig,
EventType = Abstractions.Config.EventType.ConfigChanged
});
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher Changed ReloadConfig: {path} End");
#endregion
}
}
}
/// <summary>
/// Processes the specified event
/// </summary>
/// <param name="event"></param>
/// <returns></returns>
public override async Task process(WatchedEvent @event)
{
await base.process(@event);
var path = @event.getPath();
if (@event.get_Type() == Event.EventType.NodeDataChanged &&
this.NodeChanged != null && !string.IsNullOrWhiteSpace(path))
{
var znodeName = Path.GetFileName(path);
foreach (var builder in this._builders)
{
if (builder.GetZkPathByZnodeName(znodeName) == path)
{
var configName = builder.GetConfigNameByZnodeName(znodeName);
if (configName != null)
{
await AddWatcherAndAddUpdatedNode(path, this._lastMtime).ConfigureAwait(false);
this.NodeChanged?.Invoke(builder.ConfigType, configName);
break;
}
}
}
}
}
public override Task process(WatchedEvent ev)
{
return(_handler.Invoke(new ZkWatchEventArgs()
{
Path = ev.getPath(), EventType = (WatchEventType)(int)ev.get_Type(), State = (ZkState)(int)ev.getState()
}));
}
private async Task OnNodeChanged(WatchedEvent arg)
{
var type = arg.get_Type();
var path = arg.getPath();
var key = ConvertPathToKey(path);
switch (type)
{
case Watcher.Event.EventType.NodeDeleted:
await OnNodeDeleted(path, key);
OnReload();
break;
case Watcher.Event.EventType.NodeDataChanged:
await OnNodeDataChanged(path, key);
OnReload();
break;
case Watcher.Event.EventType.NodeChildrenChanged:
await OnNodeChildrenChanged(path, key);
OnReload();
break;
default:
break;
}
}
public override Task process(WatchedEvent @event)
{
_state = @event.getState().ToString();
_type = @event.get_Type();
_path = @event.getPath();
switch (_type)
{
case Event.EventType.NodeCreated:
HandleCreate();
break;
case Event.EventType.NodeDeleted:
HandleDelete();
break;
case Event.EventType.NodeDataChanged:
HandleDataChange();
break;
case Event.EventType.NodeChildrenChanged:
HandleChildrenChange();
break;
default:
HandleNone();
break;
}
return(CompletedTask);
}
async Task OnNodeEvent(WatchedEvent e)
{
if (e == null)
{
return;
}
try
{
string nodePath = e.getPath();
if (nodePath != _connectionZkNode)
{
//连接节点只处理数据修改事件，避免节点删除时重复加载
if (e.get_Type() == Watcher.Event.EventType.NodeDataChanged)
{
await ForceLoadConnection(nodePath);
}
}
else
{
await ForceLoadConnection();
}
}
catch
{ }
}
public override async Task process(WatchedEvent @event)
{
string path = @event.getPath();
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher process : {path} .");
var eventType = @event.get_Type();
if (eventType == Event.EventType.NodeDataChanged)
{
var config = SmartSqlMapper.SqlMapConfig;
if (!config.Settings.IsWatchConfigFile)
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher Changed ,dot not watch: {path} .");
}
else
{
#region SmartSqlMapConfig File Watch
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher Changed ReloadConfig: {path} Starting");
var newConfig = await ConfigLoader.LoadAsync(path, SmartSqlMapper);
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapConfigWatcher Changed ReloadConfig: {path} End");
#endregion
}
}
}
public ZookeeperEvent(WatchedEvent @event)
{
switch (@event.getState())
{
case Watcher.Event.KeeperState.AuthFailed: State = EventState.AuthFailed; break;
case Watcher.Event.KeeperState.ConnectedReadOnly: State = EventState.ConnectedReadOnly; break;
case Watcher.Event.KeeperState.Disconnected: State = EventState.Disconnected; break;
case Watcher.Event.KeeperState.Expired: State = EventState.Expired; break;
case Watcher.Event.KeeperState.SyncConnected: State = EventState.SyncConnected; break;
}
switch (@event.get_Type())
{
case Watcher.Event.EventType.NodeChildrenChanged: Type = EventType.NodeChildrenChanged; break;
case Watcher.Event.EventType.NodeCreated: Type = EventType.NodeCreated; break;
case Watcher.Event.EventType.NodeDataChanged: Type = EventType.NodeDataChanged; break;
case Watcher.Event.EventType.NodeDeleted: Type = EventType.NodeDeleted; break;
case Watcher.Event.EventType.None: Type = EventType.None; break;
}
Path = @event.getPath();
}
public override async Task process(WatchedEvent watchedEvent)
{
if (watchedEvent.getState() != Event.KeeperState.SyncConnected || watchedEvent.getPath() != Path)
{
return;
}
await ProcessImpl(watchedEvent);
}
public override async Task process(WatchedEvent @event)
{
_logger.LogDebug($"{@event.getPath()}|{@event.get_Type()}|{@event.getState()}");
if (onWatch != null)
{
await onWatch(@event);
}
}
public override Task process(WatchedEvent e)
{
var path = e.getPath();
var state = e.getState();
Console.WriteLine($"{Name} recieve: Path-{path} State-{e.getState()} Type-{e.get_Type()}");
return(Task.FromResult(0));
}
private async static Task ZkChangedAsync(WatchedEvent @event, ZkManager zk)
{
if (@event.get_Type() == Watcher.Event.EventType.NodeDeleted)
{
GetAutoResetEvent(@event.getPath())?.Set();
}
await Task.Delay(1);
}
public override async Task process(WatchedEvent @event)
{
if (@event.getPath() == "/nscrapy/conf")
{
var newConfig = await ZkHelper.GetAsync(@event.getPath());
string configFromZK = $"appsetting.zk.{DateTime.Now.ToString("yyyy-MM-dd HH.mm.ss.ms")}.json";
using (var fs = File.OpenWrite(Path.Combine(Directory.GetCurrentDirectory(), configFromZK)))
{
var content = Encoding.UTF8.GetBytes(newConfig);
fs.Write(content, 0, content.Length);
}
if (NScrapyContext.CurrentContext != null)
{
NScrapyContext.CurrentContext.RefreshConfigFile(configFromZK);
}
}
}
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 override async Task process(WatchedEvent watchedEvent)
{
if (watchedEvent.getState() != Event.KeeperState.SyncConnected || watchedEvent.getPath() != Path)
return;
await ProcessImpl(watchedEvent);
}
internal NamespaceWatchedEvent(CuratorFrameworkImpl client, WatchedEvent @event)
: base(@event.get_Type(), @event.getState(), client.unfixForNamespace(@event.getPath()))
{
}
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 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);
}
