RpcServer (Apache HBase 2.0.6 API)

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

All Implemented Interfaces:

ConfigurationObserver, RpcServerInterface

Direct Known Subclasses:

NettyRpcServer, SimpleRpcServer
```
@InterfaceAudience.Private
public abstract class RpcServer
extends Object
implements RpcServerInterface, ConfigurationObserver
```
An RPC server that hosts protobuf described Services.

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.
`protected static interface`	`RpcServer.CallCleanup`

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`allowFallbackToSimpleAuth`
`protected static org.slf4j.Logger`	`AUDITLOG`
`protected static String`	`AUTH_FAILED_FOR`
`protected static String`	`AUTH_SUCCESSFUL_FOR`
`protected org.apache.hadoop.security.authorize.ServiceAuthorizationManager`	`authManager`
`private boolean`	`authorize`
`protected AuthenticationTokenSecretManager`	`authTokenSecretMgr`
`protected InetSocketAddress`	`bindAddress`
`protected static CallQueueTooBigException`	`CALL_QUEUE_TOO_BIG_EXCEPTION`
`protected LongAdder`	`callQueueSizeInBytes` This is a running count of the size in bytes of all outstanding calls whether currently executing or queued waiting to be run.
`protected CellBlockBuilder`	`cellBlockBuilder`
`protected org.apache.hadoop.conf.Configuration`	`conf`
`protected static ThreadLocal<RpcCall>`	`CurCall` This is set to Call object before Handler invokes an RPC and ybdie after the call returns.
`static byte`	`CURRENT_VERSION`
`protected static int`	`DEFAULT_MAX_CALLQUEUE_LENGTH_PER_HANDLER` How many calls/handler are allowed in the queue.
`protected static int`	`DEFAULT_MAX_CALLQUEUE_SIZE`
`static int`	`DEFAULT_MAX_REQUEST_SIZE` Default value for above params
`protected static int`	`DEFAULT_MIN_CLIENT_REQUEST_TIMEOUT`
`protected static int`	`DEFAULT_TRACE_LOG_MAX_LENGTH`
`protected static int`	`DEFAULT_WARN_RESPONSE_SIZE`
`protected static int`	`DEFAULT_WARN_RESPONSE_TIME`
`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.
`protected boolean`	`isSecurityEnabled`
`protected static String`	`KEY_WORD_TRUNCATED`
`static org.slf4j.Logger`	`LOG`
`protected static com.fasterxml.jackson.databind.ObjectMapper`	`MAPPER`
`static String`	`MAX_REQUEST_SIZE`
`protected long`	`maxQueueSizeInBytes` Maximum size in bytes of the currently queued and running Calls.
`protected int`	`maxRequestSize`
`protected MetricsHBaseServer`	`metrics`
`protected static String`	`MIN_CLIENT_REQUEST_TIMEOUT` Minimum allowable timeout (in milliseconds) in rpc request's header.
`protected int`	`minClientRequestTimeout`
`protected int`	`minSizeForReservoirUse`
`protected static ThreadLocal<MonitoredRPCHandler>`	`MONITORED_RPC` Keeps MonitoredRPCHandler per handler thread.
`protected 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 static RequestTooBigException`	`REQUEST_TOO_BIG_EXCEPTION`
`protected ByteBufferPool`	`reservoir`
`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.
`protected Map<String,String>`	`saslProps`
`protected RpcScheduler`	`scheduler`
`protected org.apache.hadoop.security.token.SecretManager<org.apache.hadoop.security.token.TokenIdentifier>`	`secretManager`
`protected Server`	`server`
`protected List<RpcServer.BlockingServiceAndInterface>`	`services`
`(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 `RpcServerInterface.start()`.
`protected boolean`	`tcpKeepAlive`
`protected boolean`	`tcpNoDelay`
`protected static String`	`TRACE_LOG_MAX_LENGTH`
`protected UserProvider`	`userProvider`
`protected static String`	`WARN_RESPONSE_SIZE`
`protected static String`	`WARN_RESPONSE_TIME`
`protected int`	`warnResponseSize`
`protected 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, boolean reservoirEnabled)` Constructs a server listening on the named port and address.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addCallSize(long diff)` Add/subtract from the current size of all outstanding calls.
`(package private) static Pair<ByteBuff,RpcServer.CallCleanup>`	`allocateByteBuffToReadInto(ByteBufferPool pool, int minSizeForPoolUse, int reqLen)` This is extracted to a static method for better unit testing.
`void`	`authorize(org.apache.hadoop.security.UserGroupInformation user, org.apache.hadoop.hbase.shaded.protobuf.generated.RPCProtos.ConnectionHeader connection, InetAddress addr)` Authorize the incoming client connection.
`Pair<org.apache.hbase.thirdparty.com.google.protobuf.Message,CellScanner>`	`call(RpcCall call, 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 {@link #channelRead(java.nio.channels.ReadableByteChannel, java.nio.ByteBuffer).
`protected int`	`channelRead(ReadableByteChannel channel, ByteBuffer buffer)` This is a wrapper around `ReadableByteChannel.read(java.nio.ByteBuffer)`.
`protected AuthenticationTokenSecretManager`	`createSecretManager()`
`(package private) org.apache.hadoop.conf.Configuration`	`getConf()`
`static Optional<RpcCall>`	`getCurrentCall()` Needed for features such as delayed calls.
`HBaseRPCErrorHandler`	`getErrorHandler()`
`MetricsHBaseServer`	`getMetrics()` Returns the metrics instance for reporting RPC call statistics
`(package private) static int`	`getMinSizeForReservoirUse(ByteBufferPool pool)`
`abstract int`	`getNumOpenConnections()` The number of open RPC conections
`static Optional<InetAddress>`	`getRemoteAddress()`
`static InetAddress`	`getRemoteIp()` Returns the remote side ip address when invoked inside an RPC Returns null incase of an error.
`static Optional<User>`	`getRequestUser()` Returns the user credentials associated with the current RPC request or not present if no credentials were provided.
`static Optional<String>`	`getRequestUserName()` Returns the username for any user associated with the current RPC request or not present if no user is set.
`RpcScheduler`	`getScheduler()`
`org.apache.hadoop.security.token.SecretManager<? extends org.apache.hadoop.security.token.TokenIdentifier>`	`getSecretManager()`
`protected static org.apache.hbase.thirdparty.com.google.protobuf.BlockingService`	`getService(List<RpcServer.BlockingServiceAndInterface> services, String serviceName)`
`protected static RpcServer.BlockingServiceAndInterface`	`getServiceAndInterface(List<RpcServer.BlockingServiceAndInterface> services, String serviceName)`
`protected static Class<?>`	`getServiceInterface(List<RpcServer.BlockingServiceAndInterface> services, String serviceName)`
`protected static MonitoredRPCHandler`	`getStatus()`
`protected void`	`initReconfigurable(org.apache.hadoop.conf.Configuration confToLoad)`
`static boolean`	`isInRpcCallContext()`
`boolean`	`isStarted()`
`(package private) void`	`logResponse(org.apache.hbase.thirdparty.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)`
`(package private) String`	`truncateTraceLog(String strParam)` Truncate to number of chars decided by conf hbase.ipc.trace.log.max.length if TRACE is on else to 150 chars Refer to Jira HBASE-20826 and HBASE-20942

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

Methods inherited from interface org.apache.hadoop.hbase.ipc.RpcServerInterface
call, call, getListenerAddress, join, setSocketSendBufSize, start, stop

- Field Detail
  - LOG
```
public static final org.slf4j.Logger LOG
```
  - CALL_QUEUE_TOO_BIG_EXCEPTION
```
protected static final CallQueueTooBigException CALL_QUEUE_TOO_BIG_EXCEPTION
```
  - authorize
```
private final boolean authorize
```
  - isSecurityEnabled
```
protected 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
```
protected static final int DEFAULT_MAX_CALLQUEUE_LENGTH_PER_HANDLER
```
    How many calls/handler are allowed in the queue.
    
    See Also:
    
    Constant Field Values
  - cellBlockBuilder
```
protected final CellBlockBuilder cellBlockBuilder
```
  - AUTH_FAILED_FOR
```
protected static final String AUTH_FAILED_FOR
```
    See Also:
    
    Constant Field Values
  - AUTH_SUCCESSFUL_FOR
```
protected static final String AUTH_SUCCESSFUL_FOR
```
    See Also:
    
    Constant Field Values
  - AUDITLOG
```
protected static final org.slf4j.Logger AUDITLOG
```
  - secretManager
```
protected org.apache.hadoop.security.token.SecretManager<org.apache.hadoop.security.token.TokenIdentifier> secretManager
```
  - saslProps
```
protected final Map<String,String> saslProps
```
  - authManager
```
protected org.apache.hadoop.security.authorize.ServiceAuthorizationManager authManager
```
  - CurCall
```
protected static final ThreadLocal<RpcCall> CurCall
```
    This is set to Call object before Handler invokes an RPC and ybdie after the call returns.
  - MONITORED_RPC
```
protected static final ThreadLocal<MonitoredRPCHandler> MONITORED_RPC
```
    Keeps MonitoredRPCHandler per handler thread.
  - bindAddress
```
protected final InetSocketAddress bindAddress
```
  - metrics
```
protected MetricsHBaseServer metrics
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - maxQueueSizeInBytes
```
protected final long maxQueueSizeInBytes
```
    Maximum size in bytes of the currently queued and running Calls. If a new Call puts us over this size, then we will reject the call (after parsing it though). It will go back to the client and client will retry. Set this size with "hbase.ipc.server.max.callqueue.size". The call queue size gets incremented after we parse a call and before we add it to the queue of calls for the scheduler to use. It get decremented after we have 'run' the Call. The current size is kept in callQueueSizeInBytes.
    
    See Also:
    
    callQueueSizeInBytes, DEFAULT_MAX_CALLQUEUE_SIZE
  - DEFAULT_MAX_CALLQUEUE_SIZE
```
protected static final int DEFAULT_MAX_CALLQUEUE_SIZE
```
    See Also:
    
    Constant Field Values
  - callQueueSizeInBytes
```
protected final LongAdder callQueueSizeInBytes
```
    This is a running count of the size in bytes of all outstanding calls whether currently executing or queued waiting to be run.
  - tcpNoDelay
```
protected final boolean tcpNoDelay
```
  - tcpKeepAlive
```
protected final boolean tcpKeepAlive
```
  - running
```
volatile boolean running
```
    This flag is used to indicate to sub threads when they should go down. When we call RpcServerInterface.start(), all threads started will consult this flag on whether they should keep going. It is set to false when RpcServerInterface.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 RpcServerInterface.start().
  - authTokenSecretMgr
```
protected AuthenticationTokenSecretManager authTokenSecretMgr
```
  - errorHandler
```
protected HBaseRPCErrorHandler errorHandler
```
  - MAX_REQUEST_SIZE
```
public static final String MAX_REQUEST_SIZE
```
    See Also:
    
    Constant Field Values
  - REQUEST_TOO_BIG_EXCEPTION
```
protected static final RequestTooBigException REQUEST_TOO_BIG_EXCEPTION
```
  - WARN_RESPONSE_TIME
```
protected static final String WARN_RESPONSE_TIME
```
    See Also:
    
    Constant Field Values
  - WARN_RESPONSE_SIZE
```
protected static final String WARN_RESPONSE_SIZE
```
    See Also:
    
    Constant Field Values
  - MIN_CLIENT_REQUEST_TIMEOUT
```
protected static final String MIN_CLIENT_REQUEST_TIMEOUT
```
    Minimum allowable timeout (in milliseconds) in rpc request's header. This configuration exists to prevent the rpc service regarding this request as timeout immediately.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_MIN_CLIENT_REQUEST_TIMEOUT
```
protected static final int DEFAULT_MIN_CLIENT_REQUEST_TIMEOUT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_MAX_REQUEST_SIZE
```
public static final int DEFAULT_MAX_REQUEST_SIZE
```
    Default value for above params
    
    See Also:
    
    Constant Field Values
  - DEFAULT_WARN_RESPONSE_TIME
```
protected static final int DEFAULT_WARN_RESPONSE_TIME
```
    See Also:
    
    Constant Field Values
  - DEFAULT_WARN_RESPONSE_SIZE
```
protected static final int DEFAULT_WARN_RESPONSE_SIZE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_TRACE_LOG_MAX_LENGTH
```
protected static final int DEFAULT_TRACE_LOG_MAX_LENGTH
```
    See Also:
    
    Constant Field Values
  - TRACE_LOG_MAX_LENGTH
```
protected static final String TRACE_LOG_MAX_LENGTH
```
    See Also:
    
    Constant Field Values
  - KEY_WORD_TRUNCATED
```
protected static final String KEY_WORD_TRUNCATED
```
    See Also:
    
    Constant Field Values
  - MAPPER
```
protected static final com.fasterxml.jackson.databind.ObjectMapper MAPPER
```
  - maxRequestSize
```
protected final int maxRequestSize
```
  - warnResponseTime
```
protected final int warnResponseTime
```
  - warnResponseSize
```
protected final int warnResponseSize
```
  - minClientRequestTimeout
```
protected final int minClientRequestTimeout
```
  - server
```
protected final Server server
```
  - services
```
protected final List<RpcServer.BlockingServiceAndInterface> services
```
  - scheduler
```
protected final RpcScheduler scheduler
```
  - userProvider
```
protected UserProvider userProvider
```
  - reservoir
```
protected final ByteBufferPool reservoir
```
  - minSizeForReservoirUse
```
protected final int minSizeForReservoirUse
```
  - allowFallbackToSimpleAuth
```
protected 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
```
protected static final 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.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - RpcServer
```
public RpcServer(Server server,
                 String name,
                 List<RpcServer.BlockingServiceAndInterface> services,
                 InetSocketAddress bindAddress,
                 org.apache.hadoop.conf.Configuration conf,
                 RpcScheduler scheduler,
                 boolean reservoirEnabled)
          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 -
    
    reservoirEnabled - Enable ByteBufferPool or not.
    
    Throws:
    
    IOException
- Method Detail
  - getMinSizeForReservoirUse
```
static int getMinSizeForReservoirUse(ByteBufferPool pool)
```
  - 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
```
protected void initReconfigurable(org.apache.hadoop.conf.Configuration confToLoad)
```
  - getConf
```
org.apache.hadoop.conf.Configuration getConf()
```
  - isStarted
```
public boolean isStarted()
```
    Specified by:
    
    isStarted 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
```
protected 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<org.apache.hbase.thirdparty.com.google.protobuf.Message,CellScanner> call(RpcCall call,
                                                                                      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(org.apache.hbase.thirdparty.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
  - truncateTraceLog
```
String truncateTraceLog(String strParam)
```
    Truncate to number of chars decided by conf hbase.ipc.trace.log.max.length if TRACE is on else to 150 chars Refer to Jira HBASE-20826 and HBASE-20942
    
    Parameters:
    
    strParam - stringifiedParam to be truncated
    
    Returns:
    
    truncated trace log string
  - 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.shaded.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
  - 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 {@link #channelRead(java.nio.channels.ReadableByteChannel, java.nio.ByteBuffer). 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)
  - allocateByteBuffToReadInto
```
static Pair<ByteBuff,RpcServer.CallCleanup> allocateByteBuffToReadInto(ByteBufferPool pool,
                                                                       int minSizeForPoolUse,
                                                                       int reqLen)
```
    This is extracted to a static method for better unit testing. We try to get buffer(s) from pool as much as possible.
    
    Parameters:
    
    pool - The ByteBufferPool to use
    
    minSizeForPoolUse - Only for buffer size above this, we will try to use pool. Any buffer need of size below this, create on heap ByteBuffer.
    
    reqLen - Bytes count in request
  - getCurrentCall
```
public static Optional<RpcCall> 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 Optional<User> getRequestUser()
```
    Returns the user credentials associated with the current RPC request or not present if no credentials were provided.
    
    Returns:
    
    A User
  - getNumOpenConnections
```
public abstract int getNumOpenConnections()
```
    The number of open RPC conections
    
    Returns:
    
    the number of open rpc connections
  - getRequestUserName
```
public static Optional<String> getRequestUserName()
```
    Returns the username for any user associated with the current RPC request or not present if no user is set.
  - getRemoteAddress
```
public static Optional<InetAddress> getRemoteAddress()
```
    Returns:
    
    Address of remote client if a request is ongoing, else null
  - getServiceAndInterface
```
protected 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
```
protected 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
```
protected static org.apache.hbase.thirdparty.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
```
protected 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
  - 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

Methods inherited from interface org.apache.hadoop.hbase.ipc.RpcServerInterface

Field Detail

LOG

CALL_QUEUE_TOO_BIG_EXCEPTION

authorize

isSecurityEnabled

CURRENT_VERSION

FALLBACK_TO_INSECURE_CLIENT_AUTH

DEFAULT_MAX_CALLQUEUE_LENGTH_PER_HANDLER

cellBlockBuilder

AUTH_FAILED_FOR

AUTH_SUCCESSFUL_FOR

AUDITLOG

secretManager

saslProps

authManager

CurCall

MONITORED_RPC

bindAddress

metrics

conf

maxQueueSizeInBytes

DEFAULT_MAX_CALLQUEUE_SIZE

callQueueSizeInBytes

tcpNoDelay

tcpKeepAlive

running

started

authTokenSecretMgr

errorHandler

MAX_REQUEST_SIZE

REQUEST_TOO_BIG_EXCEPTION

WARN_RESPONSE_TIME

WARN_RESPONSE_SIZE

MIN_CLIENT_REQUEST_TIMEOUT

DEFAULT_MIN_CLIENT_REQUEST_TIMEOUT

DEFAULT_MAX_REQUEST_SIZE

DEFAULT_WARN_RESPONSE_TIME

DEFAULT_WARN_RESPONSE_SIZE

DEFAULT_TRACE_LOG_MAX_LENGTH

TRACE_LOG_MAX_LENGTH

KEY_WORD_TRUNCATED

MAPPER

maxRequestSize

warnResponseTime

warnResponseSize

minClientRequestTimeout

server

services

scheduler

userProvider

reservoir

minSizeForReservoirUse

allowFallbackToSimpleAuth

rsRpcServices

NIO_BUFFER_LIMIT

Constructor Detail

RpcServer

Method Detail

getMinSizeForReservoirUse

onConfigurationChange

initReconfigurable

getConf

isStarted

refreshAuthManager

createSecretManager

getSecretManager

setSecretManager

call

logResponse

truncateTraceLog

setErrorHandler

getErrorHandler

getMetrics