public async Task testPing()
{
ZooKeeper zkIdle = await createClient();
ZooKeeper zkWatchCreator = await createClient();
for (int i = 0; i < 10; i++)
{
await zkWatchCreator.createAsync("/" + i, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT);
}
for (int i = 0; i < 10; i++)
{
await zkIdle.existsAsync("/" + i, true);
}
for (int i = 0; i < 10; i++)
{
await Task.Delay(1000);
await zkWatchCreator.deleteAsync("/" + i, -1);
}
// The bug will manifest itself here because zkIdle will expire
await zkIdle.existsAsync("/0", false);
}
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());
}
}
public static async Task <string> CreateNode_(this ZooKeeper client, string path, CreateMode mode, byte[] data = null) => await client.createAsync(path, data, Ids.OPEN_ACL_UNSAFE, mode);
/// <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();
if (_routes != null)
{
var oldRouteIds = _routes.Select(i => i.ServiceDescriptor.Id).ToArray();
var newRouteIds = routes.Select(i => i.ServiceDescriptor.Id).ToArray();
var deletedRouteIds = oldRouteIds.Except(newRouteIds).ToArray();
foreach (var deletedRouteId in deletedRouteIds)
{
var nodePath = $"{path}{deletedRouteId}";
await _zooKeeper.deleteAsync(nodePath);
}
}
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 static string create(this ZooKeeper zk, string path, byte[] data, List <ACL> acl, CreateMode createMode)
{
return(zk.createAsync(path, data, acl, createMode).GetAwaiter().GetResult());
}
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 virtual async Task InitializeAsync()
{
m_rootZK = await createClient();
m_currentRoot = await m_rootZK.createAsync("/", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
}
public Task <string> CreateAsync(string path, byte[] data, List <ACL> acl, CreateMode createMode)
{
return(_zookeeper.createAsync(path, data, acl, createMode));
}
/// <summary>
/// 获取一个Lease
/// </summary>
/// <param name="startMs">开始毫秒数</param>
/// <param name="waitMs">等待毫秒数</param>
/// <returns>Lease节点名称</returns>
private async Task <string> InternalAcquireOneLeaseAsync(long startMs, long waitMs)
{
// 获取剩余等待时间
var remainingTime = GetRemainingWaitMs(startMs, waitMs);
if (remainingTime <= 0)
{
new TimeoutException("等待超时");
}
// 获取分布式锁
await _lock.AcquireAsync(remainingTime);
string leasePath;
var success = false;
try
{
// 创建Lease临时有序节点
leasePath = await _zkClient.createAsync(ZKPaths.MakePath(_leasesPath, LEASE_BASE_NAME), null,
ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
// 节点名称
var leaseNodeName = ZKPaths.GetNodeFromPath(leasePath);
try
{
while (true)
{
var childrenResult = await _zkClient.getChildrenAsync(_leasesPath, _watcher);
// 找不到刚创建的Lease节点
if (!childrenResult.Children.Contains(leaseNodeName))
{
throw new KeeperException.NoNodeException("Sequential path not found - possible session loss");
}
// 成功获取一个Lease
if (childrenResult.Children.Count <= _maxLeases)
{
break;
}
// 剩余等待时间
remainingTime = GetRemainingWaitMs(startMs, waitMs);
if (remainingTime <= 0)
{
throw new TimeoutException("等待超时");
}
// 等待被唤醒
var result = await _signal.WaitAsync(remainingTime);
if (!result)
{
throw new TimeoutException("等待超时");
}
}
success = true;
}
finally
{
if (!success)
{
await DeleteLease(leasePath);
}
}
}
finally
{
await _lock.ReleaseAsync();
}
return(leasePath);
}
public async Task <string> Create(string path, string data, CreateMode mode)
{
return(await RetryUntilConnected(async() => await _zk.createAsync(path, Encoding.UTF8.GetBytes(data), ZooDefs.Ids.OPEN_ACL_UNSAFE, mode)));
}
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));
}
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();
}
private static async Task Main(string[] args)
{
var endpoint = args.Length > 0 ? args[0] : "localhost:2181";
var zk = new ZooKeeper(endpoint, 10000, null);
var acls = new List <ACL> {
new ACL((int)ZooDefs.Perms.ALL, ZooDefs.Ids.ANYONE_ID_UNSAFE),
};
/*
* Create this structure:
*
* /MadariUserData
* /vnets-{guid}
* /mappings/v4ca
* random key-value pair, key is random IP address, value is 64 bytes
*/
if (await zk.existsAsync(RootNodeName) == null)
{
await zk.createAsync(RootNodeName, new byte[0], acls, CreateMode.PERSISTENT);
}
var threadCount = Environment.ProcessorCount;
Action showStatus = () => Task.Run(async() =>
{
while (threadFinished < threadCount)
{
await Task.Delay(1000);
Console.WriteLine($"{DateTime.Now.ToString()} - count={nodeCount}");
}
});
var sw = Stopwatch.StartNew();
var threads = Enumerable.Range(0, threadCount).Select(x => new Thread(CreateVnetThread)).ToArray();
Parallel.ForEach(threads, t => t.Start(endpoint));
showStatus();
SpinWait.SpinUntil(() => threadFinished >= threadCount);
sw.Stop();
var rate = nodeCount / sw.Elapsed.TotalSeconds;
Console.WriteLine($"Creation completed. Total node count = {nodeCount} QPS = {rate}");
zk = new ZooKeeper(endpoint, 10000, null);
var children = (await zk.getChildrenAsync(RootNodeName)).Children;
Console.WriteLine($"Number of VNETs: {children.Count}");
var childrenPerThread = children.Count / threadCount;
threads = Enumerable.Range(0, threadCount).Select(x => new Thread(ReadVnetThread)).ToArray();
threadFinished = 0;
nodeCount = 0;
sw.Restart();
Parallel.ForEach(
Enumerable.Range(0, threadCount),
n => threads[n].Start(
Tuple.Create(
endpoint,
children.Skip(n * childrenPerThread)
.Take(Math.Min(childrenPerThread, children.Count - (n * childrenPerThread)))
.Select(x => string.Join("/", RootNodeName, x)))));
showStatus();
SpinWait.SpinUntil(() => threadFinished >= threadCount);
sw.Stop();
rate = nodeCount / sw.Elapsed.TotalSeconds;
Console.WriteLine($"Read completed. Total node count = {nodeCount} QPS = {rate}");
}
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
}
}
/**
* Make sure all the nodes in the path are created. NOTE: Unlike File.mkdirs(), Zookeeper doesn't distinguish
* between directories and files. So, every node in the path is created. The data for each node is an empty blob
*
* @param zookeeper the client
* @param path path to ensure
* @param makeLastNode if true, all nodes are created. If false, only the parent nodes are created
* @param aclProvider if not null, the ACL provider to use when creating parent nodes
* @param asContainers if true, nodes are created as {@link CreateMode#CONTAINER}
* @throws InterruptedException thread interruption
* @throws org.apache.zookeeper.KeeperException Zookeeper errors
*/
public static async void mkdirs(ZooKeeper zookeeper,
String path,
bool makeLastNode,
IInternalACLProvider aclProvider,
bool asContainers)
{
PathUtils.validatePath(path);
int pos = 1; // skip first slash, root is guaranteed to exist
do
{
pos = path.IndexOf(PATH_SEPARATOR, pos + 1);
if ( pos == -1 )
{
if ( makeLastNode )
{
pos = path.Length;
}
else
{
break;
}
}
String subPath = path.Substring(0, pos);
if ( await zookeeper.existsAsync(subPath, false) == null )
{
try
{
IList<ACL> acl = null;
if ( aclProvider != null )
{
acl = aclProvider.getAclForPath(subPath);
if ( acl == null )
{
acl = aclProvider.getDefaultAcl();
}
}
if ( acl == null )
{
acl = ZooDefs.Ids.OPEN_ACL_UNSAFE;
}
await zookeeper.createAsync(subPath,
new byte[0],
acl.ToList(),
getCreateMode(asContainers))
.ConfigureAwait(false);
}
catch ( KeeperException.NodeExistsException)
{
// ignore... someone else has created it since we checked
}
}
}
while ( pos<path.Length );
}
public async Task testPathValidation()
{
ZooKeeper zk = await createClient();
await Task.WhenAll(
verifyCreateFails(null, zk),
verifyCreateFails("", zk),
verifyCreateFails("//", zk),
verifyCreateFails("///", zk),
verifyCreateFails("////", zk),
verifyCreateFails("/.", zk),
verifyCreateFails("/..", zk),
verifyCreateFails("/./", zk),
verifyCreateFails("/../", zk),
verifyCreateFails("/foo/./", zk),
verifyCreateFails("/foo/../", zk),
verifyCreateFails("/foo/.", zk),
verifyCreateFails("/foo/..", zk),
verifyCreateFails("/./.", zk),
verifyCreateFails("/../..", zk),
verifyCreateFails("/\u0001foo", zk),
verifyCreateFails("/foo/bar/", zk),
verifyCreateFails("/foo//bar", zk),
verifyCreateFails("/foo/bar//", zk),
verifyCreateFails("foo", zk),
verifyCreateFails("a", zk));
await zk.createAsync("/createseqpar", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
// next two steps - related to sequential processing
// 1) verify that empty child name Assert.fails if not sequential
try {
await zk.createAsync("/createseqpar/", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
Assert.assertTrue(false);
}
catch (ArgumentException) {
// catch this.
}
// 2) verify that empty child name success if sequential
await zk.createAsync("/createseqpar/", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
await zk.createAsync("/createseqpar/.", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
await zk.createAsync("/createseqpar/..", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
try {
await zk.createAsync("/createseqpar//", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
Assert.assertTrue(false);
}
catch (ArgumentException) {
// catch this.
}
try {
await zk.createAsync("/createseqpar/./", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
Assert.assertTrue(false);
}
catch (ArgumentException) {
// catch this.
}
try {
await zk.createAsync("/createseqpar/../", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
Assert.assertTrue(false);
}
catch (ArgumentException) {
// catch this.
}
}
public string Create(string path, byte[] data, List <ACL> acls, CreateMode createMode)
{
return(ZooKeeper.createAsync(path, data, acls, createMode).Result);
}