Java BlockingService.callBlockingMethod方法代码示例

import com.google.protobuf.BlockingService; //导入方法依赖的package包/类
/**
 * This is a server side method, which is invoked over RPC. On success
 * the return response has protobuf response payload. On failure, the
 * exception name and the stack trace are returned in the protobuf response.
 */
@Override
public Pair<Message, CellScanner> call(BlockingService service, MethodDescriptor md,
    Message param, CellScanner cellScanner, long receiveTime, MonitoredRPCHandler status)
throws IOException {
  try {
    status.setRPC(md.getName(), new Object[]{param}, receiveTime);
    // TODO: Review after we add in encoded data blocks.
    status.setRPCPacket(param);
    status.resume("Servicing call");
    //get an instance of the method arg type
    long startTime = System.currentTimeMillis();
    PayloadCarryingRpcController controller = new PayloadCarryingRpcController(cellScanner);
    Message result = service.callBlockingMethod(md, controller, param);
    long endTime = System.currentTimeMillis();
    int processingTime = (int) (endTime - startTime);
    int qTime = (int) (startTime - receiveTime);
    int totalTime = (int) (endTime - receiveTime);
    if (LOG.isTraceEnabled()) {
      LOG.trace(CurCall.get().toString() +
          ", response " + TextFormat.shortDebugString(result) +
          " queueTime: " + qTime +
          " processingTime: " + processingTime +
          " totalTime: " + totalTime);
    }
    long requestSize = param.getSerializedSize();
    long responseSize = result.getSerializedSize();
    metrics.dequeuedCall(qTime);
    metrics.processedCall(processingTime);
    metrics.totalCall(totalTime);
    metrics.receivedRequest(requestSize);
    metrics.sentResponse(responseSize);
    // log any RPC responses that are slower than the configured warn
    // response time or larger than configured warning size
    boolean tooSlow = (processingTime > warnResponseTime && warnResponseTime > -1);
    boolean tooLarge = (responseSize > warnResponseSize && warnResponseSize > -1);
    if (tooSlow || tooLarge) {
      // when tagging, we let TooLarge trump TooSmall to keep output simple
      // note that large responses will often also be slow.
      logResponse(new Object[]{param},
          md.getName(), md.getName() + "(" + param.getClass().getName() + ")",
          (tooLarge ? "TooLarge" : "TooSlow"),
          status.getClient(), startTime, processingTime, qTime,
          responseSize);
    }
    return new Pair<Message, CellScanner>(result, controller.cellScanner());
  } catch (Throwable e) {
    // The above callBlockingMethod will always return a SE.  Strip the SE wrapper before
    // putting it on the wire.  Its needed to adhere to the pb Service Interface but we don't
    // need to pass it over the wire.
    if (e instanceof ServiceException) e = e.getCause();

    // increment the number of requests that were exceptions.
    metrics.exception(e);

    if (e instanceof LinkageError) throw new DoNotRetryIOException(e);
    if (e instanceof IOException) throw (IOException)e;
    LOG.error("Unexpected throwable object ", e);
    throw new IOException(e.getMessage(), e);
  }
}
 

import com.google.protobuf.BlockingService; //导入方法依赖的package包/类
/**
 * This is a server side method, which is invoked over RPC. On success
 * the return response has protobuf response payload. On failure, the
 * exception name and the stack trace are returned in the protobuf response.
 */
@Override
public Pair<Message, CellScanner> call(BlockingService service, MethodDescriptor md,
    Message param, CellScanner cellScanner, long receiveTime, MonitoredRPCHandler status)
throws IOException {
  try {
    status.setRPC(md.getName(), new Object[]{param}, receiveTime);
    // TODO: Review after we add in encoded data blocks.
    status.setRPCPacket(param);
    status.resume("Servicing call");
    //get an instance of the method arg type
    long startTime = System.currentTimeMillis();
    PayloadCarryingRpcController controller = new PayloadCarryingRpcController(cellScanner);
    Message result = service.callBlockingMethod(md, controller, param);
    int processingTime = (int) (System.currentTimeMillis() - startTime);
    int qTime = (int) (startTime - receiveTime);
    if (LOG.isTraceEnabled()) {
      LOG.trace(CurCall.get().toString() +
          ", response " + TextFormat.shortDebugString(result) +
          " queueTime: " + qTime +
          " processingTime: " + processingTime);
    }
    metrics.dequeuedCall(qTime);
    metrics.processedCall(processingTime);
    long responseSize = result.getSerializedSize();
    // log any RPC responses that are slower than the configured warn
    // response time or larger than configured warning size
    boolean tooSlow = (processingTime > warnResponseTime && warnResponseTime > -1);
    boolean tooLarge = (responseSize > warnResponseSize && warnResponseSize > -1);
    if (tooSlow || tooLarge) {
      // when tagging, we let TooLarge trump TooSmall to keep output simple
      // note that large responses will often also be slow.
      logResponse(new Object[]{param},
          md.getName(), md.getName() + "(" + param.getClass().getName() + ")",
          (tooLarge ? "TooLarge" : "TooSlow"),
          status.getClient(), startTime, processingTime, qTime,
          responseSize);
    }
    return new Pair<Message, CellScanner>(result, controller.cellScanner());
  } catch (Throwable e) {
    // The above callBlockingMethod will always return a SE.  Strip the SE wrapper before
    // putting it on the wire.  Its needed to adhere to the pb Service Interface but we don't
    // need to pass it over the wire.
    if (e instanceof ServiceException) e = e.getCause();
    if (e instanceof LinkageError) throw new DoNotRetryIOException(e);
    if (e instanceof IOException) throw (IOException)e;
    LOG.error("Unexpected throwable object ", e);
    throw new IOException(e.getMessage(), e);
  }
}
 

import com.google.protobuf.BlockingService; //导入方法依赖的package包/类
/**
 * This is a server side method, which is invoked over RPC. On success
 * the return response has protobuf response payload. On failure, the
 * exception name and the stack trace are returned in the protobuf response.
 */
public Pair<Message, CellScanner> call(BlockingService service, MethodDescriptor md,
    Message param, CellScanner cellScanner, long receiveTime, MonitoredRPCHandler status)
throws IOException {
  try {
    status.setRPC(md.getName(), new Object[]{param}, receiveTime);
    // TODO: Review after we add in encoded data blocks.
    status.setRPCPacket(param);
    status.resume("Servicing call");
    //get an instance of the method arg type
    long startTime = System.currentTimeMillis();
    PayloadCarryingRpcController controller = new PayloadCarryingRpcController(cellScanner);
    Message result = service.callBlockingMethod(md, controller, param);
    int processingTime = (int) (System.currentTimeMillis() - startTime);
    int qTime = (int) (startTime - receiveTime);
    if (LOG.isTraceEnabled()) {
      LOG.trace(CurCall.get().toString() +
          ", response " + TextFormat.shortDebugString(result) +
          " queueTime: " + qTime +
          " processingTime: " + processingTime);
    }
    metrics.dequeuedCall(qTime);
    metrics.processedCall(processingTime);
    long responseSize = result.getSerializedSize();
    // log any RPC responses that are slower than the configured warn
    // response time or larger than configured warning size
    boolean tooSlow = (processingTime > warnResponseTime && warnResponseTime > -1);
    boolean tooLarge = (responseSize > warnResponseSize && warnResponseSize > -1);
    if (tooSlow || tooLarge) {
      // when tagging, we let TooLarge trump TooSmall to keep output simple
      // note that large responses will often also be slow.
      StringBuilder buffer = new StringBuilder(256);
      buffer.append(md.getName());
      buffer.append("(");
      buffer.append(param.getClass().getName());
      buffer.append(")");
      logResponse(new Object[]{param},
          md.getName(), buffer.toString(), (tooLarge ? "TooLarge" : "TooSlow"),
          status.getClient(), startTime, processingTime, qTime,
          responseSize);
    }
    return new Pair<Message, CellScanner>(result,
      controller != null? controller.cellScanner(): null);
  } catch (Throwable e) {
    // The above callBlockingMethod will always return a SE.  Strip the SE wrapper before
    // putting it on the wire.  Its needed to adhere to the pb Service Interface but we don't
    // need to pass it over the wire.
    if (e instanceof ServiceException) e = e.getCause();
    if (e instanceof LinkageError) throw new DoNotRetryIOException(e);
    if (e instanceof IOException) throw (IOException)e;
    LOG.error("Unexpected throwable object ", e);
    throw new IOException(e.getMessage(), e);
  }
}
 

import com.google.protobuf.BlockingService; //导入方法依赖的package包/类
/**
 * This is a server side method, which is invoked over RPC. On success
 * the return response has protobuf response payload. On failure, the
 * exception name and the stack trace are returned in the protobuf response.
 */
public Pair<Message, CellScanner> call(BlockingService service, MethodDescriptor md,
    Message param, CellScanner cellScanner, long receiveTime, MonitoredRPCHandler status)
throws IOException {
  try {
    status.setRPC(md.getName(), new Object[]{param}, receiveTime);
    // TODO: Review after we add in encoded data blocks.
    status.setRPCPacket(param);
    status.resume("Servicing call");
    //get an instance of the method arg type
    long startTime = System.currentTimeMillis();
    PayloadCarryingRpcController controller = new PayloadCarryingRpcController(cellScanner);
    Message result = service.callBlockingMethod(md, controller, param);
    int processingTime = (int) (System.currentTimeMillis() - startTime);
    int qTime = (int) (startTime - receiveTime);
    if (LOG.isTraceEnabled()) {
      LOG.trace(CurCall.get().toString() +
          ", response " + TextFormat.shortDebugString(result) +
          " queueTime: " + qTime +
          " processingTime: " + processingTime);
    }
    metrics.dequeuedCall(qTime);
    metrics.processedCall(processingTime);
    long responseSize = result.getSerializedSize();
    // log any RPC responses that are slower than the configured warn
    // response time or larger than configured warning size
    boolean tooSlow = (processingTime > warnResponseTime && warnResponseTime > -1);
    boolean tooLarge = (responseSize > warnResponseSize && warnResponseSize > -1);
    if (tooSlow || tooLarge) {
      // when tagging, we let TooLarge trump TooSmall to keep output simple
      // note that large responses will often also be slow.
      StringBuilder buffer = new StringBuilder(256);
      buffer.append(md.getName());
      buffer.append("(");
      buffer.append(param.getClass().getName());
      buffer.append(")");
      logResponse(new Object[]{param},
          md.getName(), buffer.toString(), (tooLarge ? "TooLarge" : "TooSlow"),
          status.getClient(), startTime, processingTime, qTime,
          responseSize);
    }
    return new Pair<Message, CellScanner>(result, controller.cellScanner());
  } catch (Throwable e) {
    // The above callBlockingMethod will always return a SE.  Strip the SE wrapper before
    // putting it on the wire.  Its needed to adhere to the pb Service Interface but we don't
    // need to pass it over the wire.
    if (e instanceof ServiceException) e = e.getCause();
    if (e instanceof LinkageError) throw new DoNotRetryIOException(e);
    if (e instanceof IOException) throw (IOException)e;
    LOG.error("Unexpected throwable object ", e);
    throw new IOException(e.getMessage(), e);
  }
}
 

import com.google.protobuf.BlockingService; //导入方法依赖的package包/类
/**
 * This is a server side method, which is invoked over RPC. On success
 * the return response has protobuf response payload. On failure, the
 * exception name and the stack trace are returned in the protobuf response.
 */
public Pair<Message, CellScanner> call(BlockingService service, MethodDescriptor md,
    Message param, CellScanner cellScanner, long receiveTime, MonitoredRPCHandler status)
throws IOException {
  try {
    status.setRPC(md.getName(), new Object[]{param}, receiveTime);
    // TODO: Review after we add in encoded data blocks.
    status.setRPCPacket(param);
    status.resume("Servicing call");
    //get an instance of the method arg type
    long startTime = System.currentTimeMillis();
    PayloadCarryingRpcController controller = new PayloadCarryingRpcController(cellScanner);
    Message result = service.callBlockingMethod(md, controller, param);
    int processingTime = (int) (System.currentTimeMillis() - startTime);
    int qTime = (int) (startTime - receiveTime);
    if (LOG.isTraceEnabled()) {
      LOG.trace(CurCall.get().toString() +
          ", response " + TextFormat.shortDebugString(result) +
          " queueTime: " + qTime +
          " processingTime: " + processingTime);
    }
    metrics.dequeuedCall(qTime);
    metrics.processedCall(processingTime);
    long responseSize = result.getSerializedSize();
    // log any RPC responses that are slower than the configured warn
    // response time or larger than configured warning size
    boolean tooSlow = (processingTime > warnResponseTime && warnResponseTime > -1);
    boolean tooLarge = (responseSize > warnResponseSize && warnResponseSize > -1);
    if (tooSlow || tooLarge) {
      // when tagging, we let TooLarge trump TooSmall to keep output simple
      // note that large responses will often also be slow.
      StringBuilder buffer = new StringBuilder(256);
      buffer.append(md.getName());
      buffer.append("(");
      buffer.append(param.getClass().getName());
      buffer.append(")");
      logResponse(new Object[]{param},
          md.getName(), buffer.toString(), (tooLarge ? "TooLarge" : "TooSlow"),
          status.getClient(), startTime, processingTime, qTime,
          responseSize);
    }
    return new Pair<Message, CellScanner>(result,
      controller != null? controller.cellScanner(): null);
  } catch (Throwable e) {
    // The above callBlockingMethod will always return a SE.  Strip the SE wrapper before
    // putting it on the wire.  Its needed to adhere to the pb Service Interface but we don't
    // need to pass it over the wire.
    if (e instanceof ServiceException) e = e.getCause();
    if (e instanceof IOException) throw (IOException)e;
    LOG.error("Unexpected throwable object ", e);
    throw new IOException(e.getMessage(), e);
  }
}