Field Detail

• LOG

  private static final org.apache.commons.logging.Log LOG

• MAX_SASL_RETRIES

  private static final int MAX_SASL_RETRIES

  See Also:

  Constant Field Values

• tokenHandlers

  protected static final Map<org.apache.hadoop.hbase.protobuf.generated.AuthenticationProtos.TokenIdentifier.Kind,org.apache.hadoop.security.token.TokenSelector<? extends org.apache.hadoop.security.token.TokenIdentifier>> tokenHandlers

• client

  final AsyncRpcClient client

• channel

  private io.netty.channel.Channel channel

• name

  String name

• ticket

  final User ticket

• serviceName

  final String serviceName

• address

  final InetSocketAddress address

• ioFailureCounter

  private int ioFailureCounter

• connectFailureCounter

  private int connectFailureCounter

• useSasl

  boolean useSasl

• authMethod

  AuthMethod authMethod

• reloginMaxBackoff

  private int reloginMaxBackoff

• token

  private org.apache.hadoop.security.token.Token<? extends org.apache.hadoop.security.token.TokenIdentifier> token

• serverPrincipal

  private String serverPrincipal

• pendingCalls

  private final Map<Integer,AsyncCall> pendingCalls

• connected

  private boolean connected

• closed

  private boolean closed

• cleanupTimer

  private io.netty.util.Timeout cleanupTimer

• timeoutTask

  private final io.netty.util.TimerTask timeoutTask

Constructor Detail

• AsyncRpcChannel

  public AsyncRpcChannel(io.netty.bootstrap.Bootstrap bootstrap,
                 AsyncRpcClient client,
                 User ticket,
                 String serviceName,
                 InetSocketAddress address)

  Constructor for netty RPC channel

  Parameters:

  bootstrap - to construct channel on

  client - to connect with

  ticket - of user which uses connection

  serviceName - name of service to connect to

  address - to connect to

Method Detail

• connect

  private io.netty.channel.ChannelFuture connect(io.netty.bootstrap.Bootstrap bootstrap)

  Connect to channel

  Parameters:

  bootstrap - to connect to

  Returns:

  future of connection

• startHBaseConnection

  private void startHBaseConnection(io.netty.channel.Channel ch)

  Start HBase connection

  Parameters:

  ch - channel to start connection on

• getSaslHandler

  private SaslClientHandler getSaslHandler(org.apache.hadoop.security.UserGroupInformation realTicket,
                                 io.netty.bootstrap.Bootstrap bootstrap)
                                    throws IOException

  Get SASL handler

  Parameters:

  bootstrap - to reconnect to

  Returns:

  new SASL handler

  Throws:

  IOException - if handler failed to create

• retryOrClose

  private void retryOrClose(io.netty.bootstrap.Bootstrap bootstrap,
                  int connectCounter,
                  Throwable e)

  Retry to connect or close

  Parameters:

  bootstrap - to connect with

  connectCounter - amount of tries

  e - exception of fail

• callMethod

  public io.netty.util.concurrent.Promise<com.google.protobuf.Message> callMethod(com.google.protobuf.Descriptors.MethodDescriptor method,
                                                                         PayloadCarryingRpcController controller,
                                                                         com.google.protobuf.Message request,
                                                                         com.google.protobuf.Message responsePrototype,
                                                                         MetricsConnection.CallStats callStats)

  Calls method on channel

  Parameters:

  method - to call

  controller - to run call with

  request - to send

  responsePrototype - to construct response with

• removePendingCall

  AsyncCall removePendingCall(int id)

• writeChannelHeader

  private io.netty.channel.ChannelFuture writeChannelHeader(io.netty.channel.Channel channel)
                                                     throws IOException

  Write the channel header

  Parameters:

  channel - to write to

  Returns:

  future of write

  Throws:

  IOException - on failure to write

• writeRequest

  private void writeRequest(AsyncCall call)

  Write request to channel

  Parameters:

  call - to write

• setupAuthorization

  private void setupAuthorization()
                           throws IOException

  Set up server authorization

  Throws:

  IOException - if auth setup failed

• buildUserInfo

  private org.apache.hadoop.hbase.protobuf.generated.RPCProtos.UserInformation buildUserInfo(org.apache.hadoop.security.UserGroupInformation ugi,
                                                                                   AuthMethod authMethod)

  Build the user information

  Parameters:

  ugi - User Group Information

  authMethod - Authorization method

  Returns:

  UserInformation protobuf

• createPreamble

  private void createPreamble(io.netty.buffer.ByteBuf byteBuf,
                    AuthMethod authMethod)

  Create connection preamble

  Parameters:

  byteBuf - to write to

  authMethod - to write

• close

  public void close(Throwable e)

  Close connection

  Parameters:

  e - exception on close

• cleanupCalls

  private void cleanupCalls()

  Clean up calls.

• isAlive

  public boolean isAlive()

  Check if the connection is alive

  Returns:

  true if alive

• shouldAuthenticateOverKrb

  private boolean shouldAuthenticateOverKrb()
                                     throws IOException

  Check if user should authenticate over Kerberos

  Returns:

  true if should be authenticated over Kerberos

  Throws:

  IOException - on failure of check

• handleSaslConnectionFailure

  private void handleSaslConnectionFailure(int currRetries,
                                 Throwable 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 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).

  Parameters:

  currRetries - retry count

  ex - exception describing fail

  user - which is trying to connect

  Throws:

  IOException - if IO fail

  InterruptedException - if thread is interrupted

• getConnectionHashCode

  public int getConnectionHashCode()

• hashCode

  public int hashCode()

  Overrides:

  hashCode in class Object

• equals

  public boolean equals(Object obj)

  Overrides:

  equals in class Object

• toString

  public String toString()

  Overrides:

  toString in class Object