public CuratorFrameworkImpl(CuratorFrameworkFactory.Builder builder) { IZookeeperFactory localZookeeperFactory = makeZookeeperFactory(builder.GetZookeeperFactory()); this.client = new CuratorZookeeperClient(localZookeeperFactory, builder.GetEnsembleProvider(), builder.GetSessionTimeoutMs(), builder.GetConnectionTimeoutMs(), new WatchedWatcher(this), builder.GetRetryPolicy(), builder.CanBeReadOnly()); listeners = new ListenerContainer <ICuratorListener>(); unhandledErrorListeners = new ListenerContainer <IUnhandledErrorListener>(); backgroundOperations = new DelayQueue <OperationAndData <object> >(); @namespace = new NamespaceImpl(this, builder.GetNamespace()); maxCloseWaitMs = builder.GetMaxCloseWaitMs(); connectionStateManager = new ConnectionStateManager(this, builder.GetEventQueueSize()); compressionProvider = builder.GetCompressionProvider(); aclProvider = builder.GetAclProvider(); state = new AtomicReference <CuratorFrameworkState>(CuratorFrameworkState.LATENT); useContainerParentsIfAvailable = builder.UseContainerParentsIfAvailable(); byte[] builderDefaultData = builder.GetDefaultData(); byte[] destDefaults = new byte[builderDefaultData.Length]; Array.Copy(builderDefaultData, destDefaults, builderDefaultData.Length); defaultData = (builderDefaultData != null) ? destDefaults : new byte[0]; authInfos = buildAuths(builder); failedDeleteManager = new FailedDeleteManager(this); namespaceWatcherMap = new NamespaceWatcherMap(this); namespaceFacadeCache = new NamespaceFacadeCache(this); }
internal String fixForNamespace(String path, bool isSequential) { if (ensurePathNeeded.get()) { try { CuratorZookeeperClient zookeeperClient = client.getZookeeperClient(); RetryLoop.callWithRetry ( zookeeperClient, CallableUtils.FromFunc <object>(() => { ZKPaths.mkdirs(zookeeperClient.getZooKeeper(), ZKPaths.makePath("/", @namespace), true, client.getAclProvider(), true); return(null); }) ); ensurePathNeeded.set(false); } catch (Exception e) { ThreadUtils.checkInterrupted(e); client.logError("Ensure path threw exception", e); } } return(ZKPaths.fixForNamespace(@namespace, path, isSequential)); }
public void testBackgroundConnect() { int CONNECTION_TIMEOUT_MS = 4000; using (CuratorZookeeperClient client = new CuratorZookeeperClient(server.GetConnectionString(), 10000, CONNECTION_TIMEOUT_MS, null, new RetryOneTime(TimeSpan.FromSeconds(1)))) { Assert.False(client.IsConnected()); client.Start(); outer: do { for (int i = 0; i < (CONNECTION_TIMEOUT_MS / 1000); ++i) { if (client.IsConnected()) { goto outer; } Thread.Sleep(CONNECTION_TIMEOUT_MS); } Assert.Fail(); } while (false); } }
public async Task testSimple() { CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, 10000, 10000, null, new RetryOneTime(1)); client.start(); try { client.blockUntilConnectedOrTimedOut(); var path = "/test"; if (await client.getZooKeeper().existsAsync(path, false) != null) { client.getZooKeeper().deleteAsync(path).Wait(); } var pathTaskResult = await client.getZooKeeper().createAsync(path, new byte[] { 1, 2, 3 }, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); Assert.AreEqual(pathTaskResult, "/test"); } finally { client.Dispose(); } }
public void ensure(CuratorZookeeperClient client, string path, bool makeLastNode) { lock (this) { if (!isSet) { RetryLoop.callWithRetry ( client, CallableUtils.FromFunc <object>(() => { ZKPaths.mkdirs(client.getZooKeeper(), path, makeLastNode, _ensurePath.aclProvider, _ensurePath.asContainers()); _ensurePath.helper.Set(doNothingHelper); isSet = true; return(null); }) ); } } }
public void testBasic() { CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, DefaultSessionTimeout, DefaultConnectionTimeout, null, new RetryOneTime(1)); SessionFailRetryLoop retryLoop = client.newSessionFailRetryLoop(SessionFailRetryLoop.Mode.FAIL); retryLoop.start(); try { client.start(); try { while (retryLoop.shouldContinue()) { try { RetryLoop.callWithRetry ( client, CallableUtils.FromFunc <object>(() => { Task <Stat> existsTask = client.getZooKeeper().existsAsync("/foo/bar", false); existsTask.Wait(); Assert.Null(existsTask.Result); KillSession.kill(client.getZooKeeper(), ZkDefaultHosts, DefaultSessionTimeout); client.getZooKeeper(); client.blockUntilConnectedOrTimedOut(); existsTask = client.getZooKeeper().existsAsync("/foo/bar", false); existsTask.Wait(); Assert.Null(existsTask.Result); return(null); } )); } catch (Exception e) { retryLoop.takeException(e); } } Assert.Fail(); } catch (SessionFailRetryLoop.SessionFailedException dummy) { // correct } } finally { retryLoop.Dispose(); CloseableUtils.closeQuietly(client); } }
public void testRetryLoopWithFailure() { CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, DefaultSessionTimeout, DefaultConnectionTimeout, null, new RetryOneTime(1)); client.start(); try { int loopCount = 0; RetryLoop retryLoop = client.newRetryLoop(); while (retryLoop.shouldContinue()) { ++loopCount; switch (loopCount) { case 1: { // retryLoop.takeException(); break; } case 2: { retryLoop.markComplete(); break; } case 3: case 4: { // ignore break; } default: { Assert.Fail(); break; } } } Assert.True(loopCount >= 2); } finally { client.Dispose(); } }
public void testBasic() { IRetryPolicy retryPolicy = new RetryOneTime(1); EnsurePath ensurePath = new EnsurePath("/one/two/three"); CuratorZookeeperClient curator = new CuratorZookeeperClient(new FixedEnsembleProvider(ZkDefaultHosts), DefaultSessionTimeout, DefaultConnectionTimeout, null, retryPolicy); curator.start(); ensurePath.ensure(curator); }
public async Task testRetryLoop() { CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, DefaultSessionTimeout, DefaultConnectionTimeout, null, new RetryOneTime(1)); client.start(); try { int loopCount = 0; RetryLoop retryLoop = client.newRetryLoop(); while (retryLoop.shouldContinue()) { if (++loopCount > 2) { Assert.Fail(); break; } try { var path = "/test"; if (await client.getZooKeeper().existsAsync(path, false) != null) { client.getZooKeeper().deleteAsync(path).Wait(); } client.getZooKeeper().createAsync(path, new byte[] { 1, 2, 3 }, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL) .Wait(); retryLoop.markComplete(); } catch (Exception e) { retryLoop.takeException(e); } } Assert.True(loopCount > 0); } finally { client.Dispose(); } }
public void testFactory() { IZookeeperFactory zookeeperFactory = new SingleInstanceZkFactory(Zookeeper); CuratorZookeeperClient client = new CuratorZookeeperClient(zookeeperFactory, new FixedEnsembleProvider(ZkDefaultHosts), DefaultSessionTimeout, DefaultConnectionTimeout, null, new RetryOneTime(1), false); client.start(); Assert.AreEqual(client.getZooKeeper(), Zookeeper); }
public void testSimple() { using (CuratorZookeeperClient client = new CuratorZookeeperClient(server.GetConnectionString(), 10000, 10000, null, new RetryOneTime(TimeSpan.FromSeconds(1)))) { client.Start(); client.BlockUntilConnectedOrTimedOut(); var stat = client.GetZooKeeper().Exists("/test", false); if (stat != null) { client.GetZooKeeper().Delete("/test", -1); } String path = client.GetZooKeeper().Create("/test", new byte[] { 1, 2, 3 }, Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent); Assert.AreEqual(path, "/test"); } }
protected CuratorFrameworkImpl(CuratorFrameworkImpl parent) { client = parent.client; listeners = parent.listeners; unhandledErrorListeners = parent.unhandledErrorListeners; maxCloseWaitMs = parent.maxCloseWaitMs; backgroundOperations = parent.backgroundOperations; connectionStateManager = parent.connectionStateManager; defaultData = parent.defaultData; failedDeleteManager = parent.failedDeleteManager; compressionProvider = parent.compressionProvider; aclProvider = parent.aclProvider; namespaceFacadeCache = parent.namespaceFacadeCache; @namespace = new NamespaceImpl(this, null); state = parent.state; authInfos = parent.authInfos; _useContainerParentsIfAvailable = parent._useContainerParentsIfAvailable; }
public void TestExpiredSession() { var timing = new Timing(); var latch = new AutoResetEvent(false); var watcher = new CuratorWatcher((e) => { if (e.State == KeeperState.Expired) { latch.Set(); } }); using (var client = new CuratorZookeeperClient(server.GetConnectionString(), timing.session(), timing.connection(), watcher, new RetryOneTime(TimeSpan.FromMilliseconds(2)))) { client.Start(); bool firstTime = true; RetryLoop.CallWithRetry <bool>(client, () => { if (firstTime) { try { var stat = client.GetZooKeeper().Exists("/foo", false); if (stat == null) { client.GetZooKeeper().Create("/foo", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent); } } catch (KeeperException.NodeExistsException ignore) { } KillSession.kill(client.GetZooKeeper(), server.GetConnectionString()); Assert.IsFalse(timing.awaitLatch(latch)); } IZooKeeper zooKeeper = client.GetZooKeeper(); client.BlockUntilConnectedOrTimedOut(); Assert.IsNotNull(zooKeeper.Exists("/foo", false)); return(true); }); } }
public void testReconnect() { using (CuratorZookeeperClient client = new CuratorZookeeperClient(server.GetConnectionString(), 10000, 10000, null, new RetryOneTime(TimeSpan.FromSeconds(1)))) { client.Start(); client.BlockUntilConnectedOrTimedOut(); byte[] writtenData = { 1, 2, 3 }; var stat = client.GetZooKeeper().Exists("/test", false); if (stat == null) { client.GetZooKeeper().Create("/test", writtenData, Ids.OPEN_ACL_UNSAFE, CreateMode.Persistent); } Assert.IsTrue(client.BlockUntilConnectedOrTimedOut()); byte[] readData = client.GetZooKeeper().GetData("/test", false, null); Assert.AreEqual(readData, writtenData); } }
public void testBackgroundConnect() { int CONNECTION_TIMEOUT_MS = 4000; CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, 10000, CONNECTION_TIMEOUT_MS, null, new RetryOneTime(1)); try { Assert.False(client.isConnected()); client.start(); bool outerMustContinue = false; do { for (int i = 0; i < (CONNECTION_TIMEOUT_MS / 1000); ++i) { if (client.isConnected()) { outerMustContinue = true; break; } Thread.Sleep(CONNECTION_TIMEOUT_MS); } if (outerMustContinue) { continue; } Assert.Fail(); } while (false); } finally { client.Dispose(); } }
public void testSimple() { CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, 10000, 10000, null, new RetryOneTime(1)); client.start(); try { client.blockUntilConnectedOrTimedOut(); Task <string> pathTask = client.getZooKeeper().createAsync("/test", new byte[] { 1, 2, 3 }, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); pathTask.Wait(); Assert.AreEqual(pathTask.Result, "/test"); } finally { client.Dispose(); } }
/** * First time, synchronizes and makes sure all nodes in the path are created. Subsequent calls * with this instance are NOPs. * * @param client ZK client * @throws Exception ZK errors */ public void ensure(CuratorZookeeperClient client) { Helper localHelper = helper.Get(); localHelper.ensure(client, path, makeLastNode); }
public void testRetryStatic() { CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, DefaultSessionTimeout, DefaultConnectionTimeout, null, new RetryOneTime(1)); SessionFailRetryLoop retryLoop = client.newSessionFailRetryLoop(SessionFailRetryLoop.Mode.RETRY); retryLoop.start(); try { client.start(); AtomicBoolean secondWasDone = new AtomicBoolean(false); AtomicBoolean firstTime = new AtomicBoolean(true); SessionFailRetryLoop.callWithRetry ( client, SessionFailRetryLoop.Mode.RETRY, CallableUtils.FromFunc <object>(() => { RetryLoop.callWithRetry( client, CallableUtils.FromFunc <object>(() => { Task <Stat> existsTask; if (firstTime.compareAndSet(true, false)) { existsTask = client.getZooKeeper().existsAsync("/foo/bar", false); existsTask.Wait(); Assert.Null(existsTask.Result); KillSession.kill(client.getZooKeeper(), ZkDefaultHosts, DefaultSessionTimeout); client.getZooKeeper(); client.blockUntilConnectedOrTimedOut(); } existsTask = client.getZooKeeper().existsAsync("/foo/bar", false); existsTask.Wait(); Assert.Null(existsTask.Result); return(null); } )); RetryLoop.callWithRetry ( client, CallableUtils.FromFunc <object>(() => { Assert.False(firstTime.get()); Task <Stat> existsTask = client.getZooKeeper().existsAsync("/foo/bar", false); existsTask.Wait(); Assert.Null(existsTask.Result); secondWasDone.set(true); return(null); } )); return(null); } )); Assert.True(secondWasDone.get()); } finally { retryLoop.Dispose(); CloseableUtils.closeQuietly(client); } }
public void ensure(CuratorZookeeperClient client, string path, bool makeLastNode) { }
public void ensure(CuratorZookeeperClient client, string path, bool makeLastNode) { lock (this) { if ( !isSet ) { RetryLoop.callWithRetry ( client, CallableUtils.FromFunc<object>(() => { ZKPaths.mkdirs(client.getZooKeeper(), path, makeLastNode, _ensurePath.aclProvider, _ensurePath.asContainers()); _ensurePath.helper.Set(doNothingHelper); isSet = true; return null; }) ); } } }
public void testExpiredSession() { // WARN: test requires that this must be address of one ZK host, // not a connection string to many nodes Barrier expiresBarrier = new Barrier(2); Watcher watcher = new ExpiredWatcher(expiresBarrier); CuratorZookeeperClient client = new CuratorZookeeperClient(ZkDefaultHosts, DefaultSessionTimeout, DefaultConnectionTimeout, watcher, new RetryOneTime(2)); client.start(); try { AtomicBoolean firstTime = new AtomicBoolean(true); RetryLoop.callWithRetry( client, CallableUtils.FromFunc <object>(() => { if (firstTime.compareAndSet(true, false)) { try { Task <string> createTask = client.getZooKeeper() .createAsync("/foo", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); createTask.Wait(); } catch (AggregateException e) { if (e.InnerException is KeeperException.NodeExistsException) { // ignore } else { throw e; } } KillSession.kill(client.getZooKeeper(), ZkDefaultHosts, DefaultSessionTimeout * 3); Assert.True(expiresBarrier.SignalAndWait(DefaultSessionTimeout)); } ZooKeeper zooKeeper = client.getZooKeeper(); client.blockUntilConnectedOrTimedOut(); Task <Stat> task = zooKeeper.existsAsync("/foo", false); task.Wait(); Stat stat = task.Result; Assert.NotNull(stat); Assert.Greater(stat.getCzxid(), 0); return(null); }) ); } finally { client.Dispose(); } }