Java ResponseConverter.setControllerException方法代码示例

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void prepareBulkLoad(RpcController controller,
                                               PrepareBulkLoadRequest request,
                                               RpcCallback<PrepareBulkLoadResponse> done){
  try {
    List<BulkLoadObserver> bulkLoadObservers = getBulkLoadObservers();

    if(bulkLoadObservers != null) {
      ObserverContext<RegionCoprocessorEnvironment> ctx =
                                         new ObserverContext<RegionCoprocessorEnvironment>();
      ctx.prepare(env);

      for(BulkLoadObserver bulkLoadObserver : bulkLoadObservers) {
        bulkLoadObserver.prePrepareBulkLoad(ctx, request);
      }
    }

    String bulkToken = createStagingDir(baseStagingDir,
        getActiveUser(), ProtobufUtil.toTableName(request.getTableName())).toString();
    done.run(PrepareBulkLoadResponse.newBuilder().setBulkToken(bulkToken).build());
  } catch (IOException e) {
    ResponseConverter.setControllerException(controller, e);
  }
  done.run(null);
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void cleanupBulkLoad(RpcController controller,
                            CleanupBulkLoadRequest request,
                            RpcCallback<CleanupBulkLoadResponse> done) {
  try {
    List<BulkLoadObserver> bulkLoadObservers = getBulkLoadObservers();

    if(bulkLoadObservers != null) {
      ObserverContext<RegionCoprocessorEnvironment> ctx =
                                         new ObserverContext<RegionCoprocessorEnvironment>();
      ctx.prepare(env);

      for(BulkLoadObserver bulkLoadObserver : bulkLoadObservers) {
        bulkLoadObserver.preCleanupBulkLoad(ctx, request);
      }
    }

    fs.delete(new Path(request.getBulkToken()), true);
    done.run(CleanupBulkLoadResponse.newBuilder().build());
  } catch (IOException e) {
    ResponseConverter.setControllerException(controller, e);
  }
  done.run(null);
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
/**
 * Pass a processor to region to process multiple rows atomically.
 * 
 * The RowProcessor implementations should be the inner classes of your
 * RowProcessorEndpoint. This way the RowProcessor can be class-loaded with
 * the Coprocessor endpoint together.
 *
 * See {@code TestRowProcessorEndpoint} for example.
 *
 * The request contains information for constructing processor 
 * (see {@link #constructRowProcessorFromRequest}. The processor object defines
 * the read-modify-write procedure.
 */
@Override
public void process(RpcController controller, ProcessRequest request,
    RpcCallback<ProcessResponse> done) {
  ProcessResponse resultProto = null;
  try {
    RowProcessor<S,T> processor = constructRowProcessorFromRequest(request);
    Region region = env.getRegion();
    long nonceGroup = request.hasNonceGroup() ? request.getNonceGroup() : HConstants.NO_NONCE;
    long nonce = request.hasNonce() ? request.getNonce() : HConstants.NO_NONCE;
    region.processRowsWithLocks(processor, nonceGroup, nonce);
    T result = processor.getResult();
    ProcessResponse.Builder b = ProcessResponse.newBuilder();
    b.setRowProcessorResult(result.toByteString());
    resultProto = b.build();
  } catch (Exception e) {
    ResponseConverter.setControllerException(controller, new IOException(e));
  }
  done.run(resultProto);
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
@InterfaceAudience.Private
public void callMethod(Descriptors.MethodDescriptor method,
                       RpcController controller,
                       Message request, Message responsePrototype,
                       RpcCallback<Message> callback) {
  Message response = null;
  try {
    response = callExecService(controller, method, request, responsePrototype);
  } catch (IOException ioe) {
    LOG.warn("Call failed on IOException", ioe);
    ResponseConverter.setControllerException(controller, ioe);
  }
  if (callback != null) {
    callback.run(response);
  }
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void callMethod(Descriptors.MethodDescriptor method,
                       RpcController controller,
                       Message request, Message responsePrototype,
                       RpcCallback<Message> callback) {
  Message response = null;
  try {
    response = callExecService(method, request, responsePrototype);
  } catch (IOException ioe) {
    LOG.warn("Call failed on IOException", ioe);
    ResponseConverter.setControllerException(controller, ioe);
  }
  if (callback != null) {
    callback.run(response);
  }
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
@InterfaceAudience.Private
public void callMethod(Descriptors.MethodDescriptor method,
                       RpcController controller,
                       Message request, Message responsePrototype,
                       RpcCallback<Message> callback) {
  Message response = null;
  try {
    response = callExecService(method, request, responsePrototype);
  } catch (IOException ioe) {
    LOG.warn("Call failed on IOException", ioe);
    ResponseConverter.setControllerException(controller, ioe);
  }
  if (callback != null) {
    callback.run(response);
  }
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public synchronized void getAuths(RpcController controller, GetAuthsRequest request,
    RpcCallback<GetAuthsResponse> done) {
  byte[] user = request.getUser().toByteArray();
  GetAuthsResponse.Builder response = GetAuthsResponse.newBuilder();
  response.setUser(request.getUser());
  try {
    List<String> labels = getUserAuthsFromLabelsTable(user);
    for (String label : labels) {
      response.addAuth(HBaseZeroCopyByteString.wrap(Bytes.toBytes(label)));
    }
  } catch (IOException e) {
    ResponseConverter.setControllerException(controller, e);
  }
  done.run(response.build());
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
/**
 * Pass a processor to HRegion to process multiple rows atomically.
 * 
 * The RowProcessor implementations should be the inner classes of your
 * RowProcessorEndpoint. This way the RowProcessor can be class-loaded with
 * the Coprocessor endpoint together.
 *
 * See {@code TestRowProcessorEndpoint} for example.
 *
 * The request contains information for constructing processor 
 * (see {@link #constructRowProcessorFromRequest}. The processor object defines
 * the read-modify-write procedure.
 */
@Override
public void process(RpcController controller, ProcessRequest request,
    RpcCallback<ProcessResponse> done) {
  ProcessResponse resultProto = null;
  try {
    RowProcessor<S,T> processor = constructRowProcessorFromRequest(request);
    HRegion region = env.getRegion();
    region.processRowsWithLocks(processor);
    T result = processor.getResult();
    ProcessResponse.Builder b = ProcessResponse.newBuilder();
    b.setRowProcessorResult(result.toByteString());
    resultProto = b.build();
  } catch (Exception e) {
    ResponseConverter.setControllerException(controller, new IOException(e));
  }
  done.run(resultProto);
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void cleanupBulkLoad(RpcController controller,
                            CleanupBulkLoadRequest request,
                            RpcCallback<CleanupBulkLoadResponse> done) {
  try {
    getAccessController().preCleanupBulkLoad(env);
    fs.delete(createStagingDir(baseStagingDir,
        getActiveUser(),
        env.getRegion().getTableDesc().getTableName(),
        new Path(request.getBulkToken()).getName()),
        true);
    done.run(CleanupBulkLoadResponse.newBuilder().build());
  } catch (IOException e) {
    ResponseConverter.setControllerException(controller, e);
  }
  done.run(null);
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
/**
 * Pass a processor to HRegion to process multiple rows atomically.
 * 
 * The RowProcessor implementations should be the inner classes of your
 * RowProcessorEndpoint. This way the RowProcessor can be class-loaded with
 * the Coprocessor endpoint together.
 *
 * See {@code TestRowProcessorEndpoint} for example.
 *
 * The request contains information for constructing processor 
 * (see {@link #constructRowProcessorFromRequest}. The processor object defines
 * the read-modify-write procedure.
 */
@Override
public void process(RpcController controller, ProcessRequest request,
    RpcCallback<ProcessResponse> done) {
  ProcessResponse resultProto = null;
  try {
    RowProcessor<S,T> processor = constructRowProcessorFromRequest(request);
    HRegion region = env.getRegion();
    long nonceGroup = request.hasNonceGroup() ? request.getNonceGroup() : HConstants.NO_NONCE;
    long nonce = request.hasNonce() ? request.getNonce() : HConstants.NO_NONCE;
    region.processRowsWithLocks(processor, nonceGroup, nonce);
    T result = processor.getResult();
    ProcessResponse.Builder b = ProcessResponse.newBuilder();
    b.setRowProcessorResult(result.toByteString());
    resultProto = b.build();
  } catch (Exception e) {
    ResponseConverter.setControllerException(controller, new IOException(e));
  }
  done.run(resultProto);
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void getActiveTransactions(RpcController controller,TxnMessage.ActiveTxnRequest request,RpcCallback<TxnMessage.ActiveTxnResponse> done){
    long endTxnId=request.getEndTxnId();
    long startTxnId=request.getStartTxnId();
    try{
        byte[] destTables=null;
        if(request.hasDestinationTables())
            destTables=request.getDestinationTables().toByteArray();
        Source<TxnMessage.Txn> activeTxns=lifecycleStore.getActiveTransactions(destTables,startTxnId,endTxnId);
        TxnMessage.ActiveTxnResponse.Builder response=TxnMessage.ActiveTxnResponse.newBuilder();
        while(activeTxns.hasNext()){
            response.addTxns(activeTxns.next());
        }
        done.run(response.build());
    }catch(IOException e){
        ResponseConverter.setControllerException(controller,e);
    }

}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void getTransaction(RpcController controller,TxnMessage.TxnRequest request,RpcCallback<TxnMessage.Txn> done){
    try{
        long txnId=request.getTxnId();
        boolean isOld = request.hasIsOld() && request.getIsOld();
        TxnMessage.Txn transaction;
        if (isOld) {
            transaction = lifecycleStore.getOldTransaction(txnId);
        } else {
            transaction = lifecycleStore.getTransaction(txnId);
        }
        done.run(transaction);
    }catch(IOException ioe){
        ResponseConverter.setControllerException(controller,ioe);
    }
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void getActiveTransactionIds(RpcController controller,TxnMessage.ActiveTxnRequest request,RpcCallback<TxnMessage.ActiveTxnIdResponse> done){
    long endTxnId=request.getEndTxnId();
    long startTxnId=request.getStartTxnId();
    try{
        byte[] destTables=null;
        if(request.hasDestinationTables())
            destTables=request.getDestinationTables().toByteArray();
        long[] activeTxnIds=lifecycleStore.getActiveTransactionIds(destTables,startTxnId,endTxnId);
        TxnMessage.ActiveTxnIdResponse.Builder response=TxnMessage.ActiveTxnIdResponse.newBuilder();
        //noinspection ForLoopReplaceableByForEach
        for(int i=0;i<activeTxnIds.length;i++){
            response.addActiveTxnIds(activeTxnIds[i]);
        }
        done.run(response.build());
    }catch(IOException e){
        ResponseConverter.setControllerException(controller,e);
    }
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void getAuthenticationToken(RpcController controller,
                                   AuthenticationProtos.GetAuthenticationTokenRequest request,
                                   RpcCallback<AuthenticationProtos.GetAuthenticationTokenResponse> done) {
  AuthenticationProtos.GetAuthenticationTokenResponse.Builder response =
      AuthenticationProtos.GetAuthenticationTokenResponse.newBuilder();

  try {
    if (secretManager == null) {
      throw new IOException(
          "No secret manager configured for token authentication");
    }

    User currentUser = RpcServer.getRequestUser();
    UserGroupInformation ugi = null;
    if (currentUser != null) {
      ugi = currentUser.getUGI();
    }
    if (currentUser == null) {
      throw new AccessDeniedException("No authenticated user for request!");
    } else if (!isAllowedDelegationTokenOp(ugi)) {
      LOG.warn("Token generation denied for user="+currentUser.getName()
          +", authMethod="+ugi.getAuthenticationMethod());
      throw new AccessDeniedException(
          "Token generation only allowed for Kerberos authenticated clients");
    }

    Token<AuthenticationTokenIdentifier> token =
        secretManager.generateToken(currentUser.getName());
    response.setToken(ProtobufUtil.toToken(token)).build();
  } catch (IOException ioe) {
    ResponseConverter.setControllerException(controller, ioe);
  }
  done.run(response.build());
}
 

import org.apache.hadoop.hbase.protobuf.ResponseConverter; //导入方法依赖的package包/类
@Override
public void dummyThrow(RpcController controller,
    DummyRequest request,
    RpcCallback<DummyResponse> done) {
  ResponseConverter.setControllerException(controller, WHAT_TO_THROW);

}