private int getNextDomainId() throws KeeperException, InterruptedException { final String domainIdCounterPath = ZkPath.append(domainsRoot, KEY_DOMAIN_ID_COUNTER); if (zk.exists(domainIdCounterPath, false) == null) { zk.create(domainIdCounterPath, Integer.toString(1).getBytes()); return 1; } while (true) { final Stat stat = new Stat(); final byte[] data = zk.getData(domainIdCounterPath, false, stat); int lastVersionNumber = Integer.parseInt(new String(data)); try { lastVersionNumber++; zk.setData(domainIdCounterPath, Integer.toString(lastVersionNumber).getBytes(), stat.getVersion()); return lastVersionNumber; } catch (KeeperException.BadVersionException e) { if (LOG.isDebugEnabled()) { LOG.debug("Tried to set the domain id counter to " + lastVersionNumber + " but was preempted by another writer. Retrying."); } } } }
public void ensureCreated(String path, byte[] value, CreateMode createMode) throws InterruptedException, KeeperException { if (!path.isEmpty() && exists(path, false) == null) { ensureCreated(new File(path).getParent(), null, createMode); create(path, value, DEFAULT_ACL, createMode); NodeCreationBarrier.block(ZooKeeperPlus.this, path); } }
public void create(String path, byte[] data, CreateMode createMode) throws KeeperException, InterruptedException { create(path, data, DEFAULT_ACL, createMode); }
@Override public boolean isRingGroupConductorOnline() throws IOException { try { return zk.exists(ringGroupConductorOnlinePath, false) != null; } catch (Exception e) { throw new IOException(e); } }
public static ZkPartitionProperties create(ZooKeeperPlus zk, String partsRoot, int partNum, long numBytes, long numRecords) throws KeeperException, InterruptedException { String partPath = ZkPath.append(partsRoot, nodeName(partNum)); // if the node already exists, then don't try to create a new one if (zk.exists(partPath, false) == null) { zk.create(partPath, null); zk.createLong(ZkPath.append(partPath, "num_bytes"), numBytes); zk.createLong(ZkPath.append(partPath, "num_records"), numRecords); zk.create(ZkPath.append(partPath, DotComplete.NODE_NAME), null); } return new ZkPartitionProperties(zk, partPath); }
String value = args[3]; System.out.println("Removing node value to: " + value + ", node: " + argument); zkCli.zk.setString(argument, value); } else if (command.equals("rmr")) { System.out.println("Removing recursively node: " + argument); zkCli.zk.deleteNodeRecursively(argument); } else if (command.equals("null")) { System.out.println("Setting node to null: " + argument); zkCli.zk.setData(argument, null, -1); } else if (command.equals("count")) { System.out.println("Counting the number of descendants in: " + argument); System.out.println("Result: " + count); } else if (command.equals("ls")) { List<String> children = zkCli.zk.getChildren(argument, false); for (String child : children) { System.out.println(ZkPath.append(argument, child));
final AtomicBoolean connected = new AtomicBoolean(false); zk = new ZooKeeperPlus("127.0.0.1:" + zkClientPort, 1000000, new Watcher() { @Override public void process(WatchedEvent event) { fail("timed out waiting for the zk client connection to come online!"); LOG.debug("session timeout: " + zk.getSessionTimeout()); zk.deleteNodeRecursively(zkRoot); WaitUntil.orDie(() -> { try { return zk.exists(zkRoot, false) == null; } catch (KeeperException | InterruptedException e) { throw new RuntimeException(e);
protected void createNodeRecursively(String path) throws Exception { String[] toks = path.split("/"); String newPath = "/"; for (int i = 0; i < toks.length; i++) { newPath += toks[i]; if (zk.exists(newPath, false) == null) { zk.create(newPath, null, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } if (i != 0) { newPath += "/"; } } }
@Test public void testIt() throws Exception { final ZooKeeperPlus zk = getZk(); final String nodePath = ZkPath.append(getRoot(), "watchedNode"); zk.create(nodePath, "1".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); final WatchedLong wl = new WatchedLong(zk, nodePath); assertEquals(Long.valueOf(1), wl.get()); zk.setData(nodePath, "55".getBytes(), -1); WaitUntil.orDie(() -> Long.valueOf(55).equals(wl.get())); assertEquals(Long.valueOf(55), wl.get()); zk.setData(nodePath, null, -1); WaitUntil.orDie(() -> wl.get() == null); assertNull(wl.get()); final WatchedLong wl2 = new WatchedLong(zk, nodePath); WaitUntil.orDie(() -> null == wl2.get()); assertNull(wl2.get()); wl2.set(22L); WaitUntil.orDie(() -> Long.valueOf(22).equals(wl2.get()) && Long.valueOf(22).equals(wl.get())); assertEquals(Long.valueOf(22), wl2.get()); assertEquals(Long.valueOf(22), wl.get()); } }
public String getString(String path) throws KeeperException, InterruptedException { try { byte[] data = getData(path, false, null); if (data == null) { return null; } return new String(data, "UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } }
public void deleteNodeRecursively(String path) throws InterruptedException, KeeperException { try { delete(path, -1); } catch (KeeperException.NotEmptyException e) { List<String> children = getChildren(path, null); for (String child : children) { deleteNodeRecursively(ZkPath.append(path, child)); } delete(path, -1); } catch (KeeperException.NoNodeException e) { // Silently return if the node has already been deleted. return; } }
@Override public HostCommand nextCommand() throws IOException { try { // get the queue and sort so we have correct ordering List<String> children = zk.getChildren(ZkPath.append(path, COMMAND_QUEUE_PATH), false); Collections.sort(children); // if there are no children, the queue is empty. if (children.size() == 0) { currentCommand.set(null); return null; } // parse out the actual command String headOfQueuePath = ZkPath.append(path, COMMAND_QUEUE_PATH, children.get(0)); HostCommand nextCommand = HostCommand.valueOf(zk.getString(headOfQueuePath)); // set the current command first (modifying the queue will call the queue listeners) currentCommand.set(nextCommand); // delete the head of the queue zk.delete(headOfQueuePath, -1); return nextCommand; } catch (Exception e) { throw new IOException(e); } }
public void ensureCreated(String path, byte[] value) throws InterruptedException, KeeperException { ensureCreated(path, value, DEFAULT_CREATE_MODE); }
@Test public void testIt() throws Exception { final ZooKeeperPlus zk = getZk(); zk.ensureCreated("/", null, CreateMode.PERSISTENT); assertExists("/", zk); zk.ensureCreated("/simple", "1".getBytes(), CreateMode.PERSISTENT); assertExists("/simple", zk); zk.ensureCreated("/simple", "2".getBytes(), CreateMode.PERSISTENT); assertExists("/simple", zk); assertTrue(Arrays.equals(zk.getData("/simple", false, null), "1".getBytes())); zk.ensureCreated("/deeper/file", null, CreateMode.PERSISTENT); assertExists("/deeper/file", zk); assertExists("/deeper", zk); zk.ensureCreated("/simple/even/deeper", "3".getBytes(), CreateMode.PERSISTENT); assertTrue(Arrays.equals(zk.getData("/simple", false, null), "1".getBytes())); }
@Test public void testIt() throws Exception { final ZooKeeperPlus zk = getZk(); final String colRoot = ZkPath.append(getRoot(), "collection"); zk.create(colRoot, null, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); final ElementLoader<String> elementLoader = (zk1, basePath, relPath) -> { try { return new String(zk1.getData(ZkPath.append(basePath, relPath), false, new Stat())); } catch (Exception e) { throw new RuntimeException(e); } }; final WatchedMap<String> c1 = new WatchedMap<>(zk, colRoot, elementLoader); dumpZk(); WaitUntil.orDie(() -> 0 == c1.size()); assertEquals(0, c1.size()); zk.create(ZkPath.append(colRoot, "first"), "data".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); WaitUntil.orDie(() -> 1 == c1.size()); assertEquals(1, c1.size()); }
@Test public void testDeletion() throws Exception { getZk().create(ZkPath.append(getRoot(), "map"), null, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); getZk().create(ZkPath.append(getRoot(), "map/1"), "2".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); final WatchedMap<String> m = new WatchedMap<>(getZk(), ZkPath.append(getRoot(), "map"), new StringElementLoader()); assertEquals(new HashMap<String, String>() {{ put("1", "2"); }}, m); getZk().delete(ZkPath.append(getRoot(), "map/1"), 0); WaitUntil.orDie(() -> Collections.EMPTY_MAP.equals(m)); assertEquals(Collections.EMPTY_MAP, m); } }