public Client(Class valueClass,
    Configuration conf) 
{
    this.valueClass = valueClass;
    this.timeout = conf.getInt("ipc.client.timeout", 10000);
    this.maxIdleTime = conf.getInt("ipc.client.connection.maxidletime", 1000);
    this.maxRetries = conf.getInt("ipc.client.connect.max.retries", 10);
    this.conf = conf;
    Thread t = new ConnectionCuller();
    t.setDaemon(true);
    t.setName(valueClass.getName() + " Connection Culler");
    LOG.debug(valueClass.getName() + 
              "Connection culler maxidletime= " + maxIdleTime + "ms");
    t.start();
}

Construct an IPC client whose values are of the given Writable class.

 public Writable call(Writable param,
    InetSocketAddress address) throws IOException, InterruptedException 
{
    Connection connection = getConnection(address);
    Call call = new Call(param);
    synchronized (call) {
      connection.sendParam(call);                 // send the parameter
      long wait = timeout;
      do {
        call.wait(wait);                       // wait for the result
        wait = timeout - (System.currentTimeMillis() - call.lastActivity);
      } while (!call.done && wait  > 0);
      if (call.error != null) {
        throw new RemoteException(call.errorClass, call.error);
      } else if (!call.done) {
        throw new SocketTimeoutException("timed out waiting for rpc response");
      } else {
        return call.value;
      }
    }
}

Make a call, passing param, to the IPC server running at address, returning the value. Throws exceptions if there are network problems or if the remote code threw an exception.

 public Writable[] call(Writable[] params,
    InetSocketAddress[] addresses) throws IOException 
{
    if (addresses.length == 0) return new Writable[0];
    ParallelResults results = new ParallelResults(params.length);
    synchronized (results) {
      for (int i = 0; i <  params.length; i++) {
        ParallelCall call = new ParallelCall(params[i], results, i);
        try {
          Connection connection = getConnection(addresses[i]);
          connection.sendParam(call);             // send each parameter
        } catch (IOException e) {
          LOG.info("Calling "+addresses[i]+" caught: " + 
                   StringUtils.stringifyException(e)); // log errors
          results.size--;                         //  wait for one fewer result
        }
      }
      try {
        results.wait(timeout);                    // wait for all results
      } catch (InterruptedException e) {}
      if (results.count == 0) {
        throw new IOException("no responses");
      } else {
        return results.values;
      }
    }
}

Makes a set of calls in parallel. Each parameter is sent to the corresponding address. When all values are available, or have timed out or errored, the collected results are returned in an array. The array contains nulls for calls that timed out or errored.

 public  void setTimeout(int timeout) 
{
 this.timeout = timeout;
}

Sets the timeout used for network i/o.

 public  void stop() 
{
    LOG.info("Stopping client");
    running = false;
}

Stop all threads related to this client. No further calls may be made using this client.