Java HConstants.CLUSTER_ID_DEFAULT屬性代碼示例

@Ignore
@Test
public void testRpcScheduler() throws IOException, InterruptedException {
  PriorityFunction qosFunction = mock(PriorityFunction.class);
  Abortable abortable = new AbortServer();
  RpcScheduler scheduler = new SimpleRpcScheduler(CONF, 2, 0, 0, qosFunction, abortable, 0);
  RpcServer rpcServer = new TestRpcServer(scheduler);
  RpcClientImpl client = new RpcClientImpl(CONF, HConstants.CLUSTER_ID_DEFAULT);
  try {
    rpcServer.start();
    MethodDescriptor md = SERVICE.getDescriptorForType().findMethodByName("echo");
    EchoRequestProto param = EchoRequestProto.newBuilder().setMessage("hello").build();
    PayloadCarryingRpcController controller =
        new PayloadCarryingRpcController(CellUtil.createCellScanner(ImmutableList.of(CELL)));
    InetSocketAddress address = rpcServer.getListenerAddress();
    if (address == null) {
      throw new IOException("Listener channel is closed");
    }
    client.call(controller, md, param, md.getOutputType().toProto(), User.getCurrent(),
        address, new MetricsConnection.CallStats());
  } catch (Throwable e) {
    assert(abortable.isAborted() == true);
  } finally {
    rpcServer.stop();
  }
}
 

@Override
protected RpcClientImpl createRpcClientNoCodec(Configuration conf) {
  return new RpcClientImpl(conf, HConstants.CLUSTER_ID_DEFAULT) {
    @Override
    Codec getCodec() {
      return null;
    }
  };
}
 

@Override
protected RpcClientImpl createRpcClientRTEDuringConnectionSetup(Configuration conf)
    throws IOException {
  SocketFactory spyFactory = spy(NetUtils.getDefaultSocketFactory(conf));
  Mockito.doAnswer(new Answer<Socket>() {
    @Override
    public Socket answer(InvocationOnMock invocation) throws Throwable {
      Socket s = spy((Socket) invocation.callRealMethod());
      doThrow(new RuntimeException("Injected fault")).when(s).setSoTimeout(anyInt());
      return s;
    }
  }).when(spyFactory).createSocket();

  return new RpcClientImpl(conf, HConstants.CLUSTER_ID_DEFAULT, spyFactory);
}
 

/**
 * Tests that the RpcServer creates & dispatches CallRunner object to scheduler with non-null
 * remoteAddress set to its Call Object
 * @throws ServiceException
 */
@Test
public void testRpcServerForNotNullRemoteAddressInCallObject() throws IOException,
    ServiceException {
  final RpcScheduler scheduler = new FifoRpcScheduler(CONF, 1);
  final TestRpcServer1 rpcServer = new TestRpcServer1(scheduler);
  final InetSocketAddress localAddr = new InetSocketAddress("localhost", 0);
  final AbstractRpcClient client =
      new RpcClientImpl(CONF, HConstants.CLUSTER_ID_DEFAULT, localAddr, null);
  try {
    rpcServer.start();
    final InetSocketAddress isa = rpcServer.getListenerAddress();
    if (isa == null) {
      throw new IOException("Listener channel is closed");
    }
    final BlockingRpcChannel channel =
        client.createBlockingRpcChannel(
          ServerName.valueOf(isa.getHostName(), isa.getPort(), System.currentTimeMillis()),
          User.getCurrent(), 0);
    TestRpcServiceProtos.TestProtobufRpcProto.BlockingInterface stub =
        TestRpcServiceProtos.TestProtobufRpcProto.newBlockingStub(channel);
    final EchoRequestProto echoRequest =
        EchoRequestProto.newBuilder().setMessage("GetRemoteAddress").build();
    final EchoResponseProto echoResponse = stub.echo(null, echoRequest);
    Assert.assertEquals(localAddr.getAddress().getHostAddress(), echoResponse.getMessage());
  } finally {
    client.close();
    rpcServer.stop();
  }
}
 

protected AbstractRpcClient createRpcClient(Configuration conf, boolean isSyncClient) {
  return isSyncClient ?
      new RpcClientImpl(conf, HConstants.CLUSTER_ID_DEFAULT) :
        new AsyncRpcClient(conf) {
        @Override
        Codec getCodec() {
          return null;
        }
      };
}
 

void retrieveClusterId() {
  if (clusterId != null) return;
  this.clusterId = this.registry.getClusterId();
  if (clusterId == null) {
    clusterId = HConstants.CLUSTER_ID_DEFAULT;
    LOG.debug("clusterid came back null, using default " + clusterId);
  }
}
 

/**
 * Construct an IPC client for the cluster <code>clusterId</code>
 *
 * @param conf configuration
 * @param clusterId the cluster id
 * @param localAddr client socket bind address.
 * @param metrics the connection metrics
 */
public AbstractRpcClient(Configuration conf, String clusterId, SocketAddress localAddr,
    MetricsConnection metrics) {
  this.userProvider = UserProvider.instantiate(conf);
  this.localAddr = localAddr;
  this.tcpKeepAlive = conf.getBoolean("hbase.ipc.client.tcpkeepalive", true);
  this.clusterId = clusterId != null ? clusterId : HConstants.CLUSTER_ID_DEFAULT;
  this.failureSleep = conf.getLong(HConstants.HBASE_CLIENT_PAUSE,
      HConstants.DEFAULT_HBASE_CLIENT_PAUSE);
  this.maxRetries = conf.getInt("hbase.ipc.client.connect.max.retries", 0);
  this.tcpNoDelay = conf.getBoolean("hbase.ipc.client.tcpnodelay", true);
  this.ipcUtil = new IPCUtil(conf);

  this.minIdleTimeBeforeClose = conf.getInt(IDLE_TIME, 120000); // 2 minutes
  this.conf = conf;
  this.codec = getCodec();
  this.compressor = getCompressor(conf);
  this.fallbackAllowed = conf.getBoolean(IPC_CLIENT_FALLBACK_TO_SIMPLE_AUTH_ALLOWED_KEY,
      IPC_CLIENT_FALLBACK_TO_SIMPLE_AUTH_ALLOWED_DEFAULT);
  this.connectTO = conf.getInt(SOCKET_TIMEOUT_CONNECT, DEFAULT_SOCKET_TIMEOUT_CONNECT);
  this.readTO = conf.getInt(SOCKET_TIMEOUT_READ, DEFAULT_SOCKET_TIMEOUT_READ);
  this.writeTO = conf.getInt(SOCKET_TIMEOUT_WRITE, DEFAULT_SOCKET_TIMEOUT_WRITE);
  this.metrics = metrics;

  // login the server principal (if using secure Hadoop)
  if (LOG.isDebugEnabled()) {
    LOG.debug("Codec=" + this.codec + ", compressor=" + this.compressor +
        ", tcpKeepAlive=" + this.tcpKeepAlive +
        ", tcpNoDelay=" + this.tcpNoDelay +
        ", connectTO=" + this.connectTO +
        ", readTO=" + this.readTO +
        ", writeTO=" + this.writeTO +
        ", minIdleTimeBeforeClose=" + this.minIdleTimeBeforeClose +
        ", maxRetries=" + this.maxRetries +
        ", fallbackAllowed=" + this.fallbackAllowed +
        ", bind address=" + (this.localAddr != null ? this.localAddr : "null"));
  }
}
 

@Override
protected RpcClientImpl createRpcClient(Configuration conf) {
  return new RpcClientImpl(conf, HConstants.CLUSTER_ID_DEFAULT);
}
 

public static void main(String[] args) throws IOException, SecurityException,
    NoSuchMethodException, InterruptedException {
  if (args.length != 2) {
    System.out.println("Usage: TestIPC <CYCLES> <CELLS_PER_CYCLE>");
    return;
  }
  // ((Log4JLogger)HBaseServer.LOG).getLogger().setLevel(Level.INFO);
  // ((Log4JLogger)HBaseClient.LOG).getLogger().setLevel(Level.INFO);
  int cycles = Integer.parseInt(args[0]);
  int cellcount = Integer.parseInt(args[1]);
  Configuration conf = HBaseConfiguration.create();
  TestRpcServer rpcServer = new TestRpcServer();
  MethodDescriptor md = SERVICE.getDescriptorForType().findMethodByName("echo");
  EchoRequestProto param = EchoRequestProto.newBuilder().setMessage("hello").build();
  RpcClientImpl client = new RpcClientImpl(conf, HConstants.CLUSTER_ID_DEFAULT);
  KeyValue kv = BIG_CELL;
  Put p = new Put(CellUtil.cloneRow(kv));
  for (int i = 0; i < cellcount; i++) {
    p.add(kv);
  }
  RowMutations rm = new RowMutations(CellUtil.cloneRow(kv));
  rm.add(p);
  try {
    rpcServer.start();
    long startTime = System.currentTimeMillis();
    User user = User.getCurrent();
    InetSocketAddress address = rpcServer.getListenerAddress();
    if (address == null) {
      throw new IOException("Listener channel is closed");
    }
    for (int i = 0; i < cycles; i++) {
      List<CellScannable> cells = new ArrayList<CellScannable>();
      // Message param = RequestConverter.buildMultiRequest(HConstants.EMPTY_BYTE_ARRAY, rm);
      ClientProtos.RegionAction.Builder builder =
          RequestConverter.buildNoDataRegionAction(HConstants.EMPTY_BYTE_ARRAY, rm, cells,
            RegionAction.newBuilder(), ClientProtos.Action.newBuilder(),
            MutationProto.newBuilder());
      builder.setRegion(RegionSpecifier
          .newBuilder()
          .setType(RegionSpecifierType.REGION_NAME)
          .setValue(
            ByteString.copyFrom(HRegionInfo.FIRST_META_REGIONINFO.getEncodedNameAsBytes())));
      if (i % 100000 == 0) {
        LOG.info("" + i);
        // Uncomment this for a thread dump every so often.
        // ReflectionUtils.printThreadInfo(new PrintWriter(System.out),
        // "Thread dump " + Thread.currentThread().getName());
      }
      PayloadCarryingRpcController pcrc =
          new PayloadCarryingRpcController(CellUtil.createCellScanner(cells));
      // Pair<Message, CellScanner> response =
      client.call(pcrc, md, builder.build(), param, user, address,
          new MetricsConnection.CallStats());
      /*
       * int count = 0; while (p.getSecond().advance()) { count++; } assertEquals(cells.size(),
       * count);
       */
    }
    LOG.info("Cycled " + cycles + " time(s) with " + cellcount + " cell(s) in "
        + (System.currentTimeMillis() - startTime) + "ms");
  } finally {
    client.close();
    rpcServer.stop();
  }
}
 

/** Used in test only. */
AsyncRpcClient(Configuration configuration) {
  this(configuration, HConstants.CLUSTER_ID_DEFAULT, null, null);
}
 

@Override
public String getClusterId() {
  return HConstants.CLUSTER_ID_DEFAULT;
}