RpcServer (Apache HBase - Server 2.2.2 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`
`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 org.apache.hadoop.hbase.ipc.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 static org.apache.hbase.thirdparty.com.google.gson.Gson`	`GSON`
`protected boolean`	`isSecurityEnabled`
`protected static String`	`KEY_WORD_TRUNCATED`
`static org.slf4j.Logger`	`LOG`
`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`
`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`
`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.
`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.
`protected int`	`channelRead(ReadableByteChannel channel, ByteBuffer buffer)` This is a wrapper around `ReadableByteChannel.read(java.nio.ByteBuffer)`.
`protected AuthenticationTokenSecretManager`	`createSecretManager()`
`static Optional<RpcCall>`	`getCurrentCall()` Needed for features such as delayed calls.
`HBaseRPCErrorHandler`	`getErrorHandler()`
`MetricsHBaseServer`	`getMetrics()` Returns the metrics instance for reporting RPC call statistics
`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()`
`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)`

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
```
  - 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 org.apache.hadoop.hbase.ipc.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
```
  - 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
  - GSON
```
protected static final org.apache.hbase.thirdparty.com.google.gson.Gson GSON
```
  - 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
```
  - 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
  - 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)
```
  - 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
  - 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)
  - 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

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

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

GSON

maxRequestSize

warnResponseTime

warnResponseSize

minClientRequestTimeout

server

services

scheduler

userProvider

reservoir

minSizeForReservoirUse

allowFallbackToSimpleAuth

NIO_BUFFER_LIMIT

Constructor Detail

RpcServer

Method Detail

onConfigurationChange

initReconfigurable

isStarted

refreshAuthManager

createSecretManager

getSecretManager

setSecretManager

call

setErrorHandler

getErrorHandler

getMetrics

addCallSize

authorize

channelRead

getCurrentCall

isInRpcCallContext

getRequestUser

getNumOpenConnections

getRequestUserName