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); }