case CHILD_REMOVED: final ChildData child = event.getData(); final ZKPaths.PathAndNode childPath = ZKPaths.getPathAndNode(child.getPath()); final byte[] value = finalSubPaths.get(childPath.getNode()); if (value != null) { log.info("Node[%s] dropped, reinstating.", child.getPath()); for (String node : finalSubPaths.keySet()) { String path = ZKPaths.makePath(parentPath, node); log.info("Node[%s] is added to reinstate.", path); pathsToReinstate.add(path); for (String path : thePathsLost) { log.info("Reinstating [%s]", path); final ZKPaths.PathAndNode split = ZKPaths.getPathAndNode(path); createAnnouncement(path, announcements.get(split.getPath()).get(split.getNode()));
public String getTail(String childPaths) { return ZKPaths.getNodeFromPath(childPaths); }
public UsageListing(Exhibitor exhibitor, String startPath, int maxChildren) { if ( startPath.trim().length() == 0 ) { startPath = "/"; } ZKPaths.PathAndNode pathAndNode = ZKPaths.getPathAndNode(startPath); this.exhibitor = exhibitor; this.startPath = ZKPaths.makePath(pathAndNode.getPath(), pathAndNode.getNode()); this.maxChildren = maxChildren; }
final ZKPaths.PathAndNode pathAndNode = ZKPaths.getPathAndNode(path); ConcurrentMap<String, byte[]> subPaths = announcements.get(parentPath); if (curator.checkExists().forPath(parentPath) == null) { buildParentPath = true; announcements.putIfAbsent(parentPath, new ConcurrentHashMap<>()); final ConcurrentMap<String, byte[]> finalSubPaths = announcements.get(parentPath);
public void update(final String path, final byte[] bytes) { synchronized (toAnnounce) { if (!started) { // removeParentsIfCreated is not relevant for updates; use dummy value "false". toUpdate.add(new Announceable(path, bytes, false)); return; } } final ZKPaths.PathAndNode pathAndNode = ZKPaths.getPathAndNode(path); final String parentPath = pathAndNode.getPath(); final String nodePath = pathAndNode.getNode(); ConcurrentMap<String, byte[]> subPaths = announcements.get(parentPath); if (subPaths == null || subPaths.get(nodePath) == null) { throw new ISE("Cannot update a path[%s] that hasn't been announced!", path); } synchronized (toAnnounce) { try { byte[] oldBytes = subPaths.get(nodePath); if (!Arrays.equals(oldBytes, bytes)) { subPaths.put(nodePath, bytes); updateAnnouncement(path, bytes); } } catch (Exception e) { throw Throwables.propagate(e); } } }
/** * Unannounces an announcement created at path. Note that if all announcements get removed, the Announcer * will continue to have ZK watches on paths because clearing them out is a source of ugly race conditions. * <p/> * If you need to completely clear all the state of what is being watched and announced, stop() the Announcer. * * @param path the path to unannounce */ public void unannounce(String path) { log.info("unannouncing [%s]", path); final ZKPaths.PathAndNode pathAndNode = ZKPaths.getPathAndNode(path); final String parentPath = pathAndNode.getPath(); final ConcurrentMap<String, byte[]> subPaths = announcements.get(parentPath); if (subPaths == null || subPaths.remove(pathAndNode.getNode()) == null) { log.error("Path[%s] not announced, cannot unannounce.", path); return; } try { curator.inTransaction().delete().forPath(path).and().commit(); } catch (KeeperException.NoNodeException e) { log.info("node[%s] didn't exist anyway...", path); } catch (Exception e) { throw Throwables.propagate(e); } }
for (PathChildrenCache cache : listeners.values()) { closer.register(cache); for (Map.Entry<String, ConcurrentMap<String, byte[]>> entry : announcements.entrySet()) { String basePath = entry.getKey(); for (String announcementPath : entry.getValue().keySet()) { unannounce(ZKPaths.makePath(basePath, announcementPath)); CuratorTransaction transaction = curator.inTransaction(); for (String parent : parentsIBuilt) { try {
@Provides @Singleton @MinLagDurationValues Map<String, ValueStore<Duration>> provideMinLagDurationValues(@CassandraClusters Collection<String> cassandraClusters, @GlobalFullConsistencyZooKeeper final CuratorFramework curator, final LifeCycleRegistry lifeCycle) { final ConcurrentMap<String, ValueStore<Duration>> valuesByCluster = Maps.newConcurrentMap(); for (String cluster : cassandraClusters) { String zkPath = ZKPaths.makePath("/consistency/min-lag", cluster); ZkValueStore<Duration> holder = new ZkValueStore<>(curator, zkPath, new ZkDurationSerializer()); valuesByCluster.put(cluster, lifeCycle.manage(holder)); } return valuesByCluster; }
loadManagementPeons.put("server1", loadQueuePeon); EasyMock.expect(serverInventoryView.getInventory()).andReturn( ImmutableList.of(druidServer) curator.delete().guaranteed().forPath(ZKPaths.makePath(LOADPATH, dataSegment.getId().toString()));
private void addNewQueueIfNeeded(String newQueuePath) throws Exception { if ( newQueuePath == null ) { newQueuePath = ZKPaths.makePath(queuePath, QUEUE_PREFIX + UUID.randomUUID().toString()); } if ( !queues.containsKey(newQueuePath) ) { T queue = queueAllocator.allocateQueue(client, newQueuePath); if ( queues.putIfAbsent(newQueuePath, queue) == null ) { queue.start(); preferredQueues.add(newQueuePath); } } }
private void doWork() { for ( String path : paths ) { try { List<String> children = client.getChildren().forPath(path); for ( String name : children ) { String thisPath = ZKPaths.makePath(path, name); Stat stat = client.checkExists().forPath(thisPath); if ( (stat != null) && (stat.getNumChildren() == 0) ) { reaper.addPath(thisPath, mode); } } } catch ( Exception e ) { log.error("Could not get children for path: " + path, e); } } } }
private void processChildren(List<String> children, RefreshMode mode) throws Exception { List<String> fullPaths = children.stream().map(c -> ZKPaths.makePath(path, c)).collect(Collectors.toList()); Set<String> removedNodes = new HashSet<>(currentData.keySet()); removedNodes.removeAll(fullPaths); for (String fullPath : removedNodes) { remove(fullPath); } for (String name : children) { String fullPath = ZKPaths.makePath(path, name); if ((mode == RefreshMode.FORCE_GET_DATA_AND_STAT) || !currentData.containsKey(fullPath)) { try { getDataAndStat(fullPath); } catch (KeeperException.NoNodeException ignore) { } } } }
private void applyNewData(String fullPath, int resultCode, Stat stat, byte[] bytes) { if ( resultCode == KeeperException.Code.OK.intValue() ) // otherwise - node must have dropped or something - we should be getting another event { ChildData data = new ChildData(fullPath, stat, bytes); ChildData previousData = currentData.put(fullPath, data); if ( previousData == null ) // i.e. new { offerOperation(new EventOperation(this, new PathChildrenCacheEvent(PathChildrenCacheEvent.Type.CHILD_ADDED, data))); } else if ( previousData.getStat().getVersion() != stat.getVersion() ) { offerOperation(new EventOperation(this, new PathChildrenCacheEvent(PathChildrenCacheEvent.Type.CHILD_UPDATED, data))); } updateInitialSet(ZKPaths.getNodeFromPath(fullPath), data); } }
@Override public void applyMigration() { final long start = System.currentTimeMillis(); try { if (curator.checkExists().forPath(PENDING_TASKS_ROOT) == null) { return; } } catch (Exception e) { throw Throwables.propagate(e); } try { for (String pendingTaskId : curator.getChildren().forPath(PENDING_TASKS_ROOT)) { SingularityPendingTaskId newPendingTaskId = createFrom(pendingTaskId, start); if (!newPendingTaskId.toString().equals(pendingTaskId)) { LOG.info("Migrating {} to {}", pendingTaskId, newPendingTaskId); Optional<String> cmdLineArgs = getCmdLineArgs(pendingTaskId); taskManager.savePendingTask( new SingularityPendingTaskBuilder() .setPendingTaskId(newPendingTaskId) .setCmdLineArgsList(cmdLineArgs.isPresent() ? Optional.of(Collections.singletonList(cmdLineArgs.get())) : Optional.<List<String>> absent()) .build()); curator.delete().forPath(ZKPaths.makePath(PENDING_TASKS_ROOT, pendingTaskId)); } } } catch (Exception e) { throw Throwables.propagate(e); } }
curator.start(); closerRule.closeLater(curator); Assert.assertNotNull(curator.create().forPath("/druid")); Assert.assertTrue(curator.blockUntilConnected(10, TimeUnit.SECONDS)); final Announcer announcer = new Announcer(curator, executorService); final HostAndPortWithScheme node = HostAndPortWithScheme.fromString("localhost"); Assert.assertNotNull(curator.checkExists().forPath(announcePath)); final String nodePath = ZKPaths.makePath(announcePath, StringUtils.format("%s:%s", node.getScheme(), node.getHostText())); Assert.assertNotNull(curator.checkExists().forPath(nodePath)); Assert.assertEquals(Long.BYTES, curator.getData().decompressed().forPath(nodePath).length); Assert.assertNull(curator.checkExists() .forPath(listeningAnnouncerConfig.getAnnouncementPath(listenerKey + "FOO"))); listenerResourceAnnouncer.stop(); listenerResourceAnnouncer.start();
try Stat stat = client.setData().withVersion((int)compareVersion).forPath(ZKPaths.makePath(configPath, CONFIG_NODE_NAME), bytes); newVersion = stat.getVersion(); client.create().creatingParentsIfNeeded().forPath(ZKPaths.makePath(configPath, CONFIG_NODE_NAME), bytes); newVersion = 0;
@Test public void testLeavesBehindTurdlingsThatAlreadyExisted() throws Exception { curator.start(); curator.blockUntilConnected(); Announcer announcer = new Announcer(curator, exec); final byte[] billy = StringUtils.toUtf8("billy"); final String testPath = "/somewhere/test2"; final String parent = ZKPaths.getPathAndNode(testPath).getPath(); curator.create().forPath(parent); final Stat initialStat = curator.checkExists().forPath(parent); announcer.start(); try { Assert.assertEquals(initialStat.getMzxid(), curator.checkExists().forPath(parent).getMzxid()); awaitAnnounce(announcer, testPath, billy, true); Assert.assertEquals(initialStat.getMzxid(), curator.checkExists().forPath(parent).getMzxid()); } finally { announcer.stop(); } Assert.assertEquals(initialStat.getMzxid(), curator.checkExists().forPath(parent).getMzxid()); }
@Test public void testCleansUpItsLittleTurdlings() throws Exception { curator.start(); curator.blockUntilConnected(); Announcer announcer = new Announcer(curator, exec); final byte[] billy = StringUtils.toUtf8("billy"); final String testPath = "/somewhere/test2"; final String parent = ZKPaths.getPathAndNode(testPath).getPath(); announcer.start(); try { Assert.assertNull(curator.checkExists().forPath(parent)); awaitAnnounce(announcer, testPath, billy, true); Assert.assertNotNull(curator.checkExists().forPath(parent)); } finally { announcer.stop(); } Assert.assertNull(curator.checkExists().forPath(parent)); }
@Override protected void run(Bootstrap<EmoConfiguration> bootstrap, Namespace namespace, EmoConfiguration configuration) throws Exception { String hostString = namespace.getString("host"); String serviceName = namespace.getString("service"); CuratorFramework curator = configuration.getZooKeeperConfiguration().newCurator(); curator.start(); HostAndPort host = HostAndPort.fromString(hostString).withDefaultPort(9160); ServiceEndPoint endPoint = new ServiceEndPointBuilder() .withServiceName(serviceName) .withId(host.toString()) .build(); String dir = ZKPaths.makePath("ostrich", endPoint.getServiceName()); String path = ZKPaths.makePath(dir, endPoint.getId()); curator.newNamespaceAwareEnsurePath(dir).ensure(curator.getZookeeperClient()); try { curator.delete().forPath(path); System.out.println("Deleted."); } catch (KeeperException.NoNodeException e) { System.out.println("Not found."); } curator.close(); } }
final String path = ZKPaths.makePath(basePath, currentlyProcessing.getSegmentId().toString()); final byte[] payload = jsonMapper.writeValueAsBytes(currentlyProcessing.getChangeRequest()); curator.create().withMode(CreateMode.EPHEMERAL).forPath(path, payload); if (curator.checkExists().forPath(path) != null) { failAssign(new ISE("%s was never removed! Failing this operation!", path)); ); final Stat stat = curator.checkExists().usingWatcher( (CuratorWatcher) watchedEvent -> { switch (watchedEvent.getType()) { curator.create().withMode(CreateMode.EPHEMERAL).forPath(path, noopPayload);