org.apache.hadoop.hbase.ipc

Class BlockingRpcConnection

java.lang.Object

org.apache.hadoop.hbase.ipc.RpcConnection

org.apache.hadoop.hbase.ipc.BlockingRpcConnection

All Implemented Interfaces:

Runnable

@InterfaceAudience.Private
class BlockingRpcConnection
extends RpcConnection
implements Runnable

Thread that reads responses and notifies callers. Each connection owns a socket connected to a remote address. Calls are multiplexed through this socket: responses may be delivered out of order.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private class	BlockingRpcConnection.CallSender If the client wants to interrupt its calls easily (i.e.

Field Summary

Fields

Modifier and Type	Field and Description
private ConcurrentMap<Integer,Call>	calls
private BlockingRpcConnection.CallSender	callSender
private boolean	closed
private byte[]	connectionHeaderPreamble
private byte[]	connectionHeaderWithLength
private DataInputStream	in
private static org.slf4j.Logger	LOG
private DataOutputStream	out
private BlockingRpcClient	rpcClient
private HBaseSaslRpcClient	saslRpcClient
protected Socket	socket
private Thread	thread
private String	threadName
private boolean	waitingConnectionHeaderResponse

Fields inherited from class org.apache.hadoop.hbase.ipc.RpcConnection

authMethod, codec, compressor, conf, CRYPTO_AES_ENABLED_DEFAULT, CRYPTO_AES_ENABLED_KEY, lastTouched, reloginMaxBackoff, remoteId, serverPrincipal, timeoutTimer, token, useSasl

Constructor Summary

Constructors

Constructor and Description
BlockingRpcConnection(BlockingRpcClient rpcClient, ConnectionId remoteId)

Method Summary

Modifier and Type	Method and Description
protected void	callTimeout(Call call)
void	cleanupConnection() Does the clean up work after the connection is removed from the connection pool
private void	closeConn(IOException e)
private void	closeSocket()
private void	disposeSasl()
private void	handleConnectionFailure(int curRetries, int maxRetries, IOException ioe) Handle connection failures If the current number of retries is equal to the max number of retries, stop retrying and throw the exception; Otherwise backoff N seconds and try connecting again.
private void	handleSaslConnectionFailure(int currRetries, int maxRetries, Exception ex, org.apache.hadoop.security.UserGroupInformation user) If multiple clients with the same principal try to connect to the same server at the same time, the server assumes a replay attack is in progress.
boolean	isActive() Tell the idle connection sweeper whether we could be swept.
private void	negotiateCryptoAes(org.apache.hadoop.hbase.shaded.protobuf.generated.RPCProtos.CryptoCipherMeta cryptoCipherMeta)
private void	processResponseForConnectionHeader()
private void	readResponse()
void	run()
void	sendRequest(Call call, HBaseRpcController pcrc)
protected void	setupConnection()
private void	setupIOstreams()
private boolean	setupSaslConnection(InputStream in2, OutputStream out2)
void	shutdown() Just close connection.
private void	tracedWriteRequest(Call call)
private boolean	waitForWork()
private void	writeConnectionHeader() Write the connection header.
private void	writeConnectionHeaderPreamble(OutputStream out) Write the RPC header: <MAGIC WORD -- 'HBas'> <ONEBYTE_VERSION> <ONEBYTE_AUTH_TYPE>
private void	writeRequest(Call call) Initiates a call by sending the parameter to the remote server.

Methods inherited from class org.apache.hadoop.hbase.ipc.RpcConnection

getConnectionHeader, getConnectionHeaderPreamble, getLastTouched, getUGI, relogin, remoteId, scheduleTimeoutTask, setLastTouched, shouldAuthenticateOverKrb

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LOG

private static final org.slf4j.Logger LOG

rpcClient

private final BlockingRpcClient rpcClient

threadName

private final String threadName

thread

private Thread thread

socket

protected Socket socket

in

private DataInputStream in

out

private DataOutputStream out

saslRpcClient

private HBaseSaslRpcClient saslRpcClient

calls

private final ConcurrentMap<Integer,Call> calls

callSender

private final BlockingRpcConnection.CallSender callSender

closed

private boolean closed

connectionHeaderPreamble

private byte[] connectionHeaderPreamble

connectionHeaderWithLength

private byte[] connectionHeaderWithLength

waitingConnectionHeaderResponse

private boolean waitingConnectionHeaderResponse

Constructor Detail

BlockingRpcConnection

BlockingRpcConnection(BlockingRpcClient rpcClient,
                      ConnectionId remoteId)
               throws IOException

Throws:

IOException

Method Detail

setupConnection

protected void setupConnection()
                        throws IOException

Throws:

IOException

handleConnectionFailure

private void handleConnectionFailure(int curRetries,
                                     int maxRetries,
                                     IOException ioe)
                              throws IOException

Handle connection failures If the current number of retries is equal to the max number of retries, stop retrying and throw the exception; Otherwise backoff N seconds and try connecting again. This Method is only called from inside setupIOstreams(), which is synchronized. Hence the sleep is synchronized; the locks will be retained.

Parameters:

curRetries - current number of retries

maxRetries - max number of retries allowed

ioe - failure reason

Throws:

IOException - if max number of retries is reached

waitForWork

private boolean waitForWork()

run

public void run()

Specified by:

run in interface Runnable

disposeSasl

private void disposeSasl()

setupSaslConnection

private boolean setupSaslConnection(InputStream in2,
                                    OutputStream out2)
                             throws IOException

Throws:

IOException

handleSaslConnectionFailure

private void handleSaslConnectionFailure(int currRetries,
                                         int maxRetries,
                                         Exception ex,
                                         org.apache.hadoop.security.UserGroupInformation user)
                                  throws IOException,
                                         InterruptedException

If multiple clients with the same principal try to connect to the same server at the same time, the server assumes a replay attack is in progress. This is a feature of kerberos. In order to work around this, what is done is that the client backs off randomly and tries to initiate the connection again. The other problem is to do with ticket expiry. To handle that, a relogin is attempted.

The retry logic is governed by the RpcConnection.shouldAuthenticateOverKrb() method. In case when the user doesn't have valid credentials, we don't need to retry (from cache or ticket). In such cases, it is prudent to throw a runtime exception when we receive a SaslException from the underlying authentication implementation, so there is no retry from other high level (for eg, HCM or HBaseAdmin).

Throws:

IOException

InterruptedException

setupIOstreams

private void setupIOstreams()
                     throws IOException

Throws:

IOException

writeConnectionHeaderPreamble

private void writeConnectionHeaderPreamble(OutputStream out)
                                    throws IOException

Write the RPC header: <MAGIC WORD -- 'HBas'> <ONEBYTE_VERSION> <ONEBYTE_AUTH_TYPE>

Throws:

IOException

writeConnectionHeader

private void writeConnectionHeader()
                            throws IOException

Write the connection header.

Throws:

IOException

processResponseForConnectionHeader

private void processResponseForConnectionHeader()
                                         throws IOException

Throws:

IOException

negotiateCryptoAes

private void negotiateCryptoAes(org.apache.hadoop.hbase.shaded.protobuf.generated.RPCProtos.CryptoCipherMeta cryptoCipherMeta)
                         throws IOException

Throws:

IOException

tracedWriteRequest

private void tracedWriteRequest(Call call)
                         throws IOException

Throws:

IOException

writeRequest

private void writeRequest(Call call)
                   throws IOException

Initiates a call by sending the parameter to the remote server. Note: this is not called from the Connection thread, but by other threads.

Throws:

IOException

See Also:

readResponse()

readResponse

private void readResponse()

callTimeout

protected void callTimeout(Call call)

Specified by:

callTimeout in class RpcConnection

closeSocket

private void closeSocket()

closeConn

private void closeConn(IOException e)

shutdown

public void shutdown()

Description copied from class: RpcConnection

Just close connection. Do not need to remove from connection pool.

Specified by:

shutdown in class RpcConnection

cleanupConnection

public void cleanupConnection()

Description copied from class: RpcConnection

Does the clean up work after the connection is removed from the connection pool

Specified by:

cleanupConnection in class RpcConnection

sendRequest

public void sendRequest(Call call,
                        HBaseRpcController pcrc)
                 throws IOException

Specified by:

sendRequest in class RpcConnection

Throws:

IOException

isActive

public boolean isActive()

Description copied from class: RpcConnection

Tell the idle connection sweeper whether we could be swept.

Specified by:

isActive in class RpcConnection