Refine search
private void init(){ client = CuratorFrameworkFactory.newClient(zooKeeperUrl, new RetryForever(1000)); client.start(); treeCache = TreeCache.newBuilder(client, appBaseUrl).setCacheData(true).build(); treeCache.getListenable().addListener(new TreeCacheListener() { @Override public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception { treeCache.start(); } catch (Exception e) { throw new RuntimeException(e);
/** * Adds a listener to the pathChildrenCache, initializes the cache, then starts the cache-management background * thread */ private void buildCache() throws Exception { this.treeCache = new TreeCache(client, rootPath); // create the watcher for future configuration updates treeCache.getListenable().addListener(cacheListener, executor); // it's not blocking, so we use an extra latch 'initializedLatch' to make sure cache fully initialized before use. treeCache.start(); initializedLatch.await(); } }
.build(); try { Stat exists = client.checkExists().forPath(root); if(exists == null) { client.create().creatingParentsIfNeeded().forPath(root); .serializer(serializer) .build(); cache = new TreeCache(client, root); cache.getListenable().addListener((client1, event) -> { updateState(); });
TreeCache requestTreeCache = TreeCache.newBuilder(client, securityPath).setCacheData(true).build(); requestTreeCache.start(); requestTreeCache.getListenable().addListener((client, event) -> { if (TreeCacheEvent.Type.NODE_UPDATED.equals(event.getType()) || TreeCacheEvent.Type.NODE_ADDED.equals(event.getType()) || TreeCacheEvent.Type.NODE_REMOVED.equals(event.getType()) || TreeCacheEvent.Type.INITIALIZED.equals(event.getType())) { requestTreeCache.getCurrentChildren(securityPath).entrySet().stream().forEach(requestEntry -> { String filterName = requestEntry.getKey(); String filterPath = requestEntry.getValue().getPath(); requestTreeCache.getCurrentChildren(filterPath).entrySet().stream().forEach(itemEntry -> { String regex = null; try { TreeCache responseTreeCache = TreeCache.newBuilder(client, responsePath).setCacheData(true).build(); responseTreeCache.start(); responseTreeCache.getListenable().addListener((client, event) -> { if (TreeCacheEvent.Type.NODE_UPDATED.equals(event.getType()) || TreeCacheEvent.Type.NODE_ADDED.equals(event.getType()) || TreeCacheEvent.Type.NODE_REMOVED.equals(event.getType()) || TreeCacheEvent.Type.INITIALIZED.equals(event.getType())) { responseTreeCache.getCurrentChildren(responsePath).entrySet().stream().forEach(entry -> { String filterName = entry.getKey(); BasicConfig config = (BasicConfig) JsonUtil.fromJson(new String(entry.getValue().getData()), BasicConfig.class); TreeCache upstreamTreeCache = TreeCache.newBuilder(client, upstreamPath).setCacheData(true).build(); upstreamTreeCache.start(); upstreamTreeCache.getListenable().addListener((client, event) -> {
private void setListenter(CuratorFramework client,ZooKeeperNodeBoEnum zooKeeperNodeBoEnum)throws Exception { ExecutorService pool = Executors.newCachedThreadPool(); List<String> childrens = client.getChildren().forPath(zooKeeperNodeBoEnum.getRootPath()); List<ZooKeeperNodeInfo> tempNodeList = new ArrayList<>(); for (String node: childrens){ ZooKeeperNodeInfo zooKeeperNodeInfo = new ZooKeeperNodeInfo(); byte[] bytes = client.getData().forPath(zooKeeperNodeBoEnum.getRootPath() + '/' + node); if(bytes != null) { zooKeeperNodeInfo.deserialize(new String(bytes)); rpcClientConnectService.notifyConnect(zooKeeperNodeBoEnum, nodeMap.get(zooKeeperNodeBoEnum)); TreeCache cache = new TreeCache(client, zooKeeperNodeBoEnum.getRootPath()); cache.getListenable().addListener(new TreeCacheListener() { @Override public void childEvent(CuratorFramework client, TreeCacheEvent event) cache.start();
public static void main(String[] args) throws Exception { CuratorFramework client = CreateClientExamples.createSimple("127.0.0.1:2181"); client.getUnhandledErrorListenable().addListener((message, e) -> { System.err.println("error=" + message); e.printStackTrace(); }); client.getConnectionStateListenable().addListener((c, newState) -> { System.out.println("state=" + newState); }); client.start(); TreeCache cache = TreeCache.newBuilder(client, "/").setCacheData(false).build(); cache.getListenable().addListener((c, event) -> { if ( event.getData() != null ) { System.out.println("type=" + event.getType() + " path=" + event.getData().getPath()); } else { System.out.println("type=" + event.getType()); } }); cache.start(); BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); in.readLine(); } }
@Override public void close() throws IOException { if (client == null) { return; } // close all node cache for (Map.Entry<String, NodeCache> entry : nodeCaches.entrySet()) { NodeCache value = entry.getValue(); value.close(); } // close all children cache for (Map.Entry<String, PathChildrenCache> entry : nodeChildrenCache.entrySet()) { PathChildrenCache value = entry.getValue(); value.close(); } // close all tree cache for (Map.Entry<String, TreeCache> entry : nodeTreeCache.entrySet()) { TreeCache value = entry.getValue(); value.close(); } if (client.getState() == CuratorFrameworkState.STARTED) { client.close(); } }
public static void main(String[] args) throws Exception { TestingServer server = new TestingServer(); CuratorFramework client = null; TreeCache cache = null; try { client = CuratorFrameworkFactory.newClient(server.getConnectString(), new ExponentialBackoffRetry(1000, 3)); client.start(); cache = new TreeCache(client, PATH); cache.start(); processCommands(client, cache); } finally { CloseableUtils.closeQuietly(cache); CloseableUtils.closeQuietly(client); CloseableUtils.closeQuietly(server); } }
/** * Create a zookeeper-based namespace service * @param client the curator client * @param cache the treecache * @param filePath the file */ public Namespaces(final CuratorFramework client, final TreeCache cache, final String filePath) { requireNonNull(cache, "TreeCache may not be null!"); this.client = client; this.cache = cache; try { this.client.create().orSetData().forPath(ZNODE_NAMESPACES); this.cache.getListenable().addListener((c, e) -> { final Map<String, ChildData> tree = cache.getCurrentChildren(ZNODE_NAMESPACES); readTree(tree).forEach(data::put); }); init(filePath).forEach(data::put); } catch (final Exception ex) { LOGGER.error("Could not create a zk node cache: {}", ex); throw new RuntimeTrellisException(ex); } }
public void registerListener(TreeCacheListener listener) { cache.getListenable().addListener(listener); }
public void registerForTreeNodeEvents(String path, Consumer<TreeCacheEvent> updater) { TreeCache cache = getOrCreateTreeCache(path); if (client.getState().equals(CuratorFrameworkState.STARTED)) { startTreeCache(cache); } cache .getListenable() .addListener( new TreeCacheListener() { @Override public void childEvent(CuratorFramework client, TreeCacheEvent event) throws Exception { updater.accept(event); } }); }
public void start() { try { cache.getListenable().addListener(this); cache.start(); } catch ( Exception e ) { throw new RuntimeException(e); } }
public void close() { cache.getListenable().removeListener(this); cache.close(); entries.clear(); }
@Override public void remove() { treeCache.getListenable().removeListener(pathChildrenCacheListener); } };
@Override public void evictCacheData(final String cachePath) { TreeCache cache = caches.remove(cachePath + "/"); if (null != cache) { cache.close(); } }
/** * @param key e.g., {service}.configurators, {service}.tagrouters, {group}.dubbo.properties * @return */ @Override public Object getInternalProperty(String key) { ChildData childData = treeCache.getCurrentData(key); if (childData != null) { return new String(childData.getData(), StandardCharsets.UTF_8); } return null; }
/** * Start the discovery service */ public void start() { try { serviceDiscovery.start(); cache.start(); updateState(); } catch (Exception e) { LOG.error(e.getMessage(), e); throw new IllegalStateException("Unable to start", e); } }
public ZkTreeCache(String root) { this.root = root; treeCache = TreeCache.newBuilder(ZkConnection.client, root) /*.setExecutor(ThreadPoolManager.getExecutor())*/ .setCreateParentNodes(true) .build(); try { treeCache.start(); } catch (Exception e) { throw new RuntimeException(e); } }