/// <summary>
/// 检测私有消息
/// </summary>
/// <returns></returns>
private static async Task PrivateMsgWatcher()
{
if (m_client != null)
{
await m_client.SubscribeChildrenChange($"/Message/PrivateMessage/{m_ClientName}", async (ct, args) =>
{
List <string> currentChildrens = args.CurrentChildrens.ToList();
string path = args.Path;
Watcher.Event.EventType eventType = args.Type;
foreach (var newMsg in currentChildrens)
{
string newpath = $"/Message/PrivateMessage/{m_ClientName}/{newMsg}";
if (await m_client.ExistsAsync(newpath))
{
var data = await m_client.GetDataAsync(newpath);
string msg = Encoding.UTF8.GetString(data.ToArray());
string result = $"{msg},RecieveTime:{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}";
Console.WriteLine(result);
await m_client.DeleteAsync(newpath);
}
}
});
}
}
/// <summary>
/// 检测Client上下线
/// </summary>
/// <returns></returns>
private static async Task ClientWatcher()
{
if (m_client != null)
{
var childs = await m_client.GetChildrenAsync("/Client");
foreach (var child in childs)
{
string childpath = $"/Client/{child}";
if (await m_client.ExistsAsync(childpath))
{
await m_client.SubscribeDataChange(childpath, (ct, args) =>
{
IEnumerable <byte> currentData = args.CurrentData;
string onlineresult = Encoding.UTF8.GetString(currentData.ToArray());
string path = args.Path;
string client = path.Replace("/Client/", "");
Watcher.Event.EventType eventType = args.Type;
string result = $"通知:{client}状态是{onlineresult}";
Console.WriteLine(result);
return(Task.CompletedTask);
});
}
}
}
}
/**
* Convert a WatcherEvent sent over the wire into a full-fledged WatcherEvent
*/
internal WatchedEvent(WatcherEvent eventMessage)
{
keeperState = EnumUtil <Watcher.Event.KeeperState> .DefinedCast(eventMessage.getState());
eventType = EnumUtil <Watcher.Event.EventType> .DefinedCast(eventMessage.get_Type());
path = eventMessage.getPath();
}
public void testInvalidIntConversion()
{
try {
Watcher.Event.EventType et = EnumUtil <Watcher.Event.EventType> .DefinedCast(324242);
Assert.fail("Was able to create an invalid EventType via an integer");
}
catch (Exception)
{
// we're good.
}
}
public static NodeChangedEventType ToNodeChangedEventType(this Watcher.Event.EventType type)
{
switch (type)
{
case Watcher.Event.EventType.NodeCreated:
return(NodeChangedEventType.Created);
case Watcher.Event.EventType.NodeDeleted:
return(NodeChangedEventType.Deleted);
case Watcher.Event.EventType.NodeDataChanged:
return(NodeChangedEventType.DataChanged);
case Watcher.Event.EventType.NodeChildrenChanged:
return(NodeChangedEventType.ChildrenChanged);
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
private async Task SubscribeNodes(string path, Watcher.Event.EventType eventType)
{
var children = await ZooKeeper.getChildrenAsync(path, true);
switch (eventType)
{
case Watcher.Event.EventType.NodeChildrenChanged:
var serviceName = GetServiceNameFromPath(path);
if (children == null)
{
RefreshNodes(serviceName, new List <ServiceNodeInfo>());
}
else
{
var nodes = await QueryServiceAsync(serviceName);
RefreshNodes(serviceName, nodes.Select(p => new ServiceNodeInfo(p.ServiceId, p.Address, p.Port, p.Weight, p.EnableTls, p.Meta)).ToList());
}
break;
}
}
//public void SetCurrentData(byte[] currentData)
//{
// _currentData = currentData;
//}
internal async Task HandleNodeDataChange(IZookeeperClient client, NodeDataChangeArgs args)
{
Watcher.Event.EventType eventType = args.Type;
var nodeData = new byte[0];
if (args.CurrentData != null && args.CurrentData.Any())
{
nodeData = args.CurrentData.ToArray();
}
switch (eventType)
{
case Watcher.Event.EventType.NodeCreated:
_action(new byte[0], nodeData);
_currentData = nodeData;
break;
case Watcher.Event.EventType.NodeDataChanged:
_action(_currentData, nodeData);
_currentData = nodeData;
break;
}
}
internal async Task HandleChildrenChange(IZookeeperClient client, NodeChildrenChangeArgs args)
{
Watcher.Event.EventType eventType = args.Type;
var path = args.Path;
var watcher = new ChildrenMonitorWatcher(path, _action);
switch (eventType)
{
case Watcher.Event.EventType.NodeCreated:
await client.SubscribeChildrenChange(path, watcher.HandleChildrenChange);
break;
case Watcher.Event.EventType.NodeDataChanged:
try
{
var currentChildrens = new string[0];
if (args.CurrentChildrens != null && args.CurrentChildrens.Any())
{
currentChildrens = args.CurrentChildrens.ToArray();
}
_action(_currentData, currentChildrens);
watcher.SetCurrentData(currentChildrens);
}
catch (KeeperException.NoNodeException)
{
_action(_currentData, new string[0]);
watcher.SetCurrentData(new string[0]);
}
break;
case Watcher.Event.EventType.NodeDeleted:
_action(_currentData, new string[0]);
watcher.SetCurrentData(new string[0]);
break;
}
}
/// <summary>
/// 检测群组消息
/// </summary>
/// <returns></returns>
private static async Task GroupMsgWatcher()
{
if (m_client != null)
{
await m_client.SubscribeChildrenChange("/Message/GroupMessage", async (ct, args) =>
{
List <string> currentChildrens = args.CurrentChildrens.ToList();
string path = args.Path;
Watcher.Event.EventType eventType = args.Type;
var newadded = currentChildrens.Where(t => !groupMsgList.Contains(t)).ToList();
foreach (var newMsg in newadded)
{
string newpath = $"/Message/GroupMessage/{newMsg}";
if (await m_client.ExistsAsync(newpath))
{
var data = await m_client.GetDataAsync(newpath);
string msg = Encoding.UTF8.GetString(data.ToArray());
string result = $"{msg},RecieveTime:{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}";
Console.WriteLine(result);
}
}
groupMsgList.AddRange(newadded);
var needdelete = groupMsgList.Where(t => !currentChildrens.Contains(t)).ToList();
foreach (var delete in needdelete)
{
groupMsgList.Remove(delete);
}
});
}
}
/// <summary>
/// 创建一个新的节点子节点变更参数。
/// </summary>
/// <param name="path">节点路径。</param>
/// <param name="type">事件类型。</param>
/// <param name="currentChildrens">最新的子节点集合。</param>
public NodeChildrenChangeArgs(string path, Watcher.Event.EventType type, IEnumerable <string> currentChildrens) : base(path, type)
{
CurrentChildrens = currentChildrens;
}
/// <summary>
/// 创建一个新的节点数据变更参数。
/// </summary>
/// <param name="path">节点路径。</param>
/// <param name="type">事件类型。</param>
/// <param name="currentData">最新的节点数据。</param>
public NodeDataChangeArgs(string path, Watcher.Event.EventType type, IEnumerable <byte> currentData) : base(path, type)
{
CurrentData = currentData;
}
/// <summary>
/// 创建一个新的节点变更参数。
/// </summary>
/// <param name="path">节点路径。</param>
/// <param name="type">事件类型。</param>
protected NodeChangeArgs(string path, Watcher.Event.EventType type)
{
Path = path;
Type = type;
}
static void Main(string[] args)
{
IZookeeperClient client = new ZookeeperClient(new ZookeeperClientOptions("192.168.1.167:2181")
{
BasePath = "/", //default value
ConnectionTimeout = TimeSpan.FromSeconds(10), //default value
SessionTimeout = TimeSpan.FromSeconds(20), //default value
OperatingTimeout = TimeSpan.FromSeconds(60), //default value
ReadOnly = false, //default value
SessionId = 0, //default value
SessionPasswd = null, //default value
EnableEphemeralNodeRestore = true //default value
});
client.SubscribeChildrenChange("/microsoft", (ct, args2) =>
{
IEnumerable <string> currentChildrens = args2.CurrentChildrens;
string path = args2.Path;
Console.WriteLine("SubscribeChildrenChange:" + path);
Watcher.Event.EventType eventType = args2.Type;
return(Task.CompletedTask);
});
client.SubscribeDataChange("/year", (ct, args1) =>
{
IEnumerable <byte> currentData = args1.CurrentData;
string path = args1.Path;
Console.WriteLine("SubscribeDataChange:" + path + "*****" + args1.Type.ToString() + ":" + DateTime.Now.ToString());
Watcher.Event.EventType eventType = args1.Type;
return(Task.CompletedTask);
});
var data = Encoding.UTF8.GetBytes("2016");
//Fast create temporary nodes
client.CreateEphemeralAsync("/year", data);
client.CreateEphemeralAsync("/year", data, ZooDefs.Ids.OPEN_ACL_UNSAFE);
//Fast create permanent nodes
client.CreatePersistentAsync("/year", data);
client.CreatePersistentAsync("/year", data, ZooDefs.Ids.OPEN_ACL_UNSAFE);
//Full call
client.CreateAsync("/year", data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
//Recursively created
client.CreateRecursiveAsync("/microsoft/netcore/aspnet", data);
Console.WriteLine("start .....");
while (true)
{
Console.WriteLine("请输入内容！");
switch (Console.ReadLine())
{
case "1":
{
client.SetDataAsync("/microsoft", Encoding.UTF8.GetBytes("2018"));
}; break;
case "2":
{
var abc = client.SetDataAsync("/year", Encoding.UTF8.GetBytes("2018"));
}; break;
}
}
Console.ReadKey();
}
internal WatchedEvent(Watcher.Event.EventType eventType, Watcher.Event.KeeperState keeperState, string path)
{
this.keeperState = keeperState;
this.eventType = eventType;
this.path = path;
}
private async Task Watcher_OnChange(string path, Watcher.Event.KeeperState keeperState, Watcher.Event.EventType eventType)
{
switch (keeperState)
{
case Watcher.Event.KeeperState.Expired:
Logger.LogWarning($"ZooKeeper has been {keeperState},Reconnecting...");
ZooKeeperSessionId = 0;
CreateZooKeeperClient();
break;
case Watcher.Event.KeeperState.Disconnected:
Logger.LogWarning($"ZooKeeper has been {keeperState},Reconnecting...");
CreateZooKeeperClient();
break;
case Watcher.Event.KeeperState.SyncConnected:
if (ZooKeeperSessionId == 0)
{
ZooKeeperSessionId = ZooKeeper.getSessionId();
}
await SubscribeNodes(path, eventType);
break;
}
}
/// <summary>
/// 创建一个新的节点子节点变更参数。
/// </summary>
/// <param name="path">节点路径。</param>
/// <param name="type">事件类型。</param>
/// <param name="currentChildrenDatas">最新的子节点集合。</param>
public NodeChildrenChangeArgs(string path, Watcher.Event.EventType type, Dictionary <string, DataResult> currentChildrenDatas) : base(path, type)
{
CurrentChildrenDatas = currentChildrenDatas;
}
