Example #1
0
        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();
            }
        }
        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);
            }
        }