[
https://issues.apache.org/jira/browse/HBASE-18846?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
stack updated HBASE-18846:
--------------------------
Release Note:
Makes it so hbase-indexer/lily can rely on public APIs.
Adds being able to disable near-all HRegionServer services. This along with an
existing plugin mechanism which allows configuring the RegionServer to host an
alternate Connection implementation, makes it so we can put up a cluster of
hollowed-out HRegionServers whose only purpose is to pose as a Replication Sink
for a source HBase Cluster. In the alternate supplied Connection
implementation, hbase-indexer would install its own code to catch the
Replication.
Below and attached are sample hbase-server.xml files and alternate Connection
implementations. To start up an HRegionServer as a sink, first make sure there
is a ZooKeeper ensemble we can talk to. If none, just start one:
{code}
./bin/hbase-daemon.sh start zookeeper
{code}
To start up a single RegionServer, put in place the below sample hbase-site.xml
and a derviative of the below IndexerConnection on the CLASSPATH, and then
start the RegionServer:
{code}
./bin/hbase-daemon.sh start org.apache.hadoop.hbase.regionserver.HRegionServer
{code}
Stdout and Stderr will go into files under configured logs directory.
This patch adds configuration to disable RegionServer internal Services,
Managers, Caches, etc., starting up.
By default a RegionServer starts up an Admin and Client Service. To disable
either or both, use the below booleans:
{code}
hbase.regionserver.admin.service
hbase.regionserver.client.service
{code}
Both default true.
To make a HRegionServer startup and stay up without expecting to communicate
with a master, set the below boolean to false:
{code}
hbase.masterless
{code]
Default is false.
h3. Sample hbase-site.xml that disables internal HRegionServer Services
Below is an example hbase-site.xml that turns off most Services and that then
installs an alternate Connection implementation, one that is nulled out in all
regards except in being able to return a "Table" that can catch a Replication
Stream in its {code}batch(List<? extends Row> actions, Object[] results){code}
method. i.e. what the hbase-indexer wants. I also add the example alternate
Connection implementation below (both of these files are also attached to this
issue). Expects there to be an up and running zookeeper ensemble.
{code}
<configuration>
<!-- This file is an example for hbase-indexer. It shuts down
facility in the regionserver and interjects a special
Connection implementation which is how hbase-indexer will
receive the replication stream from source hbase cluster.
See the class referenced in the config.
Most of the config in here is booleans set to off and
setting values to zero so services doon't start. Some of
the flags are new via this patch.
-->
<!--Need this for the RegionServer to come up standalone-->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<!--This is what you implement, a Connection that returns a Table that
overrides the batch call. It is at this point you do your indexer
inserts.
-->
<property>
<name>hbase.client.connection.impl</name>
<value>org.apache.hadoop.hbase.client.IndexerConnection</value>
<description>A customs connection implementation just so we can interject
our
own Table class, one that has an override for the batch call which
receives
the replication stream edits; i.e. it is called by the replication sink
#replicateEntries method.</description>
</property>
<!--Set hbase.regionserver.info.port to -1 for no webui-->
<!--Below are configs to shut down unused services in hregionserver-->
<property>
<name>hbase.regionserver.admin.service</name>
<value>false</value>
<description>Do NOT stand up an Admin Service Interface on RPC</description>
</property>
<property>
<name>hbase.regionserver.client.service</name>
<value>false</value>
<description>Do NOT stand up a client-facing Service on RPC</description>
</property>
<property>
<name>hbase.wal.provider</name>
<value>org.apache.hadoop.hbase.wal.DisabledWALProvider</value>
<description>Set WAL service to be the null WAL</description>
</property>
<property>
<name>hbase.regionserver.workers</name>
<value>false</value>
<description>Turn off all background workers, log splitters, executors,
etc.</description>
</property>
<property>
<name>hfile.block.cache.size</name>
<value>0.0001</value>
<description>Turn off block cache completely</description>
</property>
<property>
<name>hbase.mob.file.cache.size</name>
<value>0</value>
<description>Disable MOB cache.</description>
</property>
<property>
<name>hbase.masterless</name>
<value>true</value>
<description>Do not expect Master in cluster.</description>
</property>
<property>
<name>hbase.regionserver.metahandler.count</name>
<value>1</value>
<description>How many priority handlers to run; we probably need none.
Default is 20 which is too much on a server like this.</description>
</property>
<property>
<name>hbase.regionserver.replication.handler.count</name>
<value>1</value>
<description>How many replication handlers to run; we probably need none.
Default is 3 which is too much on a server like this.</description>
</property>
<property>
<name>hbase.regionserver.handler.count</name>
<value>10</value>
<description>How many default handlers to run; tie to # of CPUs.
Default is 30 which is too much on a server like this.</description>
</property>
<property>
<name>hbase.ipc.server.read.threadpool.size</name>
<value>3</value>
<description>How many Listener request reaaders to run; tie to a portion #
of CPUs (1/4?).
Default is 10 which is too much on a server like this.</description>
</property>
</configuration>
{code}
h2. Sample Connection Implementation
Has call-out for where an hbase-indexer would insert its capture code.
{code}
package org.apache.hadoop.hbase.client;
import com.google.protobuf.Descriptors;
import com.google.protobuf.Message;
import com.google.protobuf.Service;
import com.google.protobuf.ServiceException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.coprocessor.Batch;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.ipc.CoprocessorRpcChannel;
import org.apache.hadoop.hbase.security.User;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
/**
* Sample class for hbase-indexer.
* DO NOT COMMIT TO HBASE CODEBASE!!!
* Overrides Connection just so we can return a Table that has the
* method that the replication sink calls, i.e. Table#batch.
* It is at this point that the hbase-indexer catches the replication
* stream so it can insert into the lucene index.
*/
public class IndexerConnection implements Connection {
private final Configuration conf;
private final User user;
private final ExecutorService pool;
private volatile boolean closed = false;
public IndexerConnection(Configuration conf, ExecutorService pool, User user)
throws IOException {
this.conf = conf;
this.user = user;
this.pool = pool;
}
@Override
public void abort(String why, Throwable e) {}
@Override
public boolean isAborted() {
return false;
}
@Override
public Configuration getConfiguration() {
return this.conf;
}
@Override
public BufferedMutator getBufferedMutator(TableName tableName) throws
IOException {
return null;
}
@Override
public BufferedMutator getBufferedMutator(BufferedMutatorParams params)
throws IOException {
return null;
}
@Override
public RegionLocator getRegionLocator(TableName tableName) throws IOException
{
return null;
}
@Override
public Admin getAdmin() throws IOException {
return null;
}
@Override
public void close() throws IOException {
if (!this.closed) this.closed = true;
}
@Override
public boolean isClosed() {
return this.closed;
}
@Override
public TableBuilder getTableBuilder(final TableName tn, ExecutorService pool)
{
if (isClosed()) {
throw new RuntimeException("IndexerConnection is closed.");
}
final Configuration passedInConfiguration = getConfiguration();
return new TableBuilder() {
@Override
public TableBuilder setOperationTimeout(int timeout) {
return null;
}
@Override
public TableBuilder setRpcTimeout(int timeout) {
return null;
}
@Override
public TableBuilder setReadRpcTimeout(int timeout) {
return null;
}
@Override
public TableBuilder setWriteRpcTimeout(int timeout) {
return null;
}
@Override
public Table build() {
return new Table() {
private final Configuration conf = passedInConfiguration;
private final TableName tableName = tn;
@Override
public TableName getName() {
return this.tableName;
}
@Override
public Configuration getConfiguration() {
return this.conf;
}
@Override
public void batch(List<? extends Row> actions, Object[] results)
throws IOException, InterruptedException {
// Implementation goes here.
}
@Override
public HTableDescriptor getTableDescriptor() throws IOException {
return null;
}
@Override
public TableDescriptor getDescriptor() throws IOException {
return null;
}
@Override
public boolean exists(Get get) throws IOException {
return false;
}
@Override
public boolean[] existsAll(List<Get> gets) throws IOException {
return new boolean[0];
}
@Override
public <R> void batchCallback(List<? extends Row> actions, Object[]
results, Batch.Callback<R> callback) throws IOException, InterruptedException {
}
@Override
public Result get(Get get) throws IOException {
return null;
}
@Override
public Result[] get(List<Get> gets) throws IOException {
return new Result[0];
}
@Override
public ResultScanner getScanner(Scan scan) throws IOException {
return null;
}
@Override
public ResultScanner getScanner(byte[] family) throws IOException {
return null;
}
@Override
public ResultScanner getScanner(byte[] family, byte[] qualifier)
throws IOException {
return null;
}
@Override
public void put(Put put) throws IOException {
}
@Override
public void put(List<Put> puts) throws IOException {
}
@Override
public boolean checkAndPut(byte[] row, byte[] family, byte[]
qualifier, byte[] value, Put put) throws IOException {
return false;
}
@Override
public boolean checkAndPut(byte[] row, byte[] family, byte[]
qualifier, CompareFilter.CompareOp compareOp, byte[] value, Put put) throws
IOException {
return false;
}
@Override
public boolean checkAndPut(byte[] row, byte[] family, byte[]
qualifier, CompareOperator op, byte[] value, Put put) throws IOException {
return false;
}
@Override
public void delete(Delete delete) throws IOException {
}
@Override
public void delete(List<Delete> deletes) throws IOException {
}
@Override
public boolean checkAndDelete(byte[] row, byte[] family, byte[]
qualifier, byte[] value, Delete delete) throws IOException {
return false;
}
@Override
public boolean checkAndDelete(byte[] row, byte[] family, byte[]
qualifier, CompareFilter.CompareOp compareOp, byte[] value, Delete delete)
throws IOException {
return false;
}
@Override
public boolean checkAndDelete(byte[] row, byte[] family, byte[]
qualifier, CompareOperator op, byte[] value, Delete delete) throws IOException {
return false;
}
@Override
public void mutateRow(RowMutations rm) throws IOException {
}
@Override
public Result append(Append append) throws IOException {
return null;
}
@Override
public Result increment(Increment increment) throws IOException {
return null;
}
@Override
public long incrementColumnValue(byte[] row, byte[] family, byte[]
qualifier, long amount) throws IOException {
return 0;
}
@Override
public long incrementColumnValue(byte[] row, byte[] family, byte[]
qualifier, long amount, Durability durability) throws IOException {
return 0;
}
@Override
public void close() throws IOException {
}
@Override
public CoprocessorRpcChannel coprocessorService(byte[] row) {
return null;
}
@Override
public <T extends Service, R> Map<byte[], R>
coprocessorService(Class<T> service, byte[] startKey, byte[] endKey,
Batch.Call<T, R> callable) throws ServiceException, Throwable {
return null;
}
@Override
public <T extends Service, R> void coprocessorService(Class<T>
service, byte[] startKey, byte[] endKey, Batch.Call<T, R> callable,
Batch.Callback<R> callback) throws ServiceException, Throwable {
}
@Override
public <R extends Message> Map<byte[], R>
batchCoprocessorService(Descriptors.MethodDescriptor methodDescriptor, Message
request, byte[] startKey, byte[] endKey, R responsePrototype) throws
ServiceException, Throwable {
return null;
}
@Override
public <R extends Message> void
batchCoprocessorService(Descriptors.MethodDescriptor methodDescriptor, Message
request, byte[] startKey, byte[] endKey, R responsePrototype, Batch.Callback<R>
callback) throws ServiceException, Throwable {
}
@Override
public boolean checkAndMutate(byte[] row, byte[] family, byte[]
qualifier, CompareFilter.CompareOp compareOp, byte[] value, RowMutations
mutation) throws IOException {
return false;
}
@Override
public boolean checkAndMutate(byte[] row, byte[] family, byte[]
qualifier, CompareOperator op, byte[] value, RowMutations mutation) throws
IOException {
return false;
}
@Override
public void setOperationTimeout(int operationTimeout) {
}
@Override
public int getOperationTimeout() {
return 0;
}
@Override
public int getRpcTimeout() {
return 0;
}
@Override
public void setRpcTimeout(int rpcTimeout) {
}
@Override
public int getReadRpcTimeout() {
return 0;
}
@Override
public void setReadRpcTimeout(int readRpcTimeout) {
}
@Override
public int getWriteRpcTimeout() {
return 0;
}
@Override
public void setWriteRpcTimeout(int writeRpcTimeout) {
}
};
}
};
}
}
{code}
was:
Makes it so hbase-indexer can use public APIs. Adds being able to start one or
more HRegionServer instances with all usual Services disabled. An existing
mechanism allows plugging in an alternate Connection implementation. Combining
these two features, we can put up a cluster of hollowed-out HRegionServers
whose only role is to pose as a Replication Sink. In the alternate Connection
implementation, hbase-indexer installs its own code to catch the Replication.
Adds configuration to disable RegionServer Services starting up.
By default a RegionServer starts up an Admin and Client Service. To disable
either or both, use the below booleans:
{code}hbase.regionserver.admin.service{code}
{code}hbase.regionserver.client.service{code}
Both default true.
To make a HRegionServer startup and stay up without expecting to communicate
with a master, set the below boolean to false:
{code}hbase.masterless{code]
Below is an example hbase-site.xml that turns off most Services and that then
installs an alternate Connection implementation, one that is nulled out in all
regards except in being able to return a "Table" that can catch a Replication
Stream in its {code}batch(List<? extends Row> actions, Object[] results){code}
method. i.e. what the hbase-indexer wants. I also add the example alternate
Connection implementation below (both of these files are also attached to this
issue). Expects there to be an up and running zookeeper ensemble.
{code}
<configuration>
<!-- This file is an example for hbase-indexer. It shuts down
facility in the regionserver and interjects a special
Connection implementation which is how hbase-indexer will
receive the replication stream from source hbase cluster.
See the class referenced in the config.
Most of the config in here is booleans set to off and
setting values to zero so services doon't start. Some of
the flags are new via this patch.
-->
<!--Need this for the RegionServer to come up standalone-->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<!--This is what you implement, a Connection that returns a Table that
overrides the batch call. It is at this point you do your indexer
inserts.
-->
<property>
<name>hbase.client.connection.impl</name>
<value>org.apache.hadoop.hbase.client.IndexerConnection</value>
<description>A customs connection implementation just so we can interject
our
own Table class, one that has an override for the batch call which
receives
the replication stream edits; i.e. it is called by the replication sink
#replicateEntries method.</description>
</property>
<!--Set hbase.regionserver.info.port to -1 for no webui-->
<!--Below are configs to shut down unused services in hregionserver-->
<property>
<name>hbase.regionserver.admin.service</name>
<value>false</value>
<description>Do NOT stand up an Admin Service Interface on RPC</description>
</property>
<property>
<name>hbase.regionserver.client.service</name>
<value>false</value>
<description>Do NOT stand up a client-facing Service on RPC</description>
</property>
<property>
<name>hbase.wal.provider</name>
<value>org.apache.hadoop.hbase.wal.DisabledWALProvider</value>
<description>Set WAL service to be the null WAL</description>
</property>
<property>
<name>hbase.regionserver.workers</name>
<value>false</value>
<description>Turn off all background workers, log splitters, executors,
etc.</description>
</property>
<property>
<name>hfile.block.cache.size</name>
<value>0.0001</value>
<description>Turn off block cache completely</description>
</property>
<property>
<name>hbase.mob.file.cache.size</name>
<value>0</value>
<description>Disable MOB cache.</description>
</property>
<property>
<name>hbase.masterless</name>
<value>true</value>
<description>Do not expect Master in cluster.</description>
</property>
<property>
<name>hbase.regionserver.metahandler.count</name>
<value>1</value>
<description>How many priority handlers to run; we probably need none.
Default is 20 which is too much on a server like this.</description>
</property>
<property>
<name>hbase.regionserver.replication.handler.count</name>
<value>1</value>
<description>How many replication handlers to run; we probably need none.
Default is 3 which is too much on a server like this.</description>
</property>
<property>
<name>hbase.regionserver.handler.count</name>
<value>10</value>
<description>How many default handlers to run; tie to # of CPUs.
Default is 30 which is too much on a server like this.</description>
</property>
<property>
<name>hbase.ipc.server.read.threadpool.size</name>
<value>3</value>
<description>How many Listener request reaaders to run; tie to a portion #
of CPUs (1/4?).
Default is 10 which is too much on a server like this.</description>
</property>
</configuration>
{code}
{code}
package org.apache.hadoop.hbase.client;
import com.google.protobuf.Descriptors;
import com.google.protobuf.Message;
import com.google.protobuf.Service;
import com.google.protobuf.ServiceException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.coprocessor.Batch;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.ipc.CoprocessorRpcChannel;
import org.apache.hadoop.hbase.security.User;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
/**
* Sample class for hbase-indexer.
* DO NOT COMMIT TO HBASE CODEBASE!!!
* Overrides Connection just so we can return a Table that has the
* method that the replication sink calls, i.e. Table#batch.
* It is at this point that the hbase-indexer catches the replication
* stream so it can insert into the lucene index.
*/
public class IndexerConnection implements Connection {
private final Configuration conf;
private final User user;
private final ExecutorService pool;
private volatile boolean closed = false;
public IndexerConnection(Configuration conf, ExecutorService pool, User user)
throws IOException {
this.conf = conf;
this.user = user;
this.pool = pool;
}
@Override
public void abort(String why, Throwable e) {}
@Override
public boolean isAborted() {
return false;
}
@Override
public Configuration getConfiguration() {
return this.conf;
}
@Override
public BufferedMutator getBufferedMutator(TableName tableName) throws
IOException {
return null;
}
@Override
public BufferedMutator getBufferedMutator(BufferedMutatorParams params)
throws IOException {
return null;
}
@Override
public RegionLocator getRegionLocator(TableName tableName) throws IOException
{
return null;
}
@Override
public Admin getAdmin() throws IOException {
return null;
}
@Override
public void close() throws IOException {
if (!this.closed) this.closed = true;
}
@Override
public boolean isClosed() {
return this.closed;
}
@Override
public TableBuilder getTableBuilder(final TableName tn, ExecutorService pool)
{
if (isClosed()) {
throw new RuntimeException("IndexerConnection is closed.");
}
final Configuration passedInConfiguration = getConfiguration();
return new TableBuilder() {
@Override
public TableBuilder setOperationTimeout(int timeout) {
return null;
}
@Override
public TableBuilder setRpcTimeout(int timeout) {
return null;
}
@Override
public TableBuilder setReadRpcTimeout(int timeout) {
return null;
}
@Override
public TableBuilder setWriteRpcTimeout(int timeout) {
return null;
}
@Override
public Table build() {
return new Table() {
private final Configuration conf = passedInConfiguration;
private final TableName tableName = tn;
@Override
public TableName getName() {
return this.tableName;
}
@Override
public Configuration getConfiguration() {
return this.conf;
}
@Override
public void batch(List<? extends Row> actions, Object[] results)
throws IOException, InterruptedException {
// Implementation goes here.
}
@Override
public HTableDescriptor getTableDescriptor() throws IOException {
return null;
}
@Override
public TableDescriptor getDescriptor() throws IOException {
return null;
}
@Override
public boolean exists(Get get) throws IOException {
return false;
}
@Override
public boolean[] existsAll(List<Get> gets) throws IOException {
return new boolean[0];
}
@Override
public <R> void batchCallback(List<? extends Row> actions, Object[]
results, Batch.Callback<R> callback) throws IOException, InterruptedException {
}
@Override
public Result get(Get get) throws IOException {
return null;
}
@Override
public Result[] get(List<Get> gets) throws IOException {
return new Result[0];
}
@Override
public ResultScanner getScanner(Scan scan) throws IOException {
return null;
}
@Override
public ResultScanner getScanner(byte[] family) throws IOException {
return null;
}
@Override
public ResultScanner getScanner(byte[] family, byte[] qualifier)
throws IOException {
return null;
}
@Override
public void put(Put put) throws IOException {
}
@Override
public void put(List<Put> puts) throws IOException {
}
@Override
public boolean checkAndPut(byte[] row, byte[] family, byte[]
qualifier, byte[] value, Put put) throws IOException {
return false;
}
@Override
public boolean checkAndPut(byte[] row, byte[] family, byte[]
qualifier, CompareFilter.CompareOp compareOp, byte[] value, Put put) throws
IOException {
return false;
}
@Override
public boolean checkAndPut(byte[] row, byte[] family, byte[]
qualifier, CompareOperator op, byte[] value, Put put) throws IOException {
return false;
}
@Override
public void delete(Delete delete) throws IOException {
}
@Override
public void delete(List<Delete> deletes) throws IOException {
}
@Override
public boolean checkAndDelete(byte[] row, byte[] family, byte[]
qualifier, byte[] value, Delete delete) throws IOException {
return false;
}
@Override
public boolean checkAndDelete(byte[] row, byte[] family, byte[]
qualifier, CompareFilter.CompareOp compareOp, byte[] value, Delete delete)
throws IOException {
return false;
}
@Override
public boolean checkAndDelete(byte[] row, byte[] family, byte[]
qualifier, CompareOperator op, byte[] value, Delete delete) throws IOException {
return false;
}
@Override
public void mutateRow(RowMutations rm) throws IOException {
}
@Override
public Result append(Append append) throws IOException {
return null;
}
@Override
public Result increment(Increment increment) throws IOException {
return null;
}
@Override
public long incrementColumnValue(byte[] row, byte[] family, byte[]
qualifier, long amount) throws IOException {
return 0;
}
@Override
public long incrementColumnValue(byte[] row, byte[] family, byte[]
qualifier, long amount, Durability durability) throws IOException {
return 0;
}
@Override
public void close() throws IOException {
}
@Override
public CoprocessorRpcChannel coprocessorService(byte[] row) {
return null;
}
@Override
public <T extends Service, R> Map<byte[], R>
coprocessorService(Class<T> service, byte[] startKey, byte[] endKey,
Batch.Call<T, R> callable) throws ServiceException, Throwable {
return null;
}
@Override
public <T extends Service, R> void coprocessorService(Class<T>
service, byte[] startKey, byte[] endKey, Batch.Call<T, R> callable,
Batch.Callback<R> callback) throws ServiceException, Throwable {
}
@Override
public <R extends Message> Map<byte[], R>
batchCoprocessorService(Descriptors.MethodDescriptor methodDescriptor, Message
request, byte[] startKey, byte[] endKey, R responsePrototype) throws
ServiceException, Throwable {
return null;
}
@Override
public <R extends Message> void
batchCoprocessorService(Descriptors.MethodDescriptor methodDescriptor, Message
request, byte[] startKey, byte[] endKey, R responsePrototype, Batch.Callback<R>
callback) throws ServiceException, Throwable {
}
@Override
public boolean checkAndMutate(byte[] row, byte[] family, byte[]
qualifier, CompareFilter.CompareOp compareOp, byte[] value, RowMutations
mutation) throws IOException {
return false;
}
@Override
public boolean checkAndMutate(byte[] row, byte[] family, byte[]
qualifier, CompareOperator op, byte[] value, RowMutations mutation) throws
IOException {
return false;
}
@Override
public void setOperationTimeout(int operationTimeout) {
}
@Override
public int getOperationTimeout() {
return 0;
}
@Override
public int getRpcTimeout() {
return 0;
}
@Override
public void setRpcTimeout(int rpcTimeout) {
}
@Override
public int getReadRpcTimeout() {
return 0;
}
@Override
public void setReadRpcTimeout(int readRpcTimeout) {
}
@Override
public int getWriteRpcTimeout() {
return 0;
}
@Override
public void setWriteRpcTimeout(int writeRpcTimeout) {
}
};
}
};
}
}
{code}
> Accommodate the hbase-indexer/lily/SEP consumer deploy-type
> -----------------------------------------------------------
>
> Key: HBASE-18846
> URL: https://issues.apache.org/jira/browse/HBASE-18846
> Project: HBase
> Issue Type: Bug
> Reporter: stack
> Assignee: stack
> Fix For: 2.0.0-beta-1
>
> Attachments: HBASE-18846.master.001.patch,
> HBASE-18846.master.002.patch, HBASE-18846.master.003.patch,
> IndexerConnection.java, hbase-site.xml, javadoc.txt
>
>
> This is a follow-on from HBASE-10504, Define a Replication Interface. There
> we defined a new, flexible replication endpoint for others to implement but
> it did little to help the case of the lily hbase-indexer. This issue takes up
> the case of the hbase-indexer.
> The hbase-indexer poses to hbase as a 'fake' peer cluster (For why
> hbase-indexer is implemented so, the advantage to having the indexing done in
> a separate process set that can be independently scaled, can participate in
> the same security realm, etc., see discussion in HBASE-10504). The
> hbase-indexer will start up a cut-down "RegionServer" processes that are just
> an instance of hbase RpcServer hosting an AdminProtos Service. They make
> themselves 'appear' to the Replication Source by hoisting up an ephemeral
> znode 'registering' as a RegionServer. The source cluster then streams
> WALEdits to the Admin Protos method:
> {code}
> public ReplicateWALEntryResponse replicateWALEntry(final RpcController
> controller,
> final ReplicateWALEntryRequest request) throws ServiceException {
> {code}
> The hbase-indexer relies on other hbase internals like Server so it can get a
> ZooKeeperWatcher instance and know the 'name' to use for this cut-down server.
> Thoughts on how to proceed include:
>
> * Better formalize its current digestion of hbase internals; make it so
> rpcserver is allowed to be used by others, etc. This would be hard to do
> given they use basics like Server, Protobuf serdes for WAL types, and
> AdminProtos Service. Any change in this wide API breaks (again)
> hbase-indexer. We have made a 'channel' for Coprocessor Endpoints so they
> continue to work though they use 'internal' types. They can use protos in
> hbase-protocol. hbase-protocol protos are in a limbo currently where they are
> sort-of 'public'; a TODO. Perhaps the hbase-indexer could do similar relying
> on the hbase-protocol (pb2.5) content and we could do something to reveal
> rpcserver and zk for hbase-indexer safe use.
> * Start an actual RegionServer only have it register the AdminProtos Service
> only -- not ClientProtos and the Service that does Master interaction, etc.
> [I checked, this is not as easy to do as I at first thought -- St.Ack] Then
> have the hbase-indexer implement an AdminCoprocessor to override the
> replicateWALEntry method (the Admin CP implementation may need work). This
> would narrow the hbase-indexer exposure to that of the Admin Coprocessor
> Interface
> * Over in HBASE-10504, [~enis] suggested "... if we want to provide
> isolation for the replication services in hbase, we can have a simple host as
> another daemon which hosts the ReplicationEndpoint implementation. RS's will
> use a built-in RE to send the edits to this layer, and the host will delegate
> it to the RE implementation. The flow would be something like: RS --> RE
> inside RS --> Host daemon for RE --> Actual RE implementation --> third party
> system..."
>
> Other crazy notions occur including the setup of an Admin Interface
> Coprocessor Endpoint. A new ReplicationEndpoint would feed the replication
> stream to the remote cluster via the CPEP registered channel.
> But time is short. Hopefully we can figure something that will work in 2.0
> timeframe w/o too much code movement.
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
