@Override public ZkRing load(ZooKeeperPlus zk, String basePath, String relPath) throws KeeperException, InterruptedException { if (relPath.matches("ring-\\d+")) { return new ZkRing(zk, ZkPath.append(basePath, relPath), ZkRingGroup.this, coordinator, dataLocationChangeListener); } return null; } });
public List<String> getChildrenNotHidden(String path, Watcher watcher) throws InterruptedException, KeeperException { return ZkPath.filterOutHiddenPaths(super.getChildren(path, watcher)); }
public ZkPartitionProperties(ZooKeeperPlus zk, String partInfoPath) throws KeeperException, InterruptedException { String filename = ZkPath.getFilename(partInfoPath); String[] tokens = filename.split("-"); this.partNum = Integer.parseInt(tokens[tokens.length - 1]); this.numBytes = zk.getLong(ZkPath.append(partInfoPath, "num_bytes")); this.numRecords = zk.getLong(ZkPath.append(partInfoPath, "num_records")); }
public static boolean isHidden(String path) { return getFilename(path).startsWith("."); }
public static List<String> filterOutHiddenPaths(List<String> paths) { List<String> pathsNonHidden = new ArrayList<String>(paths.size()); for (String path : paths) { if (!ZkPath.isHidden(path)) { pathsNonHidden.add(path); } } return pathsNonHidden; } }
private static int parseRingNum(String ringPath) { Matcher matcher = RING_NUMBER_PATTERN.matcher(ZkPath.getFilename(ringPath)); matcher.matches(); return Integer.parseInt(matcher.group(1)); }
@Override public WatchedThriftNode<ClientMetadata> load(ZooKeeperPlus zk, String basePath, String relPath) throws KeeperException, InterruptedException, IOException { return new WatchedThriftNode<ClientMetadata>(zk, ZkPath.append(basePath, relPath), true, null, null, emptyClientMetadata); } });
public ZkRingGroup(ZooKeeperPlus zk, String ringGroupPath, DomainGroup domainGroup, final Coordinator coordinator) throws InterruptedException, KeeperException { super(ZkPath.getFilename(ringGroupPath)); this.zk = zk; this.ringGroupPath = ringGroupPath; this.domainGroup = domainGroup; this.coordinator = coordinator; if (coordinator == null) { throw new IllegalArgumentException("Cannot initialize a ZkRingGroup with a null Coordinator."); } rings = new WatchedMap<ZkRing>(zk, ringGroupPath, new ElementLoader<ZkRing>() { @Override public ZkRing load(ZooKeeperPlus zk, String basePath, String relPath) throws KeeperException, InterruptedException { if (relPath.matches("ring-\\d+")) { return new ZkRing(zk, ZkPath.append(basePath, relPath), ZkRingGroup.this, coordinator, dataLocationChangeListener); } return null; } }); rings.addListener(new ZkRingGroup.RingsWatchedMapListener()); // Note: clients is lazy loaded in getClients() ringGroupConductorOnlinePath = ZkPath.append(ringGroupPath, RING_GROUP_CONDUCTOR_ONLINE_PATH); ringGroupConductorMode = new WatchedEnum<RingGroupConductorMode>(RingGroupConductorMode.class, zk, ringGroupConductorOnlinePath, false); }
public ZkDomainVersion(ZooKeeperPlus zk, String path, DomainVersionPropertiesSerialization domainVersionPropertiesSerialization, boolean create, DomainVersionMetadata initialMetadata) throws KeeperException, InterruptedException { this.zk = zk; this.path = path; this.domainVersionPropertiesSerialization = domainVersionPropertiesSerialization; this.versionNumber = Integer.parseInt(ZkPath.getFilename(path)); metadata = new WatchedThriftNode<DomainVersionMetadata>(zk, path, true, create ? CreateMode.PERSISTENT : null, initialMetadata, new DomainVersionMetadata()); }
public List<String> getChildrenNotHidden(String path, boolean watch) throws InterruptedException, KeeperException { return ZkPath.filterOutHiddenPaths(super.getChildren(path, watch)); }
@Override public WatchedThriftNode<ConnectedServerMetadata> load(ZooKeeperPlus zk, String basePath, String relPath) throws KeeperException, InterruptedException, IOException { return new WatchedThriftNode<>(zk, ZkPath.append(basePath, relPath), true, null, null, emptyConnectedServerMetadata); } });
public ZkDomain(ZooKeeperPlus zk, String path, boolean create, DomainMetadata initialMetadata) throws KeeperException, InterruptedException { this.zk = zk; this.path = path; this.name = ZkPath.getFilename(path); metadata = new WatchedThriftNode<DomainMetadata>(zk, path, true, create ? CreateMode.PERSISTENT : null, initialMetadata, new DomainMetadata()); if (create) { zk.ensureCreated(ZkPath.append(path, VERSIONS_PATH), null); } this.versions = new WatchedMap<ZkDomainVersion>(zk, ZkPath.append(path, VERSIONS_PATH), new WatchedMap.ElementLoader<ZkDomainVersion>() { @Override public ZkDomainVersion load(ZooKeeperPlus zk, String basePath, String relPath) throws KeeperException, InterruptedException { return new ZkDomainVersion(zk, ZkPath.append(basePath, relPath), getDomainVersionPropertiesSerialization()); } } ); }
@Test public void testGetFilename() { assertEquals("c", ZkPath.getFilename("/a/b/c")); assertEquals("b", ZkPath.getFilename("/a/b/")); }
@Test public void testFilterOutHiddenPaths() { List<String> paths = new ArrayList<String>(); String p1 = "/a/b"; String p2 = "/a/b/c"; String p3 = "/a/b/.c"; String p4 = "/a/..c"; paths.add(p1); paths.add(p2); paths.add(p3); paths.add(p4); List<String> notHiddenPaths = ZkPath.filterOutHiddenPaths(paths); assertEquals(2, notHiddenPaths.size()); assertEquals(true, notHiddenPaths.contains(p1)); assertEquals(true, notHiddenPaths.contains(p2)); assertEquals(false, notHiddenPaths.contains(p3)); assertEquals(false, notHiddenPaths.contains(p4)); } }
@Override public void clearCommandQueue() throws IOException { try { List<String> children = zk.getChildren(ZkPath.append(path, COMMAND_QUEUE_PATH), false); for (String child : children) { zk.delete(ZkPath.append(path, COMMAND_QUEUE_PATH, child), 0); } } catch (Exception e) { throw new IOException(e); } }
public ZkDomainGroup(final ZooKeeperPlus zk, final Coordinator coordinator, final String path, final boolean create, final DomainGroupMetadata initialMetadata) throws InterruptedException, KeeperException, IOException { this.zk = zk; this.coordinator = coordinator; this.path = path; this.name = ZkPath.getFilename(path); this.metadata = new WatchedThriftNode<DomainGroupMetadata>(zk, path, true, create ? CreateMode.PERSISTENT : null, initialMetadata, new DomainGroupMetadata()); this.metadata.addListener(new WatchedNodeListener<DomainGroupMetadata>() { @Override public void onWatchedNodeChange(DomainGroupMetadata value) { synchronized (listeners) { for (DomainGroupListener listener : listeners) { listener.onDomainGroupChange(ZkDomainGroup.this); } } } }); }
@Override public void setWatch() throws KeeperException, InterruptedException { zk.getChildren(ZkPath.append(path, COMMAND_QUEUE_PATH), this); }
@Override public void registerServer(ConnectedServerMetadata metadata) throws IOException { try { new WatchedThriftNode<ConnectedServerMetadata>(zk, ZkPath.append(ringGroupPath, SERVERS_PATH, SERVER_NODE), false, CreateMode.EPHEMERAL_SEQUENTIAL, metadata, emptyConnectedServerMetadata ); }catch(KeeperException e){ throw new IOException(e); }catch(InterruptedException e){ throw new IOException(e); } }
@Override public void registerClient(ClientMetadata client) throws IOException { try { new WatchedThriftNode<ClientMetadata>(zk, ZkPath.append(ringGroupPath, CLIENTS_PATH, CLIENT_NODE), false, CreateMode.EPHEMERAL_SEQUENTIAL, client, emptyClientMetadata); } catch (KeeperException e) { throw new IOException(e); } catch (InterruptedException e) { throw new IOException(e); } }