/**
* Returns node's state
*/
public async Task <Stat> setData(string path, byte[] data, int version, bool retryOnConnLoss)
{
if (retryOnConnLoss)
{
return(await _zkCmdExecutor.RetryOperation(async() => await keeper.setDataAsync(path, data, version)));
}
else
{
return(await keeper.setDataAsync(path, data, version));
}
}
internal async void Run()
{
var data = Encoding.UTF8.GetBytes("test");
ZooKeeper zk = new ZooKeeper("localhost:2181", 50000, NullWatcher.Instance);
var zNodeRoot = zk.existsAsync("/").Result.getCversion();
var zNodeA = zk.existsAsync("/a").Result;
if (zNodeA == null)
{
await zk.createAsync("/a", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
var node = zk.existsAsync("/a/1").Result;
Task <string> nodetask = null;
if (node == null)
{
nodetask = zk.createAsync("/a/1", data, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
}
nodetask.Wait();
IList <string> children = zk.getChildrenAsync("/a", false).Result.Children;
var test2 = zk.getDataAsync("/a", NodeWatcher.Instance).Result;
var test3 = zk.setDataAsync("/a", data).Result;
var closeEvent = zk.closeAsync();
closeEvent.Wait();
}
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 async Task ChangeValue(string path, string value)
{
var zk = new ZooKeeper("127.0.0.1:2181", 60000, null);
await zk.setDataAsync(path, Encoding.UTF8.GetBytes(value));
await zk.closeAsync();
}
public async Task <NodeStatus> SetDataAsync([NotNull] string path, byte[] data, int version = -1)
{
ValidateState();
var stat = await _zk.setDataAsync(path, data, version);
return(new NodeStatus(stat));
}
public async Task testDeleteRecursive()
{
ZooKeeper zk = await createClient();
// making sure setdata works on /
await zk.setDataAsync("/", "some".UTF8getBytes(), -1);
await zk.createAsync("/a", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/b", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/b/v", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/b/v/1", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/c", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/a/c/v", "some".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
IList <string> children = (await zk.getChildrenAsync("/a", false)).Children;
Assert.assertEquals("2 children - b & c should be present ", children.Count, 2);
Assert.assertTrue(children.Contains("b"));
Assert.assertTrue(children.Contains("c"));
ZKUtil.deleteRecursiveAsync(zk, "/a").GetAwaiter().GetResult();
Assert.assertNull(await zk.existsAsync("/a", null));
}
static async Task Test()
{
var output = string.Empty;
ZooKeeper zk = null;
try
{
//创建一个Zookeeper实例，第一个参数为目标服务器地址和端口，第二个参数为Session超时时间，第三个为节点变化时的回调方法
ZooKeeper.LogToFile = false;
ZooKeeper.LogToTrace = true;
zk = new ZooKeeper("127.0.0.1:2181", 10 * 1000, NullWatcher.Instance);
var stat = await zk.existsAsync("/root", true);
if (stat == null)
{
//创建一个节点root，数据是mydata,不进行ACL权限控制，节点为永久性的(即客户端shutdown了也不会消失)
output = await zk.createAsync("/root", "mydata".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
Trace.WriteLine($"output");
}
stat = await zk.existsAsync("/root/childone", true);
if (stat == null)
{
//在root下面创建一个childone znode,数据为childone,不进行ACL权限控制，节点为永久性的
output = await zk.createAsync("/root/childone", "childone".GetBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
Trace.WriteLine($"output");
}
//取得/root节点下的子节点名称,返回List<String>
var subNodes = await zk.getChildrenAsync("/root", true);
Trace.WriteLine($"SubNodes: {(string.Join(",", subNodes.Children))}");
//取得/root/childone节点下的数据,返回byte[]
var data = await zk.getDataAsync("/root/childone", true);
Trace.WriteLine($"/root/childone Data: {Encoding.UTF8.GetString(data.Data)}");
//修改节点/root/childone下的数据，第三个参数为版本，如果是-1，那会无视被修改的数据版本，直接改掉
await zk.setDataAsync("/root/childone", "childonemodify".GetBytes(), -1);
//删除/root/childone这个节点，第二个参数为版本，－1的话直接删除，无视版本
await zk.deleteAsync("/root/childone", -1);
}
catch (Exception ex)
{
Trace.WriteLine(ex.StackTrace);
}
finally
{
await zk.closeAsync();
}
}
/// <summary>
/// 设置指定的节点为指定值，如果不存在，会创建该节点
/// </summary>
/// <param name="keeper"></param>
/// <param name="path"></param>
/// <param name="values"></param>
/// <returns></returns>
public static async Task SetDataAsync(this ZooKeeper keeper, ZookeeperPathString path, byte[] values)
{
if (await keeper.ExistAsync(path))
{
await keeper.setDataAsync(path, values);
}
else
{
await keeper.CreateAsync(path, values);
}
}
/// <summary>
/// 给节点设置数据
/// </summary>
/// <param name="path">不要使用path等关键字作为路径</param>
/// <param name="data"></param>
/// <returns></returns>
public string SetData(string path, string data)
{
Task <org.apache.zookeeper.data.Stat> stat = _zooKeeper.setDataAsync(path, System.Text.Encoding.UTF8.GetBytes(data));
stat.Wait();
if (stat.Result != null && stat.Status.ToString().ToLower() == "RanToCompletion".ToLower())
{
return(_success);
}
return(_fail);
}
public async Task <bool> SetData(string path, string data)
{
try
{
await RetryUntilConnected(async() => await _zk.setDataAsync(path, Encoding.UTF8.GetBytes(data)));
}
catch (KeeperException e)
{
return(await Task.FromResult(false));
}
return(await Task.FromResult(true));
}
public async Task TestMethod1()
{
//原来zk客户端不应该作为静态对象，每次new
foreach (var i in Com.Range(100))
{
var client = new ZooKeeper("localhost:32771",
(int)TimeSpan.FromSeconds(5).TotalMilliseconds, this,
canBeReadOnly: false);
try
{
//var count = 0;
//while (client.getState() != ZooKeeper.States.CONNECTED)
//{
// if (++count > 100) { throw new Exception("loss patient to wait for connection"); }
// await Task.Delay(10);
//}
if (await client.existsAsync("/home", false) == null)
{
var path = await client.createAsync("/home", "".GetBytes(),
Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
var bs = new { id = 2, name = "fas", age = 44, time = DateTime.Now }.ToJson().GetBytes();
await client.setDataAsync("/home", bs);
var data = await client.getDataAsync("/home", false);
var children = await client.getChildrenAsync("/home");
var t = client.transaction();
//t.delete("/home");
t.setData("/home", $"{DateTime.Now.Ticks}".GetBytes());
var res = await t.commitAsync();
}
catch (Exception e)
{
//
}
finally
{
await client.closeAsync();
this.connected = false;
}
}
}
public async Task SetAsync <TContent>(string nodeName, TContent value, CreateModeEnum createMode = CreateModeEnum.PERSISTENT)
{
byte[] nodeData = JsonSerializer.SerializeToUtf8Bytes(value, typeof(TContent), _jsonOptions);
if (await _zkClient.existsAsync(nodeName) == null) // Cria..,
{
var zkCreateMode = createMode.Equals(CreateModeEnum.PERSISTENT) ? CreateMode.PERSISTENT : CreateMode.EPHEMERAL;
await _zkClient.createAsync(nodeName, nodeData, OPEN_ACL_UNSAFE, zkCreateMode);
}
else // Atualiza..,
{
await _zkClient.setDataAsync(nodeName, nodeData);
}
}
/// <summary>
/// 设置服务命令。
/// </summary>
/// <param name="routes">服务命令集合。</param>
/// <returns>一个任务。</returns>
public override async Task SetServiceCommandsAsync(IEnumerable <ServiceCommandDescriptor> serviceCommand)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("准备添加服务命令。");
}
await CreateSubdirectory(_configInfo.CommandPath);
var path = _configInfo.CommandPath;
if (!path.EndsWith("/"))
{
path += "/";
}
serviceCommand = serviceCommand.ToArray();
foreach (var command in serviceCommand)
{
var nodePath = $"{path}{command.ServiceId}";
var nodeData = _serializer.Serialize(command);
if (await _zooKeeper.existsAsync(nodePath) == null)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"节点：{nodePath}不存在将进行创建。");
}
await _zooKeeper.createAsync(nodePath, nodeData, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
else
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"将更新节点：{nodePath}的数据。");
}
var onlineData = (await _zooKeeper.getDataAsync(nodePath)).Data;
if (!DataEquals(nodeData, onlineData))
{
await _zooKeeper.setDataAsync(nodePath, nodeData);
}
}
NodeChange(command);
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("服务命令添加成功。");
}
}
/// <summary>
/// 设置服务路由。
/// </summary>
/// <param name="routes">服务路由集合。</param>
/// <returns>一个任务。</returns>
protected override async Task SetRoutesAsync(IEnumerable <ServiceRouteDescriptor> routes)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("准备添加服务路由。");
}
await CreateSubdirectory(_configInfo.RoutePath);
var path = _configInfo.RoutePath;
if (!path.EndsWith("/"))
{
path += "/";
}
routes = routes.ToArray();
foreach (var serviceRoute in routes)
{
var nodePath = $"{path}{serviceRoute.ServiceDescriptor.Id}";
var nodeData = _serializer.Serialize(serviceRoute);
if (await _zooKeeper.existsAsync(nodePath) == null)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"节点：{nodePath}不存在将进行创建。");
}
await _zooKeeper.createAsync(nodePath, nodeData, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
else
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"将更新节点：{nodePath}的数据。");
}
var onlineData = (await _zooKeeper.getDataAsync(nodePath)).Data;
if (!DataEquals(nodeData, onlineData))
{
await _zooKeeper.setDataAsync(nodePath, nodeData);
}
}
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("服务路由添加成功。");
}
}
public Task <Stat> SetDataAsync(string path, string data, bool isSync)
{
ReConn();
if (_zookeeper.existsAsync(path).Result == null)
{
_logger.LogDebug("path不存在");
return(null);
}
byte[] dat = new byte[0];
if (!string.IsNullOrEmpty(data))
{
dat = System.Text.Encoding.Default.GetBytes(data);
}
return(_zookeeper.setDataAsync(path, dat));
}
public async Task Set(string nodeName, string nodeValue)
{
byte[] data = Encoding.ASCII.GetBytes(nodeValue);
var nodeExists = await _zookeeper.existsAsync(nodeName);
if (nodeExists != null)
{
await _zookeeper.setDataAsync(nodeName, data); // Atualiza..,
}
else
{
await _zookeeper.createAsync(nodeName, data, null, CreateMode.PERSISTENT); // cria...
}
}
public bool Update(string ServiceName, string SrvInfo)
{
try
{
//get old Version
int ver = _client.getDataAsync($"/ZooDiscovery/{ServiceName}").Result.Stat.getVersion();
//set data
Stat stat = _client.setDataAsync($"/ZooDiscovery/{ServiceName}", Encoding.UTF8.GetBytes(SrvInfo)).Result;
//compara Version
return(ver != stat.getVersion());
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 给节点设置数据
/// </summary>
/// <param name="path">不要使用path等关键字作为路径</param>
/// <param name="data"></param>
/// <returns></returns>
public string SetData(string path, string data)
{
try
{
Task <org.apache.zookeeper.data.Stat> stat = _zooKeeper.setDataAsync(path, System.Text.Encoding.UTF8.GetBytes(data));
stat.Wait();
if (stat.Result != null && stat.Status.ToString().ToLower() == "RanToCompletion".ToLower())
{
return(_success);
}
}
catch (Exception ex)
{
_log.ErrorFormat("设置节点数据发生异常：{0}({1}),{2}", path, data, ex.Message + ex.StackTrace);
}
return(_fail);
}
static async Task TestWatch(ZooKeeper zk)
{
try
{
await zk.getDataAsync("/featureflags/features/theFeatureB", new MyWatcher(zk));
}
catch (Exception e)
{
Console.WriteLine("Error : " + e.Message);
}
for (byte i = 0; i < 10; i++)
{
await Task.Delay(1000);
Console.WriteLine("Modif !");
await zk.setDataAsync("/featureflags/features/theFeatureB", new byte[] { (byte)(0x31 + i) });
}
}
/// <summary>
/// 设置节点数据
/// </summary>
/// <param name="path">path</param>
/// <param name="data">data</param>
/// <returns>返回是否成功</returns>
private static bool SetNodeData(string path, string data)
{
int tryNum = 0;
gotoLable:
logger.LogInformation($"SetNodeData开始设置:{path}_{data}");
try
{
var rst = currentZookeeper.setDataAsync(path, Encoding.UTF8.GetBytes(data));
rst.Wait();
return(true);
}
catch (KeeperException.NoNodeException nodeEx) // 这样的异常不用重连
{
logger.LogError(nodeEx, $"SetNodeData 设置数据异常节点不存在 NoNodeException:{path}{data}");
return(false);
}
catch (KeeperException.BadVersionException badVersion)
{
logger.LogError(badVersion, $"SetNodeData 设置数据异常节点不存在 BadVersionException:{path}{data}");
return(false);
}
catch (Exception e)
{
logger.LogError(e, $"SetNodeData 设置数据异常:{path}{data}");
tryNum += 1;
if (tryNum < 3)
{
reConnection(e);
Thread.Sleep(500);
goto gotoLable;
}
else
{
throw e; // 设置数据的地方一定要抛异常
}
}
}
public static Stat setData(this ZooKeeper zk, string path, byte[] data, int version)
{
return(zk.setDataAsync(path, data, version).GetAwaiter().GetResult());
}
public async Task testChrootSynchronous()
{
ZooKeeper zk1 = await createClient();
await zk1.createAsync("/ch1", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk1.closeAsync();
ZooKeeper zk2 = await createClient("/ch1");
Assert.assertEquals("/ch2", await zk2.createAsync("/ch2", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT));
await zk2.closeAsync();
zk1 = await createClient();
zk2 = await createClient("/ch1");
// check get
MyWatcher w1 = new MyWatcher("/ch1");
Assert.assertNotNull(await zk1.existsAsync("/ch1", w1));
MyWatcher w2 = new MyWatcher("/ch1/ch2");
Assert.assertNotNull(await zk1.existsAsync("/ch1/ch2", w2));
MyWatcher w3 = new MyWatcher("/ch2");
Assert.assertNotNull(await zk2.existsAsync("/ch2", w3));
// set watches on child
MyWatcher w4 = new MyWatcher("/ch1");
await zk1.getChildrenAsync("/ch1", w4);
MyWatcher w5 = new MyWatcher("/");
await zk2.getChildrenAsync("/", w5);
// check set
await zk1.setDataAsync("/ch1", "1".UTF8getBytes(), -1);
await zk2.setDataAsync("/ch2", "2".UTF8getBytes(), -1);
// check watches
Assert.assertTrue(await w1.matches());
Assert.assertTrue(await w2.matches());
Assert.assertTrue(await w3.matches());
// check exceptions
try
{
await zk2.setDataAsync("/ch3", "3".UTF8getBytes(), -1);
}
catch (KeeperException.NoNodeException e)
{
Assert.assertEquals("/ch3", e.getPath());
}
Assert.assertEquals("1".UTF8getBytes(), (await zk1.getDataAsync("/ch1", false)).Data);
Assert.assertEquals("2".UTF8getBytes(), (await zk1.getDataAsync("/ch1/ch2", false)).Data);
Assert.assertEquals("2".UTF8getBytes(), (await zk2.getDataAsync("/ch2", false)).Data);
// check delete
await zk2.deleteAsync("/ch2", -1);
Assert.assertTrue(await w4.matches());
Assert.assertTrue(await w5.matches());
await zk1.deleteAsync("/ch1", -1);
Assert.assertNull(await zk1.existsAsync("/ch1", false));
Assert.assertNull(await zk1.existsAsync("/ch1/ch2", false));
Assert.assertNull(await zk2.existsAsync("/ch2", false));
}
public async Task testExistsSync()
{
Assert.assertNull(await lsnr.existsAsync("/foo", true));
Assert.assertNull(await lsnr.existsAsync("/foo/bar", true));
await client.createAsync("/foo", "parent".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
expected.Add(Watcher.Event.EventType.NodeCreated);
await client.createAsync("/foo/bar", "child".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
expected.Add(Watcher.Event.EventType.NodeCreated);
verify();
Assert.assertNotNull(await lsnr.existsAsync("/foo", true));
Assert.assertNotNull(await lsnr.existsAsync("/foo/bar", true));
try
{
Assert.assertNull(await lsnr.existsAsync("/car", true));
await client.setDataAsync("/car", "missing".UTF8getBytes(), -1);
Assert.fail();
}
catch (KeeperException e)
{
Assert.assertEquals(KeeperException.Code.NONODE, e.getCode());
Assert.assertEquals("/car", e.getPath());
}
try
{
Assert.assertNull(await lsnr.existsAsync("/foo/car", true));
await client.setDataAsync("/foo/car", "missing".UTF8getBytes(), -1);
Assert.fail();
}
catch (KeeperException e)
{
Assert.assertEquals(KeeperException.Code.NONODE, e.getCode());
Assert.assertEquals("/foo/car", e.getPath());
}
await client.setDataAsync("/foo", "parent".UTF8getBytes(), -1);
expected.Add(Watcher.Event.EventType.NodeDataChanged);
await client.setDataAsync("/foo/bar", "child".UTF8getBytes(), -1);
expected.Add(Watcher.Event.EventType.NodeDataChanged);
verify();
Assert.assertNotNull(await lsnr.existsAsync("/foo", true));
Assert.assertNotNull(await lsnr.existsAsync("/foo/bar", true));
await client.deleteAsync("/foo/bar", -1);
expected.Add(Watcher.Event.EventType.NodeDeleted);
await client.deleteAsync("/foo", -1);
expected.Add(Watcher.Event.EventType.NodeDeleted);
verify();
}
public async Task testMutipleWatcherObjs()
{
ZooKeeper zk = await createClient();
MyWatcher[] watchers = new MyWatcher[100];
MyWatcher[] watchers2 = new MyWatcher[watchers.Length];
for (int i = 0; i < watchers.Length; i++)
{
watchers[i] = new MyWatcher();
watchers2[i] = new MyWatcher();
await zk.createAsync("/foo-" + i, ("foodata" + i).UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT);
}
//
// test get/exists with single set of watchers
// get all, then exists all
//
for (int i = 0; i < watchers.Length; i++)
{
Assert.assertNotNull((await zk.getDataAsync("/foo-" + i, watchers[i])).Data);
}
for (int i = 0; i < watchers.Length; i++)
{
Assert.assertNotNull(await zk.existsAsync("/foo-" + i, watchers[i]));
}
// trigger the watches
for (int i = 0; i < watchers.Length; i++)
{
await zk.setDataAsync("/foo-" + i, ("foodata2-" + i).UTF8getBytes(), -1);
await zk.setDataAsync("/foo-" + i, ("foodata3-" + i).UTF8getBytes(), -1);
}
for (int i = 0; i < watchers.Length; i++)
{
WatchedEvent @event = watchers[i].events.poll(10 * 1000);
Assert.assertEquals("/foo-" + i, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDataChanged, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.assertEquals(0, watchers[i].events.size());
}
//
// test get/exists with single set of watchers
// get/exists together
//
for (int i = 0; i < watchers.Length; i++)
{
Assert.assertNotNull((await zk.getDataAsync("/foo-" + i, watchers[i])).Data);
Assert.assertNotNull(await zk.existsAsync("/foo-" + i, watchers[i]));
}
// trigger the watches
for (int i = 0; i < watchers.Length; i++)
{
await zk.setDataAsync("/foo-" + i, ("foodata4-" + i).UTF8getBytes(), -1);
await zk.setDataAsync("/foo-" + i, ("foodata5-" + i).UTF8getBytes(), -1);
}
for (int i = 0; i < watchers.Length; i++)
{
WatchedEvent @event = watchers[i].events.poll(10 * 1000);
Assert.assertEquals("/foo-" + i, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDataChanged, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.assertEquals(0, watchers[i].events.size());
}
//
// test get/exists with two sets of watchers
//
for (int i = 0; i < watchers.Length; i++)
{
Assert.assertNotNull((await zk.getDataAsync("/foo-" + i, watchers[i])).Data);
Assert.assertNotNull(await zk.existsAsync("/foo-" + i, watchers2[i]));
}
// trigger the watches
for (int i = 0; i < watchers.Length; i++)
{
await zk.setDataAsync("/foo-" + i, ("foodata6-" + i).UTF8getBytes(), -1);
await zk.setDataAsync("/foo-" + i, ("foodata7-" + i).UTF8getBytes(), -1);
}
for (int i = 0; i < watchers.Length; i++)
{
WatchedEvent @event = watchers[i].events.poll(10 * 1000);
Assert.assertEquals("/foo-" + i, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDataChanged, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.assertEquals(0, watchers[i].events.size());
// watchers2
WatchedEvent event2 = watchers2[i].events.poll(10 * 1000);
Assert.assertEquals("/foo-" + i, event2.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDataChanged, event2.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, event2.getState());
// small chance that an unexpected message was delivered
// after this check, but we would catch that next time
// we check events
Assert.assertEquals(0, watchers2[i].events.size());
}
}
private async Task ShowNodeInfo()
{
var selectedNode = treeViewNodes.SelectedNode;
if (selectedNode != null)
{
try
{
var dataResult = await m_zooKeeperClient.getDataAsync(selectedNode.Name);
var aCLResult = await m_zooKeeperClient.getACLAsync(selectedNode.Name);
NodeInfoForm nodeInfoForm = new NodeInfoForm();
nodeInfoForm.NodeName = selectedNode.Text;
nodeInfoForm.Text = selectedNode.Name;
nodeInfoForm.Data = dataResult.Data ?? (new byte[0]);
nodeInfoForm.ACLs = aCLResult.Acls;
nodeInfoForm.Stat = aCLResult.Stat;
nodeInfoForm.ShowDialog();
bool dataChanged = true;
bool aclsChanged = true;
var data = nodeInfoForm.Data;
if (Convert.ToBase64String(dataResult.Data ?? (new byte[0])) == Convert.ToBase64String(data))
{
dataChanged = false;
}
var acls = nodeInfoForm.ACLs;
if (aCLResult.Acls.Count == acls.Count && aCLResult.Acls.All(acl => acls.Exists(i => i.getPerms() == acl.getPerms() && i.getId().getScheme() == acl.getId().getScheme() && i.getId().getId() == acl.getId().getId())))
{
aclsChanged = false;
}
if (dataChanged || aclsChanged)
{
if (MessageBox.Show("Do You Want To Update The Modification", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
{
if (dataChanged)
{
await m_zooKeeperClient.setDataAsync(selectedNode.Name, data);
Log($"Data seted {selectedNode.Name}.");
}
if (aclsChanged)
{
await m_zooKeeperClient.setACLAsync(selectedNode.Name, acls);
Log($"ACL seted {selectedNode.Name}.");
}
}
}
}
catch (KeeperException ex)
{
Log($"{ex.Message} {selectedNode.Name}");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
}
else
{
MessageBox.Show("No Node Selected.", "Info");
}
}
private async Task performClientTest(bool withWatcherObj)
{
ZooKeeper zk = null;
MyWatcher watcher = new MyWatcher();
zk = await createClient(watcher);
LOG.info("Before create /benwashere");
await zk.createAsync("/benwashere", "".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
LOG.info("After create /benwashere");
try {
await zk.setDataAsync("/benwashere", "hi".UTF8getBytes(), 57);
Assert.fail("Should have gotten BadVersion exception");
}
catch (KeeperException.BadVersionException) {
// expected that
}
catch (KeeperException) {
Assert.fail("Should have gotten BadVersion exception");
}
LOG.info("Before delete /benwashere");
await zk.deleteAsync("/benwashere", 0);
LOG.info("After delete /benwashere");
//LOG.info("Closed client: " + zk.describeCNXN());
await Task.Delay(2000);
zk = await createClient(watcher);
//LOG.info("Created a new client: " + zk.describeCNXN());
LOG.info("Before delete /");
try {
await zk.deleteAsync("/", -1);
Assert.fail("deleted root!");
}
catch (KeeperException.BadArgumentsException) {
// good, expected that
}
// Test basic create, ls, and getData
await zk.createAsync("/pat", "Pat was here".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
LOG.info("Before create /ben");
await zk.createAsync("/pat/ben", "Ben was here".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
LOG.info("Before getChildren /pat");
List <string> children = (await zk.getChildrenAsync("/pat", false)).Children;
Assert.assertEquals(1, children.Count);
Assert.assertEquals("ben", children[0]);
IList <string> children2 = (await zk.getChildrenAsync("/pat", false)).Children;
Assert.assertEquals(children, children2);
Assert.assertEquals("Ben was here", (await zk.getDataAsync("/pat/ben", false)).Data.UTF8bytesToString());
// Test stat and watch of non existent node
try {
if (withWatcherObj)
{
Assert.assertEquals(null, await zk.existsAsync("/frog", watcher));
}
else
{
Assert.assertEquals(null, await zk.existsAsync("/frog", true));
}
LOG.info("Comment: asseting passed for frog setting /");
}
catch (KeeperException.NoNodeException) {
// OK, expected that
}
await zk.createAsync("/frog", "hi".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
// the first poll is just a session delivery
LOG.info("Comment: checking for events length " + watcher.events.size());
WatchedEvent @event = watcher.events.poll(10 * 1000);
Assert.assertEquals("/frog", @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeCreated, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
// Test child watch and create with sequence
await zk.getChildrenAsync("/pat/ben", true);
for (int i = 0; i < 10; i++)
{
await zk.createAsync("/pat/ben/" + i + "-", Convert.ToString(i).UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT_SEQUENTIAL);
}
children = (await zk.getChildrenAsync("/pat/ben", false)).Children;
children.Sort();
Assert.assertEquals(10, children.Count);
for (int i = 0; i < 10; i++)
{
string name = children[i];
Assert.assertTrue("starts with -", name.StartsWith(i + "-", StringComparison.Ordinal));
DataResult dataResult;
if (withWatcherObj)
{
dataResult = await zk.getDataAsync("/pat/ben/" + name, watcher);
}
else
{
dataResult = await zk.getDataAsync("/pat/ben/" + name, true);
}
Assert.assertEquals(i, int.Parse(dataResult.Data.UTF8bytesToString()));
await zk.setDataAsync("/pat/ben/" + name, "new".UTF8getBytes(), dataResult.Stat.getVersion());
Stat stat;
if (withWatcherObj)
{
stat = await zk.existsAsync("/pat/ben/" + name, watcher);
}
else
{
stat = await zk.existsAsync("/pat/ben/" + name, true);
}
await zk.deleteAsync("/pat/ben/" + name, stat.getVersion());
}
@event = watcher.events.poll(10 * 1000);
Assert.assertEquals("/pat/ben", @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeChildrenChanged, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
for (int i = 0; i < 10; i++)
{
@event = watcher.events.poll(10 * 1000);
string name = children[i];
Assert.assertEquals("/pat/ben/" + 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("/pat/ben/" + name, @event.getPath());
Assert.assertEquals(Watcher.Event.EventType.NodeDeleted, @event.get_Type());
Assert.assertEquals(Watcher.Event.KeeperState.SyncConnected, @event.getState());
}
await zk.createAsync("/good\u0040path", "".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
await zk.createAsync("/duplicate", "".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
try {
await zk.createAsync("/duplicate", "".UTF8getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
Assert.fail("duplicate create allowed");
}
catch (KeeperException.NodeExistsException) {
// OK, expected that
}
}
/// <summary>
/// 设置服务订阅者。
/// </summary>
/// <param name="routes">服务订阅者集合。</param>
/// <returns>一个任务。</returns>
protected override async Task SetSubscribersAsync(IEnumerable <ServiceSubscriberDescriptor> subscribers)
{
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("准备添加服务订阅者。");
}
await CreateSubdirectory(_configInfo.SubscriberPath);
var path = _configInfo.SubscriberPath;
if (!path.EndsWith("/"))
{
path += "/";
}
subscribers = subscribers.ToArray();
if (_subscribers != null)
{
var oldSubscriberIds = _subscribers.Select(i => i.ServiceDescriptor.Id).ToArray();
var newSubscriberIds = subscribers.Select(i => i.ServiceDescriptor.Id).ToArray();
var deletedSubscriberIds = oldSubscriberIds.Except(newSubscriberIds).ToArray();
foreach (var deletedSubscriberId in deletedSubscriberIds)
{
var nodePath = $"{path}{deletedSubscriberId}";
await _zooKeeper.deleteAsync(nodePath);
}
}
foreach (var serviceSubscriber in subscribers)
{
var nodePath = $"{path}{serviceSubscriber.ServiceDescriptor.Id}";
var nodeData = _serializer.Serialize(serviceSubscriber);
if (await _zooKeeper.existsAsync(nodePath) == null)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"节点：{nodePath}不存在将进行创建。");
}
await _zooKeeper.createAsync(nodePath, nodeData, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
else
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"将更新节点：{nodePath}的数据。");
}
var onlineData = (await _zooKeeper.getDataAsync(nodePath)).Data;
if (!DataEquals(nodeData, onlineData))
{
await _zooKeeper.setDataAsync(nodePath, nodeData);
}
}
}
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation("服务订阅者添加成功。");
}
}
/// <summary>
/// 更新指定路径对应的值
/// </summary>
/// <param name="path"></param>
/// <param name="value"></param>
/// <returns></returns>
public Stat Update(string path, string value)
{
var data = Encoding.UTF8.GetBytes(value);
return(_zk.setDataAsync(path, data).ConfigureAwait(false).GetAwaiter().GetResult());
}
static void Sqmple()
{
//Zookeeper连接字符串，采用host:port格式，多个地址之间使用逗号（,）隔开
string connectionString = "127.0.0.1:2181";
//会话超时时间,单位毫秒
int sessionTimeOut = 10000;
//异步监听
var watcher = new MyWatcher("ConnectWatcher");
//连接
ZooKeeper zooKeeper = new ZooKeeper(connectionString, sessionTimeOut, watcher);
Thread.Sleep(1000);//停一秒，等待连接完成
while (zooKeeper.getState() == ZooKeeper.States.CONNECTING)
{
Console.WriteLine("等待连接完成...");
Thread.Sleep(1000);
}
var state = zooKeeper.getState();
if (state != ZooKeeper.States.CONNECTED && state != ZooKeeper.States.CONNECTEDREADONLY)
{
Console.WriteLine("连接失败：" + state);
Console.ReadKey();
return;
}
//创建znode节点
{
var data = Encoding.UTF8.GetBytes("hello world");
List <ACL> acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;//创建节点时的acl权限，也可以使用下面的自定义权限
//List<ACL> acl = new List<ACL>() {
// new ACL((int)ZooDefs.Perms.READ, new Id("ip", "127.0.0.1")),
// new ACL((int)(ZooDefs.Perms.READ | ZooDefs.Perms.WRITE), new Id("auth", "id:pass"))
//};
CreateMode createMode = CreateMode.PERSISTENT;
zooKeeper.createAsync("/mynode", data, acl, createMode).Wait();
Console.WriteLine("完成创建节点");
}
//节点是否存在
{
var exists = zooKeeper.existsAsync("/mynode", new MyWatcher("ExistsWatcher")).GetAwaiter().GetResult();
Console.WriteLine("节点是否存在：" + exists);
}
//获取节点数据
{
var dataResult = zooKeeper.getDataAsync("/mynode", new MyWatcher("GetWatcher")).GetAwaiter().GetResult();
var value = Encoding.UTF8.GetString(dataResult.Data);
Console.WriteLine("完成读取节点：" + value);
}
//设置节点数据
{
var data = Encoding.UTF8.GetBytes("hello world again");
zooKeeper.setDataAsync("/mynode", data);
Console.WriteLine("设置节点数据");
}
//重新获取节点数据
{
var dataResult = zooKeeper.getDataAsync("/mynode", new MyWatcher("GetWatcher")).GetAwaiter().GetResult();
var value = Encoding.UTF8.GetString(dataResult.Data);
Console.WriteLine("重新获取节点数据：" + value);
}
//移除节点
{
zooKeeper.deleteAsync("/mynode").Wait();
Console.WriteLine("移除节点");
}
Console.WriteLine("完成");
Console.ReadKey();
}