import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Handler for {@link RegisterComponentInstance action}
 * Register/re-register an ephemeral container that is already in the app state
 * @param id the component
 * @param description
 */
public boolean registerComponent(ContainerId id, String description) throws
    IOException {
  RoleInstance instance = appState.getOwnedContainer(id);
  if (instance == null) {
    return false;
  }
  // this is where component registrations  go
  log.info("Registering component {}", id);
  String cid = RegistryPathUtils.encodeYarnID(id.toString());
  ServiceRecord container = new ServiceRecord();
  container.set(YarnRegistryAttributes.YARN_ID, cid);
  container.description = description;
  container.set(YarnRegistryAttributes.YARN_PERSISTENCE,
      PersistencePolicies.CONTAINER);
  try {
    yarnRegistryOperations.putComponent(cid, container);
  } catch (IOException e) {
    log.warn("Failed to register container {}/{}: {}",
        id, description, e, e);
  }
  return true;
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Recursively make a path
 * @param path path to create
 * @param acl ACL for path
 * @throws IOException any problem
 */
public void zkMkParentPath(String path,
    List<ACL> acl) throws
    IOException {
  // split path into elements

  zkMkPath(RegistryPathUtils.parentOf(path),
      CreateMode.PERSISTENT, true, acl);
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
@Test
public void testPutGetContainerPersistenceServiceEntry() throws Throwable {

  String path = ENTRY_PATH;
  ServiceRecord written = buildExampleServiceEntry(
      PersistencePolicies.CONTAINER);

  operations.mknode(RegistryPathUtils.parentOf(path), true);
  operations.bind(path, written, BindFlags.CREATE);
  ServiceRecord resolved = operations.resolve(path);
  validateEntry(resolved);
  assertMatches(written, resolved);
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Create a service entry with the sample endpoints, and put it
 * at the destination
 * @param path path
 * @param createFlags flags
 * @return the record
 * @throws IOException on a failure
 */
protected ServiceRecord putExampleServiceEntry(String path,
    int createFlags,
    String persistence)
    throws IOException, URISyntaxException {
  ServiceRecord record = buildExampleServiceEntry(persistence);

  registry.mknode(RegistryPathUtils.parentOf(path), true);
  operations.bind(path, record, createFlags);
  return record;
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Look up an instance
 * @return instance data
 * @throws SliderException other failures
 * @throws IOException IO problems or wrapped exceptions
 */
private ServiceRecord lookupServiceRecord(ActionRegistryArgs registryArgs) throws
    SliderException,
    IOException {
  String user;
  if (StringUtils.isNotEmpty(registryArgs.user)) {
    user = RegistryPathUtils.encodeForRegistry(registryArgs.user);
  } else {
    user = currentUser();
  }

  String path = servicePath(user, registryArgs.serviceType,
      registryArgs.name);
  return resolve(path);
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Handler for {@link UnregisterComponentInstance}
 * 
 * unregister a component. At the time this message is received,
 * the component may not have been registered
 * @param id the component
 */
public void unregisterComponent(ContainerId id) {
  log.info("Unregistering component {}", id);
  if (yarnRegistryOperations == null) {
    log.warn("Processing unregister component event before initialization " +
             "completed; init flag =" + initCompleted);
    return;
  }
  String cid = RegistryPathUtils.encodeYarnID(id.toString());
  try {
    yarnRegistryOperations.deleteComponent(cid);
  } catch (IOException e) {
    log.warn("Failed to delete container {} : {}", id, e, e);
  }
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Get the absolute path to where the service has registered itself.
 * This includes the base registry path
 * Null until the service is registered
 * @return the service registration path.
 */
public String getAbsoluteSelfRegistrationPath() {
  if (selfRegistrationPath == null) {
    return null;
  }
  String root = registryOperations.getConfig().getTrimmed(
      RegistryConstants.KEY_REGISTRY_ZK_ROOT,
      RegistryConstants.DEFAULT_ZK_REGISTRY_ROOT);
  return RegistryPathUtils.join(root, selfRegistrationPath);
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Add a component 
 * @param serviceClass service class to use under ~user
 * @param componentName component name
 * @param record record to put
 * @throws IOException
 */
public void putComponent(String serviceClass,
    String serviceName,
    String componentName,
    ServiceRecord record) throws IOException {
  String path = RegistryUtils.componentPath(
      user, serviceClass, serviceName, componentName);
  registryOperations.mknode(RegistryPathUtils.parentOf(path), true);
  registryOperations.bind(path, record, BindFlags.OVERWRITE);
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Add a service under a path, optionally purging any history
 * @param username user
 * @param serviceClass service class to use under ~user
 * @param serviceName name of the service
 * @param record service record
 * @param deleteTreeFirst perform recursive delete of the path first.
 * @return the path the service was created at
 * @throws IOException
 */
public String putService(String username,
    String serviceClass,
    String serviceName,
    ServiceRecord record,
    boolean deleteTreeFirst) throws IOException {
  String path = RegistryUtils.servicePath(
      username, serviceClass, serviceName);
  if (deleteTreeFirst) {
    registryOperations.delete(path, true);
  }
  registryOperations.mknode(RegistryPathUtils.parentOf(path), true);
  registryOperations.bind(path, record, BindFlags.OVERWRITE);
  return path;
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
@Test
public void testPurgeEntryCuratorCallback() throws Throwable {

  String path = "/users/example/hbase/hbase1/";
  ServiceRecord written = buildExampleServiceEntry(
      PersistencePolicies.APPLICATION_ATTEMPT);
  written.set(YarnRegistryAttributes.YARN_ID,
      "testAsyncPurgeEntry_attempt_001");

  operations.mknode(RegistryPathUtils.parentOf(path), true);
  operations.bind(path, written, 0);

  ZKPathDumper dump = registry.dumpPath(false);
  CuratorEventCatcher events = new CuratorEventCatcher();

  LOG.info("Initial state {}", dump);

  // container query
  String id = written.get(YarnRegistryAttributes.YARN_ID, "");
  int opcount = purge("/",
      id,
      PersistencePolicies.CONTAINER,
      RegistryAdminService.PurgePolicy.PurgeAll,
      events);
  assertPathExists(path);
  assertEquals(0, opcount);
  assertEquals("Event counter", 0, events.getCount());

  // now the application attempt
  opcount = purge("/",
      id,
      PersistencePolicies.APPLICATION_ATTEMPT,
      RegistryAdminService.PurgePolicy.PurgeAll,
      events);

  LOG.info("Final state {}", dump);

  assertPathNotFound(path);
  assertEquals("wrong no of delete operations in " + dump, 1, opcount);
  // and validate the callback event
  assertEquals("Event counter", 1, events.getCount());
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
private void putService() throws IOException {
  String path = RegistryUtils.servicePath(user, serviceClass, appIdAsName);
  registryOperations.mknode(RegistryPathUtils.parentOf(path), true);
  registryOperations.bind(path, appRecord, BindFlags.OVERWRITE);
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
private void putComponent(String containerIdAsName) throws IOException {
  String path = RegistryUtils.componentPath(user, serviceClass, appIdAsName, containerIdAsName);
  registryOperations.mknode(RegistryPathUtils.parentOf(path), true);
  registryOperations.bind(path, containerRecords.get(containerIdAsName), BindFlags.OVERWRITE);
}
 

import org.apache.hadoop.registry.client.binding.RegistryPathUtils; //导入依赖的package包/类
/**
 * Create a full path from the registry root and the supplied subdir
 * @param path path of operation
 * @return an absolute path
 * @throws IllegalArgumentException if the path is invalide
 */
protected String createFullPath(String path) throws IOException {
  return RegistryPathUtils.createFullPath(registryRoot, path);
}