public RegionReplicaSinkWriter(
        RegionReplicaOutputSink sink,
        ClusterConnection connection,
        ExecutorService pool,
        int operationTimeout) {
      this.sink = sink;
      this.connection = connection;
      this.operationTimeout = operationTimeout;
      this.rpcRetryingCallerFactory =
          RpcRetryingCallerFactory.instantiate(connection.getConfiguration());
      this.rpcControllerFactory = RpcControllerFactory.instantiate(connection.getConfiguration());
      this.pool = pool;

      int nonExistentTableCacheExpiryMs =
          connection
              .getConfiguration()
              .getInt(
                  "hbase.region.replica.replication.cache.disabledAndDroppedTables.expiryMs", 5000);
      // A cache for non existing tables that have a default expiry of 5 sec. This means that if the
      // table is created again with the same name, we might miss to replicate for that amount of
      // time. But this cache prevents overloading meta requests for every edit from a deleted file.
      disabledAndDroppedTables =
          CacheBuilder.newBuilder()
              .expireAfterWrite(nonExistentTableCacheExpiryMs, TimeUnit.MILLISECONDS)
              .initialCapacity(10)
              .maximumSize(1000)
              .build();
    }
예제 #2
0
 /**
  * Calls {@link #getMockedConnection(Configuration)} and then mocks a few more of the popular
  * {@link ClusterConnection} methods so they do 'normal' operation (see return doc below for
  * list). Be sure to shutdown the connection when done by calling {@link Connection#close()} else
  * it will stick around; this is probably not what you want.
  *
  * @param conf Configuration to use
  * @param admin An AdminProtocol; can be null but is usually itself a mock.
  * @param client A ClientProtocol; can be null but is usually itself a mock.
  * @param sn ServerName to include in the region location returned by this <code>connection</code>
  * @param hri HRegionInfo to include in the location returned when getRegionLocator is called on
  *     the mocked connection
  * @return Mock up a connection that returns a {@link Configuration} when {@link
  *     ClusterConnection#getConfiguration()} is called, a 'location' when {@link
  *     ClusterConnection#getRegionLocation(org.apache.hadoop.hbase.TableName, byte[], boolean)} is
  *     called, and that returns the passed {@link AdminProtos.AdminService.BlockingInterface}
  *     instance when {@link ClusterConnection#getAdmin(ServerName)} is called, returns the passed
  *     {@link ClientProtos.ClientService.BlockingInterface} instance when {@link
  *     ClusterConnection#getClient(ServerName)} is called (Be sure to call {@link
  *     Connection#close()} when done with this mocked Connection.
  * @throws IOException
  */
 public static ClusterConnection getMockedConnectionAndDecorate(
     final Configuration conf,
     final AdminProtos.AdminService.BlockingInterface admin,
     final ClientProtos.ClientService.BlockingInterface client,
     final ServerName sn,
     final HRegionInfo hri)
     throws IOException {
   ConnectionImplementation c = Mockito.mock(ConnectionImplementation.class);
   Mockito.when(c.getConfiguration()).thenReturn(conf);
   Mockito.doNothing().when(c).close();
   // Make it so we return a particular location when asked.
   final HRegionLocation loc = new HRegionLocation(hri, sn);
   Mockito.when(
           c.getRegionLocation(
               (TableName) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean()))
       .thenReturn(loc);
   Mockito.when(c.locateRegion((TableName) Mockito.any(), (byte[]) Mockito.any())).thenReturn(loc);
   Mockito.when(
           c.locateRegion(
               (TableName) Mockito.any(),
               (byte[]) Mockito.any(),
               Mockito.anyBoolean(),
               Mockito.anyBoolean(),
               Mockito.anyInt()))
       .thenReturn(new RegionLocations(loc));
   if (admin != null) {
     // If a call to getAdmin, return this implementation.
     Mockito.when(c.getAdmin(Mockito.any(ServerName.class))).thenReturn(admin);
   }
   if (client != null) {
     // If a call to getClient, return this client.
     Mockito.when(c.getClient(Mockito.any(ServerName.class))).thenReturn(client);
   }
   NonceGenerator ng = Mockito.mock(NonceGenerator.class);
   Mockito.when(c.getNonceGenerator()).thenReturn(ng);
   Mockito.when(c.getAsyncProcess())
       .thenReturn(
           new AsyncProcess(
               c,
               conf,
               null,
               RpcRetryingCallerFactory.instantiate(conf),
               false,
               RpcControllerFactory.instantiate(conf),
               conf.getInt(HConstants.HBASE_RPC_TIMEOUT_KEY, HConstants.DEFAULT_HBASE_RPC_TIMEOUT),
               conf.getInt(
                   HConstants.HBASE_CLIENT_OPERATION_TIMEOUT,
                   HConstants.DEFAULT_HBASE_CLIENT_OPERATION_TIMEOUT)));
   Mockito.when(c.getNewRpcRetryingCallerFactory(conf))
       .thenReturn(
           RpcRetryingCallerFactory.instantiate(
               conf, RetryingCallerInterceptorFactory.NO_OP_INTERCEPTOR, null));
   Mockito.when(c.getRpcControllerFactory()).thenReturn(Mockito.mock(RpcControllerFactory.class));
   Table t = Mockito.mock(Table.class);
   Mockito.when(c.getTable((TableName) Mockito.any())).thenReturn(t);
   ResultScanner rs = Mockito.mock(ResultScanner.class);
   Mockito.when(t.getScanner((Scan) Mockito.any())).thenReturn(rs);
   return c;
 }
예제 #3
0
 /**
  * @deprecated use {@link #ClientSmallScanner(Configuration, Scan, TableName, HConnection,
  *     RpcRetryingCallerFactory, RpcControllerFactory)} instead
  */
 public ClientSmallScanner(
     final Configuration conf,
     final Scan scan,
     final TableName tableName,
     HConnection connection,
     RpcRetryingCallerFactory rpcFactory)
     throws IOException {
   this(conf, scan, tableName, connection, rpcFactory, RpcControllerFactory.instantiate(conf));
 }
예제 #4
0
 public FlushWorker(
     Configuration conf,
     ClusterConnection conn,
     HRegionLocation addr,
     HTableMultiplexer htableMultiplexer,
     int perRegionServerBufferQueueSize,
     ExecutorService pool,
     ScheduledExecutorService executor) {
   this.addr = addr;
   this.multiplexer = htableMultiplexer;
   this.queue = new LinkedBlockingQueue<>(perRegionServerBufferQueueSize);
   RpcRetryingCallerFactory rpcCallerFactory = RpcRetryingCallerFactory.instantiate(conf);
   RpcControllerFactory rpcControllerFactory = RpcControllerFactory.instantiate(conf);
   this.ap = new AsyncProcess(conn, conf, pool, rpcCallerFactory, false, rpcControllerFactory);
   this.executor = executor;
   this.maxRetryInQueue = conf.getInt(TABLE_MULTIPLEXER_MAX_RETRIES_IN_QUEUE, 10000);
 }