RpcServer (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.ipc.RpcServer

All Implemented Interfaces:

ConfigurationObserver, RpcServerInterface
```
@InterfaceAudience.LimitedPrivate(value={"Coprocesssor","Phoenix"})
@InterfaceStability.Evolving
public class RpcServer
extends Object
implements RpcServerInterface, ConfigurationObserver
```
An RPC server that hosts protobuf described Services. An RpcServer instance has a Listener that hosts the socket. Listener has fixed number of Readers in an ExecutorPool, 10 by default. The Listener does an accept and then round robin a Reader is chosen to do the read. The reader is registered on Selector. Read does total read off the channel and the parse from which it makes a Call. The call is wrapped in a CallRunner and passed to the scheduler to be run. Reader goes back to see if more to be done and loops till done.
Scheduler can be variously implemented but default simple scheduler has handlers to which it has given the queues into which calls (i.e. CallRunner instances) are inserted. Handlers run taking from the queue. They run the CallRunner#run method on each item gotten from queue and keep taking while the server is up. CallRunner#run executes the call. When done, asks the included Call to put itself on new queue for Responder to pull from and return result to client.

See Also:
RpcClientImpl

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`RpcServer.BlockingServiceAndInterface` Datastructure for passing a `BlockingService` and its associated class of protobuf service interface.
`class`	`RpcServer.Call` Datastructure that holds all necessary to a method invocation and then afterward, carries the result.
`class`	`RpcServer.Connection` Reads calls from a connection and queues them for handling.
`private class`	`RpcServer.Listener` Listens on the socket.
`protected class`	`RpcServer.Responder`

Field Summary

Fields
Modifier and Type	Field and Description
`protected InetSocketAddress`	`address`
`private boolean`	`allowFallbackToSimpleAuth`
`private static org.apache.commons.logging.Log`	`AUDITLOG`
`private static String`	`AUTH_FAILED_FOR`
`private static String`	`AUTH_SUCCESSFUL_FOR`
`protected org.apache.hadoop.security.authorize.ServiceAuthorizationManager`	`authManager`
`private boolean`	`authorize`
`protected AuthenticationTokenSecretManager`	`authTokenSecretMgr`
`protected InetSocketAddress`	`bindAddress`
`private static CallQueueTooBigException`	`CALL_QUEUE_TOO_BIG_EXCEPTION`
`protected Counter`	`callQueueSize` This is a running count of the size of all outstanding calls by size.
`protected org.apache.hadoop.conf.Configuration`	`conf`
`protected List<RpcServer.Connection>`	`connectionList`
`protected static ThreadLocal<RpcServer.Call>`	`CurCall` This is set to Call object before Handler invokes an RPC and ybdie after the call returns.
`static byte`	`CURRENT_VERSION`
`(package private) static int`	`DEFAULT_MAX_CALLQUEUE_LENGTH_PER_HANDLER` How many calls/handler are allowed in the queue.
`private static int`	`DEFAULT_MAX_CALLQUEUE_SIZE` The maximum size that we can hold in the RPC queue
`private static int`	`DEFAULT_WARN_RESPONSE_SIZE`
`private static int`	`DEFAULT_WARN_RESPONSE_TIME` Default value for above params
`protected HBaseRPCErrorHandler`	`errorHandler`
`static String`	`FALLBACK_TO_INSECURE_CLIENT_AUTH` Whether we allow a fallback to SIMPLE auth for insecure clients when security is enabled.
`private IPCUtil`	`ipcUtil`
`private boolean`	`isSecurityEnabled`
`private RpcServer.Listener`	`listener`
`static org.apache.commons.logging.Log`	`LOG`
`private static org.codehaus.jackson.map.ObjectMapper`	`MAPPER`
`(package private) int`	`maxConnectionsToNuke`
`protected int`	`maxIdleTime`
`private int`	`maxQueueSize`
`protected MetricsHBaseServer`	`metrics`
`(package private) static ThreadLocal<MonitoredRPCHandler>`	`MONITORED_RPC` Keeps MonitoredRPCHandler per handler thread.
`private static int`	`NIO_BUFFER_LIMIT` When the read or write buffer size is larger than this limit, i/o will be done in chunks of this size.
`protected int`	`numConnections`
`protected int`	`port`
`protected long`	`purgeTimeout`
`private int`	`readThreads`
`private BoundedByteBufferPool`	`reservoir`
`protected RpcServer.Responder`	`responder`
`private RSRpcServices`	`rsRpcServices` Used to get details for scan with a scanner_id TODO try to figure out a better way and remove reference from regionserver package later.
`(package private) boolean`	`running` This flag is used to indicate to sub threads when they should go down.
`private RpcScheduler`	`scheduler`
`protected org.apache.hadoop.security.token.SecretManager<org.apache.hadoop.security.token.TokenIdentifier>`	`secretManager`
`private Server`	`server`
`private List<RpcServer.BlockingServiceAndInterface>`	`services`
`protected int`	`socketSendBufferSize`
`(package private) boolean`	`started` This flag is set to true after all threads are up and 'running' and the server is then opened for business by the call to `start()`.
`protected boolean`	`tcpKeepAlive`
`protected boolean`	`tcpNoDelay`
`protected int`	`thresholdIdleConnections`
`private UserProvider`	`userProvider`
`private static String`	`WARN_RESPONSE_SIZE`
`private static String`	`WARN_RESPONSE_TIME`
`private int`	`warnResponseSize`
`private int`	`warnResponseTime`

Constructor Summary

Constructors
Constructor and Description
`RpcServer(Server server, String name, List<RpcServer.BlockingServiceAndInterface> services, InetSocketAddress bindAddress, org.apache.hadoop.conf.Configuration conf, RpcScheduler scheduler)` Constructs a server listening on the named port and address.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addCallSize(long diff)` Add/subtract from the current size of all outstanding calls.
`void`	`authorize(org.apache.hadoop.security.UserGroupInformation user, org.apache.hadoop.hbase.protobuf.generated.RPCProtos.ConnectionHeader connection, InetAddress addr)` Authorize the incoming client connection.
`static void`	`bind(ServerSocket socket, InetSocketAddress address, int backlog)` A convenience method to bind to a given address and report better exceptions if the address is not a valid host.
`Pair<com.google.protobuf.Message,CellScanner>`	`call(com.google.protobuf.BlockingService service, com.google.protobuf.Descriptors.MethodDescriptor md, com.google.protobuf.Message param, CellScanner cellScanner, long receiveTime, MonitoredRPCHandler status)` This is a server side method, which is invoked over RPC.
`private static int`	`channelIO(ReadableByteChannel readCh, WritableByteChannel writeCh, ByteBuffer buf)` Helper for `channelRead(java.nio.channels.ReadableByteChannel, java.nio.ByteBuffer)` and `channelWrite(GatheringByteChannel, BufferChain)`.
`protected int`	`channelRead(ReadableByteChannel channel, ByteBuffer buffer)` This is a wrapper around `ReadableByteChannel.read(java.nio.ByteBuffer)`.
`protected long`	`channelWrite(GatheringByteChannel channel, BufferChain bufferChain)` This is a wrapper around `WritableByteChannel.write(java.nio.ByteBuffer)`.
`protected void`	`closeConnection(RpcServer.Connection connection)`
`private AuthenticationTokenSecretManager`	`createSecretManager()`
`(package private) org.apache.hadoop.conf.Configuration`	`getConf()`
`protected RpcServer.Connection`	`getConnection(SocketChannel channel, long time)` Subclasses of HBaseServer can override this to provide their own Connection implementations.
`static RpcCallContext`	`getCurrentCall()` Needed for features such as delayed calls.
`HBaseRPCErrorHandler`	`getErrorHandler()`
`InetSocketAddress`	`getListenerAddress()` Return the socket (ip+port) on which the RPC server is listening to.
`MetricsHBaseServer`	`getMetrics()` Returns the metrics instance for reporting RPC call statistics
`static InetAddress`	`getRemoteAddress()`
`static InetAddress`	`getRemoteIp()` Returns the remote side ip address when invoked inside an RPC Returns null incase of an error.
`static User`	`getRequestUser()` Returns the user credentials associated with the current RPC request or `null` if no credentials were provided.
`static String`	`getRequestUserName()` Returns the username for any user associated with the current RPC request or `null` if no user is set.
`RpcScheduler`	`getScheduler()`
`org.apache.hadoop.security.token.SecretManager<? extends org.apache.hadoop.security.token.TokenIdentifier>`	`getSecretManager()`
`(package private) static com.google.protobuf.BlockingService`	`getService(List<RpcServer.BlockingServiceAndInterface> services, String serviceName)`
`(package private) static RpcServer.BlockingServiceAndInterface`	`getServiceAndInterface(List<RpcServer.BlockingServiceAndInterface> services, String serviceName)`
`(package private) static Class<?>`	`getServiceInterface(List<RpcServer.BlockingServiceAndInterface> services, String serviceName)`
`(package private) static MonitoredRPCHandler`	`getStatus()`
`private void`	`initReconfigurable(org.apache.hadoop.conf.Configuration confToLoad)`
`static boolean`	`isInRpcCallContext()`
`boolean`	`isStarted()`
`void`	`join()` Wait for the server to be stopped.
`(package private) void`	`logResponse(com.google.protobuf.Message param, String methodName, String call, String tag, String clientAddress, long startTime, int processingTime, int qTime, long responseSize)` Logs an RPC response to the LOG file, producing valid JSON objects for client Operations.
`void`	`onConfigurationChange(org.apache.hadoop.conf.Configuration newConf)` This method would be called by the `ConfigurationManager` object when the `Configuration` object is reloaded from disk.
`void`	`refreshAuthManager(org.apache.hadoop.security.authorize.PolicyProvider pp)` Refresh authentication manager policy.
`void`	`setErrorHandler(HBaseRPCErrorHandler handler)` Set the handler for calling out of RPC for error conditions.
`void`	`setRsRpcServices(RSRpcServices rsRpcServices)`
`void`	`setSecretManager(org.apache.hadoop.security.token.SecretManager<? extends org.apache.hadoop.security.token.TokenIdentifier> secretManager)`
`void`	`setSocketSendBufSize(int size)` Sets the socket buffer size used for responding to RPCs.
`private void`	`setupResponse(ByteArrayOutputStream response, RpcServer.Call call, Throwable t, String error)` Setup response for the RPC Call.
`void`	`start()` Starts the service.
`void`	`stop()` Stops the service.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LOG
```
public static final org.apache.commons.logging.Log LOG
```
  - CALL_QUEUE_TOO_BIG_EXCEPTION
```
private static final CallQueueTooBigException CALL_QUEUE_TOO_BIG_EXCEPTION
```
  - authorize
```
private final boolean authorize
```
  - isSecurityEnabled
```
private boolean isSecurityEnabled
```
  - CURRENT_VERSION
```
public static final byte CURRENT_VERSION
```
    See Also:
    Constant Field Values
  - FALLBACK_TO_INSECURE_CLIENT_AUTH
```
public static final String FALLBACK_TO_INSECURE_CLIENT_AUTH
```
    Whether we allow a fallback to SIMPLE auth for insecure clients when security is enabled.
    
    See Also:
    Constant Field Values
  - DEFAULT_MAX_CALLQUEUE_LENGTH_PER_HANDLER
```
static final int DEFAULT_MAX_CALLQUEUE_LENGTH_PER_HANDLER
```
    How many calls/handler are allowed in the queue.
    
    See Also:
    Constant Field Values
  - DEFAULT_MAX_CALLQUEUE_SIZE
```
private static final int DEFAULT_MAX_CALLQUEUE_SIZE
```
    The maximum size that we can hold in the RPC queue
    
    See Also:
    Constant Field Values
  - ipcUtil
```
private final IPCUtil ipcUtil
```
  - AUTH_FAILED_FOR
```
private static final String AUTH_FAILED_FOR
```
    See Also:
    Constant Field Values
  - AUTH_SUCCESSFUL_FOR
```
private static final String AUTH_SUCCESSFUL_FOR
```
    See Also:
    Constant Field Values
  - AUDITLOG
```
private static final org.apache.commons.logging.Log AUDITLOG
```
  - secretManager
```
protected org.apache.hadoop.security.token.SecretManager<org.apache.hadoop.security.token.TokenIdentifier> secretManager
```
  - authManager
```
protected org.apache.hadoop.security.authorize.ServiceAuthorizationManager authManager
```
  - CurCall
```
protected static final ThreadLocal<RpcServer.Call> CurCall
```
    This is set to Call object before Handler invokes an RPC and ybdie after the call returns.
  - MONITORED_RPC
```
static final ThreadLocal<MonitoredRPCHandler> MONITORED_RPC
```
    Keeps MonitoredRPCHandler per handler thread.
  - bindAddress
```
protected final InetSocketAddress bindAddress
```
  - port
```
protected int port
```
  - address
```
protected InetSocketAddress address
```
  - readThreads
```
private int readThreads
```
  - maxIdleTime
```
protected int maxIdleTime
```
  - thresholdIdleConnections
```
protected int thresholdIdleConnections
```
  - maxConnectionsToNuke
```
int maxConnectionsToNuke
```
  - metrics
```
protected MetricsHBaseServer metrics
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - maxQueueSize
```
private int maxQueueSize
```
  - socketSendBufferSize
```
protected int socketSendBufferSize
```
  - tcpNoDelay
```
protected final boolean tcpNoDelay
```
  - tcpKeepAlive
```
protected final boolean tcpKeepAlive
```
  - purgeTimeout
```
protected final long purgeTimeout
```
  - running
```
volatile boolean running
```
    This flag is used to indicate to sub threads when they should go down. When we call start(), all threads started will consult this flag on whether they should keep going. It is set to false when stop() is called.
  - started
```
volatile boolean started
```
    This flag is set to true after all threads are up and 'running' and the server is then opened for business by the call to start().
  - callQueueSize
```
protected final Counter callQueueSize
```
    This is a running count of the size of all outstanding calls by size.
  - connectionList
```
protected final List<RpcServer.Connection> connectionList
```
  - listener
```
private RpcServer.Listener listener
```
  - responder
```
protected RpcServer.Responder responder
```
  - authTokenSecretMgr
```
protected AuthenticationTokenSecretManager authTokenSecretMgr
```
  - numConnections
```
protected int numConnections
```
  - errorHandler
```
protected HBaseRPCErrorHandler errorHandler
```
  - WARN_RESPONSE_TIME
```
private static final String WARN_RESPONSE_TIME
```
    See Also:
    Constant Field Values
  - WARN_RESPONSE_SIZE
```
private static final String WARN_RESPONSE_SIZE
```
    See Also:
    Constant Field Values
  - DEFAULT_WARN_RESPONSE_TIME
```
private static final int DEFAULT_WARN_RESPONSE_TIME
```
    Default value for above params
    
    See Also:
    Constant Field Values
  - DEFAULT_WARN_RESPONSE_SIZE
```
private static final int DEFAULT_WARN_RESPONSE_SIZE
```
    See Also:
    Constant Field Values
  - MAPPER
```
private static final org.codehaus.jackson.map.ObjectMapper MAPPER
```
  - warnResponseTime
```
private final int warnResponseTime
```
  - warnResponseSize
```
private final int warnResponseSize
```
  - server
```
private final Server server
```
  - services
```
private final List<RpcServer.BlockingServiceAndInterface> services
```
  - scheduler
```
private final RpcScheduler scheduler
```
  - userProvider
```
private UserProvider userProvider
```
  - reservoir
```
private final BoundedByteBufferPool reservoir
```
  - allowFallbackToSimpleAuth
```
private volatile boolean allowFallbackToSimpleAuth
```
  - rsRpcServices
```
private RSRpcServices rsRpcServices
```
    Used to get details for scan with a scanner_id
    TODO try to figure out a better way and remove reference from regionserver package later.
  - NIO_BUFFER_LIMIT
```
private static int NIO_BUFFER_LIMIT
```
    When the read or write buffer size is larger than this limit, i/o will be done in chunks of this size. Most RPC requests and responses would be be smaller.
- Constructor Detail
  - RpcServer
```
public RpcServer(Server server,
         String name,
         List<RpcServer.BlockingServiceAndInterface> services,
         InetSocketAddress bindAddress,
         org.apache.hadoop.conf.Configuration conf,
         RpcScheduler scheduler)
          throws IOException
```
    Constructs a server listening on the named port and address.
    
    Parameters:
    server - hosting instance of Server. We will do authentications if an instance else pass null for no authentication check.
    name - Used keying this rpc servers' metrics and for naming the Listener thread.
    services - A list of services.
    bindAddress - Where to listen
    conf -
    scheduler -
    
    Throws:
    
    IOException
- Method Detail
  - onConfigurationChange
```
public void onConfigurationChange(org.apache.hadoop.conf.Configuration newConf)
```
    Description copied from interface: ConfigurationObserver
    
    This method would be called by the ConfigurationManager object when the Configuration object is reloaded from disk.
    
    Specified by:
    
    onConfigurationChange in interface ConfigurationObserver
  - initReconfigurable
```
private void initReconfigurable(org.apache.hadoop.conf.Configuration confToLoad)
```
  - getConnection
```
protected RpcServer.Connection getConnection(SocketChannel channel,
                                 long time)
```
    Subclasses of HBaseServer can override this to provide their own Connection implementations.
  - setupResponse
```
private void setupResponse(ByteArrayOutputStream response,
                 RpcServer.Call call,
                 Throwable t,
                 String error)
                    throws IOException
```
    Setup response for the RPC Call.
    
    Parameters:
    response - buffer to serialize the response into
    call - RpcServer.Call to which we are setting up the response
    error - error message, if the call failed
    
    Throws:
    
    IOException
  - closeConnection
```
protected void closeConnection(RpcServer.Connection connection)
```
  - getConf
```
org.apache.hadoop.conf.Configuration getConf()
```
  - setSocketSendBufSize
```
public void setSocketSendBufSize(int size)
```
    Sets the socket buffer size used for responding to RPCs.
    
    Specified by:
    
    setSocketSendBufSize in interface RpcServerInterface
    
    Parameters:
    size - send size
  - isStarted
```
public boolean isStarted()
```
    Specified by:
    
    isStarted in interface RpcServerInterface
  - start
```
public void start()
```
    Starts the service. Must be called before any calls will be handled.
    
    Specified by:
    
    start in interface RpcServerInterface
  - refreshAuthManager
```
public void refreshAuthManager(org.apache.hadoop.security.authorize.PolicyProvider pp)
```
    Description copied from interface: RpcServerInterface
    
    Refresh authentication manager policy.
    
    Specified by:
    
    refreshAuthManager in interface RpcServerInterface
  - createSecretManager
```
private AuthenticationTokenSecretManager createSecretManager()
```
  - getSecretManager
```
public org.apache.hadoop.security.token.SecretManager<? extends org.apache.hadoop.security.token.TokenIdentifier> getSecretManager()
```
  - setSecretManager
```
public void setSecretManager(org.apache.hadoop.security.token.SecretManager<? extends org.apache.hadoop.security.token.TokenIdentifier> secretManager)
```
  - call
```
public Pair<com.google.protobuf.Message,CellScanner> call(com.google.protobuf.BlockingService service,
                                                 com.google.protobuf.Descriptors.MethodDescriptor md,
                                                 com.google.protobuf.Message param,
                                                 CellScanner cellScanner,
                                                 long receiveTime,
                                                 MonitoredRPCHandler status)
                                                   throws IOException
```
    This is a server side method, which is invoked over RPC. On success the return response has protobuf response payload. On failure, the exception name and the stack trace are returned in the protobuf response.
    
    Specified by:
    
    call in interface RpcServerInterface
    
    Throws:
    
    IOException
  - logResponse
```
void logResponse(com.google.protobuf.Message param,
               String methodName,
               String call,
               String tag,
               String clientAddress,
               long startTime,
               int processingTime,
               int qTime,
               long responseSize)
           throws IOException
```
    Logs an RPC response to the LOG file, producing valid JSON objects for client Operations.
    
    Parameters:
    param - The parameters received in the call.
    methodName - The name of the method invoked
    call - The string representation of the call
    tag - The tag that will be used to indicate this event in the log.
    clientAddress - The address of the client who made this call.
    startTime - The time that the call was initiated, in ms.
    processingTime - The duration that the call took to run, in ms.
    qTime - The duration that the call spent on the queue prior to being initiated, in ms.
    responseSize - The size in bytes of the response buffer.
    
    Throws:
    
    IOException
  - stop
```
public void stop()
```
    Stops the service. No new calls will be handled after this is called.
    
    Specified by:
    
    stop in interface RpcServerInterface
  - join
```
public void join()
          throws InterruptedException
```
    Wait for the server to be stopped. Does not wait for all subthreads to finish. See stop().
    
    Specified by:
    
    join in interface RpcServerInterface
    
    Throws:
    
    InterruptedException - e
  - getListenerAddress
```
public InetSocketAddress getListenerAddress()
```
    Return the socket (ip+port) on which the RPC server is listening to. May return null if the listener channel is closed.
    
    Specified by:
    
    getListenerAddress in interface RpcServerInterface
    
    Returns:
    the socket (ip+port) on which the RPC server is listening to, or null if this information cannot be determined
  - setErrorHandler
```
public void setErrorHandler(HBaseRPCErrorHandler handler)
```
    Set the handler for calling out of RPC for error conditions.
    
    Specified by:
    
    setErrorHandler in interface RpcServerInterface
    
    Parameters:
    handler - the handler implementation
  - getErrorHandler
```
public HBaseRPCErrorHandler getErrorHandler()
```
    Specified by:
    
    getErrorHandler in interface RpcServerInterface
  - getMetrics
```
public MetricsHBaseServer getMetrics()
```
    Returns the metrics instance for reporting RPC call statistics
    
    Specified by:
    
    getMetrics in interface RpcServerInterface
  - addCallSize
```
public void addCallSize(long diff)
```
    Description copied from interface: RpcServerInterface
    
    Add/subtract from the current size of all outstanding calls. Called on setup of a call to add call total size and then again at end of a call to remove the call size.
    
    Specified by:
    
    addCallSize in interface RpcServerInterface
    
    Parameters:
    diff - Change (plus or minus)
  - authorize
```
public void authorize(org.apache.hadoop.security.UserGroupInformation user,
             org.apache.hadoop.hbase.protobuf.generated.RPCProtos.ConnectionHeader connection,
             InetAddress addr)
               throws org.apache.hadoop.security.authorize.AuthorizationException
```
    Authorize the incoming client connection.
    
    Parameters:
    user - client user
    connection - incoming connection
    addr - InetAddress of incoming connection
    
    Throws:
    
    org.apache.hadoop.security.authorize.AuthorizationException - when the client isn't authorized to talk the protocol
  - channelWrite
```
protected long channelWrite(GatheringByteChannel channel,
                BufferChain bufferChain)
                     throws IOException
```
    This is a wrapper around WritableByteChannel.write(java.nio.ByteBuffer). If the amount of data is large, it writes to channel in smaller chunks. This is to avoid jdk from creating many direct buffers as the size of buffer increases. This also minimizes extra copies in NIO layer as a result of multiple write operations required to write a large buffer.
    
    Parameters:
    channel - writable byte channel to write to
    bufferChain - Chain of buffers to write
    
    Returns:
    number of bytes written
    
    Throws:
    
    IOException - e
    See Also:
    WritableByteChannel.write(java.nio.ByteBuffer)
  - channelRead
```
protected int channelRead(ReadableByteChannel channel,
              ByteBuffer buffer)
                   throws IOException
```
    This is a wrapper around ReadableByteChannel.read(java.nio.ByteBuffer). If the amount of data is large, it writes to channel in smaller chunks. This is to avoid jdk from creating many direct buffers as the size of ByteBuffer increases. There should not be any performance degredation.
    
    Parameters:
    channel - writable byte channel to write on
    buffer - buffer to write
    
    Returns:
    number of bytes written
    
    Throws:
    
    IOException - e
    See Also:
    ReadableByteChannel.read(java.nio.ByteBuffer)
  - channelIO
```
private static int channelIO(ReadableByteChannel readCh,
            WritableByteChannel writeCh,
            ByteBuffer buf)
                      throws IOException
```
    Helper for channelRead(java.nio.channels.ReadableByteChannel, java.nio.ByteBuffer) and channelWrite(GatheringByteChannel, BufferChain). Only one of readCh or writeCh should be non-null.
    
    Parameters:
    readCh - read channel
    writeCh - write channel
    buf - buffer to read or write into/out of
    
    Returns:
    bytes written
    
    Throws:
    
    IOException - e
    See Also:
    channelRead(java.nio.channels.ReadableByteChannel, java.nio.ByteBuffer), channelWrite(GatheringByteChannel, BufferChain)
  - getCurrentCall
```
public static RpcCallContext getCurrentCall()
```
    Needed for features such as delayed calls. We need to be able to store the current call so that we can complete it later or ask questions of what is supported by the current ongoing call.
    
    Returns:
    An RpcCallContext backed by the currently ongoing call (gotten from a thread local)
  - isInRpcCallContext
```
public static boolean isInRpcCallContext()
```
  - getRequestUser
```
public static User getRequestUser()
```
    Returns the user credentials associated with the current RPC request or null if no credentials were provided.
    
    Returns:
    A User
  - getRequestUserName
```
public static String getRequestUserName()
```
    Returns the username for any user associated with the current RPC request or null if no user is set.
  - getRemoteAddress
```
public static InetAddress getRemoteAddress()
```
    Returns:
    Address of remote client if a request is ongoing, else null
  - getServiceAndInterface
```
static RpcServer.BlockingServiceAndInterface getServiceAndInterface(List<RpcServer.BlockingServiceAndInterface> services,
                                                           String serviceName)
```
    Parameters:
    serviceName - Some arbitrary string that represents a 'service'.
    services - Available service instances
    
    Returns:
    Matching BlockingServiceAndInterface pair
  - getServiceInterface
```
static Class<?> getServiceInterface(List<RpcServer.BlockingServiceAndInterface> services,
                           String serviceName)
```
    Parameters:
    serviceName - Some arbitrary string that represents a 'service'.
    services - Available services and their service interfaces.
    
    Returns:
    Service interface class for serviceName
  - getService
```
static com.google.protobuf.BlockingService getService(List<RpcServer.BlockingServiceAndInterface> services,
                                             String serviceName)
```
    Parameters:
    serviceName - Some arbitrary string that represents a 'service'.
    services - Available services and their service interfaces.
    
    Returns:
    BlockingService that goes with the passed serviceName
  - getStatus
```
static MonitoredRPCHandler getStatus()
```
  - getRemoteIp
```
public static InetAddress getRemoteIp()
```
    Returns the remote side ip address when invoked inside an RPC Returns null incase of an error.
    
    Returns:
    InetAddress
  - bind
```
public static void bind(ServerSocket socket,
        InetSocketAddress address,
        int backlog)
                 throws IOException
```
    A convenience method to bind to a given address and report better exceptions if the address is not a valid host.
    
    Parameters:
    socket - the socket to bind
    address - the address to bind to
    backlog - the number of connections allowed in the queue
    
    Throws:
    
    BindException - if the address can't be bound
    
    UnknownHostException - if the address isn't a valid host name
    
    IOException - other random errors from bind
  - getScheduler
```
public RpcScheduler getScheduler()
```
    Specified by:
    
    getScheduler in interface RpcServerInterface
  - setRsRpcServices
```
public void setRsRpcServices(RSRpcServices rsRpcServices)
```
    Specified by:
    
    setRsRpcServices in interface RpcServerInterface

Class RpcServer

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

CALL_QUEUE_TOO_BIG_EXCEPTION

authorize

isSecurityEnabled

CURRENT_VERSION

FALLBACK_TO_INSECURE_CLIENT_AUTH

DEFAULT_MAX_CALLQUEUE_LENGTH_PER_HANDLER

DEFAULT_MAX_CALLQUEUE_SIZE

ipcUtil

AUTH_FAILED_FOR

AUTH_SUCCESSFUL_FOR

AUDITLOG

secretManager

authManager

CurCall

MONITORED_RPC

bindAddress

port

address

readThreads

maxIdleTime

thresholdIdleConnections

maxConnectionsToNuke

metrics

conf

maxQueueSize

socketSendBufferSize

tcpNoDelay

tcpKeepAlive

purgeTimeout

running

started

callQueueSize

connectionList

listener

responder

authTokenSecretMgr

numConnections

errorHandler

WARN_RESPONSE_TIME

WARN_RESPONSE_SIZE

DEFAULT_WARN_RESPONSE_TIME

DEFAULT_WARN_RESPONSE_SIZE

MAPPER

warnResponseTime

warnResponseSize

server

services

scheduler

userProvider

reservoir

allowFallbackToSimpleAuth

rsRpcServices

NIO_BUFFER_LIMIT

Constructor Detail

RpcServer

Method Detail

onConfigurationChange

initReconfigurable

getConnection

setupResponse

closeConnection

getConf

setSocketSendBufSize

isStarted

start

refreshAuthManager

createSecretManager

getSecretManager

setSecretManager

call

logResponse

stop