RpcServer.Call (Hortonworks Data Platform Apache HBase Java API Reference)

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

All Implemented Interfaces:: Delayable, RpcCallContext

Enclosing class:: RpcServer

@InterfaceAudience.LimitedPrivate(value={"Coprocesssor","Phoenix"})
 @InterfaceStability.Evolving
public class RpcServer.Call
extends java.lang.Object
implements RpcCallContext

Datastructure that holds all necessary to a method invocation and then afterward, carries the result.

Field Summary

Fields
Modifier and Type	Field and Description
`protected CellScanner`	`cellScanner`
`protected RpcServer.Connection`	`connection`
`protected boolean`	`delayResponse`
`protected boolean`	`delayReturnValue`
`protected RPCProtos.RequestHeader`	`header`
`protected int`	`id`
`protected boolean`	`isError`
`protected MethodDescriptor`	`md`
`protected Message`	`param`
`protected RpcServer.Responder`	`responder`
`protected org.apache.hadoop.hbase.ipc.BufferChain`	`response` Chain of buffers to send as response.
`protected BlockingService`	`service`
`protected long`	`size`
`protected long`	`timestamp`
`protected TraceInfo`	`tinfo`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`disconnectSince()` Check if the caller who made this IPC call has disconnected.
`void`	`endDelay()` Signal the end of a delayed RPC, without specifying the return value.
`void`	`endDelay(java.lang.Object result)` Signal that the RPC server is now allowed to send the response.
`void`	`endDelayThrowing(java.lang.Throwable t)` End the call, throwing and exception to the caller.
`RPCProtos.VersionInfo`	`getClientVersionInfo()`
`protected RPCProtos.RequestHeader`	`getHeader()`
`int`	`getPriority()`
`java.net.InetAddress`	`getRemoteAddress()`
`UserGroupInformation`	`getRemoteUser()`
`User`	`getRequestUser()` Returns the user credentials associated with the current RPC request or `null` if no credentials were provided.
`java.lang.String`	`getRequestUserName()`
`long`	`getSize()`
`boolean`	`hasPriority()`
`boolean`	`isClientCellBlockSupport()` If the client connected and specified a codec to use, then we will use this codec making cellblocks to return.
`boolean`	`isDelayed()`
`boolean`	`isReturnValueDelayed()`
`void`	`sendResponseIfReady()` If we have a response, and delay is not set, then respond immediately.
`protected void`	`setResponse(java.lang.Object m, CellScanner cells, java.lang.Throwable t, java.lang.String errorMsg)`
`protected void`	`setSaslTokenResponse(java.nio.ByteBuffer response)`
`void`	`startDelay(boolean delayReturnValue)` Signal that the call response should be delayed, thus freeing the RPC server to handle different requests.
`java.lang.String`	`toString()`

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

- Field Detail
  - id
```
protected int id
```
  - service
```
protected BlockingService service
```
  - md
```
protected MethodDescriptor md
```
  - header
```
protected RPCProtos.RequestHeader header
```
  - param
```
protected Message param
```
  - cellScanner
```
protected CellScanner cellScanner
```
  - connection
```
protected RpcServer.Connection connection
```
  - timestamp
```
protected long timestamp
```
  - response
```
protected org.apache.hadoop.hbase.ipc.BufferChain response
```
    Chain of buffers to send as response.
  - delayResponse
```
protected boolean delayResponse
```
  - responder
```
protected RpcServer.Responder responder
```
  - delayReturnValue
```
protected boolean delayReturnValue
```
  - size
```
protected long size
```
  - isError
```
protected boolean isError
```
  - tinfo
```
protected TraceInfo tinfo
```
- Method Detail
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getHeader
```
protected RPCProtos.RequestHeader getHeader()
```
  - hasPriority
```
public boolean hasPriority()
```
  - getPriority
```
public int getPriority()
```
  - setSaslTokenResponse
```
protected void setSaslTokenResponse(java.nio.ByteBuffer response)
```
  - setResponse
```
protected void setResponse(java.lang.Object m,
                           CellScanner cells,
                           java.lang.Throwable t,
                           java.lang.String errorMsg)
```
  - endDelay
```
public void endDelay(java.lang.Object result)
              throws java.io.IOException
```
    Description copied from interface: Delayable
    
    Signal that the RPC server is now allowed to send the response.
    
    Specified by:
    
    endDelay in interface Delayable
    
    Parameters:
    
    result - The value to return to the caller. If the corresponding delay response specified that the return value should not be delayed, this parameter must be null.
    
    Throws:
    
    java.io.IOException
  - endDelay
```
public void endDelay()
              throws java.io.IOException
```
    Description copied from interface: Delayable
    
    Signal the end of a delayed RPC, without specifying the return value. Use this only if the return value was not delayed
    
    Specified by:
    
    endDelay in interface Delayable
    
    Throws:
    
    java.io.IOException
  - startDelay
```
public void startDelay(boolean delayReturnValue)
```
    Description copied from interface: Delayable
    
    Signal that the call response should be delayed, thus freeing the RPC server to handle different requests.
    
    Specified by:
    
    startDelay in interface Delayable
    
    Parameters:
    
    delayReturnValue - Controls whether the return value of the call should be set when ending the delay or right away. There are cases when the return value can be set right away, even if the call is delayed.
  - endDelayThrowing
```
public void endDelayThrowing(java.lang.Throwable t)
                      throws java.io.IOException
```
    Description copied from interface: Delayable
    
    End the call, throwing and exception to the caller. This works regardless of the return value being delayed.
    
    Specified by:
    
    endDelayThrowing in interface Delayable
    
    Parameters:
    
    t - Object to throw to the client.
    
    Throws:
    
    java.io.IOException
  - isDelayed
```
public boolean isDelayed()
```
    Specified by:
    
    isDelayed in interface Delayable
    
    Returns:
    
    is the call delayed?
  - isReturnValueDelayed
```
public boolean isReturnValueDelayed()
```
    Specified by:
    
    isReturnValueDelayed in interface Delayable
    
    Returns:
    
    is the return value delayed?
  - isClientCellBlockSupport
```
public boolean isClientCellBlockSupport()
```
    Description copied from interface: RpcCallContext
    
    If the client connected and specified a codec to use, then we will use this codec making cellblocks to return. If the client did not specify a codec, we assume it does not support cellblocks and will return all content protobuf'd (though it makes our serving slower). We need to ask this question per call because a server could be hosting both clients that support cellblocks while fielding requests from clients that do not.
    
    Specified by:
    
    isClientCellBlockSupport in interface RpcCallContext
    
    Returns:
    
    True if the client supports cellblocks, else return all content in pb
  - disconnectSince
```
public long disconnectSince()
```
    Description copied from interface: RpcCallContext
    
    Check if the caller who made this IPC call has disconnected. If called from outside the context of IPC, this does nothing.
    
    Specified by:
    
    disconnectSince in interface RpcCallContext
    
    Returns:
    
    < 0 if the caller is still connected. The time in ms since the disconnection otherwise
  - getSize
```
public long getSize()
```
  - sendResponseIfReady
```
public void sendResponseIfReady()
                         throws java.io.IOException
```
    If we have a response, and delay is not set, then respond immediately. Otherwise, do not respond to client. This is called by the RPC code in the context of the Handler thread.
    
    Throws:
    
    java.io.IOException
  - getRemoteUser
```
public UserGroupInformation getRemoteUser()
```
  - getRequestUser
```
public User getRequestUser()
```
    Description copied from interface: RpcCallContext
    
    Returns the user credentials associated with the current RPC request or null if no credentials were provided.
    
    Specified by:
    
    getRequestUser in interface RpcCallContext
    
    Returns:
    
    A User
  - getRequestUserName
```
public java.lang.String getRequestUserName()
```
    Specified by:
    
    getRequestUserName in interface RpcCallContext
    
    Returns:
    
    Current request's user name or null if none ongoing.
  - getRemoteAddress
```
public java.net.InetAddress getRemoteAddress()
```
    Specified by:
    
    getRemoteAddress in interface RpcCallContext
    
    Returns:
    
    Address of remote client if a request is ongoing, else null
  - getClientVersionInfo
```
public RPCProtos.VersionInfo getClientVersionInfo()
```
    Specified by:
    
    getClientVersionInfo in interface RpcCallContext
    
    Returns:
    
    the client version info, or null if the information is not present

Class RpcServer.Call

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

id

service

md

header

param

cellScanner

connection

timestamp

response

delayResponse

responder

delayReturnValue

size

isError

tinfo

Method Detail

toString

getHeader

hasPriority

getPriority

setSaslTokenResponse

setResponse

endDelay

endDelay

startDelay

endDelayThrowing

isDelayed

isReturnValueDelayed

isClientCellBlockSupport

disconnectSince

getSize

sendResponseIfReady

getRemoteUser

getRequestUser

getRequestUserName

getRemoteAddress

getClientVersionInfo