Java BlockingService类代码示例

import com.google.protobuf.BlockingService; //导入依赖的package包/类
ZKFCRpcServer(Configuration conf,
    InetSocketAddress bindAddr,
    ZKFailoverController zkfc,
    PolicyProvider policy) throws IOException {
  this.zkfc = zkfc;
  
  RPC.setProtocolEngine(conf, ZKFCProtocolPB.class,
      ProtobufRpcEngine.class);
  ZKFCProtocolServerSideTranslatorPB translator =
      new ZKFCProtocolServerSideTranslatorPB(this);
  BlockingService service = ZKFCProtocolService
      .newReflectiveBlockingService(translator);
  this.server = new RPC.Builder(conf).setProtocol(ZKFCProtocolPB.class)
      .setInstance(service).setBindAddress(bindAddr.getHostName())
      .setPort(bindAddr.getPort()).setNumHandlers(HANDLER_COUNT)
      .setVerbose(false).build();
  
  // set service-level authorization security policy
  if (conf.getBoolean(
      CommonConfigurationKeys.HADOOP_SECURITY_AUTHORIZATION, false)) {
    server.refreshServiceAcl(conf, policy);
  }

}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
private InetSocketAddress startAndGetRPCServerAddress(InetSocketAddress serverAddress) {
  Configuration conf = new Configuration();

  try {
    RPC.setProtocolEngine(conf,
        HAServiceProtocolPB.class, ProtobufRpcEngine.class);
    HAServiceProtocolServerSideTranslatorPB haServiceProtocolXlator =
        new HAServiceProtocolServerSideTranslatorPB(new MockHAProtocolImpl());
    BlockingService haPbService = HAServiceProtocolService
        .newReflectiveBlockingService(haServiceProtocolXlator);

    Server server = new RPC.Builder(conf)
        .setProtocol(HAServiceProtocolPB.class)
        .setInstance(haPbService)
        .setBindAddress(serverAddress.getHostName())
        .setPort(serverAddress.getPort()).build();
    server.start();
    return NetUtils.getConnectAddress(server);
  } catch (IOException e) {
    return null;
  }
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  // create a server with two handlers
  server = new RPC.Builder(conf).setProtocol(Foo0.class)
      .setInstance(new Foo0Impl()).setBindAddress(ADDRESS).setPort(0)
      .setNumHandlers(2).setVerbose(false).build();
  server.addProtocol(RPC.RpcKind.RPC_WRITABLE, Foo1.class, new Foo1Impl());
  server.addProtocol(RPC.RpcKind.RPC_WRITABLE, Bar.class, new BarImpl());
  server.addProtocol(RPC.RpcKind.RPC_WRITABLE, Mixin.class, new BarImpl());
  
  
  // Add Protobuf server
  // Create server side implementation
  PBServerImpl pbServerImpl = new PBServerImpl();
  BlockingService service = TestProtobufRpcProto
      .newReflectiveBlockingService(pbServerImpl);
  server.addProtocol(RPC.RpcKind.RPC_PROTOCOL_BUFFER, TestRpcService.class,
      service);
  server.start();
  addr = NetUtils.getConnectAddress(server);
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
private static Server createMockDatanode(BlockTokenSecretManager sm,
    Token<BlockTokenIdentifier> token, Configuration conf)
    throws IOException, ServiceException {
  ClientDatanodeProtocolPB mockDN = mock(ClientDatanodeProtocolPB.class);

  BlockTokenIdentifier id = sm.createIdentifier();
  id.readFields(new DataInputStream(new ByteArrayInputStream(token
      .getIdentifier())));
  
  doAnswer(new GetLengthAnswer(sm, id)).when(mockDN)
      .getReplicaVisibleLength(any(RpcController.class),
          any(GetReplicaVisibleLengthRequestProto.class));

  RPC.setProtocolEngine(conf, ClientDatanodeProtocolPB.class,
      ProtobufRpcEngine.class);
  BlockingService service = ClientDatanodeProtocolService
      .newReflectiveBlockingService(mockDN);
  return new RPC.Builder(conf).setProtocol(ClientDatanodeProtocolPB.class)
      .setInstance(service).setBindAddress(ADDRESS).setPort(0)
      .setNumHandlers(5).setVerbose(true).setSecretManager(sm).build();
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
@Before
public  void setUp() throws IOException { // Setup server for both protocols
  conf = new Configuration();
  conf.setInt(CommonConfigurationKeys.IPC_MAXIMUM_DATA_LENGTH, 1024);
  // Set RPC engine to protobuf RPC engine
  RPC.setProtocolEngine(conf, TestRpcService.class, ProtobufRpcEngine.class);

  // Create server side implementation
  PBServerImpl serverImpl = new PBServerImpl();
  BlockingService service = TestProtobufRpcProto
      .newReflectiveBlockingService(serverImpl);

  // Get RPC server for server side implementation
  server = new RPC.Builder(conf).setProtocol(TestRpcService.class)
      .setInstance(service).setBindAddress(ADDRESS).setPort(PORT).build();
  addr = NetUtils.getConnectAddress(server);
  
  // now the second protocol
  PBServer2Impl server2Impl = new PBServer2Impl();
  BlockingService service2 = TestProtobufRpc2Proto
      .newReflectiveBlockingService(server2Impl);
  
  server.addProtocol(RPC.RpcKind.RPC_PROTOCOL_BUFFER, TestRpcService2.class,
      service2);
  server.start();
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  // create a server with two handlers
  server = new RPC.Builder(conf).setProtocol(Foo0.class)
      .setInstance(new Foo0Impl()).setBindAddress(ADDRESS).setPort(0)
      .setNumHandlers(2).setVerbose(false).build();
  server.addProtocol(RPC.RpcKind.RPC_WRITABLE, Foo1.class, new Foo1Impl());
  server.addProtocol(RPC.RpcKind.RPC_WRITABLE, Bar.class, new BarImpl());
  server.addProtocol(RPC.RpcKind.RPC_WRITABLE, Mixin.class, new BarImpl());
  
  
  // Add Protobuf server
  // Create server side implementation
  PBServerImpl pbServerImpl = 
      new PBServerImpl();
  BlockingService service = TestProtobufRpcProto
      .newReflectiveBlockingService(pbServerImpl);
  server.addProtocol(RPC.RpcKind.RPC_PROTOCOL_BUFFER, TestRpcService.class,
      service);
  server.start();
  addr = NetUtils.getConnectAddress(server);
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value="NP_NULL_ON_SOME_PATH",
    justification="Can't figure why this complaint is happening... see below")
Call(int id, final BlockingService service, final MethodDescriptor md, RequestHeader header,
     Message param, CellScanner cellScanner, Connection connection, Responder responder,
     long size, TraceInfo tinfo, final InetAddress remoteAddress) {
  this.id = id;
  this.service = service;
  this.md = md;
  this.header = header;
  this.param = param;
  this.cellScanner = cellScanner;
  this.connection = connection;
  this.timestamp = System.currentTimeMillis();
  this.response = null;
  this.responder = responder;
  this.isError = false;
  this.size = size;
  this.tinfo = tinfo;
  this.user = connection == null? null: connection.user; // FindBugs: NP_NULL_ON_SOME_PATH
  this.remoteAddress = remoteAddress;
  this.retryImmediatelySupported =
      connection == null? null: connection.retryImmediatelySupported;
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
@Before
public  void setUp() throws IOException { // Setup server for both protocols
  this.conf = HBaseConfiguration.create();
  Logger log = Logger.getLogger("org.apache.hadoop.ipc.HBaseServer");
  log.setLevel(Level.DEBUG);
  log = Logger.getLogger("org.apache.hadoop.ipc.HBaseServer.trace");
  log.setLevel(Level.TRACE);
  // Create server side implementation
  PBServerImpl serverImpl = new PBServerImpl();
  BlockingService service =
    TestRpcServiceProtos.TestProtobufRpcProto.newReflectiveBlockingService(serverImpl);
  // Get RPC server for server side implementation
  this.server = new RpcServer(null, "testrpc",
      Lists.newArrayList(new RpcServer.BlockingServiceAndInterface(service, null)),
      new InetSocketAddress(ADDRESS, PORT), conf,
      new FifoRpcScheduler(conf, 10));
  InetSocketAddress address = server.getListenerAddress();
  if (address == null) {
    throw new IOException("Listener channel is closed");
  }
  this.isa = address;
  this.server.start();
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
/**
 * Handle the blocking RPC request by forwarding it to the correct
 * service/method.
 *
 * @throws RpcException If there was some error executing the RPC.
 */
public SocketRpcProtos.Response doBlockingRpc(
    SocketRpcProtos.Request rpcRequest) throws RpcException {
  // Get the service, first try BlockingService
  BlockingService blockingService = blockingServiceMap.get(
      rpcRequest.getServiceName());
  if (blockingService != null) {
    return forwardToBlockingService(rpcRequest, blockingService);
  }

  // Now try Service
  Service service = serviceMap.get(rpcRequest.getServiceName());
  if (service == null) {
    throw new RpcException(ErrorReason.SERVICE_NOT_FOUND,
        "Could not find service: " + rpcRequest.getServiceName(), null);
  }

  // Call service using an instant callback
  Callback<Message> callback = new Callback<Message>();
  SocketRpcController socketController = new SocketRpcController();
  forwardToService(rpcRequest, callback, service, socketController);

  // Build and return response (callback invocation is optional)
  return createRpcResponse(callback.response, callback.invoked,
      socketController);
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
Call(int id, final BlockingService service, final MethodDescriptor md, RequestHeader header,
     Message param, CellScanner cellScanner, Connection connection, Responder responder,
     long size, TraceInfo tinfo) {
  this.id = id;
  this.service = service;
  this.md = md;
  this.header = header;
  this.param = param;
  this.cellScanner = cellScanner;
  this.connection = connection;
  this.timestamp = System.currentTimeMillis();
  this.response = null;
  this.delayResponse = false;
  this.responder = responder;
  this.isError = false;
  this.size = size;
  this.tinfo = tinfo;
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
/**
 * Initializes the client credentials for the current request.
 * @param user
 * @param remoteAddress
 * @param service
 */
public static void set(User user,
    InetAddress remoteAddress, BlockingService service) {
  RequestContext ctx = instance.get();
  ctx.user = user;
  ctx.remoteAddress = remoteAddress;
  ctx.service = service;
  ctx.inRequest = true;
  if (Trace.isTracing()) {
    if (user != null) {
      Trace.currentSpan().addKVAnnotation(Bytes.toBytes("user"), Bytes.toBytes(user.getName()));
    }
    if (remoteAddress != null) {
      Trace.currentSpan().addKVAnnotation(
          Bytes.toBytes("remoteAddress"),
          Bytes.toBytes(remoteAddress.getHostAddress()));
    }
  }
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
public TokenServer(Configuration conf) throws IOException {
  this.conf = conf;
  this.startcode = EnvironmentEdgeManager.currentTime();
  // Server to handle client requests.
  String hostname =
    Strings.domainNamePointerToHostName(DNS.getDefaultHost("default", "default"));
  int port = 0;
  // Creation of an ISA will force a resolve.
  InetSocketAddress initialIsa = new InetSocketAddress(hostname, port);
  if (initialIsa.getAddress() == null) {
    throw new IllegalArgumentException("Failed resolve of " + initialIsa);
  }
  final List<BlockingServiceAndInterface> sai =
    new ArrayList<BlockingServiceAndInterface>(1);
  BlockingService service =
    AuthenticationProtos.AuthenticationService.newReflectiveBlockingService(this);
  sai.add(new BlockingServiceAndInterface(service,
    AuthenticationProtos.AuthenticationService.BlockingInterface.class));
  this.rpcServer =
    new RpcServer(this, "tokenServer", sai, initialIsa, conf, new FifoRpcScheduler(conf, 1));
  this.isa = this.rpcServer.getListenerAddress();
  this.sleeper = new Sleeper(1000, this);
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
@Before
public  void setUp() throws IOException { // Setup server for both protocols
  this.conf = HBaseConfiguration.create();
  Logger log = Logger.getLogger("org.apache.hadoop.ipc.HBaseServer");
  log.setLevel(Level.DEBUG);
  log = Logger.getLogger("org.apache.hadoop.ipc.HBaseServer.trace");
  log.setLevel(Level.TRACE);
  // Create server side implementation
  PBServerImpl serverImpl = new PBServerImpl();
  BlockingService service =
    TestRpcServiceProtos.TestProtobufRpcProto.newReflectiveBlockingService(serverImpl);
  // Get RPC server for server side implementation
  this.server = new RpcServer(null, "testrpc",
      Lists.newArrayList(new RpcServer.BlockingServiceAndInterface(service, null)),
      new InetSocketAddress(ADDRESS, PORT), conf,
      new FifoRpcScheduler(conf, 10));
  this.isa = server.getListenerAddress();
  this.server.start();
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
public TokenServer(Configuration conf) throws IOException {
  this.conf = conf;
  this.startcode = EnvironmentEdgeManager.currentTimeMillis();
  // Server to handle client requests.
  String hostname =
    Strings.domainNamePointerToHostName(DNS.getDefaultHost("default", "default"));
  int port = 0;
  // Creation of an ISA will force a resolve.
  InetSocketAddress initialIsa = new InetSocketAddress(hostname, port);
  if (initialIsa.getAddress() == null) {
    throw new IllegalArgumentException("Failed resolve of " + initialIsa);
  }
  final List<BlockingServiceAndInterface> sai =
    new ArrayList<BlockingServiceAndInterface>(1);
  BlockingService service =
    AuthenticationProtos.AuthenticationService.newReflectiveBlockingService(this);
  sai.add(new BlockingServiceAndInterface(service,
    AuthenticationProtos.AuthenticationService.BlockingInterface.class));
  this.rpcServer =
    new RpcServer(this, "tokenServer", sai, initialIsa, conf, new FifoRpcScheduler(conf, 1));
  this.isa = this.rpcServer.getListenerAddress();
  this.sleeper = new Sleeper(1000, this);
}
 

import com.google.protobuf.BlockingService; //导入依赖的package包/类
private static Server createMockDatanode(BlockTokenSecretManager sm,
    Token<BlockTokenIdentifier> token, Configuration conf)
    throws IOException, ServiceException {
  ClientDatanodeProtocolPB mockDN = mock(ClientDatanodeProtocolPB.class);

  BlockTokenIdentifier id = sm.createIdentifier();
  id.readFields(
      new DataInputStream(new ByteArrayInputStream(token.getIdentifier())));
  
  doAnswer(new GetLengthAnswer(sm, id)).when(mockDN)
      .getReplicaVisibleLength(any(RpcController.class),
          any(GetReplicaVisibleLengthRequestProto.class));

  RPC.setProtocolEngine(conf, ClientDatanodeProtocolPB.class,
      ProtobufRpcEngine.class);
  BlockingService service =
      ClientDatanodeProtocolService.newReflectiveBlockingService(mockDN);
  return new RPC.Builder(conf).setProtocol(ClientDatanodeProtocolPB.class)
      .setInstance(service).setBindAddress(ADDRESS).setPort(0)
      .setNumHandlers(5).setVerbose(true).setSecretManager(sm).build();
}