Java Descriptors.ServiceDescriptor方法代码示例

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@Override
public boolean registerService(Service instance) {
  /*
   * No stacking of instances is allowed for a single service name
   */
  Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();
  if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {
    LOG.error("Coprocessor service "+serviceDesc.getFullName()+
        " already registered, rejecting request from "+instance
    );
    return false;
  }

  coprocessorServiceHandlers.put(serviceDesc.getFullName(), instance);
  if (LOG.isDebugEnabled()) {
    LOG.debug("Registered master coprocessor service: service="+serviceDesc.getFullName());
  }
  return true;
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@Override public boolean registerService(Service instance) {
  /*
   * No stacking of instances is allowed for a single service name
   */
  Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();
  if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {
    LOG.error("Coprocessor service " + serviceDesc.getFullName()
        + " already registered, rejecting request from " + instance);
    return false;
  }

  coprocessorServiceHandlers.put(serviceDesc.getFullName(), instance);
  if (LOG.isDebugEnabled()) {
    LOG.debug(
        "Registered regionserver coprocessor service: service=" + serviceDesc.getFullName());
  }
  return true;
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@Override public boolean registerService(Service instance) {
  /*
   * No stacking of instances is allowed for a single service name
   */
  Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();
  if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {
    LOG.error("Coprocessor service " + serviceDesc.getFullName()
        + " already registered, rejecting request from " + instance);
    return false;
  }

  coprocessorServiceHandlers.put(serviceDesc.getFullName(), instance);
  if (LOG.isDebugEnabled()) {
    LOG.debug("Registered coprocessor service: region=" + Bytes
        .toStringBinary(getRegionInfo().getRegionName()) + " service=" + serviceDesc
        .getFullName());
  }
  return true;
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@Test
public void testUnpack() throws InvalidProtocolBufferException {
    for (Descriptors.ServiceDescriptor serviceDescriptor : FyChessSi.getDescriptor().getServices()) {
        MethodDescriptor methodByName = serviceDescriptor.findMethodByName("onEnterRoom");
        if (methodByName != null) {
            GpbMessageDesc method = new GpbMessageDesc(methodByName);
            //
            VoEnterRoom message = VoEnterRoom.newBuilder()
                    .setRoomId(999)
                    .setSeat(8)
                    .build();
            Message unpack = method.unpack(message.toByteString());
            Message pack = method.pack(new Object[]{
                    999, 8, 10001L, "xx"
            });
            System.out.println();

        }
    }


}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@Override
public boolean registerService(Service instance) {
/*
 * No stacking of instances is allowed for a single service name
 */
    Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();
    if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {
        LOG.error("Coprocessor service " + serviceDesc.getFullName() +
                        " already registered, rejecting request from " + instance
        );
        return false;
    }

    coprocessorServiceHandlers.put(serviceDesc.getFullName(), instance);
    if (LOG.isDebugEnabled()) {
        LOG.debug("Registered master coprocessor service: service=" + serviceDesc.getFullName());
    }
    return true;
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@Override
public boolean registerService(Service instance) {
/*
 * No stacking of instances is allowed for a single service name
 */
    Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();
    if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {
        LOG.error("Coprocessor service " + serviceDesc.getFullName()
                + " already registered, rejecting request from " + instance);
        return false;
    }

    coprocessorServiceHandlers.put(serviceDesc.getFullName(), instance);
    if (LOG.isDebugEnabled()) {
        LOG.debug("Registered regionserver coprocessor service: service=" + serviceDesc.getFullName());
    }
    return true;
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
/**
 * Registers a new protocol buffer {@link Service} subclass as a coprocessor endpoint to
 * be available for handling
 * {@link HRegion#execService(com.google.protobuf.RpcController,
 * org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall)}} calls.
 * <p/>
 * <p>
 * Only a single instance may be registered per region for a given {@link Service} subclass (the
 * instances are keyed on {@link com.google.protobuf.Descriptors.ServiceDescriptor#getFullName()}.
 * After the first registration, subsequent calls with the same service name will fail with
 * a return value of {@code false}.
 * </p>
 *
 * @param instance the {@code Service} subclass instance to expose as a coprocessor endpoint
 * @return {@code true} if the registration was successful, {@code false}
 * otherwise
 */
public boolean registerService(Service instance) {
/*
 * No stacking of instances is allowed for a single service name
 */
    Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();
    if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {
        LOG.error("Coprocessor service " + serviceDesc.getFullName() +
                        " already registered, rejecting request from " + instance
        );
        return false;
    }

    coprocessorServiceHandlers.put(serviceDesc.getFullName(), instance);
    if (LOG.isDebugEnabled()) {
        LOG.debug("Registered coprocessor service: region=" +
                Bytes.toStringBinary(getRegionName()) + " service=" + serviceDesc.getFullName());
    }
    return true;
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
/**
 * Registers a new protocol buffer {@link Service} subclass as a coprocessor endpoint to
 * be available for handling
 * {@link HRegion#execService(com.google.protobuf.RpcController,
 *    org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall)}} calls.
 *
 * <p>
 * Only a single instance may be registered per region for a given {@link Service} subclass (the
 * instances are keyed on {@link com.google.protobuf.Descriptors.ServiceDescriptor#getFullName()}.
 * After the first registration, subsequent calls with the same service name will fail with
 * a return value of {@code false}.
 * </p>
 * @param instance the {@code Service} subclass instance to expose as a coprocessor endpoint
 * @return {@code true} if the registration was successful, {@code false}
 * otherwise
 */
public boolean registerService(Service instance) {
  /*
   * No stacking of instances is allowed for a single service name
   */
  Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();
  if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {
    LOG.error("Coprocessor service "+serviceDesc.getFullName()+
        " already registered, rejecting request from "+instance
    );
    return false;
  }

  coprocessorServiceHandlers.put(serviceDesc.getFullName(), instance);
  if (LOG.isDebugEnabled()) {
    LOG.debug("Registered coprocessor service: region="+
        Bytes.toStringBinary(getRegionName())+" service="+serviceDesc.getFullName());
  }
  return true;
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
public void register(Service service) {
    // TODO: Support registering multiple local services? Needs "local 2PC" effectively. Yuck.
    Descriptors.ServiceDescriptor descriptor = service.getDescriptorForType();
    for (MethodDescriptor i : descriptor.getMethods()) {
        if (methods.containsKey(i.getFullName())) {
            throw new IllegalStateException(
                    "method " + i.getFullName() + " is already registered");
        }
        methods.put(i.getFullName(), new ProtoMethodInvoker(service, i));
    }
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
/**
 * Asserts that the streaming RPC option is being parsed correctly.
 */
public void testIsStreamingRpc() throws Exception {
  Descriptors.ServiceDescriptor serviceDescriptor =
      WaveletChannelService.getDescriptor();
  assertTrue(serviceDescriptor.findMethodByName("Open").getOptions()
      .getExtension(Rpc.isStreamingRpc));
  assertFalse(serviceDescriptor.findMethodByName("Close").getOptions()
      .getExtension(Rpc.isStreamingRpc));
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@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);
  }
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
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);
  }
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@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();
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
@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);
  }
}
 

import com.google.protobuf.Descriptors; //导入方法依赖的package包/类
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);
    }
}