Java RpcMetrics类代码示例

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
@Test(timeout = 12000)
public void testLogSlowRPC() throws IOException, ServiceException {
  TestRpcService2 client = getClient2();
  // make 10 K fast calls
  for (int x = 0; x < 10000; x++) {
    try {
      client.ping2(null, newEmptyRequest());
    } catch (Exception ex) {
      throw ex;
    }
  }

  // Ensure RPC metrics are updated
  RpcMetrics rpcMetrics = server.getRpcMetrics();
  assertTrue(rpcMetrics.getProcessingSampleCount() > 999L);
  long before = rpcMetrics.getRpcSlowCalls();

  // make a really slow call. Sleep sleeps for 1000ms
  client.sleep(null, newSleepRequest(SLEEP_DURATION * 3));

  long after = rpcMetrics.getRpcSlowCalls();
  // Ensure slow call is logged.
  Assert.assertEquals(before + 1L, after);
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
@Test(timeout = 12000)
public void testEnsureNoLogIfDisabled() throws IOException, ServiceException {
  // disable slow RPC  logging
  server.setLogSlowRPC(false);
  TestRpcService2 client = getClient2();

  // make 10 K fast calls
  for (int x = 0; x < 10000; x++) {
    client.ping2(null, newEmptyRequest());
  }

  // Ensure RPC metrics are updated
  RpcMetrics rpcMetrics = server.getRpcMetrics();
  assertTrue(rpcMetrics.getProcessingSampleCount() > 999L);
  long before = rpcMetrics.getRpcSlowCalls();

  // make a really slow call. Sleep sleeps for 1000ms
  client.sleep(null, newSleepRequest(SLEEP_DURATION));

  long after = rpcMetrics.getRpcSlowCalls();

  // make sure we never called into Log slow RPC routine.
  assertEquals(before, after);
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
@Test(timeout = 12000)
public void testLogSlowRPC() throws IOException, ServiceException {
  TestRpcService2 client = getClient2();
  // make 10 K fast calls
  for (int x = 0; x < 10000; x++) {
    try {
      EmptyRequestProto emptyRequest = EmptyRequestProto.newBuilder().build();
      client.ping2(null, emptyRequest);
    } catch (Exception ex) {
      throw ex;
    }
  }

  // Ensure RPC metrics are updated
  RpcMetrics rpcMetrics = server.getRpcMetrics();
  assertTrue(rpcMetrics.getProcessingSampleCount() > 999L);
  long before = rpcMetrics.getRpcSlowCalls();

  // make a really slow call. Sleep sleeps for 1000ms
  TestProtos.SleepRequestProto sleepRequest =
      TestProtos.SleepRequestProto.newBuilder()
          .setMilliSeconds(SLEEP_DURATION * 3).build();
  TestProtos.SleepResponseProto Response = client.sleep(null, sleepRequest);

  long after = rpcMetrics.getRpcSlowCalls();
  // Ensure slow call is logged.
  Assert.assertEquals(before + 1L, after);
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
@Test(timeout = 12000)
public void testEnsureNoLogIfDisabled() throws IOException, ServiceException {
  // disable slow RPC  logging
  server.setLogSlowRPC(false);
  TestRpcService2 client = getClient2();

  // make 10 K fast calls
  for (int x = 0; x < 10000; x++) {
    EmptyRequestProto emptyRequest = EmptyRequestProto.newBuilder().build();
    client.ping2(null, emptyRequest);
  }

  // Ensure RPC metrics are updated
  RpcMetrics rpcMetrics = server.getRpcMetrics();
  assertTrue(rpcMetrics.getProcessingSampleCount() > 999L);
  long before = rpcMetrics.getRpcSlowCalls();

  // make a really slow call. Sleep sleeps for 1000ms
  TestProtos.SleepRequestProto sleepRequest =
      TestProtos.SleepRequestProto.newBuilder()
          .setMilliSeconds(SLEEP_DURATION).build();
  TestProtos.SleepResponseProto Response = client.sleep(null, sleepRequest);

  long after = rpcMetrics.getRpcSlowCalls();

  // make sure we never called into Log slow RPC routine.
  assertEquals(before, after);
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
public ConnectionSet(String serverName, int numBuckets, RpcMetrics rpcMetrics) {
  if (Server.LOG.isDebugEnabled()) {
    Server.LOG.debug("Use " + numBuckets
        + " buckets for bucketizing connections of " + serverName);
  }
  this.numBuckets = numBuckets;
  connectionBuckets = new ConnectionBucket[numBuckets];
  this.rpcMetrics = rpcMetrics;
  this.serverName = serverName;
  for (int i = 0; i < connectionBuckets.length; i++) {
    connectionBuckets[i] = new ConnectionBucket();
  }
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
/** Constructs a server listening on the named port and address.  Parameters passed must
 * be of the named class.  The <code>handlerCount</handlerCount> determines
 * the number of handler threads that will be used to process calls.
 *
 */
protected Server(String bindAddress, int port,
                Class<? extends Writable> paramClass, int handlerCount,
                Configuration conf, String serverName)
  throws IOException {
  this.bindAddress = bindAddress;
  this.conf = conf;
  this.port = port;
  this.paramClass = paramClass;
  this.handlerCount = handlerCount;
  this.socketSendBufferSize = 0;
  this.maxQueueSize = handlerCount * conf.getInt(
                                 IPC_SERVER_HANDLER_QUEUE_SIZE_KEY,
                                 MAX_QUEUE_SIZE_PER_HANDLER);
  this.maxRespSize = conf.getInt(IPC_SERVER_RPC_MAX_RESPONSE_SIZE_KEY,
                                 IPC_SERVER_RPC_MAX_RESPONSE_SIZE_DEFAULT);
  this.readThreads = conf.getInt(IPC_SERVER_RPC_READ_THREADS_KEY,
                                 IPC_SERVER_RPC_READ_THREADS_DEFAULT);
  this.callQueue  = new LinkedBlockingQueue<Call>(maxQueueSize);
  this.maxIdleTime = 2*conf.getInt("ipc.client.connection.maxidletime", 1000);
  this.maxConnectionsToNuke = conf.getInt("ipc.client.kill.max", 10);
  this.thresholdIdleConnections = conf.getInt("ipc.client.idlethreshold", 4000);

  // Start the listener here and let it bind to the port
  listener = new Listener();
  this.port = listener.getAddress().getPort();
  this.rpcMetrics = new RpcMetrics(serverName,
                        Integer.toString(this.port), this);
  this.tcpNoDelay = conf.getBoolean("ipc.server.tcpnodelay", false);


  // Create the responder here
  responder = new Responder();
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
/** Constructs a server listening on the named port and address.  Parameters passed must
 * be of the named class.  The <code>handlerCount</handlerCount> determines
 * the number of handler threads that will be used to process calls.
 * 
 */
protected Server(String bindAddress, int port, 
                Class<? extends Writable> paramClass, int handlerCount, 
                Configuration conf, String serverName) 
  throws IOException {
  this.bindAddress = bindAddress;
  this.conf = conf;
  this.port = port;
  this.paramClass = paramClass;
  this.handlerCount = handlerCount;
  this.socketSendBufferSize = 0;
  this.maxQueueSize = handlerCount * conf.getInt(
                              IPC_SERVER_HANDLER_QUEUE_SIZE_KEY,
                              IPC_SERVER_HANDLER_QUEUE_SIZE_DEFAULT);
  this.callQueue  = new LinkedBlockingQueue<Call>(maxQueueSize); 
  this.maxIdleTime = 2*conf.getInt("ipc.client.connection.maxidletime", 1000);
  this.maxConnectionsToNuke = conf.getInt("ipc.client.kill.max", 10);
  this.thresholdIdleConnections = conf.getInt("ipc.client.idlethreshold", 4000);
  
  // Start the listener here and let it bind to the port
  listener = new Listener();
  this.port = listener.getAddress().getPort();    
  this.rpcMetrics = new RpcMetrics(serverName,
                        Integer.toString(this.port), this);
  this.tcpNoDelay = conf.getBoolean("ipc.server.tcpnodelay", false);


  // Create the responder here
  responder = new Responder();
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
/** Constructs a server listening on the named port and address.  Parameters passed must
 * be of the named class.  The <code>handlerCount</handlerCount> determines
 * the number of handler threads that will be used to process calls.
 * 
 */
protected Server(String bindAddress, int port, 
                Class<? extends Writable> paramClass, int handlerCount, 
                Configuration conf, String serverName) 
  throws IOException {
  this.bindAddress = bindAddress;
  this.conf = conf;
  this.port = port;
  this.paramClass = paramClass;
  this.handlerCount = handlerCount;
  this.socketSendBufferSize = 0;
  this.maxQueueSize = handlerCount * MAX_QUEUE_SIZE_PER_HANDLER;
  this.callQueue  = new LinkedBlockingQueue<Call>(maxQueueSize); 
  this.maxIdleTime = 2*conf.getInt("ipc.client.connection.maxidletime", 1000);
  this.maxConnectionsToNuke = conf.getInt("ipc.client.kill.max", 10);
  this.thresholdIdleConnections = conf.getInt("ipc.client.idlethreshold", 4000);
  
  // Start the listener here and let it bind to the port
  listener = new Listener();
  this.port = listener.getAddress().getPort();    
  this.rpcMetrics = new RpcMetrics(serverName,
                        Integer.toString(this.port), this);
  this.tcpNoDelay = conf.getBoolean("ipc.server.tcpnodelay", false);


  // Create the responder here
  responder = new Responder();
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
/**
 * Returns a handle to the rpcMetrics (required in tests)
 * @return rpc metrics
 */
@VisibleForTesting
public RpcMetrics getRpcMetrics() {
  return rpcMetrics;
}
 

import org.apache.hadoop.ipc.metrics.RpcMetrics; //导入依赖的package包/类
/** Constructs a server listening on the named port and address.  Parameters passed must
 * be of the named class.  The <code>handlerCount</handlerCount> determines
 * the number of handler threads that will be used to process calls.
 *
 */
protected Server(String bindAddress, int port,
                Class<? extends Writable> paramClass, int handlerCount,
                Configuration conf, String serverName, boolean supportOldJobConf)
  throws IOException {
  
  this.bindAddress = bindAddress;
  this.conf = conf;
  this.port = port;
  this.paramClass = paramClass;
  this.isInvocationClass = paramClass.equals(Invocation.class);
  this.directHandling = conf.getBoolean("ipc.direct.handling", false);
  
  if (directHandling) {
    LOG.info("Starting direct handler server");
    // reader threads are directly calling protocol methods
    this.handlerCount = 0;
    // make the direct buffer size bigger for faster reads
    NIO_BUFFER_LIMIT = 8 * NIO_BUFFER_LIMIT_BASE;
    // initial response buffer size must be at least the size
    // of max NIO_BUFFER_LIMIT (see channelIO())
    INITIAL_RESP_BUF_SIZE = NIO_BUFFER_LIMIT;
  } else {
    // reader threads populate callQueue, calls are executed by handlers
    this.handlerCount = handlerCount;
  }
  
  this.socketSendBufferSize = 0;
  this.maxQueueSize = handlerCount * conf.getInt(
                                 IPC_SERVER_HANDLER_QUEUE_SIZE_KEY,
                                 MAX_QUEUE_SIZE_PER_HANDLER);
  this.maxRespSize = conf.getInt(IPC_SERVER_RPC_MAX_RESPONSE_SIZE_KEY,
                                 IPC_SERVER_RPC_MAX_RESPONSE_SIZE_DEFAULT);
  this.readThreads = conf.getInt(IPC_SERVER_RPC_READ_THREADS_KEY,
                                 IPC_SERVER_RPC_READ_THREADS_DEFAULT);
  this.supportOldJobConf = supportOldJobConf;
  conf.setBoolean("rpc.support.jobconf", supportOldJobConf);
  this.callQueue  = new ArrayBlockingQueue<Call>(maxQueueSize);
  this.maxIdleTime = 2*conf.getInt(IPC_SERVER_CLIENT_CONN_MAXIDLETIME, 1000);
  this.thresholdIdleConnections = conf.getInt(IPC_SERVER_CLIENT_IDLETHRESHOLD, 4000);

  // Start the listener here and let it bind to the port
  listener = new Listener();
  this.port = listener.getAddress().getPort();
  this.rpcMetrics = new RpcMetrics(serverName,
                        Integer.toString(this.port), this);
  // For now, we use readThreads*4 as connection bucket numbers for simplicity.
  this.connectionSet = new ConnectionSet(getIpcServerName(), readThreads * 4,
      rpcMetrics);
  this.tcpNoDelay = conf.getBoolean("ipc.server.tcpnodelay", false);
  this.pollingInterval = conf.getLong("rpc.polling.interval", 1000);

  // Create the responder here
  responder = new Responder();
}