@Override public ZooKeeperWatcher getZooKeeperWatcher() throws ZooKeeperConnectionException { if (zooKeeper == null) { try { this.zooKeeper = new ZooKeeperWatcher(conf, "fconnection", this); } catch (ZooKeeperConnectionException zce) { throw zce; } catch (IOException e) { throw new ZooKeeperConnectionException("An error is preventing" + " Wasp from connecting to ZooKeeper", e); } } return zooKeeper; }
void internalClose() { super.close(); } }
/** * Construct a master address listener with the specified * <code>zookeeper</code> reference. * <p> * This constructor does not trigger any actions, you must call methods * explicitly. Normally you will just want to execute {@link #start()} to * begin tracking of the master address. * * @param watcher * zk reference and watcher * @param abortable * abortable in case of fatal error */ public MasterAddressTracker(ZooKeeperWatcher watcher, Abortable abortable) { super(watcher, watcher.getMasterAddressZNode(), abortable); }
/** * Delete the specified node with the specified version. Sets no watches. * Throws all exceptions. */ public static boolean deleteNode(ZooKeeperWatcher zkw, String node, int version) throws KeeperException { try { zkw.getRecoverableZooKeeper().delete(node, version); return true; } catch (KeeperException.BadVersionException bve) { return false; } catch (InterruptedException ie) { zkw.interruptedException(ie); return false; } }
private static byte[] getDataInternal(ZooKeeperWatcher zkw, String znode, Stat stat, boolean watcherSet) throws KeeperException { try { byte[] data = zkw.getRecoverableZooKeeper().getData(znode, zkw, stat); logRetrievedMsg(zkw, znode, data, watcherSet); return data; } catch (KeeperException.NoNodeException e) { // This log can get pretty annoying when we cycle on 100ms waits. // Enable trace if you really want to see it. LOG.trace(zkw.prefix("Unable to get data of znode " + znode + " " + "because node does not exist (not an error)")); return null; } catch (KeeperException e) { LOG.warn(zkw.prefix("Unable to get data of znode " + znode), e); zkw.keeperException(e); return null; } catch (InterruptedException e) { LOG.warn(zkw.prefix("Unable to get data of znode " + znode), e); zkw.interruptedException(e); return null; } }
private static ArrayList<ACL> createACL(ZooKeeperWatcher zkw, String node) { if (isSecureZooKeeper(zkw.getConfiguration())) { // Certain znodes are accessed directly by the client, // so they must be readable by non-authenticated clients if ((node.equals(zkw.baseZNode) == true) || (node.equals(zkw.getMasterAddressZNode()) == true) || (node.equals(zkw.clusterIdZNode) == true) || (node.equals(zkw.fsZNode) == true) || (node.equals(zkw.backupMasterAddressesZNode) == true) || (node.startsWith(zkw.tableZNode) == true)) { return ZooKeeperWatcher.CREATOR_ALL_AND_WORLD_READABLE; } return Ids.CREATOR_ALL_ACL; } else { return Ids.OPEN_ACL_UNSAFE; } }
ZooKeeperWatcher zk = new ZooKeeperWatcher(TEST_UTIL.getConfiguration(), "testActiveMasterManagerFromZK", null, true); try { ZKUtil.deleteNode(zk, zk.getMasterAddressZNode()); ZKUtil.deleteNode(zk, zk.clusterStateZNode); } catch (KeeperException.NoNodeException nne) { zk.getMasterAddressZNode()); zk.registerListener(listener); ZKUtil.deleteNode(zk, zk.getMasterAddressZNode()); ZKUtil.deleteNode(zk, zk.getMasterAddressZNode());
EventType expectedState, int expectedVersion) throws KeeperException, KeeperException.NoNodeException { LOG.debug(zkw.prefix("Deleting existing unassigned " + "node for " + entityGroupName + " that is in expected state " + expectedState)); String node = getNodeName(zkw, entityGroupName); zkw.sync(node); Stat stat = new Stat(); byte[] bytes = ZKUtil.getDataNoWatch(zkw, node, stat); EventType et = rt.getEventType(); if (!et.equals(expectedState)) { LOG.warn(zkw.prefix("Attempting to delete unassigned node " + entityGroupName + " in " + expectedState + " state but node is in " + et + " state")); LOG.warn(zkw.prefix("Attempting to delete " + "unassigned node " + entityGroupName + " in " + expectedState + " state but after verifying state, we got a version mismatch")); .prefix("Successfully deleted unassigned node for entityGroup " + entityGroupName + " in expected state " + expectedState)); return true;
try { zkw = connection.getZooKeeperWatcher(); zkw.getRecoverableZooKeeper().getZooKeeper() .exists(zkw.baseZNode, false); } finally { if (zkw != null) { zkw.close();
/** * Starts the tracking of draining fServers. * * <p>All Draining RSs will be tracked after this method is called. * * @throws org.apache.zookeeper.KeeperException */ public void start() throws KeeperException, IOException { watcher.registerListener(this); List<String> servers = ZKUtil.listChildrenAndWatchThem(watcher, watcher.drainingZNode); add(servers); }
@Override public void processResult(int rc, String path, Object ctx, String name) { if (rc == KeeperException.Code.NODEEXISTS.intValue()) { LOG.warn("Node for " + path + " already exists"); } else if (rc != 0) { // This is result code. If non-zero, need to resubmit. LOG.warn("rc != 0 for " + path + " -- retryable connectionloss -- " + "FIX see http://wiki.apache.org/hadoop/ZooKeeper/FAQ#A2"); this.counter.addAndGet(1); return; } if (LOG.isDebugEnabled()) { LOG.debug("rs=" + ctx + ", server=" + destination); } // Async exists to set a watcher so we'll get triggered when // unassigned node changes. ZooKeeper zk = this.zkw.getRecoverableZooKeeper().getZooKeeper(); zk.exists(path, this.zkw, callBack, ctx); }
this.assignmentManager = new AssignmentManager(this, serverManager, this.balancer, this.executorService, this.metricsMaster); zooKeeper.registerListenerFirst(assignmentManager); + this.serverName + ", sessionid=0x" + Long.toHexString(this.zooKeeper.getRecoverableZooKeeper() .getSessionId()) + ", cluster-up flag was=" + wasUp);
@Test public void testRestartMaster() throws IOException, KeeperException { ZooKeeperWatcher zk = new ZooKeeperWatcher(TEST_UTIL.getConfiguration(), "testActiveMasterManagerFromZK", null, true); try { ZKUtil.deleteNode(zk, zk.getMasterAddressZNode()); ZKUtil.deleteNode(zk, zk.clusterStateZNode); } catch (KeeperException.NoNodeException nne) {
public void stop() { try { // If our address is in ZK, delete it on our way out ServerName activeMaster = null; try { activeMaster = MasterAddressTracker.getMasterAddress(this.watcher); } catch (IOException e) { LOG.warn("Failed get of master address: " + e.toString()); } if (activeMaster != null && activeMaster.equals(this.sn)) { ZKUtil.deleteNode(watcher, watcher.getMasterAddressZNode()); // We may have failed to delete the znode at the previous step, but // we delete the file anyway: a second attempt to delete the znode is // likely to fail again. ZNodeClearer.deleteMyEphemeralNodeOnDisk(); } } catch (KeeperException e) { LOG.error( this.watcher.prefix("Error deleting our own master address node"), e); } } }
/** * Instantiate a ZooKeeper connection and watcher. * @param descriptor Descriptive string that is added to zookeeper sessionid * and used as identifier for this instance. * @throws java.io.IOException * @throws com.alibaba.wasp.ZooKeeperConnectionException */ public ZooKeeperWatcher(Configuration conf, String descriptor, Abortable abortable, boolean canCreateBaseZNode) throws IOException, ZooKeeperConnectionException { this.conf = conf; // Capture a stack trace now. Will print it out later if problem so we can // distingush amongst the myriad ZKWs. try { throw new Exception("ZKW CONSTRUCTOR STACK TRACE FOR DEBUGGING"); } catch (Exception e) { this.constructorCaller = e; } this.quorum = ZKConfig.getZKQuorumServersString(conf); // Identifier will get the session id appended later below down when we // handle the sync connect event. this.identifier = descriptor; this.abortable = abortable; setNodeNames(conf); this.recoverableZooKeeper = ZKUtil.connect(conf, quorum, this, descriptor); if (canCreateBaseZNode) { createBaseZNodes(); } }
LOG.debug(prefix("Received ZooKeeper Event, " + "type=" + event.getType() + ", " + "state=" + event.getState() + ", " + "path=" + event.getPath())); connectionEvent(event); break;
zkw.sync(node);
this.watcher.registerListenerFirst(am);
public static void waitForZKConnectionIfAuthenticating(ZooKeeperWatcher zkw) throws InterruptedException { if (isSecureZooKeeper(zkw.getConfiguration())) { LOG.debug("Waiting for ZooKeeperWatcher to authenticate"); zkw.saslLatch.await(); LOG.debug("Done waiting."); } }
throws KeeperException { try { Stat s = zkw.getRecoverableZooKeeper().exists(znode, zkw); boolean exists = s != null ? true : false; if (exists) { LOG.debug(zkw.prefix("Set watcher on existing znode " + znode)); } else { LOG.debug(zkw.prefix(znode + " does not exist. Watcher is set.")); LOG.warn(zkw.prefix("Unable to set watcher on znode " + znode), e); zkw.keeperException(e); return false; } catch (InterruptedException e) { LOG.warn(zkw.prefix("Unable to set watcher on znode " + znode), e); zkw.interruptedException(e); return false;