Java ZooKeeperWatcher类代码示例

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
/**
 * A quick test that hbase:meta is assigned; blocks for short time only.
 * @return True if hbase:meta location is available and verified as good.
 * @throws InterruptedException
 * @throws IOException
 */
private boolean isMetaAssignedQuickTest(final MasterProcedureEnv env)
throws InterruptedException, IOException {
  ZooKeeperWatcher zkw = env.getMasterServices().getZooKeeper();
  MetaTableLocator mtl = env.getMasterServices().getMetaTableLocator();
  boolean metaAssigned = false;
  // Is hbase:meta location available yet?
  if (mtl.isLocationAvailable(zkw)) {
    ClusterConnection connection = env.getMasterServices().getConnection();
    // Is hbase:meta location good yet?
    long timeout =
      env.getMasterConfiguration().getLong(KEY_SHORT_WAIT_ON_META, DEFAULT_SHORT_WAIT_ON_META);
    if (mtl.verifyMetaRegionLocation(connection, zkw, timeout)) {
      metaAssigned = true;
    }
  }
  return metaAssigned;
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
/**
 * Disable all archiving of files for a given table
 * <p>
 * Inherently an <b>asynchronous operation</b>.
 * @param zooKeeper watcher for the ZK cluster
 * @param table name of the table to disable
 * @throws KeeperException if an unexpected ZK connection issues occurs
 */
private void disable(ZooKeeperWatcher zooKeeper, byte[] table) throws KeeperException {
  // ensure the latest state of the archive node is found
  zooKeeper.sync(archiveZnode);

  // if the top-level archive node is gone, then we are done
  if (ZKUtil.checkExists(zooKeeper, archiveZnode) < 0) {
    return;
  }
  // delete the table node, from the archive
  String tableNode = this.getTableNode(table);
  // make sure the table is the latest version so the delete takes
  zooKeeper.sync(tableNode);

  LOG.debug("Attempting to delete table node:" + tableNode);
  ZKUtil.deleteNodeRecursively(zooKeeper, tableNode);
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
/**
 * Top-level watcher/controller for procedures across the cluster.
 * <p>
 * On instantiation, this ensures the procedure znodes exist.  This however requires the passed in
 *  watcher has been started.
 * @param watcher watcher for the cluster ZK. Owned by <tt>this</tt> and closed via
 *          {@link #close()}
 * @param procDescription name of the znode describing the procedure to run
 * @throws KeeperException when the procedure znodes cannot be created
 */
public ZKProcedureUtil(ZooKeeperWatcher watcher, String procDescription)
    throws KeeperException {
  super(watcher);
  // make sure we are listening for events
  watcher.registerListener(this);
  // setup paths for the zknodes used in procedures
  this.baseZNode = ZKUtil.joinZNode(watcher.baseZNode, procDescription);
  acquiredZnode = ZKUtil.joinZNode(baseZNode, ACQUIRED_BARRIER_ZNODE_DEFAULT);
  reachedZnode = ZKUtil.joinZNode(baseZNode, REACHED_BARRIER_ZNODE_DEFAULT);
  abortZnode = ZKUtil.joinZNode(baseZNode, ABORT_ZNODE_DEFAULT);

  // first make sure all the ZK nodes exist
  // make sure all the parents exist (sometimes not the case in tests)
  ZKUtil.createWithParents(watcher, acquiredZnode);
  // regular create because all the parents exist
  ZKUtil.createAndFailSilent(watcher, reachedZnode);
  ZKUtil.createAndFailSilent(watcher, abortZnode);
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
@Override
public Pair<ZKProcedureCoordinatorRpcs, List<ZKProcedureMemberRpcs>> start(
    ZooKeeperWatcher watcher, String operationName,
    ProcedureCoordinator coordinator, String controllerName,
    ProcedureMember member, List<String> expected) throws Exception {
  // start the controller
  ZKProcedureCoordinatorRpcs controller = new ZKProcedureCoordinatorRpcs(
      watcher, operationName, CONTROLLER_NODE_NAME);
  controller.start(coordinator);

  // make a cohort controller for each expected node

  List<ZKProcedureMemberRpcs> cohortControllers = new ArrayList<ZKProcedureMemberRpcs>();
  for (String nodeName : expected) {
    ZKProcedureMemberRpcs cc = new ZKProcedureMemberRpcs(watcher, operationName);
    cc.start(nodeName, member);
    cohortControllers.add(cc);
  }
  return new Pair<ZKProcedureCoordinatorRpcs, List<ZKProcedureMemberRpcs>>(
      controller, cohortControllers);
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
private void checkAndMigrateQueuesToPB(ZooKeeperWatcher zkw, String znode, String rs)
    throws KeeperException, NoNodeException, InterruptedException {
  String rsPath = ZKUtil.joinZNode(znode, rs);
  List<String> peers = ZKUtil.listChildrenNoWatch(zkw, rsPath);
  if (peers == null || peers.isEmpty()) return;
  String peerPath = null;
  for (String peer : peers) {
    peerPath = ZKUtil.joinZNode(rsPath, peer);
    List<String> files = ZKUtil.listChildrenNoWatch(zkw, peerPath);
    if (files == null || files.isEmpty()) continue;
    String filePath = null;
    for (String file : files) {
      filePath = ZKUtil.joinZNode(peerPath, file);
      byte[] data = ZKUtil.getData(zkw, filePath);
      if (data == null || Bytes.equals(data, HConstants.EMPTY_BYTE_ARRAY)) continue;
      if (ProtobufUtil.isPBMagicPrefix(data)) continue;
      ZKUtil.setData(zkw, filePath,
        ZKUtil.positionToByteArray(Long.parseLong(Bytes.toString(data))));
    }
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
private void checkAndMigratePeerZnodesToPB(ZooKeeperWatcher zkw, String znode,
    List<String> peers) throws KeeperException, NoNodeException, InterruptedException {
  for (String peer : peers) {
    String peerZnode = ZKUtil.joinZNode(znode, peer);
    byte[] data = ZKUtil.getData(zkw, peerZnode);
    if (!ProtobufUtil.isPBMagicPrefix(data)) {
      migrateClusterKeyToPB(zkw, peerZnode, data);
    }
    String peerStatePath = ZKUtil.joinZNode(peerZnode,
      getConf().get("zookeeper.znode.replication.peers.state", "peer-state"));
    if (ZKUtil.checkExists(zkw, peerStatePath) != -1) {
      data = ZKUtil.getData(zkw, peerStatePath);
      if (ProtobufUtil.isPBMagicPrefix(data)) continue;
      migratePeerStateToPB(zkw, data, peerStatePath);
    }
  }
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
/**
 * Return the last failed RS name under /hbase/recovering-regions/encodedRegionName
 *
 * @param encodedRegionName
 * @throws KeeperException
 */
private String getLastFailedRSFromZK(String encodedRegionName) throws KeeperException {
  String result = null;
  long maxZxid = 0;
  ZooKeeperWatcher zkw = this.getZooKeeper();
  String nodePath = ZKUtil.joinZNode(zkw.recoveringRegionsZNode, encodedRegionName);
  List<String> failedServers = ZKUtil.listChildrenNoWatch(zkw, nodePath);
  if (failedServers == null || failedServers.isEmpty()) {
    return result;
  }
  for (String failedServer : failedServers) {
    String rsPath = ZKUtil.joinZNode(nodePath, failedServer);
    Stat stat = new Stat();
    ZKUtil.getDataNoWatch(zkw, rsPath, stat);
    if (maxZxid < stat.getCzxid()) {
      maxZxid = stat.getCzxid();
      result = failedServer;
    }
  }
  return result;
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
/**
 * Create a default snapshot handler - uses a zookeeper based member controller.
 * @param rss region server running the handler
 * @throws KeeperException if the zookeeper cluster cannot be reached
 */
@Override
public void initialize(RegionServerServices rss) throws KeeperException {
  this.rss = rss;
  ZooKeeperWatcher zkw = rss.getZooKeeper();
  this.memberRpcs = new ZKProcedureMemberRpcs(zkw,
      SnapshotManager.ONLINE_SNAPSHOT_CONTROLLER_DESCRIPTION);

  // read in the snapshot request configuration properties
  Configuration conf = rss.getConfiguration();
  long keepAlive = conf.getLong(SNAPSHOT_TIMEOUT_MILLIS_KEY, SNAPSHOT_TIMEOUT_MILLIS_DEFAULT);
  int opThreads = conf.getInt(SNAPSHOT_REQUEST_THREADS_KEY, SNAPSHOT_REQUEST_THREADS_DEFAULT);

  // create the actual snapshot procedure member
  ThreadPoolExecutor pool = ProcedureMember.defaultPool(rss.getServerName().toString(),
    opThreads, keepAlive);
  this.member = new ProcedureMember(memberRpcs, pool, new SnapshotSubprocedureBuilder());
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
@BeforeClass
public static void beforeClass() throws Exception {
  // setup configuration
  Configuration conf = UTIL.getConfiguration();
  SecureTestUtil.enableSecurity(conf);

  UTIL.startMiniCluster();

  // Wait for the ACL table to become available
  UTIL.waitTableEnabled(AccessControlLists.ACL_TABLE_NAME);

  ZKW = new ZooKeeperWatcher(UTIL.getConfiguration(),
    "TestTablePermissions", ABORTABLE);

  UTIL.createTable(TEST_TABLE, TEST_FAMILY);
  UTIL.createTable(TEST_TABLE2, TEST_FAMILY);
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
@Ignore @Test
public void testNamespaceJanitor() throws Exception {
  FileSystem fs = TEST_UTIL.getTestFileSystem();

  int fsCount = fs.listStatus(new Path(FSUtils.getRootDir(TEST_UTIL.getConfiguration()),
      HConstants.BASE_NAMESPACE_DIR)).length;
  Path fakeNSPath =
      FSUtils.getNamespaceDir(FSUtils.getRootDir(TEST_UTIL.getConfiguration()), "foo");
  assertTrue(fs.mkdirs(fakeNSPath));

  String fakeZnode = ZKUtil.joinZNode(ZooKeeperWatcher.namespaceZNode, "foo");
  int zkCount = ZKUtil.listChildrenNoWatch(TEST_UTIL.getZooKeeperWatcher(),
      ZooKeeperWatcher.namespaceZNode).size();
  ZKUtil.createWithParents(TEST_UTIL.getZooKeeperWatcher(), fakeZnode);
  Thread.sleep(10000);

  //verify namespace count is the same and orphan is removed
  assertFalse(fs.exists(fakeNSPath));
  assertEquals(fsCount, fs.listStatus(new Path(FSUtils.getRootDir(TEST_UTIL.getConfiguration()),
          HConstants.BASE_NAMESPACE_DIR)).length);

  assertEquals(-1, ZKUtil.checkExists(TEST_UTIL.getZooKeeperWatcher(), fakeZnode));
  assertEquals(zkCount,
      ZKUtil.listChildrenNoWatch(TEST_UTIL.getZooKeeperWatcher(),
          ZooKeeperWatcher.namespaceZNode).size());
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
@Test
public void testMultipleZK()
throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
  Table localMeta =
    new HTable(new Configuration(TEST_UTIL.getConfiguration()), TableName.META_TABLE_NAME);
  Configuration otherConf = new Configuration(TEST_UTIL.getConfiguration());
  otherConf.set(HConstants.ZOOKEEPER_QUORUM, "127.0.0.1");
  Table ipMeta = new HTable(otherConf, TableName.META_TABLE_NAME);

  // dummy, just to open the connection
  final byte [] row = new byte [] {'r'};
  localMeta.exists(new Get(row));
  ipMeta.exists(new Get(row));

  // make sure they aren't the same
  ZooKeeperWatcher z1 =
    getZooKeeperWatcher(HConnectionManager.getConnection(localMeta.getConfiguration()));
  ZooKeeperWatcher z2 =
    getZooKeeperWatcher(HConnectionManager.getConnection(otherConf));
  assertFalse(z1 == z2);
  assertFalse(z1.getQuorum().equals(z2.getQuorum()));

  localMeta.close();
  ipMeta.close();
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
/**
 * Create a znode with data
 * @throws Exception
 */
@Test
public void testCreateWithParents() throws Exception {
  ZooKeeperWatcher zkw =
      new ZooKeeperWatcher(new Configuration(TEST_UTIL.getConfiguration()),
          TestZooKeeper.class.getName(), null);
  byte[] expectedData = new byte[] { 1, 2, 3 };
  ZKUtil.createWithParents(zkw, "/l1/l2/l3/l4/testCreateWithParents", expectedData);
  byte[] data = ZKUtil.getData(zkw, "/l1/l2/l3/l4/testCreateWithParents");
  assertTrue(Bytes.equals(expectedData, data));
  ZKUtil.deleteNodeRecursively(zkw, "/l1");

  ZKUtil.createWithParents(zkw, "/testCreateWithParents", expectedData);
  data = ZKUtil.getData(zkw, "/testCreateWithParents");
  assertTrue(Bytes.equals(expectedData, data));
  ZKUtil.deleteNodeRecursively(zkw, "/testCreateWithParents");
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
/**
 * Create a bunch of znodes in a hierarchy, try deleting one that has childs (it will fail), then
 * delete it recursively, then delete the last znode
 * @throws Exception
 */
@Test
public void testZNodeDeletes() throws Exception {
  ZooKeeperWatcher zkw = new ZooKeeperWatcher(
    new Configuration(TEST_UTIL.getConfiguration()),
    TestZooKeeper.class.getName(), null);
  ZKUtil.createWithParents(zkw, "/l1/l2/l3/l4");
  try {
    ZKUtil.deleteNode(zkw, "/l1/l2");
    fail("We should not be able to delete if znode has childs");
  } catch (KeeperException ex) {
    assertNotNull(ZKUtil.getDataNoWatch(zkw, "/l1/l2/l3/l4", null));
  }
  ZKUtil.deleteNodeRecursively(zkw, "/l1/l2");
  // make sure it really is deleted
  assertNull(ZKUtil.getDataNoWatch(zkw, "/l1/l2/l3/l4", null));

  // do the same delete again and make sure it doesn't crash
  ZKUtil.deleteNodeRecursively(zkw, "/l1/l2");

  ZKUtil.deleteNode(zkw, "/l1");
  assertNull(ZKUtil.getDataNoWatch(zkw, "/l1/l2", null));
}
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
private void testZNodeACLs() throws IOException, KeeperException, InterruptedException {

    ZooKeeperWatcher watcher = new ZooKeeperWatcher(conf, "IntegrationTestZnodeACLs", null);
    RecoverableZooKeeper zk = ZKUtil.connect(this.conf, watcher);

    String baseZNode = watcher.baseZNode;

    LOG.info("");
    LOG.info("***********************************************************************************");
    LOG.info("Checking ZK permissions, root znode: " + baseZNode);
    LOG.info("***********************************************************************************");
    LOG.info("");

    checkZnodePermsRecursive(watcher, zk, baseZNode);

    LOG.info("Checking ZK permissions: SUCCESS");
  }
 

import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; //导入依赖的package包/类
private static ZKInterProcessReadWriteLock getReadWriteLock(String testName)
    throws IOException {
  MetadataHandler handler = new MetadataHandler() {
    @Override
    public void handleMetadata(byte[] ownerMetadata) {
      LOG.info("Lock info: " + Bytes.toString(ownerMetadata));
    }
  };
  ZooKeeperWatcher zkWatcher = getZooKeeperWatcher(testName);
  String znode = ZKUtil.joinZNode(zkWatcher.tableLockZNode, testName);

  return new ZKInterProcessReadWriteLock(zkWatcher, znode, handler);
}