org.apache.curator.framework.api.CuratorWatcher Java Examples

private void watchWeight(final String application){

		String applicationWeightsKey = ZKUtils.genApplicationWeightsKey(application);
		try{
			zkclient.getData().usingWatcher(new CuratorWatcher() {
				@Override
				public void process(WatchedEvent watchedEvent) throws Exception {
					if(watchedEvent.getType()== Watcher.Event.EventType.NodeDataChanged){
						//拿到权重列表
						doGetWeights(application,true);
					}
				}
			}).inBackground().forPath(applicationWeightsKey);
		}catch(Exception e){
			logger.error("[zookeeper] watch "+applicationWeightsKey,e);
		}
	}
 

/**
 * Return list of changes in zookeeper. in case if {@code changeListener} is provided, sets it to react
 * on changelist changes
 *
 * @param changesListener Listener to set.
 * @return Current list of changes in zookeeper
 * @throws Exception In case if there is error in communicating with zookeeper.
 */
public List<Change> getCurrentChanges(@Nullable final Runnable changesListener) throws Exception {
    final List<String> children;
    if (null == changesListener) {
        children = zk.get().getChildren()
                .forPath(ET_CACHE_PATH);
    } else {
        children = zk.get().getChildren()
                .usingWatcher((CuratorWatcher) (e) -> changesListener.run())
                .forPath(ET_CACHE_PATH);
    }
    final List<Change> changes = new ArrayList<>();
    for (final String child : children) {
        final byte[] data = zk.get().getData().forPath(getPath(child));
        changes.add(new Change(child, new String(data, Charsets.UTF_8), new Date()));
    }
    return changes;
}
 

/**
 * 监听该路径下得子节点
 *
 * @param path     路径
 * @param callback 监听回调
 * @throws Exception
 */
public void watcherChildrenNode(final String path, final WatcherEventCallback callback) throws Exception {

    final List<String> oldChildren = this.getChildren(path);
    logger.debug("oldChildren------{}", oldChildren);
    CuratorWatcher watcher = new CuratorWatcher() {
        @Override
        public void process(WatchedEvent event) throws Exception {
            try {
                WatcherEvent watcherEvent = new WatcherEvent();
                watcherEvent.setState(event.getState());
                watcherEvent.setPath(event.getPath());
                watcherEvent.setEventType(event.getType());
                watcherEvent.setOldChildrenNode(oldChildren);

                callback.watchedEvent(watcherEvent);
                if (checkExists(path)) {
                    watcherChildrenNode(path, callback);
                }
            } catch (Exception e) {
                logger.debug("{}", e.getMessage());
            }
        }
    };
    curator.getChildren().usingWatcher(watcher).forPath(path);
}
 

/**
	 * 监控限流配置
     */
	private void watchLimit(){
		try{
			zkclient.getData().usingWatcher(new CuratorWatcher() {
				@Override
				public void process(WatchedEvent watchedEvent) throws Exception {
					watchLimit();
					fetchLimit();
				}
			}).inBackground().forPath(ZKUtils.genLimitKey(this.getApplication()));
		}catch(Exception e){
			if(e instanceof KeeperException.NoNodeException){
//				limitCache.addOrUpdate(new ArrayList<LimitDefine>());
			}else{
				logger.error("fetch application request limit config failed",e);
			}
		}
	}
 

@VisibleForTesting
protected SharedValue(WatcherRemoveCuratorFramework client, String path, byte[] seedValue, CuratorWatcher watcher)
{
    this.client = client;
    this.path = PathUtils.validatePath(path);
    this.seedValue = Arrays.copyOf(seedValue, seedValue.length);
    // inject watcher for testing
    this.watcher = watcher;
    currentValue = new AtomicReference<VersionedValue<byte[]>>(new VersionedValue<byte[]>(UNINITIALIZED_VERSION, Arrays.copyOf(seedValue, seedValue.length)));
}
 

@Override
public AsyncPathable<AsyncStage<Void>> removing(CuratorWatcher watcher, Watcher.WatcherType watcherType)
{
    this.curatorWatcher = Objects.requireNonNull(watcher, "watcher cannot be null");
    this.watcherType = Objects.requireNonNull(watcherType, "watcherType cannot be null");
    this.watcher = null;
    return this;
}
 

@Override
public AsyncPathable<AsyncStage<Void>> removing(CuratorWatcher watcher, Watcher.WatcherType watcherType, Set<RemoveWatcherOption> options)
{
    this.curatorWatcher = Objects.requireNonNull(watcher, "watcher cannot be null");
    this.options = Objects.requireNonNull(options, "options cannot be null");
    this.watcherType = Objects.requireNonNull(watcherType, "watcherType cannot be null");
    this.watcher = null;
    return this;
}
 

@Override
public AsyncPathable<AsyncStage<Void>> removing(CuratorWatcher watcher, Set<RemoveWatcherOption> options)
{
    this.curatorWatcher = Objects.requireNonNull(watcher, "watcher cannot be null");
    this.options = Objects.requireNonNull(options, "options cannot be null");
    this.watcher = null;
    return this;
}
 

@Override
public AsyncPathable<AsyncStage<Void>> removing(CuratorWatcher watcher)
{
    this.curatorWatcher = Objects.requireNonNull(watcher, "watcher cannot be null");
    this.watcher = null;
    return this;
}
 

@Test
public void testRemoveCuratorWatch() throws Exception
{       
    Timing timing = new Timing();
    CuratorFrameworkImpl client = (CuratorFrameworkImpl)CuratorFrameworkFactory.builder().
            connectString(server.getConnectString()).
            retryPolicy(new RetryOneTime(1)).
            build();
    try
    {
        client.start();
        
        final CountDownLatch removedLatch = new CountDownLatch(1);
        
        final String path = "/";            
        CuratorWatcher watcher = new CuratorWatcher()
        {
            
            @Override
            public void process(WatchedEvent event) throws Exception
            {
                if(event.getPath().equals(path) && event.getType() == EventType.DataWatchRemoved) {
                    removedLatch.countDown();
                }
            }
        };
                    
        client.checkExists().usingWatcher(watcher).forPath(path);

        client.watches().remove(watcher).forPath(path);

        Assert.assertTrue(timing.awaitLatch(removedLatch), "Timed out waiting for watch removal");
    }
    finally
    {
        CloseableUtils.closeQuietly(client);
    }
}
 

NamespaceWatcher(CuratorFrameworkImpl client, CuratorWatcher curatorWatcher, String unfixedPath)
{
    this.client = client;
    this.actualWatcher = null;
    this.curatorWatcher = curatorWatcher;
    this.unfixedPath = Preconditions.checkNotNull(unfixedPath, "unfixedPath cannot be null");
}
 

public Watching(CuratorFrameworkImpl client, CuratorWatcher watcher)
{
    this.client = client;
    this.watcher = null;
    this.curatorWatcher = watcher;
    this.watched = false;
}
 

private static void process() throws Exception {

        CuratorFramework client = CuratorFrameworkFactory.newClient("127.0.0.1:2181",
                new RetryNTimes(10, 5000));
        client.start();

        // monitor child node
        List<String> children = client.getChildren().usingWatcher(new CuratorWatcher() {
            @Override
            public void process(WatchedEvent event) throws Exception {
                logger.info("monitor: {}", event);
            }
        }).forPath("/");
        logger.info("children: {}", children);

        addListener(client);

        // create node
        String result = client.create().withMode(CreateMode.PERSISTENT).withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
                .forPath("/test", "Data".getBytes());
        logger.info("result: {}", result);

        // set node
        client.setData().forPath("/test", "111".getBytes());
        client.setData().forPath("/test", "222".getBytes());

        // delete node
        logger.info("path: {}", client.checkExists().forPath("/test"));
        client.delete().withVersion(-1).forPath("/test");
        logger.info("path: {}", client.checkExists().forPath("/test"));

        client.close();
        logger.info("client close");
    }
 

public static List<String> getChilds(CuratorFramework client, String path, CuratorWatcher watcher) {
    try {
        if (watcher != null) {
            return (List) ((BackgroundPathable) client.getChildren().usingWatcher(watcher)).forPath(path);
        }
        return (List) client.getChildren().forPath(path);
    } catch (Exception e) {
        LOGGER.error("ZKUtil-->>getChilds(CuratorFramework client, String path, CuratorWatcher watcher) error,", e);
    }
    return null;
}
 

public static String getData(CuratorFramework client, String path, CuratorWatcher watcher) {
    try {
        if (client.checkExists().forPath(path) == null) {
            return null;
        }
        if (watcher != null) {
            return List2StringUtil
                    .toString((byte[]) ((BackgroundPathable) client.getData().usingWatcher(watcher)).forPath(path));
        }
        return List2StringUtil.toString((byte[]) client.getData().forPath(path));
    } catch (Exception e) {
        LOGGER.error("ZKUtil-->>getData(CuratorFramework client, String path, CuratorWatcher watcher)  error ", e);
    }
    return null;
}
 

public static boolean exists(CuratorFramework client, String path, CuratorWatcher watcher) {
    try {
        if (watcher != null) {
            return ((BackgroundPathable) client.checkExists().usingWatcher(watcher)).forPath(path) != null;
        }
        return client.checkExists().forPath(path) != null;
    } catch (Exception e) {
        LOGGER.error("ZKUtil-->>exists(CuratorFramework client, String path, CuratorWatcher watcher) error, ", e);
    }
    return false;
}
 

@PostConstruct
private void watchDefaultStorage() {
    try {
        curator.getData().usingWatcher((CuratorWatcher) event -> {
            final byte[] defaultStorageId = curator.getData().forPath(ZK_TIMELINES_DEFAULT_STORAGE);
            if (defaultStorageId != null) {
                final Storage storage = getStorage(new String(defaultStorageId));
                defaultStorage.setStorage(storage);
            }
            watchDefaultStorage();
        }).forPath(ZK_TIMELINES_DEFAULT_STORAGE);
    } catch (final Exception e) {
        LOG.warn("Error while creating watcher for default storage updates {}", e.getMessage(), e);
    }
}
 

public void start() throws Exception {
    CuratorFramework curatorFramework = serviceRegistry.getService().getCuratorFramework();
    if(!disableWatchers) {
        curatorFramework.getChildren()
                .usingWatcher(new CuratorWatcher() {
                    @Override
                    public void process(WatchedEvent event) throws Exception {
                        switch (event.getType()) {

                            case NodeChildrenChanged: {
                                checkForUpdate();
                                break;
                            }
                            case None:
                            case NodeCreated:
                            case NodeDeleted:
                            case NodeDataChanged:
                            default:
                                break;
                        }
                    }
                })
                .forPath(PathBuilder.path(serviceRegistry.getService())); //Start watcher on service node
    }
    updateRegistry();
    logger.info("Started polling zookeeper for changes for service:{}", serviceRegistry.getService().getServiceName());
}
 

@Override
public BackgroundPathable<List<String>> usingWatcher(CuratorWatcher watcher)
{
    watching = new Watching(client, watcher);
    return this;
}
 

public void removeTargetChildListener(String path, CuratorWatcher listener) {
  ((CuratorWatcherImpl) listener).unwatch();
}
 

@Override
public CuratorWatcher createTargetChildListener(String path, ChildListener listener) {
    return new CuratorWatcherImpl(listener);
}
 

@Test
public void testNoOrphanedNodes() throws Exception
{
    final Timing timing = new Timing();
    final ExecutorService executor = Executors.newFixedThreadPool(1);
    CuratorFramework client = CuratorFrameworkFactory.newClient(server.getConnectString(), timing.session(), timing.connection(), new RetryOneTime(1));
    client.start();
    try
    {
        final InterProcessSemaphoreV2 semaphore = new InterProcessSemaphoreV2(client, "/test", 1);
        Lease lease = semaphore.acquire(timing.forWaiting().seconds(), TimeUnit.SECONDS);
        Assert.assertNotNull(lease);
        final List<String> childNodes = client.getChildren().forPath("/test/leases");
        Assert.assertEquals(childNodes.size(), 1);

        final CountDownLatch nodeCreatedLatch = new CountDownLatch(1);
        client.getChildren().usingWatcher(new CuratorWatcher()
        {
            @Override
            public void process(WatchedEvent event) throws Exception
            {
                if ( event.getType() == Watcher.Event.EventType.NodeCreated )
                {
                    nodeCreatedLatch.countDown();
                }
            }
        }).forPath("/test/leases");

        final Future<Lease> leaseFuture = executor.submit(new Callable<Lease>()
        {
            @Override
            public Lease call() throws Exception
            {
                return semaphore.acquire(timing.forWaiting().multiple(2).seconds(), TimeUnit.SECONDS);
            }
        });

        // wait for second lease to create its node
        timing.awaitLatch(nodeCreatedLatch);
        String newNode = null;
        for ( String c : client.getChildren().forPath("/test/leases") )
        {
            if ( !childNodes.contains(c) )
            {
                newNode = c;
            }
        }
        Assert.assertNotNull(newNode);

        // delete the ephemeral node to trigger a retry
        client.delete().forPath("/test/leases/" + newNode);

        // release first lease so second one can be acquired
        lease.close();
        lease = leaseFuture.get();
        Assert.assertNotNull(lease);
        lease.close();
        Assert.assertEquals(client.getChildren().forPath("/test/leases").size(), 0);

        // no more lease exist. must be possible to acquire a new one
        Assert.assertNotNull(semaphore.acquire(timing.forWaiting().seconds(), TimeUnit.SECONDS));
    }
    finally
    {
        executor.shutdownNow();
        TestCleanState.closeAndTestClean(client);
    }
}
 

@Override
public void removeTargetChildListener(String path, CuratorWatcher listener) {
    ((CuratorWatcherImpl) listener).unwatch();
}
 

@Override
public AsyncPathable<AsyncStage<Void>> usingWatcher(CuratorWatcher watcher)
{
    watching = new Watching(client, watcher);
    return this;
}
 

@Test
public void testNoOrphanedNodes() throws Exception
{
    final Timing timing = new Timing();
    final ExecutorService executor = Executors.newFixedThreadPool(1);
    CuratorFramework client = CuratorFrameworkFactory.newClient(server.getConnectString(), timing.session(), timing.connection(), new RetryOneTime(1));
    client.start();
    try
    {
        final InterProcessSemaphoreV2 semaphore = new InterProcessSemaphoreV2(client, "/test", 1);
        Lease lease = semaphore.acquire(timing.forWaiting().seconds(), TimeUnit.SECONDS);
        Assert.assertNotNull(lease);
        final List<String> childNodes = client.getChildren().forPath("/test/leases");
        Assert.assertEquals(childNodes.size(), 1);

        final CountDownLatch nodeCreatedLatch = new CountDownLatch(1);
        client.getChildren().usingWatcher(new CuratorWatcher()
        {
            @Override
            public void process(WatchedEvent event) throws Exception
            {
                if ( event.getType() == Watcher.Event.EventType.NodeCreated )
                {
                    nodeCreatedLatch.countDown();
                }
            }
        }).forPath("/test/leases");

        final Future<Lease> leaseFuture = executor.submit(new Callable<Lease>()
        {
            @Override
            public Lease call() throws Exception
            {
                return semaphore.acquire(timing.forWaiting().multiple(2).seconds(), TimeUnit.SECONDS);
            }
        });

        // wait for second lease to create its node
        timing.awaitLatch(nodeCreatedLatch);
        String newNode = null;
        for ( String c : client.getChildren().forPath("/test/leases") )
        {
            if ( !childNodes.contains(c) )
            {
                newNode = c;
            }
        }
        Assert.assertNotNull(newNode);

        // delete the ephemeral node to trigger a retry
        client.delete().forPath("/test/leases/" + newNode);

        // release first lease so second one can be acquired
        lease.close();
        lease = leaseFuture.get();
        Assert.assertNotNull(lease);
        lease.close();
        Assert.assertEquals(client.getChildren().forPath("/test/leases").size(), 0);

        // no more lease exist. must be possible to acquire a new one
        Assert.assertNotNull(semaphore.acquire(timing.forWaiting().seconds(), TimeUnit.SECONDS));
    }
    finally
    {
        client.close();
        executor.shutdownNow();
    }
}
 

NamespaceWatcher    getNamespaceWatcher(CuratorWatcher watcher)
{
    return get(watcher, new NamespaceWatcher(client, watcher));
}
 

Watching(CuratorFrameworkImpl client, CuratorWatcher watcher)
{
    this.watcher = (watcher != null) ? client.getNamespaceWatcherMap().getNamespaceWatcher(watcher) : null;
    this.watched = false;
}
 

NamespaceWatcher(CuratorFrameworkImpl client, CuratorWatcher curatorWatcher)
{
    this.client = client;
    this.actualWatcher = null;
    this.curatorWatcher = curatorWatcher;
}
 

@Override
public BackgroundPathable<List<String>> usingWatcher(CuratorWatcher watcher)
{
    watching = new Watching(client, watcher);
    return this;
}
 

public WatchesBuilderImpl(CuratorFrameworkImpl client, Watcher watcher, CuratorWatcher curatorWatcher, WatcherType watcherType, boolean guaranteed, boolean local, boolean quietly, Backgrounding backgrounding)
{
    super(client, watcher, curatorWatcher, watcherType, guaranteed, local, quietly, backgrounding);
}