import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
/**
 * List children of a directory and retrieve their
 * {@link RegistryPathStatus} values.
 * <p>
 * This is not an atomic operation; A child may be deleted
 * during the iteration through the child entries. If this happens,
 * the <code>PathNotFoundException</code> is caught and that child
 * entry ommitted.
 *
 * @param path path
 * @return a possibly empty map of child entries listed by
 * their short name.
 * @throws PathNotFoundException path is not in the registry.
 * @throws InvalidPathnameException the path is invalid.
 * @throws IOException Any other IO Exception
 */
public static Map<String, RegistryPathStatus> statChildren(
    RegistryOperations registryOperations,
    String path)
    throws PathNotFoundException,
    InvalidPathnameException,
    IOException {
  List<String> childNames = registryOperations.list(path);
  Map<String, RegistryPathStatus> results =
      new HashMap<String, RegistryPathStatus>();
  for (String childName : childNames) {
    String child = join(path, childName);
    try {
      RegistryPathStatus stat = registryOperations.stat(child);
      results.put(childName, stat);
    } catch (PathNotFoundException pnfe) {
      if (LOG.isDebugEnabled()) {
        LOG.debug("stat failed on {}: moved? {}", child, pnfe, pnfe);
      }
      // and continue
    }
  }
  return results;
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
public YarnRegistryViewForProviders(RegistryOperations registryOperations,
    String user,
    String sliderServiceClass,
    String instanceName,
    ApplicationAttemptId applicationAttemptId) {
  Preconditions.checkArgument(registryOperations != null,
      "null registry operations");
  Preconditions.checkArgument(user != null, "null user");
  Preconditions.checkArgument(SliderUtils.isSet(sliderServiceClass),
      "unset service class");
  Preconditions.checkArgument(SliderUtils.isSet(instanceName),
      "instanceName");
  Preconditions.checkArgument(applicationAttemptId != null,
      "null applicationAttemptId");
  this.registryOperations = registryOperations;
  this.user = user;
  this.sliderServiceClass = sliderServiceClass;
  this.instanceName = instanceName;
  this.applicationAttemptId = applicationAttemptId;
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
protected YarnRegistryViewForProviders createYarnRegistryViewForProviders(
    Configuration conf) throws IOException {
  conf.set(SliderXmlConfKeys.REGISTRY_PATH,
      SliderXmlConfKeys.DEFAULT_REGISTRY_PATH);

  RegistryOperations registryOperations = new MockRegistryOperations();
  registryOperations.init(conf);
  YarnRegistryViewForProviders registryViewForProviders =
      new YarnRegistryViewForProviders(registryOperations,
          "hbase",
          SliderKeys.APP_TYPE,
          "hbase1",
          new MockApplicationAttemptId(new MockApplicationId(1), 1));
  registryViewForProviders.registerSelf(new ServiceRecord(), true);
  return registryViewForProviders;
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
public YarnRegistryViewForProviders(RegistryOperations registryOperations,
                                    String user,
                                    String jstormServiceClass,
                                    String instanceName,
                                    ApplicationAttemptId applicationAttemptId) {
  Preconditions.checkArgument(registryOperations != null,
      "null registry operations");
  Preconditions.checkArgument(user != null, "null user");
  Preconditions.checkArgument(JstormYarnUtils.isSet(jstormServiceClass),
      "unset service class");
  Preconditions.checkArgument(JstormYarnUtils.isSet(instanceName),
      "instanceName");
  Preconditions.checkArgument(applicationAttemptId != null,
      "null applicationAttemptId");
  this.registryOperations = registryOperations;
  this.user = user;
  this.jstormServiceClass = jstormServiceClass;
  this.instanceName = instanceName;
  this.applicationAttemptId = applicationAttemptId;
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
/**
 * List service records directly under a path
 * @param registryOperations registry operations instance
 * @param path path to list
 * @return a mapping of the service records that were resolved, indexed
 * by their full path
 * @throws IOException
 */
public static Map<String, ServiceRecord> listServiceRecords(
    RegistryOperations registryOperations,
    String path) throws IOException {
  Map<String, RegistryPathStatus> children =
      statChildren(registryOperations, path);
  return extractServiceRecords(registryOperations,
      path,
      children.values());
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
public RegistryCli(RegistryOperations reg,
    Configuration conf,
    PrintStream sysout,
    PrintStream syserr) {
  super(conf);
  Preconditions.checkArgument(reg != null, "Null registry");
  registry = reg;
  this.sysout = sysout;
  this.syserr = syserr;
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
/**
 * test that ZK can write as itself
 * @throws Throwable
 */
@Test
public void testZookeeperCanWriteUnderSystem() throws Throwable {

  RMRegistryOperationsService rmRegistryOperations =
      startRMRegistryOperations();
  RegistryOperations operations = rmRegistryOperations;
  operations.mknode(PATH_SYSTEM_SERVICES + "hdfs",
      false);
  ZKPathDumper pathDumper = rmRegistryOperations.dumpPath(true);
  LOG.info(pathDumper.toString());
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
@Test
public void testAnonReadAccess() throws Throwable {
  RMRegistryOperationsService rmRegistryOperations =
      startRMRegistryOperations();
  describe(LOG, "testAnonReadAccess");
  RegistryOperations operations =
      RegistryOperationsFactory.createAnonymousInstance(zkClientConf);
  addToTeardown(operations);
  operations.start();

  assertFalse("RegistrySecurity.isClientSASLEnabled()==true",
      RegistrySecurity.isClientSASLEnabled());
  operations.list(PATH_SYSTEM_SERVICES);
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
@Test
public void testAnonNoWriteAccess() throws Throwable {
  RMRegistryOperationsService rmRegistryOperations =
      startRMRegistryOperations();
  describe(LOG, "testAnonNoWriteAccess");
  RegistryOperations operations =
      RegistryOperationsFactory.createAnonymousInstance(zkClientConf);
  addToTeardown(operations);
  operations.start();

  String servicePath = PATH_SYSTEM_SERVICES + "hdfs";
  expectMkNodeFailure(operations, servicePath);
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
@Test
public void testAnonNoWriteAccessOffRoot() throws Throwable {
  RMRegistryOperationsService rmRegistryOperations =
      startRMRegistryOperations();
  describe(LOG, "testAnonNoWriteAccessOffRoot");
  RegistryOperations operations =
      RegistryOperationsFactory.createAnonymousInstance(zkClientConf);
  addToTeardown(operations);
  operations.start();
  assertFalse("mknode(/)", operations.mknode("/", false));
  expectMkNodeFailure(operations, "/sub");
  expectDeleteFailure(operations, PATH_SYSTEM_SERVICES, true);
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
@Test
public void testAlicePathRestrictedAnonAccess() throws Throwable {
  RMRegistryOperationsService rmRegistryOperations =
      startRMRegistryOperations();
  String aliceHome = rmRegistryOperations.initUserRegistry(ALICE);
  describe(LOG, "Creating anonymous accessor");
  RegistryOperations anonOperations =
      RegistryOperationsFactory.createAnonymousInstance(zkClientConf);
  addToTeardown(anonOperations);
  anonOperations.start();
  anonOperations.list(aliceHome);
  expectMkNodeFailure(anonOperations, aliceHome + "/anon");
  expectDeleteFailure(anonOperations, aliceHome, true);
}
 

import org.apache.hadoop.registry.client.api.RegistryOperations; //导入依赖的package包/类
private RegistryOperations createRegistryOperationsInstance() {
  if (registryOperations == null) {
    registryOperations = RegistryOperationsFactory.createInstance("YarnRegistry", conf);
    registryOperations.start();
  }
  return registryOperations;
}