Java SecretManager类代码示例

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
private List<AuthMethod> getAuthMethods(SecretManager<?> secretManager,
                                           Configuration conf) {
  AuthenticationMethod confAuthenticationMethod =
      SecurityUtil.getAuthenticationMethod(conf);        
  List<AuthMethod> authMethods = new ArrayList<AuthMethod>();
  if (confAuthenticationMethod == AuthenticationMethod.TOKEN) {
    if (secretManager == null) {
      throw new IllegalArgumentException(AuthenticationMethod.TOKEN +
          " authentication requires a secret manager");
    } 
  } else if (secretManager != null) {
    LOG.debug(AuthenticationMethod.TOKEN +
        " authentication enabled for secret manager");
    // most preferred, go to the front of the line!
    authMethods.add(AuthenticationMethod.TOKEN.getAuthMethod());
  }
  authMethods.add(confAuthenticationMethod.getAuthMethod());        
  
  LOG.debug("Server accepts auth methods:" + authMethods);
  return authMethods;
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
protected static RPC.Server setupTestServer(Configuration serverConf,
                                     int numHandlers,
                                     SecretManager<?> serverSm)
    throws IOException {
  RPC.Builder builder = newServerBuilder(serverConf);

  if (numHandlers > 0) {
    builder.setNumHandlers(numHandlers);
  }

  if (serverSm != null) {
    builder.setSecretManager(serverSm);
  }

  return setupTestServer(builder);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
@Test(timeout = 15000)
public void testAllocateOnHA() throws YarnException, IOException, InterruptedException {
  AllocateRequest request = AllocateRequest.newInstance(0, 50f,
      new ArrayList<ResourceRequest>(),
      new ArrayList<ContainerId>(),
      ResourceBlacklistRequest.newInstance(new ArrayList<String>(),
          new ArrayList<String>()));
  int nbTry = 0;
  AllocateResponse response = null;
  while (nbTry < 10) {
    try {
      response = amClient.allocate(request);
      break;
    } catch (IOException ex) {
      if (!(ex instanceof SecretManager.InvalidToken)) {
        throw ex;
      }
    }
    Thread.sleep(200);
    nbTry++;
  }
  Assert.assertEquals(response, this.cluster.createFakeAllocateResponse());
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
public static <T extends TokenIdentifier> T getIdentifier(String id,
    SecretManager<T> secretManager) throws InvalidToken {
  byte[] tokenId = decodeIdentifier(id);
  T tokenIdentifier = secretManager.createIdentifier();
  try {
    tokenIdentifier.readFields(new DataInputStream(new ByteArrayInputStream(
        tokenId)));
  } catch (IOException e) {
    throw (InvalidToken) new InvalidToken(
        "Can't de-serialize tokenIdentifier").initCause(e);
  }
  return tokenIdentifier;
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
@Override
public RPC.Server getServer(Class<?> protocolClass,
                    Object protocolImpl, String bindAddress, int port,
                    int numHandlers, int numReaders, int queueSizePerHandler,
                    boolean verbose, Configuration conf,
                    SecretManager<? extends TokenIdentifier> secretManager,
                    String portRangeConfig) 
  throws IOException {
  return new Server(protocolClass, protocolImpl, conf, bindAddress, port,
      numHandlers, numReaders, queueSizePerHandler, verbose, secretManager,
      portRangeConfig);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
protected Server(String bindAddress, int port,
    Class<? extends Writable> rpcRequestClass, int handlerCount,
    int numReaders, int queueSizePerHandler, Configuration conf,
    String serverName, SecretManager<? extends TokenIdentifier> secretManager)
  throws IOException {
  this(bindAddress, port, rpcRequestClass, handlerCount, numReaders, 
      queueSizePerHandler, conf, serverName, secretManager, null);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
@Override
public RPC.Server getServer(Class<?> protocol, Object protocolImpl,
    String bindAddress, int port, int numHandlers, int numReaders,
    int queueSizePerHandler, boolean verbose, Configuration conf,
    SecretManager<? extends TokenIdentifier> secretManager,
    String portRangeConfig)
    throws IOException {
  return new Server(protocol, protocolImpl, conf, bindAddress, port,
      numHandlers, numReaders, queueSizePerHandler, verbose, secretManager,
      portRangeConfig);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
/**
 * Construct an RPC server.
 * 
 * @param protocolClass the class of protocol
 * @param protocolImpl the protocolImpl whose methods will be called
 * @param conf the configuration to use
 * @param bindAddress the address to bind on to listen for connection
 * @param port the port to listen for connections on
 * @param numHandlers the number of method handler threads to run
 * @param verbose whether each call should be logged
 * @param portRangeConfig A config parameter that can be used to restrict
 * the range of ports used when port is 0 (an ephemeral port)
 */
public Server(Class<?> protocolClass, Object protocolImpl,
    Configuration conf, String bindAddress, int port, int numHandlers,
    int numReaders, int queueSizePerHandler, boolean verbose,
    SecretManager<? extends TokenIdentifier> secretManager, 
    String portRangeConfig)
    throws IOException {
  super(bindAddress, port, null, numHandlers,
      numReaders, queueSizePerHandler, conf, classNameBase(protocolImpl
          .getClass().getName()), secretManager, portRangeConfig);
  this.verbose = verbose;  
  registerProtocolAndImpl(RPC.RpcKind.RPC_PROTOCOL_BUFFER, protocolClass,
      protocolImpl);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
protected Server(String bindAddress, int port, 
                 Class<? extends Writable> paramClass, int handlerCount,
                 int numReaders, int queueSizePerHandler,
                 Configuration conf, String serverName, 
                 SecretManager<? extends TokenIdentifier> secretManager,
                 String portRangeConfig) throws IOException {
  super(bindAddress, port, paramClass, handlerCount, numReaders, queueSizePerHandler,
        conf, serverName, secretManager, portRangeConfig);
  initProtocolMetaInfo(conf);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
private void verifyTokenFailWithRetry(DelegationTokenManager tm,
    Token<DelegationTokenIdentifier> token, int retryCount)
    throws IOException, InterruptedException {
  try {
    tm.verifyToken(token);
  } catch (SecretManager.InvalidToken er) {
    throw er;
  }
  if (retryCount > 0) {
    Thread.sleep(RETRY_WAIT);
    verifyTokenFailWithRetry(tm, token, retryCount - 1);
  }
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
@Override
public org.apache.hadoop.ipc.RPC.Server getServer(
    Class<?> protocol, Object instance, String bindAddress, int port,
    int numHandlers, int numReaders, int queueSizePerHandler,
    boolean verbose, Configuration conf,
    SecretManager<? extends TokenIdentifier> secretManager,
    String portRangeConfig) throws IOException {
  return null;
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
/**
 * Construct an RPC server.
 *
 * @param protocolClass the class of protocol
 * @param protocolImpl the protocolImpl whose methods will be called
 * @param conf the configuration to use
 * @param bindAddress the address to bind on to listen for connection
 * @param port the port to listen for connections on
 * @param numHandlers the number of method handler threads to run
 * @param verbose whether each call should be logged
 * @param portRangeConfig A config parameter that can be used to restrict
 * the range of ports used when port is 0 (an ephemeral port)
 */
public Server(Class<?> protocolClass, Object protocolImpl,
    Configuration conf, String bindAddress, int port, int numHandlers,
    int numReaders, int queueSizePerHandler, boolean verbose,
    SecretManager<? extends TokenIdentifier> secretManager,
    String portRangeConfig)
    throws IOException {
  super(bindAddress, port, null, numHandlers,
      numReaders, queueSizePerHandler, conf, classNameBase(protocolImpl
          .getClass().getName()), secretManager, portRangeConfig);
  this.verbose = verbose;
  registerProtocolAndImpl(RPC.RpcKind.RPC_PROTOCOL_BUFFER, protocolClass,
      protocolImpl);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
public ClientToAMTokenSecretManager(
    ApplicationAttemptId applicationAttemptID, byte[] key) {
  super();
  if (key !=  null) {
    this.masterKey = SecretManager.createSecretKey(key);
  } else {
    this.masterKey = null;
  }
  
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
@Private
@Override
public byte[] retrievePassword(ClientToAMTokenIdentifier identifier)
    throws SecretManager.InvalidToken {
  SecretKey masterKey = getMasterKey(identifier.getApplicationAttemptID());
  if (masterKey == null) {
    throw new SecretManager.InvalidToken("Illegal client-token!");
  }
  return createPassword(identifier.getBytes(), masterKey);
}
 

import org.apache.hadoop.security.token.SecretManager; //导入依赖的package包/类
private Server createServer(Class<?> pbProtocol, InetSocketAddress addr, Configuration conf, 
    SecretManager<? extends TokenIdentifier> secretManager, int numHandlers, 
    BlockingService blockingService, String portRangeConfig) throws IOException {
  RPC.setProtocolEngine(conf, pbProtocol, ProtobufRpcEngine.class);
  RPC.Server server = new RPC.Builder(conf).setProtocol(pbProtocol)
      .setInstance(blockingService).setBindAddress(addr.getHostName())
      .setPort(addr.getPort()).setNumHandlers(numHandlers).setVerbose(false)
      .setSecretManager(secretManager).setPortRangeConfig(portRangeConfig)
      .build();
  LOG.info("Adding protocol "+pbProtocol.getCanonicalName()+" to the server");
  server.addProtocol(RPC.RpcKind.RPC_PROTOCOL_BUFFER, pbProtocol, blockingService);
  return server;
}