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();
}
/**
* 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;
}
/**
* @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));
}
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);
}