/** * Creates a new cache. The given watcher is called whenever a watched node changes. * * @param zooKeepers * comma-separated list of ZooKeeper host[:port]s * @param sessionTimeout * ZooKeeper session timeout * @param watcher * watcher object */ public ZooCache(String zooKeepers, int sessionTimeout, Watcher watcher) { this(new ZooReader(zooKeepers, sessionTimeout), watcher); }
private int updateAuthKeys(String path) throws KeeperException, InterruptedException { int keysAdded = 0; for (String child : zk.getChildren(path, this)) { String childPath = path + "/" + child; try { // Get the node data and reset the watcher AuthenticationKey key = deserializeKey(zk.getData(childPath, this, null)); secretManager.addKey(key); keysAdded++; } catch (NoNodeException e) { // The master expired(deleted) the key between when we saw it in getChildren() and when we // went to add it to our secret manager. log.trace("{} was deleted when we tried to access it", childPath); } } return keysAdded; }
protected void updateHostsFromZooKeeper() throws KeeperException, InterruptedException { if (pathExists || zoo.exists(path)) { pathExists = true; updateHosts(path, zoo.getChildren(path, this)); } else { zoo.exists(path, this); } }
Set<TServerInstance> getTServers(Instance instance) throws KeeperException, InterruptedException { Set<TServerInstance> result = new HashSet<>(); ZooReader rdr = new ZooReader(instance.getZooKeepers(), instance.getZooKeepersSessionTimeOut()); String base = ZooUtil.getRoot(instance) + Constants.ZTSERVERS; for (String child : rdr.getChildren(base)) { try { List<String> children = rdr.getChildren(base + "/" + child); if (children.size() > 0) { Collections.sort(children); Stat stat = new Stat(); byte[] data = rdr.getData(base + "/" + child + "/" + children.get(0), stat); if (!"master".equals(new String(data, UTF_8))) { result.add(new TServerInstance(AddressUtil.parseAddress(child, false), stat.getEphemeralOwner())); } } } catch (KeeperException.NoNodeException ex) { // someone beat us too it } } return result; }
@Override public byte[] getData(String zPath, Stat stat) throws KeeperException, InterruptedException { return getData(zPath, false, stat); }
@Override public boolean exists(String zPath) throws KeeperException, InterruptedException { final Retry retry = getRetryFactory().createRetry(); while (true) { try { return getZooKeeper().exists(zPath, false) != null; } catch (KeeperException e) { final Code code = e.code(); if (code == Code.CONNECTIONLOSS || code == Code.OPERATIONTIMEOUT || code == Code.SESSIONEXPIRED) { retryOrThrow(retry, e); } else { throw e; } } retry.waitForNextAttempt(); } }
private static TreeSet<UUID> getInstanceIDs(ZooReader zk, boolean printErrors) { TreeSet<UUID> ts = new TreeSet<>(); try { List<String> children = zk.getChildren(Constants.ZROOT); for (String iid : children) { if (iid.equals("instances")) continue; try { ts.add(UUID.fromString(iid)); } catch (Exception e) { log.error("Exception: ", e); } } } catch (Exception e) { handleException(e, printErrors); } return ts; }
/** * Entry point to seed the local {@link AuthenticationKey} cache from ZooKeeper and set the first * watcher for future updates in ZooKeeper. */ public void updateAuthKeys() throws KeeperException, InterruptedException { // Might cause two watchers on baseNode, but only at startup for each tserver. if (zk.exists(baseNode, this)) { log.info("Added {} existing AuthenticationKeys to local cache from ZooKeeper", updateAuthKeys(baseNode)); } }
/** * Returns a ZooKeeper session. Calls should be made within run of ZooRunnable after caches are * checked. This will be performed at each retry of the run method. Calls to this method should be * made, ideally, after cache checks since other threads may have succeeded when updating the * cache. Doing this will ensure that we don't pay the cost of retrieving a ZooKeeper session on * each retry until we've ensured the caches aren't populated for a given node. * * @return ZooKeeper session. */ private ZooKeeper getZooKeeper() { return zReader.getZooKeeper(); }
@Override public void visit(ZooReader zoo, String path) throws Exception { Stat stat = zoo.getStatus(path); if (stat.getEphemeralOwner() != 0) ephemerals.add(path); } });
protected ZooKeeper getZooKeeper() { return getSession(keepers, timeout, null, null); }
public static String getLocation(Instance instance) throws KeeperException, InterruptedException { ZooReader zr = new ZooReader(instance.getZooKeepers(), 30000); byte[] loc = zr.getData(ZooUtil.getRoot(instance) + Constants.ZMONITOR_HTTP_ADDR, null); return loc == null ? null : new String(loc, UTF_8); } }
@Test public void tserverReplicationServicePortsAreAdvertised() throws Exception { // Wait for the cluster to be up Connector conn = getConnector(); Instance inst = conn.getInstance(); // Wait for a tserver to come up to fulfill this request conn.tableOperations().create("foo"); Scanner s = conn.createScanner("foo", Authorizations.EMPTY); Assert.assertEquals(0, Iterables.size(s)); ZooReader zreader = new ZooReader(inst.getZooKeepers(), inst.getZooKeepersSessionTimeOut()); Set<String> tserverHost = new HashSet<>(); tserverHost.addAll(zreader.getChildren(ZooUtil.getRoot(inst) + Constants.ZTSERVERS)); Set<HostAndPort> replicationServices = new HashSet<>(); for (String tserver : tserverHost) { try { byte[] portData = zreader.getData( ZooUtil.getRoot(inst) + ReplicationConstants.ZOO_TSERVERS + "/" + tserver, null); HostAndPort replAddress = HostAndPort.fromString(new String(portData, UTF_8)); replicationServices.add(replAddress); } catch (Exception e) { log.error("Could not find port for {}", tserver, e); Assert.fail("Did not find replication port advertisement for " + tserver); } } // Each tserver should also have equial replicaiton services running internally Assert.assertEquals("Expected an equal number of replication servicers and tservers", tserverHost.size(), replicationServices.size()); }
private synchronized void updateHosts(String path, List<String> children) { log.debug("Scanning trace hosts in zookeeper: {}", path); try { List<String> hosts = new ArrayList<>(); for (String child : children) { byte[] data = zoo.getData(path + "/" + child, null); hosts.add(new String(data, UTF_8)); } this.hosts.clear(); this.hosts.addAll(hosts); log.debug("Trace hosts: {}", this.hosts); } catch (Exception ex) { log.error("unable to get destination hosts in zookeeper", ex); } } }
@Override public List<String> getChildren(String zPath) throws KeeperException, InterruptedException { final Retry retry = getRetryFactory().createRetry(); while (true) { try { return getZooKeeper().getChildren(zPath, false); } catch (KeeperException e) { final Code code = e.code(); if (code == Code.CONNECTIONLOSS || code == Code.OPERATIONTIMEOUT || code == Code.SESSIONEXPIRED) { retryOrThrow(retry, e); } else { throw e; } } retry.waitForNextAttempt(); } }
protected void updateHostsFromZooKeeper() throws KeeperException, InterruptedException { if (pathExists || zoo.exists(path)) { pathExists = true; updateHosts(path, zoo.getChildren(path, this)); } else { zoo.exists(path, this); } }
private static void recurse(ZooReader zoo, String root, Visitor v) { try { v.visit(zoo, root); for (String child : zoo.getChildren(root)) { recurse(zoo, root + "/" + child, v); } } catch (Exception ex) { throw new RuntimeException(ex); } }
@Override public boolean isPropertySet(Property prop, boolean cacheAndWatch) { if (fixedProps.containsKey(prop.getKey())) { return true; } if (cacheAndWatch) { if (getRaw(prop.getKey()) != null) { return true; } } else { ZooReader zr = context.getZooReaderWriter(); String zPath = propPathPrefix + "/" + prop.getKey(); try { if (zr.exists(zPath)) { return true; } } catch (KeeperException | InterruptedException e) { throw new IllegalStateException(e); } } return parent.isPropertySet(prop, cacheAndWatch); }