org.apache.hadoop.fs.CacheFlag#org.apache.hadoop.ipc.ProtobufHelper源码实例Demo

/**
 * Helper method to wrap the request and send the message.
 */
private SCMDatanodeResponse submitRequest(Type type,
    Consumer<SCMDatanodeRequest.Builder> builderConsumer) throws IOException {
  final SCMDatanodeResponse response;
  try {
    Builder builder = SCMDatanodeRequest.newBuilder()
        .setCmdType(type);
    builderConsumer.accept(builder);
    SCMDatanodeRequest wrapper = builder.build();

    response = rpcProxy.submitRequest(NULL_RPC_CONTROLLER, wrapper);
  } catch (ServiceException ex) {
    throw ProtobufHelper.getRemoteException(ex);
  }
  return response;
}
 

/**
 * Helper method to wrap the request and send the message.
 */
private ScmContainerLocationResponse submitRequest(
    StorageContainerLocationProtocolProtos.Type type,
    Consumer<Builder> builderConsumer) throws IOException {
  final ScmContainerLocationResponse response;
  try {

    Builder builder = ScmContainerLocationRequest.newBuilder()
        .setCmdType(type)
        .setTraceID(TracingUtil.exportCurrentSpan());
    builderConsumer.accept(builder);
    ScmContainerLocationRequest wrapper = builder.build();

    response = submitRpcRequest(wrapper);
  } catch (ServiceException ex) {
    throw ProtobufHelper.getRemoteException(ex);
  }
  return response;
}
 

/**
 * Helper method to wrap the request and send the message.
 */
private SCMSecurityResponse submitRequest(
    SCMSecurityProtocolProtos.Type type,
    Consumer<Builder> builderConsumer) throws IOException {
  final SCMSecurityResponse response;
  try {

    Builder builder = SCMSecurityRequest.newBuilder()
        .setCmdType(type)
        .setTraceID(TracingUtil.exportCurrentSpan());
    builderConsumer.accept(builder);
    SCMSecurityRequest wrapper = builder.build();

    response = rpcProxy.submitRequest(NULL_RPC_CONTROLLER, wrapper);
  } catch (ServiceException ex) {
    throw ProtobufHelper.getRemoteException(ex);
  }
  return response;
}
 

@Override
public OMResponse submitRequest(OMRequest payload) throws IOException {
  try {
    OMResponse omResponse =
        rpcProxy.submitRequest(NULL_RPC_CONTROLLER, payload);

    if (omResponse.hasLeaderOMNodeId() && omFailoverProxyProvider != null) {
      String leaderOmId = omResponse.getLeaderOMNodeId();

      // Failover to the OM node returned by OMResponse leaderOMNodeId if
      // current proxy is not pointing to that node.
      omFailoverProxyProvider.performFailoverIfRequired(leaderOmId);
    }
    return omResponse;
  } catch (ServiceException e) {
    OMNotLeaderException notLeaderException = getNotLeaderException(e);
    if (notLeaderException == null) {
      throw ProtobufHelper.getRemoteException(e);
    }
    throw new IOException("Could not determine or connect to OM Leader.");
  }
}
 

@Override
public ReplicaRecoveryInfo initReplicaRecovery(RecoveringBlock rBlock)
    throws IOException {
  InitReplicaRecoveryRequestProto req = InitReplicaRecoveryRequestProto
      .newBuilder().setBlock(PBHelper.convert(rBlock)).build();
  InitReplicaRecoveryResponseProto resp;
  try {
    resp = rpcProxy.initReplicaRecovery(NULL_CONTROLLER, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
  if (!resp.getReplicaFound()) {
    // No replica found on the remote node.
    return null;
  } else {
    if (!resp.hasBlock() || !resp.hasState()) {
      throw new IOException("Replica was found but missing fields. " +
          "Req: " + req + "\n" +
          "Resp: " + resp);
    }
  }
  
  BlockProto b = resp.getBlock();
  return new ReplicaRecoveryInfo(b.getBlockId(), b.getNumBytes(),
      b.getGenStamp(), PBHelper.convert(resp.getState()));
}
 

@Override
public long addSpanReceiver(SpanReceiverInfo info) throws IOException {
  try {
    AddSpanReceiverRequestProto.Builder bld =
        AddSpanReceiverRequestProto.newBuilder();
    bld.setClassName(info.getClassName());
    for (ConfigurationPair configPair : info.configPairs) {
      ConfigPair tuple = ConfigPair.newBuilder().
          setKey(configPair.getKey()).
          setValue(configPair.getValue()).build();
      bld.addConfig(tuple);
    }
    AddSpanReceiverResponseProto resp =
        rpcProxy.addSpanReceiver(null, bld.build());
    return resp.getId();
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public void blockReceivedAndDeleted(DatanodeRegistration registration,
    String poolId, StorageReceivedDeletedBlocks[] receivedAndDeletedBlocks)
    throws IOException {
  BlockReceivedAndDeletedRequestProto.Builder builder = 
      BlockReceivedAndDeletedRequestProto.newBuilder()
      .setRegistration(PBHelper.convert(registration))
      .setBlockPoolId(poolId);
  for (StorageReceivedDeletedBlocks storageBlock : receivedAndDeletedBlocks) {
    StorageReceivedDeletedBlocksProto.Builder repBuilder = 
        StorageReceivedDeletedBlocksProto.newBuilder();
    repBuilder.setStorageUuid(storageBlock.getStorage().getStorageID());  // Set for wire compatibility.
    repBuilder.setStorage(PBHelper.convert(storageBlock.getStorage()));
    for (ReceivedDeletedBlockInfo rdBlock : storageBlock.getBlocks()) {
      repBuilder.addBlocks(PBHelper.convert(rdBlock));
    }
    builder.addBlocks(repBuilder.build());
  }
  try {
    rpcProxy.blockReceivedAndDeleted(NULL_CONTROLLER, builder.build());
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
}
 

@Override
public void journal(JournalInfo journalInfo, long epoch, long firstTxnId,
    int numTxns, byte[] records) throws IOException {
  JournalRequestProto req = JournalRequestProto.newBuilder()
      .setJournalInfo(PBHelper.convert(journalInfo))
      .setEpoch(epoch)
      .setFirstTxnId(firstTxnId)
      .setNumTxns(numTxns)
      .setRecords(PBHelper.getByteString(records))
      .build();
  try {
    rpcProxy.journal(NULL_CONTROLLER, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public BlockLocalPathInfo getBlockLocalPathInfo(ExtendedBlock block,
    Token<BlockTokenIdentifier> token) throws IOException {
  GetBlockLocalPathInfoRequestProto req =
      GetBlockLocalPathInfoRequestProto.newBuilder()
      .setBlock(PBHelper.convert(block))
      .setToken(PBHelper.convert(token)).build();
  GetBlockLocalPathInfoResponseProto resp;
  try {
    resp = rpcProxy.getBlockLocalPathInfo(NULL_CONTROLLER, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
  return new BlockLocalPathInfo(PBHelper.convert(resp.getBlock()),
      resp.getLocalPath(), resp.getLocalMetaPath());
}
 

@Override
public SpanReceiverInfo[] listSpanReceivers() throws IOException {
  ArrayList<SpanReceiverInfo> infos = new ArrayList<SpanReceiverInfo>(1);
  try {
    ListSpanReceiversRequestProto req =
        ListSpanReceiversRequestProto.newBuilder().build();
    ListSpanReceiversResponseProto resp =
        rpcProxy.listSpanReceivers(null, req);
    for (SpanReceiverListInfo info : resp.getDescriptionsList()) {
      infos.add(new SpanReceiverInfo(info.getId(), info.getClassName()));
    }
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
  return infos.toArray(new SpanReceiverInfo[infos.size()]);
}
 

@Override
public HAServiceStatus getServiceStatus() throws IOException {
  GetServiceStatusResponseProto status;
  try {
    status = rpcProxy.getServiceStatus(NULL_CONTROLLER,
        GET_SERVICE_STATUS_REQ);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
  
  HAServiceStatus ret = new HAServiceStatus(
      convert(status.getState()));
  if (status.getReadyToBecomeActive()) {
    ret.setReadyToBecomeActive();
  } else {
    ret.setNotReadyToBecomeActive(status.getNotReadyReason());
  }
  return ret;
}
 

@Override
public BatchedEntries<EncryptionZone> listEncryptionZones(long id)
    throws IOException {
  final ListEncryptionZonesRequestProto req =
    ListEncryptionZonesRequestProto.newBuilder()
        .setId(id)
        .build();
  try {
    EncryptionZonesProtos.ListEncryptionZonesResponseProto response =
        rpcProxy.listEncryptionZones(null, req);
    List<EncryptionZone> elements =
        Lists.newArrayListWithCapacity(response.getZonesCount());
    for (EncryptionZoneProto p : response.getZonesList()) {
      elements.add(PBHelper.convert(p));
    }
    return new BatchedListEntries<EncryptionZone>(elements,
        response.getHasMore());
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public LocatedBlock addBlock(String src, String clientName,
    ExtendedBlock previous, DatanodeInfo[] excludeNodes, long fileId,
    String[] favoredNodes)
    throws AccessControlException, FileNotFoundException,
    NotReplicatedYetException, SafeModeException, UnresolvedLinkException,
    IOException {
  AddBlockRequestProto.Builder req = AddBlockRequestProto.newBuilder()
      .setSrc(src).setClientName(clientName).setFileId(fileId);
  if (previous != null) 
    req.setPrevious(PBHelper.convert(previous)); 
  if (excludeNodes != null) 
    req.addAllExcludeNodes(PBHelper.convert(excludeNodes));
  if (favoredNodes != null) {
    req.addAllFavoredNodes(Arrays.asList(favoredNodes));
  }
  try {
    return PBHelper.convert(rpcProxy.addBlock(null, req.build()).getBlock());
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public Boolean canRollBack(String journalId, StorageInfo storage,
    StorageInfo prevStorage, int targetLayoutVersion) throws IOException {
  try {
    CanRollBackResponseProto response = rpcProxy.canRollBack(
        NULL_CONTROLLER,
        CanRollBackRequestProto.newBuilder()
          .setJid(convertJournalId(journalId))
          .setStorage(PBHelper.convert(storage))
          .setPrevStorage(PBHelper.convert(prevStorage))
          .setTargetLayoutVersion(targetLayoutVersion)
          .build());
    return response.getCanRollBack();
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public void updatePipeline(String clientName, ExtendedBlock oldBlock,
    ExtendedBlock newBlock, DatanodeID[] newNodes, String[] storageIDs) throws IOException {
  UpdatePipelineRequestProto req = UpdatePipelineRequestProto.newBuilder()
      .setClientName(clientName)
      .setOldBlock(PBHelper.convert(oldBlock))
      .setNewBlock(PBHelper.convert(newBlock))
      .addAllNewNodes(Arrays.asList(PBHelper.convert(newNodes)))
      .addAllStorageIDs(storageIDs == null ? null : Arrays.asList(storageIDs))
      .build();
  try {
    rpcProxy.updatePipeline(null, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

/**
 * Submits client request to SCM server.
 * @param req client request
 * @return response from SCM
 * @throws IOException thrown if any Protobuf service exception occurs
 */
private SCMBlockLocationResponse submitRequest(
    SCMBlockLocationRequest req) throws IOException {
  try {
    SCMBlockLocationResponse response =
        rpcProxy.send(NULL_RPC_CONTROLLER, req);
    return response;
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public String[] getGroupsForUser(String user) throws IOException {
  GetGroupsForUserRequestProto requestProto = 
      GetGroupsForUserRequestProto.newBuilder().setUser(user).build();
  try {
    GetGroupsForUserResponseProto responseProto =
        proxy.getGroupsForUser(null, requestProto);
    return (String[]) responseProto.getGroupsList().toArray(
        new String[responseProto.getGroupsCount()]);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public void checkAccess(String path, FsAction mode) throws IOException {
  CheckAccessRequestProto req = CheckAccessRequestProto.newBuilder()
      .setPath(path).setMode(PBHelper.convert(mode)).build();
  try {
    rpcProxy.checkAccess(null, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public String[] getGroupsForUser(String user) throws IOException {
  GetGroupsForUserRequestProto request = GetGroupsForUserRequestProto
      .newBuilder().setUser(user).build();
  GetGroupsForUserResponseProto resp;
  try {
    resp = rpcProxy.getGroupsForUser(NULL_CONTROLLER, request);
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
  return resp.getGroupsList().toArray(new String[resp.getGroupsCount()]);
}
 

@Override
public void refreshJobRetentionSettings() throws IOException {
  try {
    rpcProxy.refreshJobRetentionSettings(NULL_CONTROLLER,
        VOID_REFRESH_JOB_RETENTION_SETTINGS_REQUEST);
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
}
 

@Override
public void refreshLogRetentionSettings() throws IOException {
  try {
    rpcProxy.refreshLogRetentionSettings(NULL_CONTROLLER,
        VOID_REFRESH_LOG_RETENTION_SETTINGS_REQUEST);
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
}
 

@Override
public String updateReplicaUnderRecovery(ExtendedBlock oldBlock,
    long recoveryId, long newBlockId, long newLength) throws IOException {
  UpdateReplicaUnderRecoveryRequestProto req = 
      UpdateReplicaUnderRecoveryRequestProto.newBuilder()
      .setBlock(PBHelper.convert(oldBlock))
      .setNewLength(newLength).setNewBlockId(newBlockId)
      .setRecoveryId(recoveryId).build();
  try {
    return rpcProxy.updateReplicaUnderRecovery(NULL_CONTROLLER, req
        ).getStorageUuid();
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public DatanodeRegistration registerDatanode(DatanodeRegistration registration
    ) throws IOException {
  RegisterDatanodeRequestProto.Builder builder = RegisterDatanodeRequestProto
      .newBuilder().setRegistration(PBHelper.convert(registration));
  RegisterDatanodeResponseProto resp;
  try {
    resp = rpcProxy.registerDatanode(NULL_CONTROLLER, builder.build());
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
  return PBHelper.convert(resp.getRegistration());
}
 

@Override
public Long getJournalCTime(String journalId) throws IOException {
  try {
    GetJournalCTimeResponseProto response = rpcProxy.getJournalCTime(
        NULL_CONTROLLER,
        GetJournalCTimeRequestProto.newBuilder()
          .setJid(convertJournalId(journalId))
          .build());
    return response.getResultCTime();
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public void refreshSuperUserGroupsConfiguration() throws IOException {
  try {
    rpcProxy.refreshSuperUserGroupsConfiguration(NULL_CONTROLLER,
        VOID_REFRESH_SUPERUSER_GROUPS_CONFIGURATION_REQUEST);
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
}
 

@Override
public void doUpgrade(String journalId, StorageInfo sInfo) throws IOException {
  try {
    rpcProxy.doUpgrade(NULL_CONTROLLER,
        DoUpgradeRequestProto.newBuilder()
          .setJid(convertJournalId(journalId))
          .setSInfo(PBHelper.convert(sInfo))
          .build());
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public void refreshCallQueue() throws IOException {
  try {
    rpcProxy.refreshCallQueue(NULL_CONTROLLER,
        VOID_REFRESH_CALL_QUEUE_REQUEST);
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
}
 

@Override
public void reportBadBlocks(LocatedBlock[] blocks) throws IOException {
  ReportBadBlocksRequestProto.Builder builder = ReportBadBlocksRequestProto
      .newBuilder();
  for (int i = 0; i < blocks.length; i++) {
    builder.addBlocks(i, PBHelper.convert(blocks[i]));
  }
  ReportBadBlocksRequestProto req = builder.build();
  try {
    rpcProxy.reportBadBlocks(NULL_CONTROLLER, req);
  } catch (ServiceException se) {
    throw ProtobufHelper.getRemoteException(se);
  }
}
 

@Override
public void purgeLogsOlderThan(RequestInfo reqInfo, long minTxIdToKeep)
    throws IOException {
  PurgeLogsRequestProto req = PurgeLogsRequestProto.newBuilder()
      .setReqInfo(convert(reqInfo))
      .setMinTxIdToKeep(minTxIdToKeep)
      .build();
  try {
    rpcProxy.purgeLogs(NULL_CONTROLLER, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}
 

@Override
public void modifyAclEntries(String src, List<AclEntry> aclSpec)
    throws IOException {
  ModifyAclEntriesRequestProto req = ModifyAclEntriesRequestProto
      .newBuilder().setSrc(src)
      .addAllAclSpec(PBHelper.convertAclEntryProto(aclSpec)).build();
  try {
    rpcProxy.modifyAclEntries(null, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}