Java 类org.apache.hadoop.hbase.exceptions.UnknownProtocolException 实例源码

public static MethodDescriptor getMethodDescriptor(final String methodName,
    final ServiceDescriptor serviceDesc)
throws UnknownProtocolException {
  Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
  if (methodDesc == null) {
    throw new UnknownProtocolException("Unknown method " + methodName + " called on service " +
        serviceDesc.getFullName());
  }
  return methodDesc;
}

/**
 * Executes a single protocol buffer coprocessor endpoint {@link Service} method using
 * the registered protocol handlers.  {@link Service} implementations must be registered via the
 * {@link HRegion#registerService(com.google.protobuf.Service)}
 * method before they are available.
 *
 * @param controller an {@code RpcContoller} implementation to pass to the invoked service
 * @param call a {@code CoprocessorServiceCall} instance identifying the service, method,
 *     and parameters for the method invocation
 * @return a protocol buffer {@code Message} instance containing the method's result
 * @throws IOException if no registered service handler is found or an error
 *     occurs during the invocation
 * @see org.apache.hadoop.hbase.regionserver.HRegion#registerService(com.google.protobuf.Service)
 */
public Message execService(RpcController controller, CoprocessorServiceCall call)
    throws IOException {
  String serviceName = call.getServiceName();
  String methodName = call.getMethodName();
  if (!coprocessorServiceHandlers.containsKey(serviceName)) {
    throw new UnknownProtocolException(null,
        "No registered coprocessor service found for name "+serviceName+
        " in region "+Bytes.toStringBinary(getRegionName()));
  }

  Service service = coprocessorServiceHandlers.get(serviceName);
  Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
  Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
  if (methodDesc == null) {
    throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on service "+serviceName+
            " in region "+Bytes.toStringBinary(getRegionName()));
  }

  Message request = service.getRequestPrototype(methodDesc).newBuilderForType()
      .mergeFrom(call.getRequest()).build();
  final Message.Builder responseBuilder =
      service.getResponsePrototype(methodDesc).newBuilderForType();
  service.callMethod(methodDesc, controller, request, new RpcCallback<Message>() {
    @Override
    public void run(Message message) {
      if (message != null) {
        responseBuilder.mergeFrom(message);
      }
    }
  });

  return responseBuilder.build();
}

@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    master.checkInitialized();
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!master.coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
        "No registered master coprocessor service found for name "+serviceName);
    }

    Service service = master.coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on master service "+serviceName);
    }

    //invoke the method
    Message.Builder builderForType = service.getRequestPrototype(methodDesc).newBuilderForType();
    ProtobufUtil.mergeFrom(builderForType, call.getRequest());
    Message execRequest = builderForType.build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest, new RpcCallback<Message>() {
      @Override
      public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    Message execResult = responseBuilder.build();

    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    ClientProtos.CoprocessorServiceResponse.Builder builder =
      ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
      RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(
      builder.getValueBuilder().setName(execResult.getClass().getName())
        .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

public CoprocessorServiceResponse execRegionServerService(
    @SuppressWarnings("UnusedParameters") final RpcController controller,
    final CoprocessorServiceRequest serviceRequest) throws ServiceException {
  try {
    ServerRpcController serviceController = new ServerRpcController();
    CoprocessorServiceCall call = serviceRequest.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
          "No registered coprocessor service found for name " + serviceName);
    }
    Service service = coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
          "Unknown method " + methodName + " called on service " + serviceName);
    }
    Message.Builder builderForType = service.getRequestPrototype(methodDesc).newBuilderForType();
    ProtobufUtil.mergeFrom(builderForType, call.getRequest());
    Message request = builderForType.build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, serviceController, request, new RpcCallback<Message>() {
      @Override public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    IOException exception = ResponseConverter.getControllerException(serviceController);
    if (exception != null) {
      throw exception;
    }
    Message execResult = responseBuilder.build();
    ClientProtos.CoprocessorServiceResponse.Builder builder =
        ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter
        .buildRegionSpecifier(RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(builder.getValueBuilder().setName(execResult.getClass().getName())
        .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

@Override public Message execService(RpcController controller, CoprocessorServiceCall call)
    throws IOException {
  String serviceName = call.getServiceName();
  String methodName = call.getMethodName();
  if (!coprocessorServiceHandlers.containsKey(serviceName)) {
    throw new UnknownProtocolException(null,
        "No registered coprocessor service found for name " + serviceName + " in region " + Bytes
            .toStringBinary(getRegionInfo().getRegionName()));
  }

  Service service = coprocessorServiceHandlers.get(serviceName);
  Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
  Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
  if (methodDesc == null) {
    throw new UnknownProtocolException(service.getClass(),
        "Unknown method " + methodName + " called on service " + serviceName + " in region "
            + Bytes.toStringBinary(getRegionInfo().getRegionName()));
  }

  Message.Builder builder = service.getRequestPrototype(methodDesc).newBuilderForType();
  ProtobufUtil.mergeFrom(builder, call.getRequest());
  Message request = builder.build();

  if (coprocessorHost != null) {
    request = coprocessorHost.preEndpointInvocation(service, methodName, request);
  }

  final Message.Builder responseBuilder =
      service.getResponsePrototype(methodDesc).newBuilderForType();
  service.callMethod(methodDesc, controller, request, new RpcCallback<Message>() {
    @Override public void run(Message message) {
      if (message != null) {
        responseBuilder.mergeFrom(message);
      }
    }
  });

  if (coprocessorHost != null) {
    coprocessorHost.postEndpointInvocation(service, methodName, request, responseBuilder);
  }

  IOException exception = ResponseConverter.getControllerException(controller);
  if (exception != null) {
    throw exception;
  }

  return responseBuilder.build();
}

@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    master.checkInitialized();
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!master.coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
        "No registered master coprocessor service found for name "+serviceName);
    }

    Service service = master.coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on master service "+serviceName);
    }

    //invoke the method
    Message execRequest = service.getRequestPrototype(methodDesc).newBuilderForType()
        .mergeFrom(call.getRequest()).build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest, new RpcCallback<Message>() {
      @Override
      public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    Message execResult = responseBuilder.build();

    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    ClientProtos.CoprocessorServiceResponse.Builder builder =
      ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
      RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(
      builder.getValueBuilder().setName(execResult.getClass().getName())
        .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

public CoprocessorServiceResponse execRegionServerService(final RpcController controller,
                                                          final CoprocessorServiceRequest serviceRequest) throws ServiceException {
    try {
        ServerRpcController execController = new ServerRpcController();
        CoprocessorServiceCall call = serviceRequest.getCall();
        String serviceName = call.getServiceName();
        String methodName = call.getMethodName();
        if (!coprocessorServiceHandlers.containsKey(serviceName)) {
            throw new UnknownProtocolException(null,
                    "No registered coprocessor service found for name " + serviceName);
        }
        Service service = coprocessorServiceHandlers.get(serviceName);
        Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
        Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
        if (methodDesc == null) {
            throw new UnknownProtocolException(service.getClass(), "Unknown method " + methodName
                    + " called on service " + serviceName);
        }
        Message request =
                service.getRequestPrototype(methodDesc).newBuilderForType().mergeFrom(call.getRequest())
                        .build();
        final Message.Builder responseBuilder =
                service.getResponsePrototype(methodDesc).newBuilderForType();
        service.callMethod(methodDesc, controller, request, new RpcCallback<Message>() {
            @Override
            public void run(Message message) {
                if (message != null) {
                    responseBuilder.mergeFrom(message);
                }
            }
        });
        Message execResult = responseBuilder.build();
        if (execController.getFailedOn() != null) {
            throw execController.getFailedOn();
        }
        ClientProtos.CoprocessorServiceResponse.Builder builder =
                ClientProtos.CoprocessorServiceResponse.newBuilder();
        builder.setRegion(RequestConverter.buildRegionSpecifier(RegionSpecifierType.REGION_NAME,
                HConstants.EMPTY_BYTE_ARRAY));
        builder.setValue(builder.getValueBuilder().setName(execResult.getClass().getName())
                .setValue(execResult.toByteString()));
        return builder.build();
    } catch (IOException ie) {
        throw new ServiceException(ie);
    }
}

/**
 * Executes a single protocol buffer coprocessor endpoint {@link Service} method using
 * the registered protocol handlers.  {@link Service} implementations must be registered via the
 * {@link HRegion#registerService(com.google.protobuf.Service)}
 * method before they are available.
 *
 * @param controller an {@code RpcController} implementation to pass to the invoked service
 * @param call       a {@code CoprocessorServiceCall} instance identifying the service, method,
 *                   and parameters for the method invocation
 * @return a protocol buffer {@code Message} instance containing the method's result
 * @throws IOException if no registered service handler is found or an error
 *                     occurs during the invocation
 * @see org.apache.hadoop.hbase.regionserver.HRegion#registerService(com.google.protobuf.Service)
 */
public Message execService(RpcController controller, CoprocessorServiceCall call)
        throws IOException {
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!coprocessorServiceHandlers.containsKey(serviceName)) {
        throw new UnknownProtocolException(null,
                "No registered coprocessor service found for name " + serviceName +
                        " in region " + Bytes.toStringBinary(getRegionName()));
    }

    Service service = coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
        throw new UnknownProtocolException(service.getClass(),
                "Unknown method " + methodName + " called on service " + serviceName +
                        " in region " + Bytes.toStringBinary(getRegionName()));
    }

    Message request = service.getRequestPrototype(methodDesc).newBuilderForType()
            .mergeFrom(call.getRequest()).build();

    if (coprocessorHost != null) {
        request = coprocessorHost.preEndpointInvocation(service, methodName, request);
    }

    final Message.Builder responseBuilder =
            service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, controller, request, new RpcCallback<Message>() {
        @Override
        public void run(Message message) {
            if (message != null) {
                responseBuilder.mergeFrom(message);
            }
        }
    });

    if (coprocessorHost != null) {
        coprocessorHost.postEndpointInvocation(service, methodName, request, responseBuilder);
    }

    return responseBuilder.build();
}

@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
          "No registered master coprocessor service found for name "+serviceName);
    }

    Service service = coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
          "Unknown method "+methodName+" called on master service "+serviceName);
    }

    //invoke the method
    Message execRequest = service.getRequestPrototype(methodDesc).newBuilderForType()
        .mergeFrom(call.getRequest()).build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest, new RpcCallback<Message>() {
      @Override
      public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    Message execResult = responseBuilder.build();

    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    ClientProtos.CoprocessorServiceResponse.Builder builder =
        ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
        RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(
        builder.getValueBuilder().setName(execResult.getClass().getName())
            .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

/**
 * Executes a single protocol buffer coprocessor endpoint {@link Service} method using
 * the registered protocol handlers.  {@link Service} implementations must be registered via the
 * {@link HRegion#registerService(com.google.protobuf.Service)}
 * method before they are available.
 *
 * @param controller an {@code RpcContoller} implementation to pass to the invoked service
 * @param call a {@code CoprocessorServiceCall} instance identifying the service, method,
 *     and parameters for the method invocation
 * @return a protocol buffer {@code Message} instance containing the method's result
 * @throws IOException if no registered service handler is found or an error
 *     occurs during the invocation
 * @see org.apache.hadoop.hbase.regionserver.HRegion#registerService(com.google.protobuf.Service)
 */
public Message execService(RpcController controller, CoprocessorServiceCall call)
    throws IOException {
  String serviceName = call.getServiceName();
  String methodName = call.getMethodName();
  if (!coprocessorServiceHandlers.containsKey(serviceName)) {
    throw new UnknownProtocolException(null,
        "No registered coprocessor service found for name "+serviceName+
        " in region "+Bytes.toStringBinary(getRegionName()));
  }

  Service service = coprocessorServiceHandlers.get(serviceName);
  Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
  Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
  if (methodDesc == null) {
    throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on service "+serviceName+
            " in region "+Bytes.toStringBinary(getRegionName()));
  }

  Message request = service.getRequestPrototype(methodDesc).newBuilderForType()
      .mergeFrom(call.getRequest()).build();

  if (coprocessorHost != null) {
    request = coprocessorHost.preEndpointInvocation(service, methodName, request);
  }

  final Message.Builder responseBuilder =
      service.getResponsePrototype(methodDesc).newBuilderForType();
  service.callMethod(methodDesc, controller, request, new RpcCallback<Message>() {
    @Override
    public void run(Message message) {
      if (message != null) {
        responseBuilder.mergeFrom(message);
      }
    }
  });

  if (coprocessorHost != null) {
    coprocessorHost.postEndpointInvocation(service, methodName, request, responseBuilder);
  }

  return responseBuilder.build();
}

@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    master.checkInitialized();
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!master.coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
        "No registered Master Coprocessor Endpoint found for " + serviceName +
        ". Has it been enabled?");
    }

    com.google.protobuf.Service service = master.coprocessorServiceHandlers.get(serviceName);
    com.google.protobuf.Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    com.google.protobuf.Descriptors.MethodDescriptor methodDesc =
        CoprocessorRpcUtils.getMethodDescriptor(methodName, serviceDesc);

    com.google.protobuf.Message execRequest =
        CoprocessorRpcUtils.getRequest(service, methodDesc, call.getRequest());
    final com.google.protobuf.Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest,
        new com.google.protobuf.RpcCallback<com.google.protobuf.Message>() {
      @Override
      public void run(com.google.protobuf.Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    com.google.protobuf.Message execResult = responseBuilder.build();
    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    return CoprocessorRpcUtils.getResponse(execResult, HConstants.EMPTY_BYTE_ARRAY);
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

public CoprocessorServiceResponse execRegionServerService(
    @SuppressWarnings("UnusedParameters") final RpcController controller,
    final CoprocessorServiceRequest serviceRequest) throws ServiceException {
  try {
    ServerRpcController serviceController = new ServerRpcController();
    CoprocessorServiceCall call = serviceRequest.getCall();
    String serviceName = call.getServiceName();
    com.google.protobuf.Service service = coprocessorServiceHandlers.get(serviceName);
    if (service == null) {
      throw new UnknownProtocolException(null, "No registered coprocessor executorService found for " +
          serviceName);
    }
    com.google.protobuf.Descriptors.ServiceDescriptor serviceDesc =
        service.getDescriptorForType();

    String methodName = call.getMethodName();
    com.google.protobuf.Descriptors.MethodDescriptor methodDesc =
        serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(), "Unknown method " + methodName +
          " called on executorService " + serviceName);
    }

    com.google.protobuf.Message request =
        CoprocessorRpcUtils.getRequest(service, methodDesc, call.getRequest());
    final com.google.protobuf.Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, serviceController, request,
        new com.google.protobuf.RpcCallback<com.google.protobuf.Message>() {
      @Override
      public void run(com.google.protobuf.Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    IOException exception = CoprocessorRpcUtils.getControllerException(serviceController);
    if (exception != null) {
      throw exception;
    }
    return CoprocessorRpcUtils.getResponse(responseBuilder.build(), HConstants.EMPTY_BYTE_ARRAY);
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

/**
 * Executes a single protocol buffer coprocessor endpoint {@link Service} method using
 * the registered protocol handlers.  {@link Service} implementations must be registered via the
 * {@link #registerService(com.google.protobuf.Service)}
 * method before they are available.
 *
 * @param controller an {@code RpcContoller} implementation to pass to the invoked service
 * @param call a {@code CoprocessorServiceCall} instance identifying the service, method,
 *     and parameters for the method invocation
 * @return a protocol buffer {@code Message} instance containing the method's result
 * @throws IOException if no registered service handler is found or an error
 *     occurs during the invocation
 * @see #registerService(com.google.protobuf.Service)
 */
public com.google.protobuf.Message execService(com.google.protobuf.RpcController controller,
    CoprocessorServiceCall call) throws IOException {
  String serviceName = call.getServiceName();
  com.google.protobuf.Service service = coprocessorServiceHandlers.get(serviceName);
  if (service == null) {
    throw new UnknownProtocolException(null, "No registered coprocessor service found for " +
        serviceName + " in region " + Bytes.toStringBinary(getRegionInfo().getRegionName()));
  }
  com.google.protobuf.Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();

  String methodName = call.getMethodName();
  com.google.protobuf.Descriptors.MethodDescriptor methodDesc =
      CoprocessorRpcUtils.getMethodDescriptor(methodName, serviceDesc);

  com.google.protobuf.Message.Builder builder =
      service.getRequestPrototype(methodDesc).newBuilderForType();

  org.apache.hadoop.hbase.protobuf.ProtobufUtil.mergeFrom(builder,
      call.getRequest().toByteArray());
  com.google.protobuf.Message request =
      CoprocessorRpcUtils.getRequest(service, methodDesc, call.getRequest());

  if (coprocessorHost != null) {
    request = coprocessorHost.preEndpointInvocation(service, methodName, request);
  }

  final com.google.protobuf.Message.Builder responseBuilder =
      service.getResponsePrototype(methodDesc).newBuilderForType();
  service.callMethod(methodDesc, controller, request,
      new com.google.protobuf.RpcCallback<com.google.protobuf.Message>() {
    @Override
    public void run(com.google.protobuf.Message message) {
      if (message != null) {
        responseBuilder.mergeFrom(message);
      }
    }
  });

  if (coprocessorHost != null) {
    coprocessorHost.postEndpointInvocation(service, methodName, request, responseBuilder);
  }
  IOException exception =
      org.apache.hadoop.hbase.ipc.CoprocessorRpcUtils.getControllerException(controller);
  if (exception != null) {
    throw exception;
  }

  return responseBuilder.build();
}

@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    master.checkInitialized();
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!master.coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
        "No registered master coprocessor service found for name "+serviceName);
    }

    Service service = master.coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on master service "+serviceName);
    }

    //invoke the method
    Message execRequest = service.getRequestPrototype(methodDesc).newBuilderForType()
        .mergeFrom(call.getRequest()).build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest, new RpcCallback<Message>() {
      @Override
      public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    Message execResult = responseBuilder.build();

    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    ClientProtos.CoprocessorServiceResponse.Builder builder =
      ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
      RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(
      builder.getValueBuilder().setName(execResult.getClass().getName())
        .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

/**
 * Executes a single protocol buffer coprocessor endpoint {@link Service} method using
 * the registered protocol handlers.  {@link Service} implementations must be registered via the
 * {@link HRegion#registerService(com.google.protobuf.Service)}
 * method before they are available.
 *
 * @param controller an {@code RpcContoller} implementation to pass to the invoked service
 * @param call a {@code CoprocessorServiceCall} instance identifying the service, method,
 *     and parameters for the method invocation
 * @return a protocol buffer {@code Message} instance containing the method's result
 * @throws IOException if no registered service handler is found or an error
 *     occurs during the invocation
 * @see org.apache.hadoop.hbase.regionserver.HRegion#registerService(com.google.protobuf.Service)
 */
public Message execService(RpcController controller, CoprocessorServiceCall call)
    throws IOException {
  String serviceName = call.getServiceName();
  String methodName = call.getMethodName();
  if (!coprocessorServiceHandlers.containsKey(serviceName)) {
    throw new UnknownProtocolException(null,
        "No registered coprocessor service found for name "+serviceName+
        " in region "+Bytes.toStringBinary(getRegionName()));
  }

  Service service = coprocessorServiceHandlers.get(serviceName);
  Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
  Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
  if (methodDesc == null) {
    throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on service "+serviceName+
            " in region "+Bytes.toStringBinary(getRegionName()));
  }

  Message request = service.getRequestPrototype(methodDesc).newBuilderForType()
      .mergeFrom(call.getRequest()).build();

  if (coprocessorHost != null) {
    request = coprocessorHost.preEndpointInvocation(service, methodName, request);
  }

  final Message.Builder responseBuilder =
      service.getResponsePrototype(methodDesc).newBuilderForType();
  service.callMethod(methodDesc, controller, request, new RpcCallback<Message>() {
    @Override
    public void run(Message message) {
      if (message != null) {
        responseBuilder.mergeFrom(message);
      }
    }
  });

  if (coprocessorHost != null) {
    coprocessorHost.postEndpointInvocation(service, methodName, request, responseBuilder);
  }

  return responseBuilder.build();
}

@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
          "No registered master coprocessor service found for name "+serviceName);
    }

    Service service = coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
          "Unknown method "+methodName+" called on master service "+serviceName);
    }

    //invoke the method
    Message execRequest = service.getRequestPrototype(methodDesc).newBuilderForType()
        .mergeFrom(call.getRequest()).build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest, new RpcCallback<Message>() {
      @Override
      public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    Message execResult = responseBuilder.build();

    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    ClientProtos.CoprocessorServiceResponse.Builder builder =
        ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
        RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(
        builder.getValueBuilder().setName(execResult.getClass().getName())
            .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}