diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/HTableDescriptor.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/HTableDescriptor.java index 5eb737b3eb1..c09d434f3dd 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/HTableDescriptor.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/HTableDescriptor.java @@ -149,17 +149,6 @@ public class HTableDescriptor implements TableDescriptor, Comparable listTableDescriptors() throws IOException; + /** * List all the userspace tables matching the given pattern. * @@ -108,18 +119,44 @@ public interface Admin extends Abortable, Closeable { * @return - returns an array of read-only HTableDescriptors * @throws IOException if a remote or network exception occurs * @see #listTables() + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptors(java.util.regex.Pattern)} */ + @Deprecated HTableDescriptor[] listTables(Pattern pattern) throws IOException; + /** + * List all the userspace tables matching the given pattern. + * + * @param pattern The compiled regular expression to match against + * @return - returns a list of TableDescriptors + * @throws IOException if a remote or network exception occurs + * @see #listTables() + */ + List listTableDescriptors(Pattern pattern) throws IOException; + /** * List all the userspace tables matching the given regular expression. * * @param regex The regular expression to match against - * @return - returns an array of HTableDescriptors + * @return - returns an array of read-only HTableDescriptors + * @throws IOException if a remote or network exception occurs + * @see #listTables(java.util.regex.Pattern) + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptors(java.lang.String)} + */ + @Deprecated + HTableDescriptor[] listTables(String regex) throws IOException; + + /** + * List all the userspace tables matching the given regular expression. + * + * @param regex The regular expression to match against + * @return - returns a list of TableDescriptors * @throws IOException if a remote or network exception occurs * @see #listTables(java.util.regex.Pattern) */ - HTableDescriptor[] listTables(String regex) throws IOException; + List listTableDescriptors(String regex) throws IOException; /** * List all the tables matching the given pattern. @@ -129,10 +166,25 @@ public interface Admin extends Abortable, Closeable { * @return - returns an array of read-only HTableDescriptors * @throws IOException if a remote or network exception occurs * @see #listTables() + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptors(java.util.regex.Pattern, boolean)} */ + @Deprecated HTableDescriptor[] listTables(Pattern pattern, boolean includeSysTables) throws IOException; + /** + * List all the tables matching the given pattern. + * + * @param pattern The compiled regular expression to match against + * @param includeSysTables False to match only against userspace tables + * @return - returns a list of TableDescriptors + * @throws IOException if a remote or network exception occurs + * @see #listTables() + */ + List listTableDescriptors(Pattern pattern, boolean includeSysTables) + throws IOException; + /** * List all the tables matching the given pattern. * @@ -141,10 +193,25 @@ public interface Admin extends Abortable, Closeable { * @return - returns an array of read-only HTableDescriptors * @throws IOException if a remote or network exception occurs * @see #listTables(java.util.regex.Pattern, boolean) + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptors(java.lang.String, boolean)} */ + @Deprecated HTableDescriptor[] listTables(String regex, boolean includeSysTables) throws IOException; + /** + * List all the tables matching the given pattern. + * + * @param regex The regular expression to match against + * @param includeSysTables False to match only against userspace tables + * @return - returns a list of TableDescriptors + * @throws IOException if a remote or network exception occurs + * @see #listTables(java.util.regex.Pattern, boolean) + */ + List listTableDescriptors(String regex, boolean includeSysTables) + throws IOException; + /** * List all of the names of userspace tables. * @@ -196,10 +263,24 @@ public interface Admin extends Abortable, Closeable { * @return the read-only tableDescriptor * @throws org.apache.hadoop.hbase.TableNotFoundException * @throws IOException if a remote or network exception occurs + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptor(TableName)} */ + @Deprecated HTableDescriptor getTableDescriptor(final TableName tableName) throws TableNotFoundException, IOException; + /** + * Method for getting the tableDescriptor + * + * @param tableName as a {@link TableName} + * @return the tableDescriptor + * @throws org.apache.hadoop.hbase.TableNotFoundException + * @throws IOException if a remote or network exception occurs + */ + TableDescriptor listTableDescriptor(final TableName tableName) + throws TableNotFoundException, IOException; + /** * Creates a new table. Synchronous operation. * @@ -209,8 +290,50 @@ public interface Admin extends Abortable, Closeable { * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent * threads, the table may have been created between test-for-existence and attempt-at-creation). * @throws IOException if a remote or network exception occurs + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTable(TableDescriptor)} */ - void createTable(HTableDescriptor desc) throws IOException; + @Deprecated + default void createTable(HTableDescriptor desc) throws IOException { + createTable((TableDescriptor) desc); + } + + /** + * Creates a new table. Synchronous operation. + * + * @param desc table descriptor for table + * @throws IllegalArgumentException if the table name is reserved + * @throws org.apache.hadoop.hbase.MasterNotRunningException if master is not running + * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent + * threads, the table may have been created between test-for-existence and attempt-at-creation). + * @throws IOException if a remote or network exception occurs + */ + void createTable(TableDescriptor desc) throws IOException; + + /** + * Creates a new table with the specified number of regions. The start key specified will become + * the end key of the first region of the table, and the end key specified will become the start + * key of the last region of the table (the first region has a null start key and the last region + * has a null end key). BigInteger math will be used to divide the key range specified into enough + * segments to make the required number of total regions. Synchronous operation. + * + * @param desc table descriptor for table + * @param startKey beginning of key range + * @param endKey end of key range + * @param numRegions the total number of regions to create + * @throws IllegalArgumentException if the table name is reserved + * @throws org.apache.hadoop.hbase.MasterNotRunningException if master is not running + * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent + * threads, the table may have been created between test-for-existence and attempt-at-creation). + * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTable(TableDescriptor, byte[], byte[], int)} + */ + @Deprecated + default void createTable(HTableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions) + throws IOException { + createTable((TableDescriptor) desc, startKey, endKey, numRegions); + } /** * Creates a new table with the specified number of regions. The start key specified will become @@ -229,7 +352,7 @@ public interface Admin extends Abortable, Closeable { * threads, the table may have been created between test-for-existence and attempt-at-creation). * @throws IOException */ - void createTable(HTableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions) + void createTable(TableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions) throws IOException; /** @@ -245,8 +368,52 @@ public interface Admin extends Abortable, Closeable { * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent * threads, the table may have been created between test-for-existence and attempt-at-creation). * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTable(TableDescriptor, byte[][])} */ - void createTable(final HTableDescriptor desc, byte[][] splitKeys) throws IOException; + @Deprecated + default void createTable(final HTableDescriptor desc, byte[][] splitKeys) throws IOException { + createTable((TableDescriptor) desc, splitKeys); + } + + /** + * Creates a new table with an initial set of empty regions defined by the specified split keys. + * The total number of regions created will be the number of split keys plus one. Synchronous + * operation. Note : Avoid passing empty split key. + * + * @param desc table descriptor for table + * @param splitKeys array of split keys for the initial regions of the table + * @throws IllegalArgumentException if the table name is reserved, if the split keys are repeated + * and if the split key has empty byte array. + * @throws org.apache.hadoop.hbase.MasterNotRunningException if master is not running + * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent + * threads, the table may have been created between test-for-existence and attempt-at-creation). + * @throws IOException + */ + void createTable(final TableDescriptor desc, byte[][] splitKeys) throws IOException; + + /** + * Creates a new table but does not block and wait for it to come online. + * You can use Future.get(long, TimeUnit) to wait on the operation to complete. + * It may throw ExecutionException if there was an error while executing the operation + * or TimeoutException in case the wait timeout was not long enough to allow the + * operation to complete. + * Throws IllegalArgumentException Bad table name, if the split keys + * are repeated and if the split key has empty byte array. + * + * @param desc table descriptor for table + * @param splitKeys keys to check if the table has been created with all split keys + * @throws IOException if a remote or network exception occurs + * @return the result of the async creation. You can use Future.get(long, TimeUnit) + * to wait on the operation to complete. + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTableAsync(TableDescriptor, byte[][])} + */ + @Deprecated + default Future createTableAsync(final HTableDescriptor desc, final byte[][] splitKeys) + throws IOException { + return createTableAsync((TableDescriptor) desc, splitKeys); + } /** * Creates a new table but does not block and wait for it to come online. @@ -263,7 +430,7 @@ public interface Admin extends Abortable, Closeable { * @return the result of the async creation. You can use Future.get(long, TimeUnit) * to wait on the operation to complete. */ - Future createTableAsync(final HTableDescriptor desc, final byte[][] splitKeys) + Future createTableAsync(final TableDescriptor desc, final byte[][] splitKeys) throws IOException; /** @@ -291,7 +458,8 @@ public interface Admin extends Abortable, Closeable { /** * Deletes tables matching the passed in pattern and wait on completion. Warning: Use this method * carefully, there is no prompting and the effect is immediate. Consider using {@link - * #listTables(java.lang.String)} and {@link #deleteTable(org.apache.hadoop.hbase.TableName)} + * #listTableDescriptors(java.lang.String)} + * and {@link #deleteTable(org.apache.hadoop.hbase.TableName)} * * @param regex The regular expression to match table names against * @return Table descriptors for tables that couldn't be deleted. @@ -299,20 +467,30 @@ public interface Admin extends Abortable, Closeable { * @throws IOException * @see #deleteTables(java.util.regex.Pattern) * @see #deleteTable(org.apache.hadoop.hbase.TableName) + * @deprecated since 2.0 version and will be removed in 3.0 version + * This is just a trivial helper method without any magic. + * Consider using {@link #listTableDescriptors(java.lang.String)} + * and {@link #enableTable(org.apache.hadoop.hbase.TableName)} */ + @Deprecated HTableDescriptor[] deleteTables(String regex) throws IOException; /** * Delete tables matching the passed in pattern and wait on completion. Warning: Use this method * carefully, there is no prompting and the effect is immediate. Consider using {@link - * #listTables(java.util.regex.Pattern) } and + * #listTableDescriptors(java.util.regex.Pattern)} and * {@link #deleteTable(org.apache.hadoop.hbase.TableName)} * * @param pattern The pattern to match table names against * @return Table descriptors for tables that couldn't be deleted * The return htds are read-only * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version + * This is just a trivial helper method without any magic. + * Consider using {@link #listTableDescriptors(java.util.regex.Pattern)} + * and {@link #enableTable(org.apache.hadoop.hbase.TableName)} */ + @Deprecated HTableDescriptor[] deleteTables(Pattern pattern) throws IOException; /** @@ -372,7 +550,7 @@ public interface Admin extends Abortable, Closeable { /** * Enable tables matching the passed in pattern and wait on completion. Warning: Use this method * carefully, there is no prompting and the effect is immediate. Consider using {@link - * #listTables(java.lang.String)} and {@link #enableTable(org.apache.hadoop.hbase.TableName)} + * #listTableDescriptors(java.lang.String)} and {@link #enableTable(org.apache.hadoop.hbase.TableName)} * * @param regex The regular expression to match table names against * @throws IOException @@ -380,20 +558,30 @@ public interface Admin extends Abortable, Closeable { * The return HTDs are read-only. * @see #enableTables(java.util.regex.Pattern) * @see #enableTable(org.apache.hadoop.hbase.TableName) + * @deprecated since 2.0 version and will be removed in 3.0 version + * This is just a trivial helper method without any magic. + * Consider using {@link #listTableDescriptors(java.lang.String)} + * and {@link #enableTable(org.apache.hadoop.hbase.TableName)} */ + @Deprecated HTableDescriptor[] enableTables(String regex) throws IOException; /** * Enable tables matching the passed in pattern and wait on completion. Warning: Use this method * carefully, there is no prompting and the effect is immediate. Consider using {@link - * #listTables(java.util.regex.Pattern) } and + * #listTableDescriptors(java.util.regex.Pattern)} and * {@link #enableTable(org.apache.hadoop.hbase.TableName)} * * @param pattern The pattern to match table names against * @throws IOException * @return Table descriptors for tables that couldn't be enabled. * The return HTDs are read-only. + * @deprecated since 2.0 version and will be removed in 3.0 version + * This is just a trivial helper method without any magic. + * Consider using {@link #listTableDescriptors(java.util.regex.Pattern)} + * and {@link #enableTable(org.apache.hadoop.hbase.TableName)} */ + @Deprecated HTableDescriptor[] enableTables(Pattern pattern) throws IOException; /** @@ -425,7 +613,8 @@ public interface Admin extends Abortable, Closeable { /** * Disable tables matching the passed in pattern and wait on completion. Warning: Use this method * carefully, there is no prompting and the effect is immediate. Consider using {@link - * #listTables(java.lang.String)} and {@link #disableTable(org.apache.hadoop.hbase.TableName)} + * #listTableDescriptors(java.lang.String)} + * and {@link #disableTable(org.apache.hadoop.hbase.TableName)} * * @param regex The regular expression to match table names against * @return Table descriptors for tables that couldn't be disabled @@ -433,20 +622,30 @@ public interface Admin extends Abortable, Closeable { * @throws IOException * @see #disableTables(java.util.regex.Pattern) * @see #disableTable(org.apache.hadoop.hbase.TableName) + * @deprecated since 2.0 version and will be removed in 3.0 version + * This is just a trivial helper method without any magic. + * Consider using {@link #listTableDescriptors(java.lang.String)} + * and {@link #disableTable(org.apache.hadoop.hbase.TableName)} */ + @Deprecated HTableDescriptor[] disableTables(String regex) throws IOException; /** * Disable tables matching the passed in pattern and wait on completion. Warning: Use this method * carefully, there is no prompting and the effect is immediate. Consider using {@link - * #listTables(java.util.regex.Pattern) } and + * #listTableDescriptors(java.util.regex.Pattern)} and * {@link #disableTable(org.apache.hadoop.hbase.TableName)} * * @param pattern The pattern to match table names against * @return Table descriptors for tables that couldn't be disabled * The return htds are read-only * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version + * This is just a trivial helper method without any magic. + * Consider using {@link #listTableDescriptors(java.util.regex.Pattern)} + * and {@link #disableTable(org.apache.hadoop.hbase.TableName)} */ + @Deprecated HTableDescriptor[] disableTables(Pattern pattern) throws IOException; /** @@ -1014,10 +1213,21 @@ public interface Admin extends Abortable, Closeable { * @param tableName name of table. * @param htd modified description of the table * @throws IOException if a remote or network exception occurs + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #modifyTable(TableDescriptor)} */ + @Deprecated void modifyTable(final TableName tableName, final HTableDescriptor htd) throws IOException; + /** + * Modify an existing table, more IRB friendly version. + * + * @param td modified description of the table + * @throws IOException if a remote or network exception occurs + */ + void modifyTable(final TableDescriptor td) throws IOException; + /** * Modify an existing table, more IRB friendly version. Asynchronous operation. This means that * it may be a while before your schema change is updated across all of the table. @@ -1031,10 +1241,29 @@ public interface Admin extends Abortable, Closeable { * @throws IOException if a remote or network exception occurs * @return the result of the async modify. You can use Future.get(long, TimeUnit) to wait on the * operation to complete + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #modifyTableAsync(TableDescriptor)} */ + @Deprecated Future modifyTableAsync(final TableName tableName, final HTableDescriptor htd) throws IOException; + /** + * Modify an existing table, more IRB friendly version. Asynchronous operation. This means that + * it may be a while before your schema change is updated across all of the table. + * You can use Future.get(long, TimeUnit) to wait on the operation to complete. + * It may throw ExecutionException if there was an error while executing the operation + * or TimeoutException in case the wait timeout was not long enough to allow the + * operation to complete. + * + * @param td description of the table + * @throws IOException if a remote or network exception occurs + * @return the result of the async modify. You can use Future.get(long, TimeUnit) to wait on the + * operation to complete + */ + Future modifyTableAsync(TableDescriptor td) + throws IOException; + /** * Shuts down the HBase cluster * @@ -1177,10 +1406,23 @@ public interface Admin extends Abortable, Closeable { * @param name namespace name * @return HTD[] the read-only tableDescriptors * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptorsByNamespace(byte[])} */ + @Deprecated HTableDescriptor[] listTableDescriptorsByNamespace(final String name) throws IOException; + /** + * Get list of table descriptors by namespace + * + * @param name namespace name + * @return returns a list of TableDescriptors + * @throws IOException + */ + List listTableDescriptorsByNamespace(final byte[] name) + throws IOException; + /** * Get list of table names by namespace * @@ -1210,17 +1452,33 @@ public interface Admin extends Abortable, Closeable { * @param tableNames List of table names * @return HTD[] the read-only tableDescriptors * @throws IOException if a remote or network exception occurs + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptors(List)} */ + @Deprecated HTableDescriptor[] getTableDescriptorsByTableName(List tableNames) throws IOException; + /** + * Get tableDescriptors + * + * @param tableNames List of table names + * @return returns a list of TableDescriptors + * @throws IOException if a remote or network exception occurs + */ + List listTableDescriptors(List tableNames) + throws IOException; + /** * Get tableDescriptors * * @param names List of table names * @return HTD[] the read-only tableDescriptors * @throws IOException if a remote or network exception occurs + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #listTableDescriptors(List)} */ + @Deprecated HTableDescriptor[] getTableDescriptors(List names) throws IOException; diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java index 1c6ea03b0c8..7518b9cff60 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java @@ -206,6 +206,7 @@ import com.google.common.annotations.VisibleForTesting; import com.google.protobuf.Descriptors; import com.google.protobuf.Message; import com.google.protobuf.RpcController; +import java.util.stream.Collectors; /** * HBaseAdmin is no longer a client API. It is marked InterfaceAudience.Private indicating that @@ -307,6 +308,96 @@ public class HBaseAdmin implements Admin { return new AbortProcedureFuture(this, procId, abortProcResponse); } + @Override + public List listTableDescriptors() throws IOException { + return listTableDescriptors((Pattern)null, false); + } + + @Override + public List listTableDescriptors(Pattern pattern) throws IOException { + return listTableDescriptors(pattern, false); + } + + @Override + public List listTableDescriptors(String regex) throws IOException { + return listTableDescriptors(Pattern.compile(regex), false); + } + + @Override + public List listTableDescriptors(Pattern pattern, boolean includeSysTables) throws IOException { + return executeCallable(new MasterCallable>(getConnection(), + getRpcControllerFactory()) { + @Override + protected List rpcCall() throws Exception { + GetTableDescriptorsRequest req = + RequestConverter.buildGetTableDescriptorsRequest(pattern, includeSysTables); + return ProtobufUtil.toTableDescriptorList(master.getTableDescriptors(getRpcController(), + req)); + } + }); + } + + @Override + public List listTableDescriptors(String regex, boolean includeSysTables) throws IOException { + return listTableDescriptors(Pattern.compile(regex), includeSysTables); + } + + @Override + public TableDescriptor listTableDescriptor(TableName tableName) throws TableNotFoundException, IOException { + return getTableDescriptor(tableName, getConnection(), rpcCallerFactory, rpcControllerFactory, + operationTimeout, rpcTimeout); + } + + @Override + public void modifyTable(TableDescriptor td) throws IOException { + get(modifyTableAsync(td), syncWaitTimeout, TimeUnit.MILLISECONDS); + } + + @Override + public Future modifyTableAsync(TableDescriptor td) throws IOException { + ModifyTableResponse response = executeCallable( + new MasterCallable(getConnection(), getRpcControllerFactory()) { + @Override + protected ModifyTableResponse rpcCall() throws Exception { + setPriority(td.getTableName()); + ModifyTableRequest request = RequestConverter.buildModifyTableRequest( + td.getTableName(), td, ng.getNonceGroup(), ng.newNonce()); + return master.modifyTable(getRpcController(), request); + } + }); + return new ModifyTableFuture(this, td.getTableName(), response); + } + + @Override + public List listTableDescriptorsByNamespace(byte[] name) throws IOException { + return executeCallable(new MasterCallable>(getConnection(), + getRpcControllerFactory()) { + @Override + protected List rpcCall() throws Exception { + return master.listTableDescriptorsByNamespace(getRpcController(), + ListTableDescriptorsByNamespaceRequest.newBuilder() + .setNamespaceName(Bytes.toString(name)).build()) + .getTableSchemaList() + .stream() + .map(ProtobufUtil::convertToTableDesc) + .collect(Collectors.toList()); + } + }); + } + + @Override + public List listTableDescriptors(List tableNames) throws IOException { + return executeCallable(new MasterCallable>(getConnection(), + getRpcControllerFactory()) { + @Override + protected List rpcCall() throws Exception { + GetTableDescriptorsRequest req = + RequestConverter.buildGetTableDescriptorsRequest(tableNames); + return ProtobufUtil.toTableDescriptorList(master.getTableDescriptors(getRpcController(), req)); + } + }); + } + private static class AbortProcedureFuture extends ProcedureFuture { private boolean isAbortInProgress; @@ -419,11 +510,40 @@ public class HBaseAdmin implements Admin { @Override public HTableDescriptor getTableDescriptor(final TableName tableName) throws IOException { - return getTableDescriptor(tableName, getConnection(), rpcCallerFactory, rpcControllerFactory, + return getHTableDescriptor(tableName, getConnection(), rpcCallerFactory, rpcControllerFactory, operationTimeout, rpcTimeout); } - static HTableDescriptor getTableDescriptor(final TableName tableName, Connection connection, + static TableDescriptor getTableDescriptor(final TableName tableName, Connection connection, + RpcRetryingCallerFactory rpcCallerFactory, final RpcControllerFactory rpcControllerFactory, + int operationTimeout, int rpcTimeout) throws IOException { + if (tableName == null) return null; + TableDescriptor td = + executeCallable(new MasterCallable(connection, rpcControllerFactory) { + @Override + protected TableDescriptor rpcCall() throws Exception { + GetTableDescriptorsRequest req = + RequestConverter.buildGetTableDescriptorsRequest(tableName); + GetTableDescriptorsResponse htds = master.getTableDescriptors(getRpcController(), req); + if (!htds.getTableSchemaList().isEmpty()) { + return ProtobufUtil.convertToTableDesc(htds.getTableSchemaList().get(0)); + } + return null; + } + }, rpcCallerFactory, operationTimeout, rpcTimeout); + if (td != null) { + return td; + } + throw new TableNotFoundException(tableName.getNameAsString()); + } + + /** + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #getTableDescriptor(TableName, + * Connection, RpcRetryingCallerFactory,RpcControllerFactory,int,int)} + */ + @Deprecated + static HTableDescriptor getHTableDescriptor(final TableName tableName, Connection connection, RpcRetryingCallerFactory rpcCallerFactory, final RpcControllerFactory rpcControllerFactory, int operationTimeout, int rpcTimeout) throws IOException { if (tableName == null) return null; @@ -455,13 +575,13 @@ public class HBaseAdmin implements Admin { } @Override - public void createTable(HTableDescriptor desc) + public void createTable(TableDescriptor desc) throws IOException { createTable(desc, null); } @Override - public void createTable(HTableDescriptor desc, byte [] startKey, + public void createTable(TableDescriptor desc, byte [] startKey, byte [] endKey, int numRegions) throws IOException { if(numRegions < 3) { @@ -481,13 +601,13 @@ public class HBaseAdmin implements Admin { } @Override - public void createTable(final HTableDescriptor desc, byte [][] splitKeys) + public void createTable(final TableDescriptor desc, byte [][] splitKeys) throws IOException { get(createTableAsync(desc, splitKeys), syncWaitTimeout, TimeUnit.MILLISECONDS); } @Override - public Future createTableAsync(final HTableDescriptor desc, final byte[][] splitKeys) + public Future createTableAsync(final TableDescriptor desc, final byte[][] splitKeys) throws IOException { if (desc.getTableName() == null) { throw new IllegalArgumentException("TableName cannot be null"); @@ -524,19 +644,19 @@ public class HBaseAdmin implements Admin { } private static class CreateTableFuture extends TableFuture { - private final HTableDescriptor desc; + private final TableDescriptor desc; private final byte[][] splitKeys; - public CreateTableFuture(final HBaseAdmin admin, final HTableDescriptor desc, + public CreateTableFuture(final HBaseAdmin admin, final TableDescriptor desc, final byte[][] splitKeys, final CreateTableResponse response) { super(admin, desc.getTableName(), (response != null && response.hasProcId()) ? response.getProcId() : null); this.splitKeys = splitKeys; - this.desc = new ImmutableHTableDescriptor(desc); + this.desc = desc; } @Override - protected HTableDescriptor getTableDescriptor() { + protected TableDescriptor getTableDescriptor() { return desc; } @@ -3546,7 +3666,7 @@ public class HBaseAdmin implements Admin { /** * @return the table descriptor */ - protected HTableDescriptor getTableDescriptor() throws IOException { + protected TableDescriptor getTableDescriptor() throws IOException { return getAdmin().getTableDescriptorByTableName(getTableName()); } @@ -3642,7 +3762,7 @@ public class HBaseAdmin implements Admin { protected void waitForAllRegionsOnline(final long deadlineTs, final byte[][] splitKeys) throws IOException, TimeoutException { - final HTableDescriptor desc = getTableDescriptor(); + final TableDescriptor desc = getTableDescriptor(); final AtomicInteger actualRegCount = new AtomicInteger(0); final MetaTableAccessor.Visitor visitor = new MetaTableAccessor.Visitor() { @Override diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java index d207f6a0986..46ce902c163 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java @@ -263,7 +263,17 @@ public class HTable implements Table { */ @Override public HTableDescriptor getTableDescriptor() throws IOException { - HTableDescriptor htd = HBaseAdmin.getTableDescriptor(tableName, connection, rpcCallerFactory, + HTableDescriptor htd = HBaseAdmin.getHTableDescriptor(tableName, connection, rpcCallerFactory, + rpcControllerFactory, operationTimeout, readRpcTimeout); + if (htd != null) { + return new ImmutableHTableDescriptor(htd); + } + return null; + } + + @Override + public TableDescriptor getDescriptor() throws IOException { + HTableDescriptor htd = HBaseAdmin.getHTableDescriptor(tableName, connection, rpcCallerFactory, rpcControllerFactory, operationTimeout, readRpcTimeout); if (htd != null) { return new ImmutableHTableDescriptor(htd); diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java index 933329f7346..c76c2f5f637 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java @@ -65,9 +65,18 @@ public interface Table extends Closeable { /** * Gets the {@link org.apache.hadoop.hbase.HTableDescriptor table descriptor} for this table. * @throws java.io.IOException if a remote or network exception occurs. + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #getDescriptor()} */ + @Deprecated HTableDescriptor getTableDescriptor() throws IOException; + /** + * Gets the {@link org.apache.hadoop.hbase.client.TableDescriptor table descriptor} for this table. + * @throws java.io.IOException if a remote or network exception occurs. + */ + TableDescriptor getDescriptor() throws IOException; + /** * Test for the existence of columns in the table, as specified by the Get. *

@@ -604,7 +613,7 @@ public interface Table extends Closeable { /** * Get timeout (millisecond) of each rpc request in this Table instance. * - * @returns Currently configured read timeout + * @return Currently configured read timeout * @deprecated Use getReadRpcTimeout or getWriteRpcTimeout instead */ @Deprecated diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptor.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptor.java index 33e896c9c5b..65e64f8aa2a 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptor.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptor.java @@ -207,6 +207,14 @@ public interface TableDescriptor { */ byte[] getValue(byte[] key); + /** + * Getter for accessing the metadata associated with the key. + * + * @param key The key. + * @return Null if no mapping for the key + */ + String getValue(String key); + /** * @return Getter for fetching an unmodifiable map. */ diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptorBuilder.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptorBuilder.java index 7a90a71e71f..44d5c99fbfd 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptorBuilder.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/TableDescriptorBuilder.java @@ -500,13 +500,20 @@ public class TableDescriptorBuilder { @Override public Bytes getValue(Bytes key) { - return values.get(key); + Bytes rval = values.get(key); + return rval == null ? null : new Bytes(rval.copyBytes()); + } + + @Override + public String getValue(String key) { + Bytes rval = values.get(new Bytes(Bytes.toBytes(key))); + return rval == null ? null : Bytes.toString(rval.get(), rval.getOffset(), rval.getLength()); } @Override public byte[] getValue(byte[] key) { Bytes value = values.get(new Bytes(key)); - return value == null ? null : value.get(); + return value == null ? null : value.copyBytes(); } private T getOrDefault(Bytes key, Function function, T defaultValue) { diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/security/EncryptionUtil.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/security/EncryptionUtil.java index c7e0be7ac3a..6a570366efa 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/security/EncryptionUtil.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/security/EncryptionUtil.java @@ -35,6 +35,7 @@ import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.classification.InterfaceStability; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.io.crypto.Cipher; import org.apache.hadoop.hbase.io.crypto.Encryption; import org.apache.hadoop.hbase.shaded.com.google.protobuf.UnsafeByteOperations; @@ -182,7 +183,7 @@ public final class EncryptionUtil { * @throws IOException if an encryption key for the column cannot be unwrapped */ public static Encryption.Context createEncryptionContext(Configuration conf, - HColumnDescriptor family) throws IOException { + ColumnFamilyDescriptor family) throws IOException { Encryption.Context cryptoContext = Encryption.Context.NONE; String cipherName = family.getEncryptionType(); if (cipherName != null) { diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java index a74d7370e1a..5c44b4e0da2 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java @@ -1305,17 +1305,17 @@ public final class RequestConverter { * Creates a protocol buffer ModifyTableRequest * * @param tableName - * @param hTableDesc + * @param tableDesc * @return a ModifyTableRequest */ public static ModifyTableRequest buildModifyTableRequest( final TableName tableName, - final HTableDescriptor hTableDesc, + final TableDescriptor tableDesc, final long nonceGroup, final long nonce) { ModifyTableRequest.Builder builder = ModifyTableRequest.newBuilder(); builder.setTableName(ProtobufUtil.toProtoTableName((tableName))); - builder.setTableSchema(ProtobufUtil.convertToTableSchema(hTableDesc)); + builder.setTableSchema(ProtobufUtil.convertToTableSchema(tableDesc)); builder.setNonceGroup(nonceGroup); builder.setNonce(nonce); return builder.build(); diff --git a/hbase-examples/src/main/java/org/apache/hadoop/hbase/coprocessor/example/ZooKeeperScanPolicyObserver.java b/hbase-examples/src/main/java/org/apache/hadoop/hbase/coprocessor/example/ZooKeeperScanPolicyObserver.java index b7df9b4e210..35f85f71a56 100644 --- a/hbase-examples/src/main/java/org/apache/hadoop/hbase/coprocessor/example/ZooKeeperScanPolicyObserver.java +++ b/hbase-examples/src/main/java/org/apache/hadoop/hbase/coprocessor/example/ZooKeeperScanPolicyObserver.java @@ -182,7 +182,7 @@ public class ZooKeeperScanPolicyObserver implements RegionObserver { } long ttl = Math.max(EnvironmentEdgeManager.currentTime() - Bytes.toLong(data), oldSI.getTtl()); - return new ScanInfo(oldSI.getConfiguration(), store.getFamily(), ttl, + return new ScanInfo(oldSI.getConfiguration(), store.getColumnFamilyDescriptor(), ttl, oldSI.getTimeToPurgeDeletes(), oldSI.getComparator()); } diff --git a/hbase-rest/src/main/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java b/hbase-rest/src/main/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java index 5012a5a9415..63dfcaabfdd 100644 --- a/hbase-rest/src/main/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java +++ b/hbase-rest/src/main/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java @@ -54,6 +54,7 @@ import org.apache.hadoop.hbase.client.Row; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.client.coprocessor.Batch; import org.apache.hadoop.hbase.client.coprocessor.Batch.Callback; import org.apache.hadoop.hbase.client.metrics.ScanMetrics; @@ -508,6 +509,11 @@ public class RemoteHTable implements Table { // no-op } + @Override + public TableDescriptor getDescriptor() throws IOException { + return getTableDescriptor(); + } + class Scanner implements ResultScanner { String uri; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/HFileSplitterJob.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/HFileSplitterJob.java index 604e5021f5b..a07868d95d7 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/HFileSplitterJob.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/HFileSplitterJob.java @@ -126,7 +126,7 @@ public class HFileSplitterJob extends Configured implements Tool { try (Connection conn = ConnectionFactory.createConnection(conf); Table table = conn.getTable(tableName); RegionLocator regionLocator = conn.getRegionLocator(tableName)) { - HFileOutputFormat2.configureIncrementalLoad(job, table.getTableDescriptor(), regionLocator); + HFileOutputFormat2.configureIncrementalLoad(job, table.getDescriptor(), regionLocator); } LOG.debug("success configuring load incremental job"); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/client/HTableWrapper.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/client/HTableWrapper.java index 051a8f26e91..88248724167 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/client/HTableWrapper.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/client/HTableWrapper.java @@ -219,6 +219,11 @@ public final class HTableWrapper implements Table { return table.getTableDescriptor(); } + @Override + public TableDescriptor getDescriptor() throws IOException { + return table.getDescriptor(); + } + @Override public TableName getName() { return table.getName(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/ConstraintProcessor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/ConstraintProcessor.java index f2176417be0..b8360821302 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/ConstraintProcessor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/ConstraintProcessor.java @@ -29,6 +29,7 @@ import org.apache.hadoop.hbase.CoprocessorEnvironment; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Durability; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.coprocessor.ObserverContext; import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment; import org.apache.hadoop.hbase.coprocessor.RegionObserver; @@ -67,7 +68,7 @@ public class ConstraintProcessor implements RegionObserver { "Constraints only act on regions - started in an environment that was not a region"); } RegionCoprocessorEnvironment env = (RegionCoprocessorEnvironment) environment; - HTableDescriptor desc = env.getRegion().getTableDesc(); + TableDescriptor desc = env.getRegion().getTableDescriptor(); // load all the constraints from the HTD try { this.constraints = Constraints.getConstraints(desc, classloader); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/Constraints.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/Constraints.java index 5ed9aa845fc..203442a1309 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/Constraints.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/constraint/Constraints.java @@ -34,6 +34,7 @@ import org.apache.commons.logging.LogFactory; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.Pair; @@ -555,7 +556,7 @@ public final class Constraints { * @throws IOException * if any part of reading/arguments fails */ - static List getConstraints(HTableDescriptor desc, + static List getConstraints(TableDescriptor desc, ClassLoader classloader) throws IOException { List constraints = new ArrayList<>(); // loop through all the key, values looking for constraints diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/CopyTable.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/CopyTable.java index c0d809b4e2e..21b85560ec6 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/CopyTable.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/CopyTable.java @@ -160,7 +160,7 @@ public class CopyTable extends Configured implements Tool { try (Connection conn = ConnectionFactory.createConnection(getConf()); Admin admin = conn.getAdmin()) { HFileOutputFormat2.configureIncrementalLoadMap(job, - admin.getTableDescriptor((TableName.valueOf(dstTableName)))); + admin.listTableDescriptor((TableName.valueOf(dstTableName)))); } } else { TableMapReduceUtil.initTableMapperJob(tableName, scan, diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java index f847608846a..56af23aadb1 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java @@ -25,7 +25,6 @@ import java.net.URLEncoder; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collection; import java.util.List; import java.util.Map; import java.util.Set; @@ -44,20 +43,19 @@ import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellComparator; import org.apache.hadoop.hbase.CellUtil; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.HRegionLocation; -import org.apache.hadoop.hbase.HTableDescriptor; -import org.apache.hadoop.hbase.KeyValue; -import org.apache.hadoop.hbase.KeyValueUtil; -import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.RegionLocator; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.fs.HFileSystem; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.HRegionLocation; +import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; import org.apache.hadoop.hbase.io.compress.Compression; import org.apache.hadoop.hbase.io.compress.Compression.Algorithm; @@ -67,10 +65,13 @@ import org.apache.hadoop.hbase.io.hfile.HFile; import org.apache.hadoop.hbase.io.hfile.HFileContext; import org.apache.hadoop.hbase.io.hfile.HFileContextBuilder; import org.apache.hadoop.hbase.io.hfile.HFileWriterImpl; +import org.apache.hadoop.hbase.KeyValue; +import org.apache.hadoop.hbase.KeyValueUtil; import org.apache.hadoop.hbase.regionserver.BloomType; import org.apache.hadoop.hbase.regionserver.HStore; import org.apache.hadoop.hbase.regionserver.StoreFile; import org.apache.hadoop.hbase.regionserver.StoreFileWriter; +import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.util.FSUtils; @@ -94,23 +95,33 @@ import com.google.common.annotations.VisibleForTesting; * all HFiles being written. *

* Using this class as part of a MapReduce job is best done - * using {@link #configureIncrementalLoad(Job, HTableDescriptor, RegionLocator)}. + * using {@link #configureIncrementalLoad(Job, TableDescriptor, RegionLocator)}. */ @InterfaceAudience.Public public class HFileOutputFormat2 extends FileOutputFormat { private static final Log LOG = LogFactory.getLog(HFileOutputFormat2.class); static class TableInfo { - private HTableDescriptor hTableDescriptor; + private TableDescriptor tableDesctiptor; private RegionLocator regionLocator; - public TableInfo(HTableDescriptor hTableDescriptor, RegionLocator regionLocator) { - this.hTableDescriptor = hTableDescriptor; + public TableInfo(TableDescriptor tableDesctiptor, RegionLocator regionLocator) { + this.tableDesctiptor = tableDesctiptor; this.regionLocator = regionLocator; } + /** + * The modification for the returned HTD doesn't affect the inner TD. + * @return A clone of inner table descriptor + * @deprecated use {@link #getTableDescriptor} + */ + @Deprecated public HTableDescriptor getHTableDescriptor() { - return hTableDescriptor; + return new HTableDescriptor(tableDesctiptor); + } + + public TableDescriptor getTableDescriptor() { + return tableDesctiptor; } public RegionLocator getRegionLocator() { @@ -539,7 +550,7 @@ public class HFileOutputFormat2 */ public static void configureIncrementalLoad(Job job, Table table, RegionLocator regionLocator) throws IOException { - configureIncrementalLoad(job, table.getTableDescriptor(), regionLocator); + configureIncrementalLoad(job, table.getDescriptor(), regionLocator); } /** @@ -556,7 +567,7 @@ public class HFileOutputFormat2 * The user should be sure to set the map output value class to either KeyValue or Put before * running this function. */ - public static void configureIncrementalLoad(Job job, HTableDescriptor tableDescriptor, + public static void configureIncrementalLoad(Job job, TableDescriptor tableDescriptor, RegionLocator regionLocator) throws IOException { ArrayList singleTableInfo = new ArrayList<>(); singleTableInfo.add(new TableInfo(tableDescriptor, regionLocator)); @@ -601,13 +612,13 @@ public class HFileOutputFormat2 /* Now get the region start keys for every table required */ List allTableNames = new ArrayList<>(multiTableInfo.size()); List regionLocators = new ArrayList<>( multiTableInfo.size()); - List tableDescriptors = new ArrayList<>( multiTableInfo.size()); + List tableDescriptors = new ArrayList<>( multiTableInfo.size()); for( TableInfo tableInfo : multiTableInfo ) { regionLocators.add(tableInfo.getRegionLocator()); allTableNames.add(tableInfo.getRegionLocator().getName().getNameAsString()); - tableDescriptors.add(tableInfo.getHTableDescriptor()); + tableDescriptors.add(tableInfo.getTableDescriptor()); } // Record tablenames for creating writer by favored nodes, and decoding compression, block size and other attributes of columnfamily per table conf.set(OUTPUT_TABLE_NAME_CONF_KEY, StringUtils.join(allTableNames, Bytes @@ -635,7 +646,7 @@ public class HFileOutputFormat2 LOG.info("Incremental output configured for tables: " + StringUtils.join(allTableNames, ",")); } - public static void configureIncrementalLoadMap(Job job, HTableDescriptor tableDescriptor) throws + public static void configureIncrementalLoadMap(Job job, TableDescriptor tableDescriptor) throws IOException { Configuration conf = job.getConfiguration(); @@ -643,10 +654,10 @@ public class HFileOutputFormat2 job.setOutputValueClass(KeyValue.class); job.setOutputFormatClass(HFileOutputFormat2.class); - ArrayList singleTableDescriptor = new ArrayList<>(1); + ArrayList singleTableDescriptor = new ArrayList<>(1); singleTableDescriptor.add(tableDescriptor); - conf.set(OUTPUT_TABLE_NAME_CONF_KEY, tableDescriptor.getNameAsString()); + conf.set(OUTPUT_TABLE_NAME_CONF_KEY, tableDescriptor.getTableName().getNameAsString()); // Set compression algorithms based on column families conf.set(COMPRESSION_FAMILIES_CONF_KEY, serializeColumnFamilyAttribute(compressionDetails, singleTableDescriptor)); @@ -793,18 +804,17 @@ public class HFileOutputFormat2 @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE") @VisibleForTesting - static String serializeColumnFamilyAttribute(Function fn, List allTables) + static String serializeColumnFamilyAttribute(Function fn, List allTables) throws UnsupportedEncodingException { StringBuilder attributeValue = new StringBuilder(); int i = 0; - for (HTableDescriptor tableDescriptor : allTables) { + for (TableDescriptor tableDescriptor : allTables) { if (tableDescriptor == null) { // could happen with mock table instance // CODEREVIEW: Can I set an empty string in conf if mock table instance? return ""; } - Collection families = tableDescriptor.getFamilies(); - for (HColumnDescriptor familyDescriptor : families) { + for (ColumnFamilyDescriptor familyDescriptor : tableDescriptor.getColumnFamilies()) { if (i++ > 0) { attributeValue.append('&'); } @@ -829,7 +839,7 @@ public class HFileOutputFormat2 * on failure to read column family descriptors */ @VisibleForTesting - static Function compressionDetails = familyDescriptor -> + static Function compressionDetails = familyDescriptor -> familyDescriptor.getCompressionType().getName(); /** @@ -845,7 +855,7 @@ public class HFileOutputFormat2 * on failure to read column family descriptors */ @VisibleForTesting - static Function blockSizeDetails = familyDescriptor -> String + static Function blockSizeDetails = familyDescriptor -> String .valueOf(familyDescriptor.getBlocksize()); /** @@ -861,10 +871,10 @@ public class HFileOutputFormat2 * on failure to read column family descriptors */ @VisibleForTesting - static Function bloomTypeDetails = familyDescriptor -> { + static Function bloomTypeDetails = familyDescriptor -> { String bloomType = familyDescriptor.getBloomFilterType().toString(); if (bloomType == null) { - bloomType = HColumnDescriptor.DEFAULT_BLOOMFILTER; + bloomType = ColumnFamilyDescriptorBuilder.DEFAULT_BLOOMFILTER.name(); } return bloomType; }; @@ -881,7 +891,7 @@ public class HFileOutputFormat2 * on failure to read column family descriptors */ @VisibleForTesting - static Function dataBlockEncodingDetails = familyDescriptor -> { + static Function dataBlockEncodingDetails = familyDescriptor -> { DataBlockEncoding encoding = familyDescriptor.getDataBlockEncoding(); if (encoding == null) { encoding = DataBlockEncoding.NONE; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/Import.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/Import.java index 3c72c2bfaa3..727d31f1406 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/Import.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/Import.java @@ -230,7 +230,7 @@ public class Import extends Configured implements Tool { int reduceNum = context.getNumReduceTasks(); Configuration conf = context.getConfiguration(); TableName tableName = TableName.valueOf(context.getConfiguration().get(TABLE_NAME)); - try (Connection conn = ConnectionFactory.createConnection(conf); + try (Connection conn = ConnectionFactory.createConnection(conf); RegionLocator regionLocator = conn.getRegionLocator(tableName)) { byte[][] startKeys = regionLocator.getStartKeys(); if (startKeys.length != reduceNum) { @@ -622,10 +622,10 @@ public class Import extends Configured implements Tool { if (hfileOutPath != null && conf.getBoolean(HAS_LARGE_RESULT, false)) { LOG.info("Use Large Result!!"); - try (Connection conn = ConnectionFactory.createConnection(conf); + try (Connection conn = ConnectionFactory.createConnection(conf); Table table = conn.getTable(tableName); RegionLocator regionLocator = conn.getRegionLocator(tableName)) { - HFileOutputFormat2.configureIncrementalLoad(job, table.getTableDescriptor(), regionLocator); + HFileOutputFormat2.configureIncrementalLoad(job, table.getDescriptor(), regionLocator); job.setMapperClass(KeyValueSortImporter.class); job.setReducerClass(KeyValueReducer.class); Path outputDir = new Path(hfileOutPath); @@ -655,7 +655,7 @@ public class Import extends Configured implements Tool { FileOutputFormat.setOutputPath(job, outputDir); job.setMapOutputKeyClass(ImmutableBytesWritable.class); job.setMapOutputValueClass(KeyValue.class); - HFileOutputFormat2.configureIncrementalLoad(job, table.getTableDescriptor(), regionLocator); + HFileOutputFormat2.configureIncrementalLoad(job, table.getDescriptor(), regionLocator); TableMapReduceUtil.addDependencyJarsForClasses(job.getConfiguration(), com.google.common.base.Preconditions.class); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/ImportTsv.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/ImportTsv.java index aa7b12987a5..e4506594190 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/ImportTsv.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/ImportTsv.java @@ -63,6 +63,8 @@ import org.apache.hadoop.util.ToolRunner; import com.google.common.base.Preconditions; import com.google.common.base.Splitter; import com.google.common.collect.Lists; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; /** * Tool to import data from a TSV file. @@ -521,15 +523,15 @@ public class ImportTsv extends Configured implements Tool { if(!noStrict) { ArrayList unmatchedFamilies = new ArrayList<>(); Set cfSet = getColumnFamilies(columns); - HTableDescriptor tDesc = table.getTableDescriptor(); + TableDescriptor tDesc = table.getDescriptor(); for (String cf : cfSet) { - if(tDesc.getFamily(Bytes.toBytes(cf)) == null) { + if(!tDesc.hasColumnFamily(Bytes.toBytes(cf))) { unmatchedFamilies.add(cf); } } if(unmatchedFamilies.size() > 0) { ArrayList familyNames = new ArrayList<>(); - for (HColumnDescriptor family : table.getTableDescriptor().getFamilies()) { + for (ColumnFamilyDescriptor family : table.getDescriptor().getColumnFamilies()) { familyNames.add(family.getNameAsString()); } String msg = @@ -553,7 +555,7 @@ public class ImportTsv extends Configured implements Tool { if (!isDryRun) { Path outputDir = new Path(hfileOutPath); FileOutputFormat.setOutputPath(job, outputDir); - HFileOutputFormat2.configureIncrementalLoad(job, table.getTableDescriptor(), + HFileOutputFormat2.configureIncrementalLoad(job, table.getDescriptor(), regionLocator); } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java index 3af42905f1e..b4b0f0f16d9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java @@ -70,6 +70,7 @@ import org.apache.hadoop.hbase.TableNotFoundException; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.ClientServiceCallable; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.RegionLocator; @@ -647,9 +648,9 @@ public class LoadIncrementalHFiles extends Configured implements Tool { */ private void validateFamiliesInHFiles(Table table, Deque queue, boolean silence) throws IOException { - Collection families = table.getTableDescriptor().getFamilies(); - List familyNames = new ArrayList<>(families.size()); - for (HColumnDescriptor family : families) { + ColumnFamilyDescriptor[] families = table.getDescriptor().getColumnFamilies(); + List familyNames = new ArrayList<>(families.length); + for (ColumnFamilyDescriptor family : families) { familyNames.add(family.getNameAsString()); } Iterator queueIter = queue.iterator(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/MultiTableHFileOutputFormat.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/MultiTableHFileOutputFormat.java index fdcf30ea50d..5c779d67fc8 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/MultiTableHFileOutputFormat.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/MultiTableHFileOutputFormat.java @@ -21,9 +21,8 @@ package org.apache.hadoop.hbase.mapreduce; import com.google.common.annotations.VisibleForTesting; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.classification.InterfaceAudience; -import org.apache.hadoop.hbase.client.RegionLocator; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.io.ImmutableBytesWritable; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.mapreduce.Job; @@ -84,7 +83,7 @@ public class MultiTableHFileOutputFormat extends HFileOutputFormat2 { /** * Analogous to - * {@link HFileOutputFormat2#configureIncrementalLoad(Job, HTableDescriptor, RegionLocator)}, + * {@link HFileOutputFormat2#configureIncrementalLoad(Job, TableDescriptor, RegionLocator)}, * this function will configure the requisite number of reducers to write HFiles for multple * tables simultaneously * diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/WALPlayer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/WALPlayer.java index 06e43e73a06..59678eb3631 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/WALPlayer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/WALPlayer.java @@ -307,7 +307,7 @@ public class WALPlayer extends Configured implements Tool { try (Connection conn = ConnectionFactory.createConnection(conf); Table table = conn.getTable(tableName); RegionLocator regionLocator = conn.getRegionLocator(tableName)) { - HFileOutputFormat2.configureIncrementalLoad(job, table.getTableDescriptor(), regionLocator); + HFileOutputFormat2.configureIncrementalLoad(job, table.getDescriptor(), regionLocator); } TableMapReduceUtil.addDependencyJarsForClasses(job.getConfiguration(), com.google.common.base.Preconditions.class); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreCompactor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreCompactor.java index 56c0242f8b6..c475b17bbbc 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreCompactor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreCompactor.java @@ -75,7 +75,7 @@ public class DefaultMobStoreCompactor extends DefaultCompactor { public InternalScanner createScanner(List scanners, ScanType scanType, FileDetails fd, long smallestReadPoint) throws IOException { Scan scan = new Scan(); - scan.setMaxVersions(store.getFamily().getMaxVersions()); + scan.setMaxVersions(store.getColumnFamilyDescriptor().getMaxVersions()); return new StoreScanner(store, store.getScanInfo(), scan, scanners, scanType, smallestReadPoint, fd.earliestPutTs); } @@ -103,7 +103,7 @@ public class DefaultMobStoreCompactor extends DefaultCompactor { throw new IllegalArgumentException("The store " + store + " is not a HMobStore"); } mobStore = (HMobStore) store; - mobSizeThreshold = store.getFamily().getMobThreshold(); + mobSizeThreshold = store.getColumnFamilyDescriptor().getMobThreshold(); } @Override @@ -195,7 +195,7 @@ public class DefaultMobStoreCompactor extends DefaultCompactor { ScannerContext.newBuilder().setBatchLimit(compactionKVMax).build(); throughputController.start(compactionName); KeyValueScanner kvs = (scanner instanceof KeyValueScanner)? (KeyValueScanner)scanner : null; - long shippedCallSizeLimit = (long) numofFilesToCompact * this.store.getFamily().getBlocksize(); + long shippedCallSizeLimit = (long) numofFilesToCompact * this.store.getColumnFamilyDescriptor().getBlocksize(); try { try { // If the mob file writer could not be created, directly write the cell to the store file. diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreFlusher.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreFlusher.java index 1a1c5a70067..f11bd99b9b2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreFlusher.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/DefaultMobStoreFlusher.java @@ -72,7 +72,7 @@ public class DefaultMobStoreFlusher extends DefaultStoreFlusher { public DefaultMobStoreFlusher(Configuration conf, Store store) throws IOException { super(conf, store); - mobCellValueSizeThreshold = store.getFamily().getMobThreshold(); + mobCellValueSizeThreshold = store.getColumnFamilyDescriptor().getMobThreshold(); this.targetPath = MobUtils.getMobFamilyPath(conf, store.getTableName(), store.getColumnFamilyName()); if (!this.store.getFileSystem().exists(targetPath)) { @@ -115,7 +115,7 @@ public class DefaultMobStoreFlusher extends DefaultStoreFlusher { synchronized (flushLock) { status.setStatus("Flushing " + store + ": creating writer"); // Write the map out to the disk - writer = store.createWriterInTmp(cellsCount, store.getFamily().getCompressionType(), + writer = store.createWriterInTmp(cellsCount, store.getColumnFamilyDescriptor().getCompressionType(), false, true, true, false, snapshot.getTimeRangeTracker()); IOException e = null; try { @@ -173,7 +173,7 @@ public class DefaultMobStoreFlusher extends DefaultStoreFlusher { long mobSize = 0; long time = snapshot.getTimeRangeTracker().getMax(); mobFileWriter = mobStore.createWriterInTmp(new Date(time), snapshot.getCellsCount(), - store.getFamily().getCompressionType(), store.getRegionInfo().getStartKey(), false); + store.getColumnFamilyDescriptor().getCompressionType(), store.getRegionInfo().getStartKey(), false); // the target path is {tableName}/.mob/{cfName}/mobFiles // the relative path is mobFiles byte[] fileName = Bytes.toBytes(mobFileWriter.getPath().getName()); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java index 6c803558dcd..d18d282b065 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java @@ -21,6 +21,7 @@ package org.apache.hadoop.hbase.mob; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.io.hfile.CacheConfig; /** @@ -31,7 +32,7 @@ public class MobCacheConfig extends CacheConfig { private static MobFileCache mobFileCache; - public MobCacheConfig(Configuration conf, HColumnDescriptor family) { + public MobCacheConfig(Configuration conf, ColumnFamilyDescriptor family) { super(conf, family); instantiateMobFileCache(conf); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobUtils.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobUtils.java index a869b7acdc9..80bda28dc21 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobUtils.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobUtils.java @@ -54,6 +54,7 @@ import org.apache.hadoop.hbase.TagType; import org.apache.hadoop.hbase.TagUtil; import org.apache.hadoop.hbase.backup.HFileArchiver; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.MobCompactPartitionPolicy; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.io.HFileLink; @@ -651,7 +652,7 @@ public final class MobUtils { * @throws IOException */ public static StoreFileWriter createWriter(Configuration conf, FileSystem fs, - HColumnDescriptor family, Path path, long maxKeyCount, + ColumnFamilyDescriptor family, Path path, long maxKeyCount, Compression.Algorithm compression, CacheConfig cacheConfig, Encryption.Context cryptoContext, ChecksumType checksumType, int bytesPerChecksum, int blocksize, BloomType bloomType, boolean isCompaction) diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java index c558b267d8a..b7e75544c8e 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java @@ -69,7 +69,7 @@ public class ActivePolicyEnforcement { * @see #getPolicyEnforcement(TableName) */ public SpaceViolationPolicyEnforcement getPolicyEnforcement(Region r) { - return getPolicyEnforcement(Objects.requireNonNull(r).getTableDesc().getTableName()); + return getPolicyEnforcement(Objects.requireNonNull(r).getTableDescriptor().getTableName()); } /** diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java index 756251a5e2f..4d3c1bcc9c9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java @@ -183,7 +183,7 @@ public class RegionServerRpcQuotaManager { } else { ugi = User.getCurrent().getUGI(); } - TableName table = region.getTableDesc().getTableName(); + TableName table = region.getTableDescriptor().getTableName(); OperationQuota quota = getQuota(ugi, table); try { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java index e7157d0cfa6..5d3b50bb1c8 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java @@ -332,7 +332,7 @@ public class CompactSplit implements CompactionRequestor, PropagatingConfigurati final String why, int priority, CompactionRequest request, boolean selectNow, User user) throws IOException { if (this.server.isStopped() - || (r.getTableDesc() != null && !r.getTableDesc().isCompactionEnabled())) { + || (r.getTableDescriptor() != null && !r.getTableDescriptor().isCompactionEnabled())) { return null; } @@ -345,7 +345,7 @@ public class CompactSplit implements CompactionRequestor, PropagatingConfigurati final RegionServerSpaceQuotaManager spaceQuotaManager = this.server.getRegionServerSpaceQuotaManager(); if (spaceQuotaManager != null && spaceQuotaManager.areCompactionsDisabled( - r.getTableDesc().getTableName())) { + r.getTableDescriptor().getTableName())) { if (LOG.isDebugEnabled()) { LOG.debug("Ignoring compaction request for " + r + " as an active space quota violation " + " policy disallows compactions."); @@ -562,7 +562,7 @@ public class CompactSplit implements CompactionRequestor, PropagatingConfigurati public void run() { Preconditions.checkNotNull(server); if (server.isStopped() - || (region.getTableDesc() != null && !region.getTableDesc().isCompactionEnabled())) { + || (region.getTableDescriptor() != null && !region.getTableDescriptor().isCompactionEnabled())) { return; } doCompaction(user); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactingMemStore.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactingMemStore.java index 5b9372a8268..f07009c0017 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactingMemStore.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactingMemStore.java @@ -408,7 +408,7 @@ public class CompactingMemStore extends AbstractMemStore { } private byte[] getFamilyNameInBytes() { - return store.getFamily().getName(); + return store.getColumnFamilyDescriptor().getName(); } private ThreadPoolExecutor getPool() { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ConstantSizeRegionSplitPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ConstantSizeRegionSplitPolicy.java index d915f2edc2b..324c1de3d0b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ConstantSizeRegionSplitPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ConstantSizeRegionSplitPolicy.java @@ -26,6 +26,7 @@ import org.apache.hadoop.hbase.HBaseInterfaceAudience; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.TableDescriptor; /** * A {@link RegionSplitPolicy} implementation which splits a region @@ -47,7 +48,7 @@ public class ConstantSizeRegionSplitPolicy extends RegionSplitPolicy { protected void configureForRegion(HRegion region) { super.configureForRegion(region); Configuration conf = getConf(); - HTableDescriptor desc = region.getTableDesc(); + TableDescriptor desc = region.getTableDescriptor(); if (desc != null) { this.desiredMaxFileSize = desc.getMaxFileSize(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DefaultStoreFlusher.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DefaultStoreFlusher.java index ef49f295f40..21f93ff9526 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DefaultStoreFlusher.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DefaultStoreFlusher.java @@ -64,7 +64,7 @@ public class DefaultStoreFlusher extends StoreFlusher { synchronized (flushLock) { status.setStatus("Flushing " + store + ": creating writer"); // Write the map out to the disk - writer = store.createWriterInTmp(cellsCount, store.getFamily().getCompressionType(), + writer = store.createWriterInTmp(cellsCount, store.getColumnFamilyDescriptor().getCompressionType(), /* isCompaction = */ false, /* includeMVCCReadpoint = */ true, /* includesTags = */ snapshot.isTagsPresent(), diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DelimitedKeyPrefixRegionSplitPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DelimitedKeyPrefixRegionSplitPolicy.java index 36e79291bba..daba0698e6e 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DelimitedKeyPrefixRegionSplitPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/DelimitedKeyPrefixRegionSplitPolicy.java @@ -51,9 +51,9 @@ public class DelimitedKeyPrefixRegionSplitPolicy extends IncreasingToUpperBoundR protected void configureForRegion(HRegion region) { super.configureForRegion(region); // read the prefix length from the table descriptor - String delimiterString = region.getTableDesc().getValue(DELIMITER_KEY); + String delimiterString = region.getTableDescriptor().getValue(DELIMITER_KEY); if (delimiterString == null || delimiterString.length() == 0) { - LOG.error(DELIMITER_KEY + " not specified for table " + region.getTableDesc().getTableName() + + LOG.error(DELIMITER_KEY + " not specified for table " + region.getTableDescriptor().getTableName() + ". Using default RegionSplitPolicy"); return; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushAllLargeStoresPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushAllLargeStoresPolicy.java index 6138f5f2200..3bfec52d4bd 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushAllLargeStoresPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushAllLargeStoresPolicy.java @@ -38,7 +38,7 @@ public class FlushAllLargeStoresPolicy extends FlushLargeStoresPolicy{ @Override protected void configureForRegion(HRegion region) { super.configureForRegion(region); - int familyNumber = region.getTableDesc().getFamilies().size(); + int familyNumber = region.getTableDescriptor().getColumnFamilyCount(); if (familyNumber <= 1) { // No need to parse and set flush size lower bound if only one family // Family number might also be zero in some of our unit test case @@ -50,7 +50,7 @@ public class FlushAllLargeStoresPolicy extends FlushLargeStoresPolicy{ @Override public Collection selectStoresToFlush() { // no need to select stores if only one family - if (region.getTableDesc().getFamilies().size() == 1) { + if (region.getTableDescriptor().getColumnFamilyCount() == 1) { return region.stores.values(); } // start selection diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushLargeStoresPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushLargeStoresPolicy.java index 119fdb52935..f8850ab149d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushLargeStoresPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushLargeStoresPolicy.java @@ -43,7 +43,7 @@ public abstract class FlushLargeStoresPolicy extends FlushPolicy { protected long flushSizeLowerBound = -1; protected long getFlushSizeLowerBound(HRegion region) { - int familyNumber = region.getTableDesc().getFamilies().size(); + int familyNumber = region.getTableDescriptor().getColumnFamilyCount(); // For multiple families, lower bound is the "average flush size" by default // unless setting in configuration is larger. long flushSizeLowerBound = region.getMemstoreFlushSize() / familyNumber; @@ -55,11 +55,11 @@ public abstract class FlushLargeStoresPolicy extends FlushPolicy { } // use the setting in table description if any String flushedSizeLowerBoundString = - region.getTableDesc().getValue(HREGION_COLUMNFAMILY_FLUSH_SIZE_LOWER_BOUND); + region.getTableDescriptor().getValue(HREGION_COLUMNFAMILY_FLUSH_SIZE_LOWER_BOUND); if (flushedSizeLowerBoundString == null) { if (LOG.isDebugEnabled()) { LOG.debug("No " + HREGION_COLUMNFAMILY_FLUSH_SIZE_LOWER_BOUND - + " set in description of table " + region.getTableDesc().getTableName() + + " set in description of table " + region.getTableDescriptor().getTableName() + ", use config (" + flushSizeLowerBound + ") instead"); } } else { @@ -69,7 +69,7 @@ public abstract class FlushLargeStoresPolicy extends FlushPolicy { // fall back for fault setting LOG.warn("Number format exception when parsing " + HREGION_COLUMNFAMILY_FLUSH_SIZE_LOWER_BOUND + " for table " - + region.getTableDesc().getTableName() + ":" + flushedSizeLowerBoundString + ". " + nfe + + region.getTableDescriptor().getTableName() + ":" + flushedSizeLowerBoundString + ". " + nfe + ", use config (" + flushSizeLowerBound + ") instead"); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushPolicyFactory.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushPolicyFactory.java index b93594e6849..64ca0c3a4c6 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushPolicyFactory.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushPolicyFactory.java @@ -25,6 +25,7 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseInterfaceAudience; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.util.ReflectionUtils; /** @@ -47,7 +48,7 @@ public class FlushPolicyFactory { * Create the FlushPolicy configured for the given table. */ public static FlushPolicy create(HRegion region, Configuration conf) throws IOException { - Class clazz = getFlushPolicyClass(region.getTableDesc(), conf); + Class clazz = getFlushPolicyClass(region.getTableDescriptor(), conf); FlushPolicy policy = ReflectionUtils.newInstance(clazz, conf); policy.configureForRegion(region); return policy; @@ -56,7 +57,7 @@ public class FlushPolicyFactory { /** * Get FlushPolicy class for the given table. */ - public static Class getFlushPolicyClass(HTableDescriptor htd, + public static Class getFlushPolicyClass(TableDescriptor htd, Configuration conf) throws IOException { String className = htd.getFlushPolicyClassName(); if (className == null) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HMobStore.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HMobStore.java index c240df3a1d7..fb837e815d3 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HMobStore.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HMobStore.java @@ -45,6 +45,7 @@ import org.apache.hadoop.hbase.Tag; import org.apache.hadoop.hbase.TagType; import org.apache.hadoop.hbase.TagUtil; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.filter.Filter; import org.apache.hadoop.hbase.filter.FilterList; @@ -91,7 +92,7 @@ public class HMobStore extends HStore { private volatile long mobFlushedCellsSize = 0; private volatile long mobScanCellsCount = 0; private volatile long mobScanCellsSize = 0; - private HColumnDescriptor family; + private ColumnFamilyDescriptor family; private Map> map = new ConcurrentHashMap<>(); private final IdLock keyLock = new IdLock(); // When we add a MOB reference cell to the HFile, we will add 2 tags along with it @@ -102,7 +103,7 @@ public class HMobStore extends HStore { // cloning snapshot for mob files. private final byte[] refCellTags; - public HMobStore(final HRegion region, final HColumnDescriptor family, + public HMobStore(final HRegion region, final ColumnFamilyDescriptor family, final Configuration confParam) throws IOException { super(region, family, confParam); this.family = family; @@ -112,7 +113,7 @@ public class HMobStore extends HStore { family.getNameAsString()); List locations = new ArrayList<>(2); locations.add(mobFamilyPath); - TableName tn = region.getTableDesc().getTableName(); + TableName tn = region.getTableDescriptor().getTableName(); locations.add(HFileArchiveUtil.getStoreArchivePath(conf, tn, MobUtils.getMobRegionInfo(tn) .getEncodedName(), family.getNameAsString())); map.put(Bytes.toString(tn.getName()), locations); @@ -128,7 +129,7 @@ public class HMobStore extends HStore { * Creates the mob cache config. */ @Override - protected void createCacheConf(HColumnDescriptor family) { + protected void createCacheConf(ColumnFamilyDescriptor family) { cacheConf = new MobCacheConfig(conf, family); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java index b460d1ac9e7..b02b042766c 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java @@ -88,12 +88,10 @@ import org.apache.hadoop.hbase.CellUtil; import org.apache.hadoop.hbase.CompoundConfiguration; import org.apache.hadoop.hbase.DoNotRetryIOException; import org.apache.hadoop.hbase.DroppedSnapshotException; -import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.HConstants.OperationStatusCode; import org.apache.hadoop.hbase.HDFSBlocksDistribution; import org.apache.hadoop.hbase.HRegionInfo; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.KeyValueUtil; import org.apache.hadoop.hbase.NamespaceDescriptor; @@ -105,6 +103,7 @@ import org.apache.hadoop.hbase.TagUtil; import org.apache.hadoop.hbase.UnknownScannerException; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.client.Append; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Get; @@ -117,6 +116,8 @@ import org.apache.hadoop.hbase.client.RegionReplicaUtil; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.apache.hadoop.hbase.conf.ConfigurationManager; import org.apache.hadoop.hbase.conf.PropagatingConfigurationObserver; import org.apache.hadoop.hbase.coprocessor.RegionObserver.MutationType; @@ -635,7 +636,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi // Coprocessor host private RegionCoprocessorHost coprocessorHost; - private HTableDescriptor htableDescriptor = null; + private TableDescriptor htableDescriptor = null; private RegionSplitPolicy splitPolicy; private FlushPolicy flushPolicy; @@ -675,7 +676,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi @VisibleForTesting public HRegion(final Path tableDir, final WAL wal, final FileSystem fs, final Configuration confParam, final HRegionInfo regionInfo, - final HTableDescriptor htd, final RegionServerServices rsServices) { + final TableDescriptor htd, final RegionServerServices rsServices) { this(new HRegionFileSystem(confParam, fs, tableDir, regionInfo), wal, confParam, htd, rsServices); } @@ -697,7 +698,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @param rsServices reference to {@link RegionServerServices} or null */ public HRegion(final HRegionFileSystem fs, final WAL wal, final Configuration confParam, - final HTableDescriptor htd, final RegionServerServices rsServices) { + final TableDescriptor htd, final RegionServerServices rsServices) { if (htd == null) { throw new IllegalArgumentException("Need table descriptor"); } @@ -727,10 +728,10 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi this.isLoadingCfsOnDemandDefault = conf.getBoolean(LOAD_CFS_ON_DEMAND_CONFIG_KEY, true); this.htableDescriptor = htd; - Set families = this.htableDescriptor.getFamiliesKeys(); + Set families = this.htableDescriptor.getColumnFamilyNames(); for (byte[] family : families) { if (!replicationScope.containsKey(family)) { - int scope = htd.getFamily(family).getScope(); + int scope = htd.getColumnFamily(family).getScope(); // Only store those families that has NON-DEFAULT scope if (scope != REPLICATION_SCOPE_LOCAL) { // Do a copy before storing it here. @@ -826,7 +827,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi if (flushSize <= 0) { flushSize = conf.getLong(HConstants.HREGION_MEMSTORE_FLUSH_SIZE, - HTableDescriptor.DEFAULT_MEMSTORE_FLUSH_SIZE); + TableDescriptorBuilder.DEFAULT_MEMSTORE_FLUSH_SIZE); } this.memstoreFlushSize = flushSize; this.blockingMemStoreSize = this.memstoreFlushSize * @@ -858,7 +859,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi //Refuse to open the region if there is no column family in the table if (htableDescriptor.getColumnFamilyCount() == 0) { - throw new DoNotRetryIOException("Table " + htableDescriptor.getNameAsString() + + throw new DoNotRetryIOException("Table " + htableDescriptor.getTableName().getNameAsString()+ " should have at least one column family."); } @@ -987,14 +988,14 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi // initialized to -1 so that we pick up MemstoreTS from column families long maxMemstoreTS = -1; - if (!htableDescriptor.getFamilies().isEmpty()) { + if (htableDescriptor.getColumnFamilyCount() != 0) { // initialize the thread pool for opening stores in parallel. ThreadPoolExecutor storeOpenerThreadPool = getStoreOpenAndCloseThreadPool("StoreOpener-" + this.getRegionInfo().getShortNameToLog()); CompletionService completionService = new ExecutorCompletionService<>(storeOpenerThreadPool); // initialize each store in parallel - for (final HColumnDescriptor family : htableDescriptor.getFamilies()) { + for (final ColumnFamilyDescriptor family : htableDescriptor.getColumnFamilies()) { status.setStatus("Instantiating store for column family " + family); completionService.submit(new Callable() { @Override @@ -1006,10 +1007,10 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi boolean allStoresOpened = false; boolean hasSloppyStores = false; try { - for (int i = 0; i < htableDescriptor.getFamilies().size(); i++) { + for (int i = 0; i < htableDescriptor.getColumnFamilyCount(); i++) { Future future = completionService.take(); HStore store = future.get(); - this.stores.put(store.getFamily().getName(), store); + this.stores.put(store.getColumnFamilyDescriptor().getName(), store); if (store.isSloppyMemstore()) { hasSloppyStores = true; } @@ -1027,8 +1028,9 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } allStoresOpened = true; if(hasSloppyStores) { - htableDescriptor.setFlushPolicyClassName(FlushNonSloppyStoresFirstPolicy.class - .getName()); + htableDescriptor = TableDescriptorBuilder.newBuilder(htableDescriptor) + .setFlushPolicyClassName(FlushNonSloppyStoresFirstPolicy.class.getName()) + .build(); LOG.info("Setting FlushNonSloppyStoresFirstPolicy for the region=" + this); } } catch (InterruptedException e) { @@ -1076,7 +1078,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi for (StoreFile storeFile: storeFiles) { storeFileNames.add(storeFile.getPath()); } - allStoreFiles.put(store.getFamily().getName(), storeFileNames); + allStoreFiles.put(store.getColumnFamilyDescriptor().getName(), storeFileNames); } return allStoreFiles; } @@ -1146,13 +1148,13 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi /** * This is a helper function to compute HDFS block distribution on demand * @param conf configuration - * @param tableDescriptor HTableDescriptor of the table + * @param tableDescriptor TableDescriptor of the table * @param regionInfo encoded name of the region * @return The HDFS blocks distribution for the given region. * @throws IOException */ public static HDFSBlocksDistribution computeHDFSBlocksDistribution(final Configuration conf, - final HTableDescriptor tableDescriptor, final HRegionInfo regionInfo) throws IOException { + final TableDescriptor tableDescriptor, final HRegionInfo regionInfo) throws IOException { Path tablePath = FSUtils.getTableDir(FSUtils.getRootDir(conf), tableDescriptor.getTableName()); return computeHDFSBlocksDistribution(conf, tableDescriptor, regionInfo, tablePath); } @@ -1160,20 +1162,20 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi /** * This is a helper function to compute HDFS block distribution on demand * @param conf configuration - * @param tableDescriptor HTableDescriptor of the table + * @param tableDescriptor TableDescriptor of the table * @param regionInfo encoded name of the region * @param tablePath the table directory * @return The HDFS blocks distribution for the given region. * @throws IOException */ public static HDFSBlocksDistribution computeHDFSBlocksDistribution(final Configuration conf, - final HTableDescriptor tableDescriptor, final HRegionInfo regionInfo, Path tablePath) + final TableDescriptor tableDescriptor, final HRegionInfo regionInfo, Path tablePath) throws IOException { HDFSBlocksDistribution hdfsBlocksDistribution = new HDFSBlocksDistribution(); FileSystem fs = tablePath.getFileSystem(conf); HRegionFileSystem regionFs = new HRegionFileSystem(conf, fs, tablePath, regionInfo); - for (HColumnDescriptor family : tableDescriptor.getFamilies()) { + for (ColumnFamilyDescriptor family : tableDescriptor.getColumnFamilies()) { List locatedFileStatusList = HRegionFileSystem .getStoreFilesLocatedStatus(regionFs, family.getNameAsString(), true); if (locatedFileStatusList == null) { @@ -1338,7 +1340,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi && wasRecovering && !newState) { // force a flush only if region replication is set up for this region. Otherwise no need. - boolean forceFlush = getTableDesc().getRegionReplication() > 1; + boolean forceFlush = getTableDescriptor().getRegionReplication() > 1; MonitoredTask status = TaskMonitor.get().createStatus("Recovering region " + this); @@ -1672,7 +1674,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi .submit(new Callable>>() { @Override public Pair> call() throws IOException { - return new Pair<>(store.getFamily().getName(), store.close()); + return new Pair<>(store.getColumnFamilyDescriptor().getName(), store.close()); } }); } @@ -1799,7 +1801,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } protected ThreadPoolExecutor getStoreOpenAndCloseThreadPool( final String threadNamePrefix) { - int numStores = Math.max(1, this.htableDescriptor.getFamilies().size()); + int numStores = Math.max(1, this.htableDescriptor.getColumnFamilyCount()); int maxThreads = Math.min(numStores, conf.getInt(HConstants.HSTORE_OPEN_AND_CLOSE_THREADS_MAX, HConstants.DEFAULT_HSTORE_OPEN_AND_CLOSE_THREADS_MAX)); @@ -1808,7 +1810,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi protected ThreadPoolExecutor getStoreFileOpenAndCloseThreadPool( final String threadNamePrefix) { - int numStores = Math.max(1, this.htableDescriptor.getFamilies().size()); + int numStores = Math.max(1, this.htableDescriptor.getColumnFamilyCount()); int maxThreads = Math.max(1, conf.getInt(HConstants.HSTORE_OPEN_AND_CLOSE_THREADS_MAX, HConstants.DEFAULT_HSTORE_OPEN_AND_CLOSE_THREADS_MAX) @@ -1842,10 +1844,15 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi ////////////////////////////////////////////////////////////////////////////// @Override - public HTableDescriptor getTableDesc() { + public TableDescriptor getTableDescriptor() { return this.htableDescriptor; } + @VisibleForTesting + void setTableDescriptor(TableDescriptor desc) { + htableDescriptor = desc; + } + /** @return WAL in use for this region */ public WAL getWAL() { return this.wal; @@ -2280,7 +2287,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi */ boolean shouldFlushStore(Store store) { long earliest = this.wal.getEarliestMemstoreSeqNum(getRegionInfo().getEncodedNameAsBytes(), - store.getFamily().getName()) - 1; + store.getColumnFamilyDescriptor().getName()) - 1; if (earliest > 0 && earliest + flushPerChanges < mvcc.getReadPoint()) { if (LOG.isDebugEnabled()) { LOG.debug("Flush column family " + store.getColumnFamilyName() + " of " + @@ -2461,7 +2468,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi Map flushedFamilyNamesToSeq = new HashMap<>(); for (Store store: storesToFlush) { - flushedFamilyNamesToSeq.put(store.getFamily().getName(), + flushedFamilyNamesToSeq.put(store.getColumnFamilyDescriptor().getName(), ((HStore) store).preFlushSeqIDEstimation()); } @@ -2501,9 +2508,9 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi for (Store s : storesToFlush) { MemstoreSize flushableSize = s.getSizeToFlush(); totalSizeOfFlushableStores.incMemstoreSize(flushableSize); - storeFlushCtxs.put(s.getFamily().getName(), s.createFlushContext(flushOpSeqId)); - committedFiles.put(s.getFamily().getName(), null); // for writing stores to WAL - storeFlushableSize.put(s.getFamily().getName(), flushableSize); + storeFlushCtxs.put(s.getColumnFamilyDescriptor().getName(), s.createFlushContext(flushOpSeqId)); + committedFiles.put(s.getColumnFamilyDescriptor().getName(), null); // for writing stores to WAL + storeFlushableSize.put(s.getColumnFamilyDescriptor().getName(), flushableSize); } // write the snapshot start to WAL @@ -2661,7 +2668,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi if (needsCompaction) { compactionRequested = true; } - byte[] storeName = it.next().getFamily().getName(); + byte[] storeName = it.next().getColumnFamilyDescriptor().getName(); List storeCommittedFiles = flush.getCommittedFiles(); committedFiles.put(storeName, storeCommittedFiles); // Flush committed no files, indicating flush is empty or flush was canceled @@ -2796,7 +2803,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi // Verify families are all valid if (!scan.hasFamilies()) { // Adding all families to scanner - for (byte[] family : this.htableDescriptor.getFamiliesKeys()) { + for (byte[] family : this.htableDescriptor.getColumnFamilyNames()) { scan.addFamily(family); } } else { @@ -2831,7 +2838,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi public void prepareDelete(Delete delete) throws IOException { // Check to see if this is a deleteRow insert if(delete.getFamilyCellMap().isEmpty()){ - for(byte [] family : this.htableDescriptor.getFamiliesKeys()){ + for(byte [] family : this.htableDescriptor.getColumnFamilyNames()){ // Don't eat the timestamp delete.addFamily(family, delete.getTimeStamp()); } @@ -3643,7 +3650,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi private void removeNonExistentColumnFamilyForReplay(final Map> familyMap) { List nonExistentList = null; for (byte[] family : familyMap.keySet()) { - if (!this.htableDescriptor.hasFamily(family)) { + if (!this.htableDescriptor.hasColumnFamily(family)) { if (nonExistentList == null) { nonExistentList = new ArrayList<>(); } @@ -3997,7 +4004,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi private void applyToMemstore(final Store store, final List cells, final boolean delta, MemstoreSize memstoreSize) throws IOException { // Any change in how we update Store/MemStore needs to also be done in other applyToMemstore!!!! - boolean upsert = delta && store.getFamily().getMaxVersions() == 1; + boolean upsert = delta && store.getColumnFamilyDescriptor().getMaxVersions() == 1; if (upsert) { ((HStore) store).upsert(cells, getSmallestReadPoint(), memstoreSize); } else { @@ -4352,7 +4359,8 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi continue; } // Figure which store the edit is meant for. - if (store == null || !CellUtil.matchingFamily(cell, store.getFamily().getName())) { + if (store == null || !CellUtil.matchingFamily(cell, + store.getColumnFamilyDescriptor().getName())) { store = getHStore(cell); } if (store == null) { @@ -4369,7 +4377,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi continue; } // Now, figure if we should skip this edit. - if (key.getLogSeqNum() <= maxSeqIdInStores.get(store.getFamily() + if (key.getLogSeqNum() <= maxSeqIdInStores.get(store.getColumnFamilyDescriptor() .getName())) { skippedEdits++; continue; @@ -5170,12 +5178,14 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi // only drop memstore snapshots if they are smaller than last flush for the store if (this.prepareFlushResult.flushOpSeqId <= storeSeqId) { StoreFlushContext ctx = this.prepareFlushResult.storeFlushCtxs == null ? - null : this.prepareFlushResult.storeFlushCtxs.get(store.getFamily().getName()); + null : this.prepareFlushResult.storeFlushCtxs.get( + store.getColumnFamilyDescriptor().getName()); if (ctx != null) { MemstoreSize snapshotSize = store.getSizeToFlush(); ctx.abort(); this.decrMemstoreSize(snapshotSize); - this.prepareFlushResult.storeFlushCtxs.remove(store.getFamily().getName()); + this.prepareFlushResult.storeFlushCtxs.remove( + store.getColumnFamilyDescriptor().getName()); totalFreedDataSize += snapshotSize.getDataSize(); } } @@ -5280,7 +5290,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return true; } - protected HStore instantiateHStore(final HColumnDescriptor family) throws IOException { + protected HStore instantiateHStore(final ColumnFamilyDescriptor family) throws IOException { if (family.isMobEnabled()) { if (HFile.getFormatVersion(this.conf) < HFile.MIN_FORMAT_VERSION_WITH_TAGS) { throw new IOException("A minimum HFile version of " @@ -6500,7 +6510,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @return the new instance */ static HRegion newHRegion(Path tableDir, WAL wal, FileSystem fs, - Configuration conf, HRegionInfo regionInfo, final HTableDescriptor htd, + Configuration conf, HRegionInfo regionInfo, final TableDescriptor htd, RegionServerServices rsServices) { try { @SuppressWarnings("unchecked") @@ -6509,7 +6519,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi Constructor c = regionClass.getConstructor(Path.class, WAL.class, FileSystem.class, - Configuration.class, HRegionInfo.class, HTableDescriptor.class, + Configuration.class, HRegionInfo.class, TableDescriptor.class, RegionServerServices.class); return c.newInstance(tableDir, wal, fs, conf, regionInfo, htd, rsServices); @@ -6530,7 +6540,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion createHRegion(final HRegionInfo info, final Path rootDir, - final Configuration conf, final HTableDescriptor hTableDescriptor, + final Configuration conf, final TableDescriptor hTableDescriptor, final WAL wal, final boolean initialize) throws IOException { LOG.info("creating HRegion " + info.getTable().getNameAsString() @@ -6546,7 +6556,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi public static HRegion createHRegion(final HRegionInfo info, final Path rootDir, final Configuration conf, - final HTableDescriptor hTableDescriptor, + final TableDescriptor hTableDescriptor, final WAL wal) throws IOException { return createHRegion(info, rootDir, conf, hTableDescriptor, wal, true); @@ -6565,7 +6575,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion openHRegion(final HRegionInfo info, - final HTableDescriptor htd, final WAL wal, + final TableDescriptor htd, final WAL wal, final Configuration conf) throws IOException { return openHRegion(info, htd, wal, conf, null, null); @@ -6587,7 +6597,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion openHRegion(final HRegionInfo info, - final HTableDescriptor htd, final WAL wal, final Configuration conf, + final TableDescriptor htd, final WAL wal, final Configuration conf, final RegionServerServices rsServices, final CancelableProgressable reporter) throws IOException { @@ -6608,7 +6618,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion openHRegion(Path rootDir, final HRegionInfo info, - final HTableDescriptor htd, final WAL wal, final Configuration conf) + final TableDescriptor htd, final WAL wal, final Configuration conf) throws IOException { return openHRegion(rootDir, info, htd, wal, conf, null, null); } @@ -6629,7 +6639,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion openHRegion(final Path rootDir, final HRegionInfo info, - final HTableDescriptor htd, final WAL wal, final Configuration conf, + final TableDescriptor htd, final WAL wal, final Configuration conf, final RegionServerServices rsServices, final CancelableProgressable reporter) throws IOException { @@ -6658,7 +6668,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion openHRegion(final Configuration conf, final FileSystem fs, - final Path rootDir, final HRegionInfo info, final HTableDescriptor htd, final WAL wal) + final Path rootDir, final HRegionInfo info, final TableDescriptor htd, final WAL wal) throws IOException { return openHRegion(conf, fs, rootDir, info, htd, wal, null, null); } @@ -6680,7 +6690,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion openHRegion(final Configuration conf, final FileSystem fs, - final Path rootDir, final HRegionInfo info, final HTableDescriptor htd, final WAL wal, + final Path rootDir, final HRegionInfo info, final TableDescriptor htd, final WAL wal, final RegionServerServices rsServices, final CancelableProgressable reporter) throws IOException { Path tableDir = FSUtils.getTableDir(rootDir, info.getTable()); @@ -6704,7 +6714,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi * @throws IOException */ public static HRegion openHRegion(final Configuration conf, final FileSystem fs, - final Path rootDir, final Path tableDir, final HRegionInfo info, final HTableDescriptor htd, + final Path rootDir, final Path tableDir, final HRegionInfo info, final TableDescriptor htd, final WAL wal, final RegionServerServices rsServices, final CancelableProgressable reporter) throws IOException { @@ -6732,7 +6742,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi throws IOException { HRegionFileSystem regionFs = other.getRegionFileSystem(); HRegion r = newHRegion(regionFs.getTableDir(), other.getWAL(), regionFs.getFileSystem(), - other.baseConf, other.getRegionInfo(), other.getTableDesc(), null); + other.baseConf, other.getRegionInfo(), other.getTableDescriptor(), null); return r.openHRegion(reporter); } @@ -6769,7 +6779,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } public static void warmupHRegion(final HRegionInfo info, - final HTableDescriptor htd, final WAL wal, final Configuration conf, + final TableDescriptor htd, final WAL wal, final Configuration conf, final RegionServerServices rsServices, final CancelableProgressable reporter) throws IOException { @@ -6797,14 +6807,14 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi private void checkCompressionCodecs() throws IOException { - for (HColumnDescriptor fam: this.htableDescriptor.getColumnFamilies()) { + for (ColumnFamilyDescriptor fam: this.htableDescriptor.getColumnFamilies()) { CompressionTest.testCompression(fam.getCompressionType()); CompressionTest.testCompression(fam.getCompactionCompressionType()); } } private void checkEncryption() throws IOException { - for (HColumnDescriptor fam: this.htableDescriptor.getColumnFamilies()) { + for (ColumnFamilyDescriptor fam: this.htableDescriptor.getColumnFamilies()) { EncryptionTest.testEncryption(conf, fam.getEncryptionType(), fam.getEncryptionKey()); } } @@ -6825,7 +6835,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi // Create the daughter HRegion instance HRegion r = HRegion.newHRegion(this.fs.getTableDir(), this.getWAL(), fs.getFileSystem(), - this.getBaseConf(), hri, this.getTableDesc(), rsServices); + this.getBaseConf(), hri, this.getTableDescriptor(), rsServices); r.readRequestsCount.add(this.getReadRequestsCount() / 2); r.filteredReadRequestsCount.add(this.getFilteredReadRequestsCount() / 2); r.writeRequestsCount.add(this.getWriteRequestsCount() / 2); @@ -6842,7 +6852,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi final HRegion region_b) throws IOException { HRegion r = HRegion.newHRegion(this.fs.getTableDir(), this.getWAL(), fs.getFileSystem(), this.getBaseConf(), mergedRegionInfo, - this.getTableDesc(), this.rsServices); + this.getTableDescriptor(), this.rsServices); r.readRequestsCount.add(this.getReadRequestsCount() + region_b.getReadRequestsCount()); r.filteredReadRequestsCount.add(this.getFilteredReadRequestsCount() @@ -6949,7 +6959,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi checkFamily(family); } } else { // Adding all families to scanner - for (byte[] family : this.htableDescriptor.getFamiliesKeys()) { + for (byte[] family : this.htableDescriptor.getColumnFamilyNames()) { get.addFamily(family); } } @@ -7472,7 +7482,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi final Mutation mutation, final Durability effectiveDurability, final long now, final List deltas, final List results) throws IOException { - byte [] columnFamily = store.getFamily().getName(); + byte [] columnFamily = store.getColumnFamilyDescriptor().getName(); List toApply = new ArrayList<>(deltas.size()); // Get previous values for all columns in this family. List currentValues = get(mutation, store, deltas, @@ -7642,7 +7652,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi get.setIsolationLevel(isolation); } for (Cell cell: coordinates) { - get.addColumn(store.getFamily().getName(), CellUtil.cloneQualifier(cell)); + get.addColumn(store.getColumnFamilyDescriptor().getName(), CellUtil.cloneQualifier(cell)); } // Increments carry time range. If an Increment instance, put it on the Get. if (tr != null) { @@ -7665,7 +7675,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi void checkFamily(final byte [] family) throws NoSuchColumnFamilyException { - if (!this.htableDescriptor.hasFamily(family)) { + if (!this.htableDescriptor.hasColumnFamily(family)) { throw new NoSuchColumnFamilyException("Column family " + Bytes.toString(family) + " does not exist in region " + this + " in table " + this.htableDescriptor); @@ -8204,7 +8214,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi buf.append(getRegionInfo().isMetaTable() ? " meta table " : " "); buf.append("stores: "); for (Store s : getStores()) { - buf.append(s.getFamily().getNameAsString()); + buf.append(s.getColumnFamilyDescriptor().getNameAsString()); buf.append(" size: "); buf.append(s.getSizeOfMemStore().getDataSize()); buf.append(" "); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java index f0537e0f15b..3593ce63adb 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java @@ -3013,7 +3013,7 @@ public class HRegionServer extends HasThread implements Set tables = new HashSet<>(); synchronized (this.onlineRegions) { for (Region region: this.onlineRegions.values()) { - tables.add(region.getTableDesc().getTableName()); + tables.add(region.getTableDescriptor().getTableName()); } } return tables; @@ -3167,7 +3167,7 @@ public class HRegionServer extends HasThread implements if (exceptionToThrow instanceof IOException) throw (IOException)exceptionToThrow; throw new IOException(exceptionToThrow); } - if (regionToClose.getTableDesc().hasSerialReplicationScope()) { + if (regionToClose.getTableDescriptor().hasSerialReplicationScope()) { // For serial replication, we need add a final barrier on this region. But the splitting // or merging may be reverted, so we should make sure if we reopen this region, the open // barrier is same as this final barrier @@ -3185,7 +3185,7 @@ public class HRegionServer extends HasThread implements Put finalBarrier = MetaTableAccessor.makeBarrierPut( Bytes.toBytes(regionEncodedName.get(i)), seq, - regionToClose.getTableDesc().getTableName().getName()); + regionToClose.getTableDescriptor().getTableName().getName()); MetaTableAccessor.putToMetaTable(getConnection(), finalBarrier); } // Offline the region diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java index 03c31af0111..1639953851c 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java @@ -98,6 +98,7 @@ import com.google.common.collect.ImmutableCollection; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; import com.google.common.collect.Sets; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; /** * A Store holds a column family in a Region. Its a memstore and a set of zero @@ -129,7 +130,7 @@ public class HStore implements Store { protected final MemStore memstore; // This stores directory in the filesystem. protected final HRegion region; - private final HColumnDescriptor family; + private final ColumnFamilyDescriptor family; private final HRegionFileSystem fs; protected Configuration conf; protected CacheConfig cacheConf; @@ -213,7 +214,7 @@ public class HStore implements Store { * failed. Can be null. * @throws IOException */ - protected HStore(final HRegion region, final HColumnDescriptor family, + protected HStore(final HRegion region, final ColumnFamilyDescriptor family, final Configuration confParam) throws IOException { this.fs = region.getRegionFileSystem(); @@ -227,7 +228,7 @@ public class HStore implements Store { // add global config first, then table and cf overrides, then cf metadata. this.conf = new CompoundConfiguration() .add(confParam) - .addStringMap(region.getTableDesc().getConfiguration()) + .addStringMap(region.getTableDescriptor().getConfiguration()) .addStringMap(family.getConfiguration()) .addBytesMap(family.getValues()); this.blocksize = family.getBlocksize(); @@ -320,7 +321,7 @@ public class HStore implements Store { * Creates the cache config. * @param family The current column family. */ - protected void createCacheConf(final HColumnDescriptor family) { + protected void createCacheConf(final ColumnFamilyDescriptor family) { this.cacheConf = new CacheConfig(conf, family); } @@ -341,7 +342,7 @@ public class HStore implements Store { * @param family * @return TTL in seconds of the specified family */ - public static long determineTTLFromFamily(final HColumnDescriptor family) { + public static long determineTTLFromFamily(final ColumnFamilyDescriptor family) { // HCD.getTimeToLive returns ttl in seconds. Convert to milliseconds. long ttl = family.getTimeToLive(); if (ttl == HConstants.FOREVER) { @@ -455,7 +456,7 @@ public class HStore implements Store { } @Override - public HColumnDescriptor getFamily() { + public ColumnFamilyDescriptor getColumnFamilyDescriptor() { return this.family; } @@ -1418,7 +1419,7 @@ public class HStore implements Store { } HRegionInfo info = this.region.getRegionInfo(); CompactionDescriptor compactionDescriptor = ProtobufUtil.toCompactionDescriptor(info, - family.getName(), inputPaths, outputPaths, fs.getStoreDir(getFamily().getNameAsString())); + family.getName(), inputPaths, outputPaths, fs.getStoreDir(getColumnFamilyDescriptor().getNameAsString())); // Fix reaching into Region to get the maxWaitForSeqId. // Does this method belong in Region altogether given it is making so many references up there? // Could be Region#writeCompactionMarker(compactionDescriptor); @@ -1736,9 +1737,9 @@ public class HStore implements Store { private void removeUnneededFiles() throws IOException { if (!conf.getBoolean("hbase.store.delete.expired.storefile", true)) return; - if (getFamily().getMinVersions() > 0) { + if (getColumnFamilyDescriptor().getMinVersions() > 0) { LOG.debug("Skipping expired store file removal due to min version being " + - getFamily().getMinVersions()); + getColumnFamilyDescriptor().getMinVersions()); return; } this.lock.readLock().lock(); @@ -2546,7 +2547,7 @@ public class HStore implements Store { } // Only if this is successful it has to be removed try { - this.fs.removeStoreFiles(this.getFamily().getNameAsString(), filesToRemove); + this.fs.removeStoreFiles(this.getColumnFamilyDescriptor().getNameAsString(), filesToRemove); } catch (FailedArchiveException fae) { // Even if archiving some files failed, we still need to clear out any of the // files which were successfully archived. Otherwise we will receive a diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java index 8a310b83342..3092e5ba726 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java @@ -24,9 +24,10 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.apache.hadoop.hbase.procedure2.util.StringUtils; /** @@ -56,13 +57,13 @@ public class IncreasingToUpperBoundRegionSplitPolicy extends ConstantSizeRegionS if (initialSize > 0) { return; } - HTableDescriptor desc = region.getTableDesc(); + TableDescriptor desc = region.getTableDescriptor(); if (desc != null) { initialSize = 2 * desc.getMemStoreFlushSize(); } if (initialSize <= 0) { initialSize = 2 * conf.getLong(HConstants.HREGION_MEMSTORE_FLUSH_SIZE, - HTableDescriptor.DEFAULT_MEMSTORE_FLUSH_SIZE); + TableDescriptorBuilder.DEFAULT_MEMSTORE_FLUSH_SIZE); } } @@ -106,7 +107,7 @@ public class IncreasingToUpperBoundRegionSplitPolicy extends ConstantSizeRegionS if (rss == null) { return 0; } - TableName tablename = region.getTableDesc().getTableName(); + TableName tablename = region.getTableDescriptor().getTableName(); int tableRegionsCount = 0; try { List hri = rss.getOnlineRegions(tablename); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/KeyPrefixRegionSplitPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/KeyPrefixRegionSplitPolicy.java index b987a884cff..8b937566f8f 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/KeyPrefixRegionSplitPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/KeyPrefixRegionSplitPolicy.java @@ -46,14 +46,14 @@ public class KeyPrefixRegionSplitPolicy extends IncreasingToUpperBoundRegionSpli prefixLength = 0; // read the prefix length from the table descriptor - String prefixLengthString = region.getTableDesc().getValue( + String prefixLengthString = region.getTableDescriptor().getValue( PREFIX_LENGTH_KEY); if (prefixLengthString == null) { //read the deprecated value - prefixLengthString = region.getTableDesc().getValue(PREFIX_LENGTH_KEY_DEPRECATED); + prefixLengthString = region.getTableDescriptor().getValue(PREFIX_LENGTH_KEY_DEPRECATED); if (prefixLengthString == null) { LOG.error(PREFIX_LENGTH_KEY + " not specified for table " - + region.getTableDesc().getTableName() + + region.getTableDescriptor().getTableName() + ". Using default RegionSplitPolicy"); return; } @@ -63,13 +63,13 @@ public class KeyPrefixRegionSplitPolicy extends IncreasingToUpperBoundRegionSpli } catch (NumberFormatException nfe) { /* Differentiate NumberFormatException from an invalid value range reported below. */ LOG.error("Number format exception when parsing " + PREFIX_LENGTH_KEY + " for table " - + region.getTableDesc().getTableName() + ":" + + region.getTableDescriptor().getTableName() + ":" + prefixLengthString + ". " + nfe); return; } if (prefixLength <= 0) { LOG.error("Invalid value for " + PREFIX_LENGTH_KEY + " for table " - + region.getTableDesc().getTableName() + ":" + + region.getTableDescriptor().getTableName() + ":" + prefixLengthString + ". Using default RegionSplitPolicy"); } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java index 2f2a4cf4e14..f5d87b09b8c 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java @@ -551,7 +551,7 @@ class MemStoreFlusher implements FlushRequester { private boolean isTooManyStoreFiles(Region region) { // When compaction is disabled, the region is flushable - if (!region.getTableDesc().isCompactionEnabled()) { + if (!region.getTableDescriptor().isCompactionEnabled()) { return false; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionWrapperImpl.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionWrapperImpl.java index ecee53fd012..58a0e6ef831 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionWrapperImpl.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionWrapperImpl.java @@ -30,7 +30,7 @@ import org.apache.commons.logging.LogFactory; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.CompatibilitySingletonFactory; import org.apache.hadoop.hbase.HRegionInfo; -import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.metrics2.MetricsExecutor; @@ -65,7 +65,7 @@ public class MetricsRegionWrapperImpl implements MetricsRegionWrapper, Closeable @Override public String getTableName() { - HTableDescriptor tableDesc = this.region.getTableDesc(); + TableDescriptor tableDesc = this.region.getTableDescriptor(); if (tableDesc == null) { return UNKNOWN; } @@ -74,7 +74,7 @@ public class MetricsRegionWrapperImpl implements MetricsRegionWrapper, Closeable @Override public String getNamespace() { - HTableDescriptor tableDesc = this.region.getTableDesc(); + TableDescriptor tableDesc = this.region.getTableDescriptor(); if (tableDesc == null) { return UNKNOWN; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java index c5f0f7bef3f..4ac99d7dda9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java @@ -62,7 +62,7 @@ public class MetricsTableWrapperAggregateImpl implements MetricsTableWrapperAggr Map localMetricsTableMap = new HashMap<>(); for (Region r : regionServer.getOnlineRegionsLocalContext()) { - TableName tbl= r.getTableDesc().getTableName(); + TableName tbl= r.getTableDescriptor().getTableName(); MetricsTableValues metricsTable = localMetricsTableMap.get(tbl); if (metricsTable == null) { metricsTable = new MetricsTableValues(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java index 0c69bd9de6c..9499a79ac7b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java @@ -110,7 +110,7 @@ public class RSDumpServlet extends StateDumpServlet { if (hRegion.getLockedRows().size() > 0) { for (HRegion.RowLockContext rowLockContext : hRegion.getLockedRows().values()) { sb.setLength(0); - sb.append(hRegion.getTableDesc().getTableName()).append(",") + sb.append(hRegion.getTableDescriptor().getTableName()).append(",") .append(hRegion.getRegionInfo().getEncodedName()).append(","); sb.append(rowLockContext.toString()); out.println(sb.toString()); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java index 8da34ced14b..4c0625a0d8b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java @@ -1548,7 +1548,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, if (QuotaUtil.isQuotaEnabled(getConfiguration()) && !Superusers.isSuperUser(RpcServer.getRequestUser()) && this.regionServer.getRegionServerSpaceQuotaManager().areCompactionsDisabled( - region.getTableDesc().getTableName())) { + region.getTableDescriptor().getTableName())) { throw new DoNotRetryIOException("Compactions on this region are " + "disabled due to a space quota violation."); } @@ -1784,7 +1784,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, requestCount.increment(); Set columnFamilies; if (request.getFamilyCount() == 0) { - columnFamilies = region.getTableDesc().getFamiliesKeys(); + columnFamilies = region.getTableDescriptor().getColumnFamilyNames(); } else { columnFamilies = new TreeSet<>(Bytes.BYTES_RAWCOMPARATOR); for (ByteString cf: request.getFamilyList()) { @@ -2890,7 +2890,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, if (!scan.hasFamilies()) { // Adding all families to scanner - for (byte[] family : region.getTableDesc().getFamiliesKeys()) { + for (byte[] family : region.getTableDescriptor().getColumnFamilyNames()) { scan.addFamily(family); } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java index 63e18c3fe65..4c188fe2849 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java @@ -41,6 +41,7 @@ import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.conf.ConfigurationObserver; import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; import org.apache.hadoop.hbase.filter.ByteArrayComparable; @@ -79,7 +80,7 @@ public interface Region extends ConfigurationObserver { HRegionInfo getRegionInfo(); /** @return table descriptor for this region */ - HTableDescriptor getTableDesc(); + TableDescriptor getTableDescriptor(); /** @return true if region is available (not closed and not closing) */ boolean isAvailable(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java index 0abc9882c1c..4570cecd6c3 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java @@ -55,6 +55,7 @@ import org.apache.hadoop.hbase.client.Mutation; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; import org.apache.hadoop.hbase.coprocessor.CoprocessorService; import org.apache.hadoop.hbase.coprocessor.EndpointObserver; @@ -260,7 +261,7 @@ public class RegionCoprocessorHost } static List getTableCoprocessorAttrsFromSchema(Configuration conf, - HTableDescriptor htd) { + TableDescriptor htd) { List result = Lists.newArrayList(); for (Map.Entry e: htd.getValues().entrySet()) { String key = Bytes.toString(e.getKey().get()).trim(); @@ -324,7 +325,7 @@ public class RegionCoprocessorHost * @throws IOException */ public static void testTableCoprocessorAttrs(final Configuration conf, - final HTableDescriptor htd) throws IOException { + final TableDescriptor htd) throws IOException { String pathPrefix = UUID.randomUUID().toString(); for (TableCoprocessorAttribute attr: getTableCoprocessorAttrsFromSchema(conf, htd)) { if (attr.getPriority() < 0) { @@ -362,15 +363,15 @@ public class RegionCoprocessorHost // scan the table attributes for coprocessor load specifications // initialize the coprocessors List configured = new ArrayList<>(); - for (TableCoprocessorAttribute attr: getTableCoprocessorAttrsFromSchema(conf, - region.getTableDesc())) { + for (TableCoprocessorAttribute attr: getTableCoprocessorAttrsFromSchema(conf, + region.getTableDescriptor())) { // Load encompasses classloading and coprocessor initialization try { RegionEnvironment env = load(attr.getPath(), attr.getClassName(), attr.getPriority(), attr.getConf()); configured.add(env); LOG.info("Loaded coprocessor " + attr.getClassName() + " from HTD of " + - region.getTableDesc().getTableName().getNameAsString() + " successfully."); + region.getTableDescriptor().getTableName().getNameAsString() + " successfully."); } catch (Throwable t) { // Coprocessor failed to load, do we abort on error? if (conf.getBoolean(ABORT_ON_ERROR_KEY, DEFAULT_ABORT_ON_ERROR)) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServicesForStores.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServicesForStores.java index 8cdfd3be829..f980065ea69 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServicesForStores.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServicesForStores.java @@ -82,7 +82,7 @@ public class RegionServicesForStores { } public int getNumStores() { - return region.getTableDesc().getColumnFamilyCount(); + return region.getTableDescriptor().getColumnFamilyCount(); } // methods for tests diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionSplitPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionSplitPolicy.java index e20b3e21cf5..c6ee946d0e8 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionSplitPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionSplitPolicy.java @@ -23,13 +23,14 @@ import java.util.List; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.conf.Configured; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.HBaseInterfaceAudience; import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.util.ReflectionUtils; import com.google.common.base.Preconditions; + /** * A split policy determines when a region should be split. * @see IncreasingToUpperBoundRegionSplitPolicy Default split policy since @@ -101,14 +102,14 @@ public abstract class RegionSplitPolicy extends Configured { public static RegionSplitPolicy create(HRegion region, Configuration conf) throws IOException { Class clazz = getSplitPolicyClass( - region.getTableDesc(), conf); + region.getTableDescriptor(), conf); RegionSplitPolicy policy = ReflectionUtils.newInstance(clazz, conf); policy.configureForRegion(region); return policy; } public static Class getSplitPolicyClass( - HTableDescriptor htd, Configuration conf) throws IOException { + TableDescriptor htd, Configuration conf) throws IOException { String className = htd.getRegionSplitPolicyClassName(); if (className == null) { className = conf.get(HConstants.HBASE_REGION_SPLIT_POLICY_KEY, diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ScanInfo.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ScanInfo.java index 2a66e55d155..6be129f5141 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ScanInfo.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ScanInfo.java @@ -21,7 +21,7 @@ package org.apache.hadoop.hbase.regionserver; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.CellComparator; -import org.apache.hadoop.hbase.HColumnDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.KeepDeletedCells; import org.apache.hadoop.hbase.util.Bytes; @@ -57,13 +57,13 @@ public class ScanInfo { /** * @param conf - * @param family {@link HColumnDescriptor} describing the column family + * @param family {@link ColumnFamilyDescriptor} describing the column family * @param ttl Store's TTL (in ms) * @param timeToPurgeDeletes duration in ms after which a delete marker can be purged during a * major compaction. * @param comparator The store's comparator */ - public ScanInfo(final Configuration conf, final HColumnDescriptor family, final long ttl, + public ScanInfo(final Configuration conf, final ColumnFamilyDescriptor family, final long ttl, final long timeToPurgeDeletes, final CellComparator comparator) { this(conf, family.getName(), family.getMinVersions(), family.getMaxVersions(), ttl, family.getKeepDeletedCells(), family.getBlocksize(), timeToPurgeDeletes, comparator); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java index b1473cb4107..5fde5764aea 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java @@ -150,7 +150,7 @@ public class SecureBulkLoadManager { } String bulkToken = - createStagingDir(baseStagingDir, getActiveUser(), region.getTableDesc().getTableName()) + createStagingDir(baseStagingDir, getActiveUser(), region.getTableDescriptor().getTableName()) .toString(); return bulkToken; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Store.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Store.java index 766b562c477..e2fabae0a20 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Store.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Store.java @@ -25,11 +25,11 @@ import java.util.NavigableSet; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.hbase.CellComparator; import org.apache.hadoop.hbase.HBaseInterfaceAudience; -import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HRegionInfo; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.classification.InterfaceStability; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.conf.PropagatingConfigurationObserver; import org.apache.hadoop.hbase.io.HeapSize; @@ -361,7 +361,7 @@ public interface Store extends HeapSize, StoreConfigInformation, PropagatingConf */ MemstoreSize getSizeOfSnapshot(); - HColumnDescriptor getFamily(); + ColumnFamilyDescriptor getColumnFamilyDescriptor(); /** * @return The maximum sequence id in all store files. diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileScanner.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileScanner.java index 13a5f019193..603ff0aa5d7 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileScanner.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileScanner.java @@ -472,7 +472,7 @@ public class StoreFileScanner implements KeyValueScanner { @Override public boolean shouldUseScanner(Scan scan, Store store, long oldestUnexpiredTS) { // if the file has no entries, no need to validate or create a scanner. - byte[] cf = store.getFamily().getName(); + byte[] cf = store.getColumnFamilyDescriptor().getName(); TimeRange timeRange = scan.getColumnFamilyTimeRange().get(cf); if (timeRange == null) { timeRange = scan.getTimeRange(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StripeStoreFlusher.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StripeStoreFlusher.java index 3f9688dd417..aa7024b137a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StripeStoreFlusher.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StripeStoreFlusher.java @@ -110,7 +110,7 @@ public class StripeStoreFlusher extends StoreFlusher { @Override public StoreFileWriter createWriter() throws IOException { StoreFileWriter writer = store.createWriterInTmp( - kvCount, store.getFamily().getCompressionType(), + kvCount, store.getColumnFamilyDescriptor().getCompressionType(), /* isCompaction = */ false, /* includeMVCCReadpoint = */ true, /* includesTags = */ true, diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java index 463ed86b954..de452408ee1 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java @@ -93,9 +93,9 @@ public abstract class Compactor { this.store = store; this.compactionKVMax = this.conf.getInt(HConstants.COMPACTION_KV_MAX, HConstants.COMPACTION_KV_MAX_DEFAULT); - this.compactionCompression = (this.store.getFamily() == null) ? - Compression.Algorithm.NONE : this.store.getFamily().getCompactionCompressionType(); - this.keepSeqIdPeriod = Math.max(this.conf.getInt(HConstants.KEEP_SEQID_PERIOD, + this.compactionCompression = (this.store.getColumnFamilyDescriptor() == null) ? + Compression.Algorithm.NONE : this.store.getColumnFamilyDescriptor().getCompactionCompressionType(); + this.keepSeqIdPeriod = Math.max(this.conf.getInt(HConstants.KEEP_SEQID_PERIOD, HConstants.MIN_KEEP_SEQID_PERIOD), HConstants.MIN_KEEP_SEQID_PERIOD); this.dropCacheMajor = conf.getBoolean(MAJOR_COMPACTION_DROP_CACHE, true); this.dropCacheMinor = conf.getBoolean(MINOR_COMPACTION_DROP_CACHE, true); @@ -397,7 +397,7 @@ public abstract class Compactor { throughputController.start(compactionName); KeyValueScanner kvs = (scanner instanceof KeyValueScanner)? (KeyValueScanner)scanner : null; - long shippedCallSizeLimit = (long) numofFilesToCompact * this.store.getFamily().getBlocksize(); + long shippedCallSizeLimit = (long) numofFilesToCompact * this.store.getColumnFamilyDescriptor().getBlocksize(); try { do { hasMore = scanner.next(cells, scannerContext); @@ -499,7 +499,7 @@ public abstract class Compactor { protected InternalScanner createScanner(Store store, List scanners, ScanType scanType, long smallestReadPoint, long earliestPutTs) throws IOException { Scan scan = new Scan(); - scan.setMaxVersions(store.getFamily().getMaxVersions()); + scan.setMaxVersions(store.getColumnFamilyDescriptor().getMaxVersions()); return new StoreScanner(store, store.getScanInfo(), scan, scanners, scanType, smallestReadPoint, earliestPutTs); } @@ -517,7 +517,7 @@ public abstract class Compactor { long smallestReadPoint, long earliestPutTs, byte[] dropDeletesFromRow, byte[] dropDeletesToRow) throws IOException { Scan scan = new Scan(); - scan.setMaxVersions(store.getFamily().getMaxVersions()); + scan.setMaxVersions(store.getColumnFamilyDescriptor().getMaxVersions()); return new StoreScanner(store, store.getScanInfo(), scan, scanners, smallestReadPoint, earliestPutTs, dropDeletesFromRow, dropDeletesToRow); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/throttle/ThroughputControlUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/throttle/ThroughputControlUtil.java index b3c414720cb..7216c7ba2df 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/throttle/ThroughputControlUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/throttle/ThroughputControlUtil.java @@ -50,6 +50,7 @@ public final class ThroughputControlUtil { } } return store.getRegionInfo().getRegionNameAsString() + NAME_DELIMITER - + store.getFamily().getNameAsString() + NAME_DELIMITER + opName + NAME_DELIMITER + counter; + + store.getColumnFamilyDescriptor().getNameAsString() + + NAME_DELIMITER + opName + NAME_DELIMITER + counter; } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessControlLists.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessControlLists.java index b719eba2f99..1eab848edfc 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessControlLists.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessControlLists.java @@ -359,7 +359,7 @@ public class AccessControlLists { * metadata table. */ static boolean isAclRegion(Region region) { - return ACL_TABLE_NAME.equals(region.getTableDesc().getTableName()); + return ACL_TABLE_NAME.equals(region.getTableDescriptor().getTableName()); } /** diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessController.java index aa0c09458e3..e393804f12d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessController.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AccessController.java @@ -134,6 +134,7 @@ import com.google.protobuf.Message; import com.google.protobuf.RpcCallback; import com.google.protobuf.RpcController; import com.google.protobuf.Service; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; /** * Provides basic authorization checks for data access and administrative @@ -954,7 +955,7 @@ public class AccessController implements MasterObserver, RegionObserver, RegionS } else if (env instanceof RegionCoprocessorEnvironment) { // if running at region regionEnv = (RegionCoprocessorEnvironment) env; - conf.addStringMap(regionEnv.getRegion().getTableDesc().getConfiguration()); + conf.addStringMap(regionEnv.getRegion().getTableDescriptor().getConfiguration()); zk = regionEnv.getRegionServerServices().getZooKeeper(); compatibleEarlyTermination = conf.getBoolean(AccessControlConstants.CF_ATTRIBUTE_EARLY_OUT, AccessControlConstants.DEFAULT_ATTRIBUTE_EARLY_OUT); @@ -1551,7 +1552,7 @@ public class AccessController implements MasterObserver, RegionObserver, RegionS Region region = getRegion(env); TableName table = getTableName(region); Map cfVsMaxVersions = Maps.newHashMap(); - for (HColumnDescriptor hcd : region.getTableDesc().getFamilies()) { + for (ColumnFamilyDescriptor hcd : region.getTableDescriptor().getColumnFamilies()) { cfVsMaxVersions.put(new SimpleMutableByteRange(hcd.getName()), hcd.getMaxVersions()); } if (!authResult.isAllowed()) { @@ -2155,7 +2156,7 @@ public class AccessController implements MasterObserver, RegionObserver, RegionS User user = getActiveUser(ctx); for(Pair el : familyPaths) { requirePermission(user, "preBulkLoadHFile", - ctx.getEnvironment().getRegion().getTableDesc().getTableName(), + ctx.getEnvironment().getRegion().getTableDescriptor().getTableName(), el.getFirst(), null, Action.CREATE); @@ -2173,7 +2174,7 @@ public class AccessController implements MasterObserver, RegionObserver, RegionS public void prePrepareBulkLoad(ObserverContext ctx, PrepareBulkLoadRequest request) throws IOException { requireAccess(getActiveUser(ctx), "prePrepareBulkLoad", - ctx.getEnvironment().getRegion().getTableDesc().getTableName(), Action.CREATE); + ctx.getEnvironment().getRegion().getTableDescriptor().getTableName(), Action.CREATE); } /** @@ -2187,7 +2188,7 @@ public class AccessController implements MasterObserver, RegionObserver, RegionS public void preCleanupBulkLoad(ObserverContext ctx, CleanupBulkLoadRequest request) throws IOException { requireAccess(getActiveUser(ctx), "preCleanupBulkLoad", - ctx.getEnvironment().getRegion().getTableDesc().getTableName(), Action.CREATE); + ctx.getEnvironment().getRegion().getTableDescriptor().getTableName(), Action.CREATE); } /* ---- EndpointObserver implementation ---- */ @@ -2392,7 +2393,7 @@ public class AccessController implements MasterObserver, RegionObserver, RegionS AccessControlProtos.CheckPermissionsResponse response = null; try { User user = RpcServer.getRequestUser(); - TableName tableName = regionEnv.getRegion().getTableDesc().getTableName(); + TableName tableName = regionEnv.getRegion().getTableDescriptor().getTableName(); for (Permission permission : permissions) { if (permission instanceof TablePermission) { // Check table permissions @@ -2586,7 +2587,7 @@ public class AccessController implements MasterObserver, RegionObserver, RegionS @Override public void preMerge(ObserverContext ctx, Region regionA, Region regionB) throws IOException { - requirePermission(getActiveUser(ctx), "mergeRegions", regionA.getTableDesc().getTableName(), + requirePermission(getActiveUser(ctx), "mergeRegions", regionA.getTableDescriptor().getTableName(), null, null, Action.ADMIN); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/visibility/VisibilityUtils.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/visibility/VisibilityUtils.java index 4441c086e97..32c08a9b5a3 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/visibility/VisibilityUtils.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/visibility/VisibilityUtils.java @@ -43,6 +43,7 @@ import org.apache.hadoop.hbase.Tag; import org.apache.hadoop.hbase.TagType; import org.apache.hadoop.hbase.TagUtil; import org.apache.hadoop.hbase.classification.InterfaceAudience; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.exceptions.DeserializationException; import org.apache.hadoop.hbase.filter.Filter; import org.apache.hadoop.hbase.io.util.StreamUtils; @@ -267,7 +268,7 @@ public class VisibilityUtils { public static Filter createVisibilityLabelFilter(Region region, Authorizations authorizations) throws IOException { Map cfVsMaxVersions = new HashMap<>(); - for (HColumnDescriptor hcd : region.getTableDesc().getFamilies()) { + for (ColumnFamilyDescriptor hcd : region.getTableDescriptor().getColumnFamilies()) { cfVsMaxVersions.put(new SimpleMutableByteRange(hcd.getName()), hcd.getMaxVersions()); } VisibilityLabelService vls = VisibilityLabelServiceManager.getInstance() diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/snapshot/SnapshotManifest.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/snapshot/SnapshotManifest.java index 7ba5312bcbf..86687d9ccb2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/snapshot/SnapshotManifest.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/snapshot/SnapshotManifest.java @@ -216,7 +216,7 @@ public final class SnapshotManifest { for (Store store : region.getStores()) { // 2.1. build the snapshot reference for the store - Object familyData = visitor.familyOpen(regionData, store.getFamily().getName()); + Object familyData = visitor.familyOpen(regionData, store.getColumnFamilyDescriptor().getName()); monitor.rethrowException(); List storeFiles = new ArrayList<>(store.getStorefiles()); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java index 1e1aa9a96c1..3316ec5b836 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java @@ -71,6 +71,7 @@ import org.apache.hadoop.hbase.TableNotEnabledException; import org.apache.hadoop.hbase.TableNotFoundException; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.client.Admin; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.Get; @@ -79,6 +80,7 @@ import org.apache.hadoop.hbase.client.RegionLocator; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter; import org.apache.hadoop.hbase.tool.Canary.RegionTask.TaskType; import org.apache.hadoop.hbase.util.Bytes; @@ -117,14 +119,14 @@ public final class Canary implements Tool { public long getReadFailureCount(); public long incReadFailureCount(); public void publishReadFailure(ServerName serverName, HRegionInfo region, Exception e); - public void publishReadFailure(ServerName serverName, HRegionInfo region, HColumnDescriptor column, Exception e); + public void publishReadFailure(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, Exception e); public void updateReadFailedHostList(HRegionInfo region, String serverName); public Map getReadFailures(); - public void publishReadTiming(ServerName serverName, HRegionInfo region, HColumnDescriptor column, long msTime); + public void publishReadTiming(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, long msTime); public long getWriteFailureCount(); public void publishWriteFailure(ServerName serverName, HRegionInfo region, Exception e); - public void publishWriteFailure(ServerName serverName, HRegionInfo region, HColumnDescriptor column, Exception e); - public void publishWriteTiming(ServerName serverName, HRegionInfo region, HColumnDescriptor column, long msTime); + public void publishWriteFailure(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, Exception e); + public void publishWriteTiming(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, long msTime); public void updateWriteFailedHostList(HRegionInfo region, String serverName); public Map getWriteFailures(); } @@ -161,7 +163,7 @@ public final class Canary implements Tool { } @Override - public void publishReadFailure(ServerName serverName, HRegionInfo region, HColumnDescriptor column, Exception e) { + public void publishReadFailure(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, Exception e) { readFailureCount.incrementAndGet(); LOG.error(String.format("read from region %s on regionserver %s column family %s failed", region.getRegionNameAsString(), serverName, column.getNameAsString()), e); @@ -173,7 +175,7 @@ public final class Canary implements Tool { } @Override - public void publishReadTiming(ServerName serverName, HRegionInfo region, HColumnDescriptor column, long msTime) { + public void publishReadTiming(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, long msTime) { LOG.info(String.format("read from region %s on regionserver %s column family %s in %dms", region.getRegionNameAsString(), serverName, column.getNameAsString(), msTime)); } @@ -200,14 +202,14 @@ public final class Canary implements Tool { } @Override - public void publishWriteFailure(ServerName serverName, HRegionInfo region, HColumnDescriptor column, Exception e) { + public void publishWriteFailure(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, Exception e) { writeFailureCount.incrementAndGet(); LOG.error(String.format("write to region %s on regionserver %s column family %s failed", region.getRegionNameAsString(), serverName, column.getNameAsString()), e); } @Override - public void publishWriteTiming(ServerName serverName, HRegionInfo region, HColumnDescriptor column, long msTime) { + public void publishWriteTiming(ServerName serverName, HRegionInfo region, ColumnFamilyDescriptor column, long msTime) { LOG.info(String.format("write to region %s on regionserver %s column family %s in %dms", region.getRegionNameAsString(), serverName, column.getNameAsString(), msTime)); } @@ -348,14 +350,14 @@ public final class Canary implements Tool { public Void read() { Table table = null; - HTableDescriptor tableDesc = null; + TableDescriptor tableDesc = null; try { if (LOG.isDebugEnabled()) { LOG.debug(String.format("reading table descriptor for table %s", region.getTable())); } table = connection.getTable(region.getTable()); - tableDesc = table.getTableDescriptor(); + tableDesc = table.getDescriptor(); } catch (IOException e) { LOG.debug("sniffRegion failed", e); sink.publishReadFailure(serverName, region, e); @@ -374,7 +376,7 @@ public final class Canary implements Tool { Scan scan = null; ResultScanner rs = null; StopWatch stopWatch = new StopWatch(); - for (HColumnDescriptor column : tableDesc.getColumnFamilies()) { + for (ColumnFamilyDescriptor column : tableDesc.getColumnFamilies()) { stopWatch.reset(); startKey = region.getStartKey(); // Can't do a get on empty start row so do a Scan of first element if any instead. @@ -439,17 +441,17 @@ public final class Canary implements Tool { */ private Void write() { Table table = null; - HTableDescriptor tableDesc = null; + TableDescriptor tableDesc = null; try { table = connection.getTable(region.getTable()); - tableDesc = table.getTableDescriptor(); + tableDesc = table.getDescriptor(); byte[] rowToCheck = region.getStartKey(); if (rowToCheck.length == 0) { rowToCheck = new byte[]{0x0}; } int writeValueSize = connection.getConfiguration().getInt(HConstants.HBASE_CANARY_WRITE_VALUE_SIZE_KEY, 10); - for (HColumnDescriptor column : tableDesc.getColumnFamilies()) { + for (ColumnFamilyDescriptor column : tableDesc.getColumnFamilies()) { Put put = new Put(rowToCheck); byte[] value = new byte[writeValueSize]; Bytes.random(value); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionSplitter.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionSplitter.java index 87ff0106689..1e56e7f1dec 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionSplitter.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionSplitter.java @@ -43,12 +43,12 @@ import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs.FSDataOutputStream; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.ClusterStatus; import org.apache.hadoop.hbase.HBaseConfiguration; -import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HRegionInfo; import org.apache.hadoop.hbase.HRegionLocation; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.MetaTableAccessor; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -66,6 +66,8 @@ import com.google.common.base.Preconditions; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; /** * The {@link RegionSplitter} class provides several utilities to help in the @@ -378,16 +380,16 @@ public class RegionSplitter { LOG.debug("Creating table " + tableName + " with " + columnFamilies.length + " column families. Presplitting to " + splitCount + " regions"); - HTableDescriptor desc = new HTableDescriptor(tableName); + TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName); for (String cf : columnFamilies) { - desc.addFamily(new HColumnDescriptor(Bytes.toBytes(cf))); + builder.addColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(cf)).build()); } try (Connection connection = ConnectionFactory.createConnection(conf)) { Admin admin = connection.getAdmin(); try { Preconditions.checkArgument(!admin.tableExists(tableName), "Table already exists: " + tableName); - admin.createTable(desc, splitAlgo.split(splitCount)); + admin.createTable(builder.build(), splitAlgo.split(splitCount)); } finally { admin.close(); } @@ -684,9 +686,9 @@ public class RegionSplitter { FileSystem fs = tableDir.getFileSystem(connection.getConfiguration()); // Clear the cache to forcibly refresh region information ((ClusterConnection)connection).clearRegionCache(); - HTableDescriptor htd = null; + TableDescriptor htd = null; try (Table table = connection.getTable(tableName)) { - htd = table.getTableDescriptor(); + htd = table.getDescriptor(); } try (RegionLocator regionLocator = connection.getRegionLocator(tableName)) { @@ -725,7 +727,7 @@ public class RegionSplitter { // Check every Column Family for that region -- check does not have references. boolean refFound = false; - for (HColumnDescriptor c : htd.getFamilies()) { + for (ColumnFamilyDescriptor c : htd.getColumnFamilies()) { if ((refFound = regionFs.hasReferences(c.getNameAsString()))) { break; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/ServerRegionReplicaUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/ServerRegionReplicaUtil.java index 648ccc622d7..34a97597b8d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/ServerRegionReplicaUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/ServerRegionReplicaUtil.java @@ -97,7 +97,7 @@ public class ServerRegionReplicaUtil extends RegionReplicaUtil { * @return whether the replica is read only */ public static boolean isReadOnly(HRegion region) { - return region.getTableDesc().isReadOnly() + return region.getTableDescriptor().isReadOnly() || !isDefaultReplica(region.getRegionInfo()); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java index 5c8b29b8942..24a2f9c6fa8 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java @@ -76,6 +76,7 @@ import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.client.TableState; import org.apache.hadoop.hbase.fs.HFileSystem; import org.apache.hadoop.hbase.io.compress.Compression; @@ -137,6 +138,9 @@ import org.apache.zookeeper.ZooKeeper; import org.apache.zookeeper.ZooKeeper.States; import edu.umd.cs.findbugs.annotations.Nullable; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; /** * Facility for testing HBase. Replacement for @@ -1360,7 +1364,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Create a table. * @param tableName * @param family - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, String family) @@ -1372,7 +1376,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Create a table. * @param tableName * @param families - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, String[] families) @@ -1388,7 +1392,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Create a table. * @param tableName * @param family - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[] family) @@ -1401,7 +1405,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param tableName * @param family * @param numRegions - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createMultiRegionTable(TableName tableName, byte[] family, int numRegions) @@ -1418,7 +1422,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Create a table. * @param tableName * @param families - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[][] families) @@ -1430,7 +1434,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Create a table with multiple regions. * @param tableName * @param families - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createMultiRegionTable(TableName tableName, byte[][] families) throws IOException { @@ -1442,7 +1446,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param tableName * @param families * @param splitKeys - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[][] families, byte[][] splitKeys) @@ -1467,10 +1471,26 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param htd * @param families * @param c Configuration to use - * @return An HTable instance for the created table. + * @return A Table instance for the created table. + * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTable(TableDescriptor, byte[][], Configuration)} + */ + @Deprecated + public Table createTable(HTableDescriptor htd, byte[][] families, Configuration c) + throws IOException { + return createTable((TableDescriptor) htd, families, c); + } + + /** + * Create a table. + * @param htd + * @param families + * @param c Configuration to use + * @return A Table instance for the created table. * @throws IOException */ - public Table createTable(HTableDescriptor htd, byte[][] families, Configuration c) + public Table createTable(TableDescriptor htd, byte[][] families, Configuration c) throws IOException { return createTable(htd, families, null, c); } @@ -1481,34 +1501,68 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param families * @param splitKeys * @param c Configuration to use - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTable(TableDescriptor, byte[][], byte[][], Configuration)} */ + @Deprecated public Table createTable(HTableDescriptor htd, byte[][] families, byte[][] splitKeys, Configuration c) throws IOException { + return createTable((TableDescriptor) htd, families, splitKeys, c); + } + + /** + * Create a table. + * @param htd + * @param families + * @param splitKeys + * @param c Configuration to use + * @return A Table instance for the created table. + * @throws IOException + */ + public Table createTable(TableDescriptor htd, byte[][] families, byte[][] splitKeys, + Configuration c) throws IOException { + TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(htd); for (byte[] family : families) { - HColumnDescriptor hcd = new HColumnDescriptor(family); // Disable blooms (they are on by default as of 0.95) but we disable them here because // tests have hard coded counts of what to expect in block cache, etc., and blooms being // on is interfering. - hcd.setBloomFilterType(BloomType.NONE); - htd.addFamily(hcd); + builder.addColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(family) + .setBloomFilterType(BloomType.NONE) + .build()); } - getAdmin().createTable(htd, splitKeys); + TableDescriptor td = builder.build(); + getAdmin().createTable(td, splitKeys); // HBaseAdmin only waits for regions to appear in hbase:meta // we should wait until they are assigned - waitUntilAllRegionsAssigned(htd.getTableName()); - return getConnection().getTable(htd.getTableName()); + waitUntilAllRegionsAssigned(td.getTableName()); + return getConnection().getTable(td.getTableName()); } /** * Create a table. * @param htd * @param splitRows - * @return An HTable instance for the created table. + * @return A Table instance for the created table. + * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTable(TableDescriptor, byte[][])} + */ + @Deprecated + public Table createTable(HTableDescriptor htd, byte[][] splitRows) + throws IOException { + return createTable((TableDescriptor) htd, splitRows); + } + + /** + * Create a table. + * @param htd + * @param splitRows + * @return A Table instance for the created table. * @throws IOException */ - public Table createTable(HTableDescriptor htd, byte[][] splitRows) + public Table createTable(TableDescriptor htd, byte[][] splitRows) throws IOException { getAdmin().createTable(htd, splitRows); // HBaseAdmin only waits for regions to appear in hbase:meta @@ -1523,7 +1577,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param families * @param splitKeys * @param c Configuration to use - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[][] families, byte[][] splitKeys, @@ -1536,7 +1590,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param tableName * @param family * @param numVersions - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[] family, int numVersions) @@ -1549,7 +1603,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param tableName * @param families * @param numVersions - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[][] families, int numVersions) @@ -1563,7 +1617,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param families * @param numVersions * @param splitKeys - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[][] families, int numVersions, @@ -1585,7 +1639,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param tableName * @param families * @param numVersions - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createMultiRegionTable(TableName tableName, byte[][] families, int numVersions) @@ -1599,7 +1653,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param families * @param numVersions * @param blockSize - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[][] families, @@ -1642,7 +1696,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param tableName * @param families * @param numVersions - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[][] families, @@ -1668,7 +1722,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param tableName * @param family * @param splitRows - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createTable(TableName tableName, byte[] family, byte[][] splitRows) @@ -1687,7 +1741,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Create a table with multiple regions. * @param tableName * @param family - * @return An HTable instance for the created table. + * @return A Table instance for the created table. * @throws IOException */ public Table createMultiRegionTable(TableName tableName, byte[] family) throws IOException { @@ -1696,11 +1750,22 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { /** * Modify a table, synchronous. Waiting logic similar to that of {@code admin.rb#alter_status}. + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #modifyTableSync(Admin, TableDescriptor)} */ + @Deprecated @SuppressWarnings("serial") public static void modifyTableSync(Admin admin, HTableDescriptor desc) throws IOException, InterruptedException { - admin.modifyTable(desc.getTableName(), desc); + modifyTableSync(admin, (TableDescriptor) desc); + } + /** + * Modify a table, synchronous. Waiting logic similar to that of {@code admin.rb#alter_status}. + */ + @SuppressWarnings("serial") + public static void modifyTableSync(Admin admin, TableDescriptor desc) + throws IOException, InterruptedException { + admin.modifyTable(desc); Pair status = new Pair() {{ setFirst(0); setSecond(0); @@ -1840,8 +1905,24 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param endKey * @return * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createLocalHRegion(TableDescriptor, byte[], byte[])} */ + @Deprecated public HRegion createLocalHRegion(HTableDescriptor desc, byte [] startKey, + byte [] endKey) throws IOException { + return createLocalHRegion((TableDescriptor) desc, startKey, endKey); + } + + /** + * Create an HRegion that writes to the local tmp dirs + * @param desc + * @param startKey + * @param endKey + * @return + * @throws IOException + */ + public HRegion createLocalHRegion(TableDescriptor desc, byte [] startKey, byte [] endKey) throws IOException { HRegionInfo hri = new HRegionInfo(desc.getTableName(), startKey, endKey); @@ -1851,8 +1932,19 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { /** * Create an HRegion that writes to the local tmp dirs. Creates the WAL for you. Be sure to call * {@link HBaseTestingUtility#closeRegionAndWAL(HRegion)} when you're finished with it. + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createLocalHRegion(HRegionInfo, TableDescriptor)} */ + @Deprecated public HRegion createLocalHRegion(HRegionInfo info, HTableDescriptor desc) throws IOException { + return createLocalHRegion(info, (TableDescriptor) desc); + } + + /** + * Create an HRegion that writes to the local tmp dirs. Creates the WAL for you. Be sure to call + * {@link HBaseTestingUtility#closeRegionAndWAL(HRegion)} when you're finished with it. + */ + public HRegion createLocalHRegion(HRegionInfo info, TableDescriptor desc) throws IOException { return createRegionAndWAL(info, getDataTestDir(), getConfiguration(), desc); } @@ -1863,9 +1955,25 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @param wal wal for this region. * @return created hregion * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createLocalHRegion(HRegionInfo, TableDescriptor, WAL)} */ + @Deprecated public HRegion createLocalHRegion(HRegionInfo info, HTableDescriptor desc, WAL wal) throws IOException { + return createLocalHRegion(info, (TableDescriptor) desc, wal); + } + + /** + * Create an HRegion that writes to the local tmp dirs with specified wal + * @param info regioninfo + * @param desc table descriptor + * @param wal wal for this region. + * @return created hregion + * @throws IOException + */ + public HRegion createLocalHRegion(HRegionInfo info, TableDescriptor desc, WAL wal) + throws IOException { return HRegion.createHRegion(info, getDataTestDir(), getConfiguration(), desc, wal); } @@ -2366,6 +2474,23 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { Bytes.toBytes("xxx"), Bytes.toBytes("yyy"), Bytes.toBytes("zzz") }; + /** + * Create rows in hbase:meta for regions of the specified table with the specified + * start keys. The first startKey should be a 0 length byte array if you + * want to form a proper range of regions. + * @param conf + * @param htd + * @param startKeys + * @return list of region info for regions added to meta + * @throws IOException + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createMultiRegionsInMeta(Configuration, TableDescriptor, byte[][])} + */ + @Deprecated + public List createMultiRegionsInMeta(final Configuration conf, + final HTableDescriptor htd, byte [][] startKeys) throws IOException { + return createMultiRegionsInMeta(conf, (TableDescriptor) htd, startKeys); + } /** * Create rows in hbase:meta for regions of the specified table with the specified * start keys. The first startKey should be a 0 length byte array if you @@ -2377,7 +2502,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @throws IOException */ public List createMultiRegionsInMeta(final Configuration conf, - final HTableDescriptor htd, byte [][] startKeys) + final TableDescriptor htd, byte [][] startKeys) throws IOException { Table meta = getConnection().getTable(TableName.META_TABLE_NAME); Arrays.sort(startKeys, Bytes.BYTES_COMPARATOR); @@ -2415,19 +2540,44 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { /** * Create a region with it's own WAL. Be sure to call * {@link HBaseTestingUtility#closeRegionAndWAL(HRegion)} to clean up all resources. + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createRegionAndWAL(HRegionInfo, Path, Configuration, TableDescriptor)} */ + @Deprecated public static HRegion createRegionAndWAL(final HRegionInfo info, final Path rootDir, final Configuration conf, final HTableDescriptor htd) throws IOException { - return createRegionAndWAL(info, rootDir, conf, htd, true); + return createRegionAndWAL(info, rootDir, conf, (TableDescriptor) htd); } /** * Create a region with it's own WAL. Be sure to call * {@link HBaseTestingUtility#closeRegionAndWAL(HRegion)} to clean up all resources. */ + public static HRegion createRegionAndWAL(final HRegionInfo info, final Path rootDir, + final Configuration conf, final TableDescriptor htd) throws IOException { + return createRegionAndWAL(info, rootDir, conf, htd, true); + } + + /** + * Create a region with it's own WAL. Be sure to call + * {@link HBaseTestingUtility#closeRegionAndWAL(HRegion)} to clean up all resources. + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createRegionAndWAL(HRegionInfo, Path, Configuration, TableDescriptor, boolean)} + */ + @Deprecated public static HRegion createRegionAndWAL(final HRegionInfo info, final Path rootDir, final Configuration conf, final HTableDescriptor htd, boolean initialize) throws IOException { + return createRegionAndWAL(info, rootDir, conf, (TableDescriptor) htd, initialize); + } + + /** + * Create a region with it's own WAL. Be sure to call + * {@link HBaseTestingUtility#closeRegionAndWAL(HRegion)} to clean up all resources. + */ + public static HRegion createRegionAndWAL(final HRegionInfo info, final Path rootDir, + final Configuration conf, final TableDescriptor htd, boolean initialize) + throws IOException { ChunkCreator.initialize(MemStoreLABImpl.CHUNK_SIZE_DEFAULT, false, 0, 0, 0, null); WAL wal = createWal(conf, rootDir, info); return HRegion.createHRegion(info, rootDir, conf, htd, wal, initialize); @@ -2738,7 +2888,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * [2] https://issues.apache.org/jira/browse/ZOOKEEPER-1105 * * @param nodeZK - the ZK watcher to expire - * @param checkStatus - true to check if we can create an HTable with the + * @param checkStatus - true to check if we can create a Table with the * current configuration. */ public void expireSession(ZooKeeperWatcher nodeZK, boolean checkStatus) @@ -3435,7 +3585,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { Get get) throws IOException { Scan scan = new Scan(get); InternalScanner scanner = (InternalScanner) store.getScanner(scan, - scan.getFamilyMap().get(store.getFamily().getName()), + scan.getFamilyMap().get(store.getColumnFamilyDescriptor().getName()), // originally MultiVersionConcurrencyControl.resetThreadReadPoint() was called to set // readpoint 0. 0); @@ -3480,7 +3630,7 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { ) throws IOException { Get get = new Get(row); Map> s = get.getFamilyMap(); - s.put(store.getFamily().getName(), columns); + s.put(store.getColumnFamilyDescriptor().getName(), columns); return getFromStoreFile(store,get); } @@ -3802,9 +3952,24 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Creates a pre-split table for load testing. If the table already exists, * logs a warning and continues. * @return the number of regions the table was split into + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createPreSplitLoadTestTable(Configuration, + * TableDescriptor, ColumnFamilyDescriptor)} */ + @Deprecated public static int createPreSplitLoadTestTable(Configuration conf, HTableDescriptor desc, HColumnDescriptor hcd) throws IOException { + return createPreSplitLoadTestTable(conf, (TableDescriptor) desc, + (ColumnFamilyDescriptor) hcd); + } + + /** + * Creates a pre-split table for load testing. If the table already exists, + * logs a warning and continues. + * @return the number of regions the table was split into + */ + public static int createPreSplitLoadTestTable(Configuration conf, + TableDescriptor desc, ColumnFamilyDescriptor hcd) throws IOException { return createPreSplitLoadTestTable(conf, desc, hcd, DEFAULT_REGIONS_PER_SERVER); } @@ -3812,11 +3977,15 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * Creates a pre-split table for load testing. If the table already exists, * logs a warning and continues. * @return the number of regions the table was split into + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createPreSplitLoadTestTable(Configuration, + * TableDescriptor, ColumnFamilyDescriptor, int)} */ + @Deprecated public static int createPreSplitLoadTestTable(Configuration conf, HTableDescriptor desc, HColumnDescriptor hcd, int numRegionsPerServer) throws IOException { - return createPreSplitLoadTestTable(conf, desc, new HColumnDescriptor[] {hcd}, - numRegionsPerServer); + return createPreSplitLoadTestTable(conf, (TableDescriptor) desc, + (ColumnFamilyDescriptor) hcd, numRegionsPerServer); } /** @@ -3825,8 +3994,35 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @return the number of regions the table was split into */ public static int createPreSplitLoadTestTable(Configuration conf, - HTableDescriptor desc, HColumnDescriptor[] hcds, int numRegionsPerServer) throws IOException { + TableDescriptor desc, ColumnFamilyDescriptor hcd, int numRegionsPerServer) throws IOException { + return createPreSplitLoadTestTable(conf, desc, new ColumnFamilyDescriptor[] {hcd}, + numRegionsPerServer); + } + /** + * Creates a pre-split table for load testing. If the table already exists, + * logs a warning and continues. + * @return the number of regions the table was split into + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createPreSplitLoadTestTable(Configuration, + * TableDescriptor, ColumnFamilyDescriptor[], int)} + */ + @Deprecated + public static int createPreSplitLoadTestTable(Configuration conf, + HTableDescriptor desc, HColumnDescriptor[] hcds, + int numRegionsPerServer) throws IOException { + return createPreSplitLoadTestTable(conf, (TableDescriptor) desc, + (ColumnFamilyDescriptor[]) hcds, numRegionsPerServer); + } + + /** + * Creates a pre-split table for load testing. If the table already exists, + * logs a warning and continues. + * @return the number of regions the table was split into + */ + public static int createPreSplitLoadTestTable(Configuration conf, + TableDescriptor desc, ColumnFamilyDescriptor[] hcds, + int numRegionsPerServer) throws IOException { return createPreSplitLoadTestTable(conf, desc, hcds, new RegionSplitter.HexStringSplit(), numRegionsPerServer); } @@ -3837,13 +4033,15 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { * @return the number of regions the table was split into */ public static int createPreSplitLoadTestTable(Configuration conf, - HTableDescriptor desc, HColumnDescriptor[] hcds, + TableDescriptor td, ColumnFamilyDescriptor[] cds, SplitAlgorithm splitter, int numRegionsPerServer) throws IOException { - for (HColumnDescriptor hcd : hcds) { - if (!desc.hasFamily(hcd.getName())) { - desc.addFamily(hcd); + TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(td); + for (ColumnFamilyDescriptor cd : cds) { + if (!td.hasColumnFamily(cd.getName())) { + builder.addColumnFamily(cd); } } + td = builder.build(); int totalNumberOfRegions = 0; Connection unmanagedConnection = ConnectionFactory.createConnection(conf); Admin admin = unmanagedConnection.getAdmin(); @@ -3865,12 +4063,12 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { byte[][] splits = splitter.split( totalNumberOfRegions); - admin.createTable(desc, splits); + admin.createTable(td, splits); } catch (MasterNotRunningException e) { LOG.error("Master not running", e); throw new IOException(e); } catch (TableExistsException e) { - LOG.warn("Table " + desc.getTableName() + + LOG.warn("Table " + td.getTableName() + " already exists, continuing"); } finally { admin.close(); @@ -3940,13 +4138,25 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { + " on server " + server); } - public HRegion createTestRegion(String tableName, HColumnDescriptor hcd) + /** + * @deprecated since 2.0 version and will be removed in 3.0 version. + * use {@link #createTestRegion(String, ColumnFamilyDescriptor)} + */ + @Deprecated + public HRegion createTestRegion(String tableName, HColumnDescriptor cd) throws IOException { - HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(tableName)); - htd.addFamily(hcd); + return createTestRegion(tableName, (ColumnFamilyDescriptor) cd); + } + + public HRegion createTestRegion(String tableName, ColumnFamilyDescriptor cd) + throws IOException { + TableDescriptor td + = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName)) + .addColumnFamily(cd) + .build(); HRegionInfo info = new HRegionInfo(TableName.valueOf(tableName), null, null, false); - return createRegionAndWAL(info, getDataTestDir(), getConfiguration(), htd); + return createRegionAndWAL(info, getDataTestDir(), getConfiguration(), td); } public void setFileSystemURI(String fsURI) { @@ -4049,13 +4259,13 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { boolean tableAvailable = getAdmin().isTableAvailable(tableName); if (tableAvailable) { try (Table table = getConnection().getTable(tableName)) { - HTableDescriptor htd = table.getTableDescriptor(); + TableDescriptor htd = table.getDescriptor(); for (HRegionLocation loc : getConnection().getRegionLocator(tableName) .getAllRegionLocations()) { Scan scan = new Scan().withStartRow(loc.getRegionInfo().getStartKey()) .withStopRow(loc.getRegionInfo().getEndKey()).setOneRowLimit() .setMaxResultsPerColumnFamily(1).setCacheBlocks(false); - for (byte[] family : htd.getFamiliesKeys()) { + for (byte[] family : htd.getColumnFamilyNames()) { scan.addFamily(family); } try (ResultScanner scanner = table.getScanner(scan)) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java index 1044a180150..2914e4bb4d4 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java @@ -629,7 +629,7 @@ public class MiniHBaseCluster extends HBaseCluster { for (JVMClusterUtil.RegionServerThread t: this.hbaseCluster.getRegionServers()) { for(Region r: t.getRegionServer().getOnlineRegionsLocalContext()) { - if(r.getTableDesc().getTableName().equals(tableName)) { + if(r.getTableDescriptor().getTableName().equals(tableName)) { r.flush(true); } } @@ -657,7 +657,7 @@ public class MiniHBaseCluster extends HBaseCluster { for (JVMClusterUtil.RegionServerThread t: this.hbaseCluster.getRegionServers()) { for(Region r: t.getRegionServer().getOnlineRegionsLocalContext()) { - if(r.getTableDesc().getTableName().equals(tableName)) { + if(r.getTableDescriptor().getTableName().equals(tableName)) { r.compact(major); } } @@ -703,7 +703,7 @@ public class MiniHBaseCluster extends HBaseCluster { for (JVMClusterUtil.RegionServerThread rst : getRegionServerThreads()) { HRegionServer hrs = rst.getRegionServer(); for (Region region : hrs.getOnlineRegionsLocalContext()) { - if (region.getTableDesc().getTableName().equals(tableName)) { + if (region.getTableDescriptor().getTableName().equals(tableName)) { ret.add((HRegion)region); } } @@ -801,7 +801,7 @@ public class MiniHBaseCluster extends HBaseCluster { for (JVMClusterUtil.RegionServerThread rst : getRegionServerThreads()) { HRegionServer hrs = rst.getRegionServer(); for (Region region : hrs.getOnlineRegions(tableName)) { - if (region.getTableDesc().getTableName().equals(tableName)) { + if (region.getTableDescriptor().getTableName().equals(tableName)) { ret.add((HRegion)region); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java index 76401381087..35d7eb16521 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java @@ -33,7 +33,9 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.client.Admin; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.regionserver.CompactingMemStore; import org.apache.hadoop.hbase.regionserver.ConstantSizeRegionSplitPolicy; import org.apache.hadoop.hbase.regionserver.HRegion; @@ -98,7 +100,7 @@ public class TestIOFencing { @SuppressWarnings("deprecation") public CompactionBlockerRegion(Path tableDir, WAL log, FileSystem fs, Configuration confParam, HRegionInfo info, - HTableDescriptor htd, RegionServerServices rsServices) { + TableDescriptor htd, RegionServerServices rsServices) { super(tableDir, log, fs, confParam, info, htd, rsServices); } @@ -158,7 +160,7 @@ public class TestIOFencing { public BlockCompactionsInPrepRegion(Path tableDir, WAL log, FileSystem fs, Configuration confParam, HRegionInfo info, - HTableDescriptor htd, RegionServerServices rsServices) { + TableDescriptor htd, RegionServerServices rsServices) { super(tableDir, log, fs, confParam, info, htd, rsServices); } @Override @@ -181,18 +183,18 @@ public class TestIOFencing { public static class BlockCompactionsInCompletionRegion extends CompactionBlockerRegion { public BlockCompactionsInCompletionRegion(Path tableDir, WAL log, FileSystem fs, Configuration confParam, HRegionInfo info, - HTableDescriptor htd, RegionServerServices rsServices) { + TableDescriptor htd, RegionServerServices rsServices) { super(tableDir, log, fs, confParam, info, htd, rsServices); } @Override - protected HStore instantiateHStore(final HColumnDescriptor family) throws IOException { + protected HStore instantiateHStore(final ColumnFamilyDescriptor family) throws IOException { return new BlockCompactionsInCompletionHStore(this, family, this.conf); } } public static class BlockCompactionsInCompletionHStore extends HStore { CompactionBlockerRegion r; - protected BlockCompactionsInCompletionHStore(HRegion region, HColumnDescriptor family, + protected BlockCompactionsInCompletionHStore(HRegion region, ColumnFamilyDescriptor family, Configuration confParam) throws IOException { super(region, family, confParam); r = (CompactionBlockerRegion) region; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java index 1acb842bc61..9ed63f7b989 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java @@ -256,7 +256,7 @@ public class TestHFileArchiving { clearArchiveDirectory(); // then get the current store files - byte[][]columns = region.getTableDesc().getFamiliesKeys().toArray(new byte[0][]); + byte[][]columns = region.getTableDescriptor().getColumnFamilyNames().toArray(new byte[0][]); List storeFiles = region.getStoreFileList(columns); // then delete the table so the hfiles get archived @@ -335,7 +335,7 @@ public class TestHFileArchiving { clearArchiveDirectory(); // then get the current store files - byte[][]columns = region.getTableDesc().getFamiliesKeys().toArray(new byte[0][]); + byte[][]columns = region.getTableDescriptor().getColumnFamilyNames().toArray(new byte[0][]); List storeFiles = region.getStoreFileList(columns); // then delete the table so the hfiles get archived diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackup.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackup.java index 77bed436fb3..48deabb3ba5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackup.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestIncrementalBackup.java @@ -181,7 +181,7 @@ public class TestIncrementalBackup extends TestBackupBase { false, tablesRestoreIncMultiple, tablesMapIncMultiple, true)); hTable = (HTable) conn.getTable(table1_restore); - LOG.debug("After incremental restore: " + hTable.getTableDescriptor()); + LOG.debug("After incremental restore: " + hTable.getDescriptor()); LOG.debug("f1 has " + TEST_UTIL.countRows(hTable, famName) + " rows"); Assert.assertEquals(TEST_UTIL.countRows(hTable, famName), NB_ROWS_IN_BATCH + ADD_ROWS); LOG.debug("f2 has " + TEST_UTIL.countRows(hTable, fam2Name) + " rows"); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin1.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin1.java index c5681b12aad..8c7f87f956d 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin1.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin1.java @@ -420,8 +420,8 @@ public class TestAdmin1 { htd.addFamily(fam3); this.admin.createTable(htd); Table table = TEST_UTIL.getConnection().getTable(htd.getTableName()); - HTableDescriptor confirmedHtd = table.getTableDescriptor(); - assertEquals(htd.compareTo(confirmedHtd), 0); + TableDescriptor confirmedHtd = table.getDescriptor(); + assertEquals(TableDescriptor.COMPARATOR.compare(htd, confirmedHtd), 0); MetaTableAccessor.fullScanMetaAndPrint(TEST_UTIL.getConnection()); table.close(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java index e7d7f0af065..62c8e7b808d 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java @@ -270,7 +270,7 @@ public class TestAvoidCellReferencesIntoShippedBlocks { List scanners, ScanType scanType, long earliestPutTs) throws IOException { Scan scan = new Scan(); - scan.setMaxVersions(store.getFamily().getMaxVersions()); + scan.setMaxVersions(store.getColumnFamilyDescriptor().getMaxVersions()); return new CompactorStoreScanner(store, store.getScanInfo(), scan, scanners, scanType, store.getSmallestReadPoint(), earliestPutTs); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java index ffeb617356a..7a32e6afc20 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java @@ -260,7 +260,7 @@ public class TestMetaCache { HBaseProtos.RegionSpecifier regionSpec) throws ServiceException { try { return TABLE_NAME.equals( - rpcServices.getRegion(regionSpec).getTableDesc().getTableName()); + rpcServices.getRegion(regionSpec).getTableDescriptor().getTableName()); } catch (IOException ioe) { throw new ServiceException(ioe); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestReplicaWithCluster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestReplicaWithCluster.java index 148da52ac22..437afaf9639 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestReplicaWithCluster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestReplicaWithCluster.java @@ -302,11 +302,13 @@ public class TestReplicaWithCluster { @Test (timeout=120000) public void testChangeTable() throws Exception { - HTableDescriptor hdt = HTU.createTableDescriptor("testChangeTable"); - hdt.setRegionReplication(NB_SERVERS); - hdt.addCoprocessor(SlowMeCopro.class.getName()); - Table table = HTU.createTable(hdt, new byte[][]{f}, null); - + TableDescriptor td = TableDescriptorBuilder.newBuilder(TableName.valueOf("testChangeTable")) + .setRegionReplication(NB_SERVERS) + .addCoprocessor(SlowMeCopro.class.getName()) + .addColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(f).build()) + .build(); + HTU.getAdmin().createTable(td); + Table table = HTU.getConnection().getTable(td.getTableName()); // basic test: it should work. Put p = new Put(row); p.addColumn(f, row, row); @@ -317,13 +319,14 @@ public class TestReplicaWithCluster { Assert.assertFalse(r.isStale()); // Add a CF, it should work. - HTableDescriptor bHdt = HTU.getAdmin().getTableDescriptor(hdt.getTableName()); - HColumnDescriptor hcd = new HColumnDescriptor(row); - hdt.addFamily(hcd); - HTU.getAdmin().disableTable(hdt.getTableName()); - HTU.getAdmin().modifyTable(hdt.getTableName(), hdt); - HTU.getAdmin().enableTable(hdt.getTableName()); - HTableDescriptor nHdt = HTU.getAdmin().getTableDescriptor(hdt.getTableName()); + TableDescriptor bHdt = HTU.getAdmin().listTableDescriptor(td.getTableName()); + td = TableDescriptorBuilder.newBuilder(td) + .addColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(row).build()) + .build(); + HTU.getAdmin().disableTable(td.getTableName()); + HTU.getAdmin().modifyTable(td); + HTU.getAdmin().enableTable(td.getTableName()); + TableDescriptor nHdt = HTU.getAdmin().listTableDescriptor(td.getTableName()); Assert.assertEquals("fams=" + Arrays.toString(nHdt.getColumnFamilies()), bHdt.getColumnFamilyCount() + 1, nHdt.getColumnFamilyCount()); @@ -347,12 +350,12 @@ public class TestReplicaWithCluster { } Admin admin = HTU.getAdmin(); - nHdt =admin.getTableDescriptor(hdt.getTableName()); + nHdt =admin.listTableDescriptor(td.getTableName()); Assert.assertEquals("fams=" + Arrays.toString(nHdt.getColumnFamilies()), bHdt.getColumnFamilyCount() + 1, nHdt.getColumnFamilyCount()); - admin.disableTable(hdt.getTableName()); - admin.deleteTable(hdt.getTableName()); + admin.disableTable(td.getTableName()); + admin.deleteTable(td.getTableName()); admin.close(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/SimpleRegionObserver.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/SimpleRegionObserver.java index c508b028231..d65e85b7516 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/SimpleRegionObserver.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/SimpleRegionObserver.java @@ -348,7 +348,7 @@ public class SimpleRegionObserver implements RegionObserver { assertNotNull(e.getRegion()); assertNotNull(get); assertNotNull(results); - if (e.getRegion().getTableDesc().getTableName().equals( + if (e.getRegion().getTableDescriptor().getTableName().equals( TestRegionObserverInterface.TEST_TABLE)) { boolean foundA = false; boolean foundB = false; @@ -380,7 +380,7 @@ public class SimpleRegionObserver implements RegionObserver { assertNotNull(e); assertNotNull(e.getRegion()); assertNotNull(familyMap); - if (e.getRegion().getTableDesc().getTableName().equals( + if (e.getRegion().getTableDescriptor().getTableName().equals( TestRegionObserverInterface.TEST_TABLE)) { List cells = familyMap.get(TestRegionObserverInterface.A); assertNotNull(cells); @@ -417,7 +417,7 @@ public class SimpleRegionObserver implements RegionObserver { assertNotNull(e.getRegion()); assertNotNull(familyMap); List cells = familyMap.get(TestRegionObserverInterface.A); - if (e.getRegion().getTableDesc().getTableName().equals( + if (e.getRegion().getTableDescriptor().getTableName().equals( TestRegionObserverInterface.TEST_TABLE)) { assertNotNull(cells); assertNotNull(cells.get(0)); @@ -615,7 +615,7 @@ public class SimpleRegionObserver implements RegionObserver { RegionCoprocessorEnvironment e = ctx.getEnvironment(); assertNotNull(e); assertNotNull(e.getRegion()); - if (e.getRegion().getTableDesc().getTableName().equals( + if (e.getRegion().getTableDescriptor().getTableName().equals( TestRegionObserverInterface.TEST_TABLE)) { assertNotNull(familyPaths); assertEquals(1,familyPaths.size()); @@ -634,7 +634,7 @@ public class SimpleRegionObserver implements RegionObserver { RegionCoprocessorEnvironment e = ctx.getEnvironment(); assertNotNull(e); assertNotNull(e.getRegion()); - if (e.getRegion().getTableDesc().getTableName().equals( + if (e.getRegion().getTableDescriptor().getTableName().equals( TestRegionObserverInterface.TEST_TABLE)) { assertNotNull(familyPaths); assertEquals(1,familyPaths.size()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorConfiguration.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorConfiguration.java index fb2f20cfbc8..1102cf84283 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorConfiguration.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorConfiguration.java @@ -99,7 +99,7 @@ public class TestCoprocessorConfiguration { Configuration conf = new Configuration(CONF); HRegion region = mock(HRegion.class); when(region.getRegionInfo()).thenReturn(REGIONINFO); - when(region.getTableDesc()).thenReturn(TABLEDESC); + when(region.getTableDescriptor()).thenReturn(TABLEDESC); RegionServerServices rsServices = mock(RegionServerServices.class); systemCoprocessorLoaded.set(false); tableCoprocessorLoaded.set(false); @@ -141,7 +141,7 @@ public class TestCoprocessorConfiguration { conf.setBoolean(CoprocessorHost.COPROCESSORS_ENABLED_CONF_KEY, false); HRegion region = mock(HRegion.class); when(region.getRegionInfo()).thenReturn(REGIONINFO); - when(region.getTableDesc()).thenReturn(TABLEDESC); + when(region.getTableDescriptor()).thenReturn(TABLEDESC); RegionServerServices rsServices = mock(RegionServerServices.class); systemCoprocessorLoaded.set(false); tableCoprocessorLoaded.set(false); @@ -159,7 +159,7 @@ public class TestCoprocessorConfiguration { conf.setBoolean(CoprocessorHost.USER_COPROCESSORS_ENABLED_CONF_KEY, false); HRegion region = mock(HRegion.class); when(region.getRegionInfo()).thenReturn(REGIONINFO); - when(region.getTableDesc()).thenReturn(TABLEDESC); + when(region.getTableDescriptor()).thenReturn(TABLEDESC); RegionServerServices rsServices = mock(RegionServerServices.class); systemCoprocessorLoaded.set(false); tableCoprocessorLoaded.set(false); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java index b99087d54ac..26cfed74864 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java @@ -23,7 +23,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; import java.io.IOException; -import java.util.Collections; import java.util.List; import java.util.NavigableSet; import java.util.concurrent.CountDownLatch; @@ -46,6 +45,7 @@ import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.filter.FilterBase; import org.apache.hadoop.hbase.regionserver.ChunkCreator; import org.apache.hadoop.hbase.regionserver.HRegion; @@ -228,7 +228,7 @@ public class TestRegionObserverScannerOpenHook { @SuppressWarnings("deprecation") public CompactionCompletionNotifyingRegion(Path tableDir, WAL log, FileSystem fs, Configuration confParam, HRegionInfo info, - HTableDescriptor htd, RegionServerServices rsServices) { + TableDescriptor htd, RegionServerServices rsServices) { super(tableDir, log, fs, confParam, info, htd, rsServices); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java index 67add2f1bf8..b3859ff6370 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java @@ -52,6 +52,7 @@ import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.RegionLocator; import org.apache.hadoop.hbase.client.Result; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.favored.FavoredNodeAssignmentHelper; import org.apache.hadoop.hbase.favored.FavoredNodeLoadBalancer; import org.apache.hadoop.hbase.favored.FavoredNodesPlan; @@ -424,13 +425,12 @@ public class TestRegionPlacement { // All regions are supposed to have favored nodes, // except for hbase:meta and ROOT if (favoredServerList == null) { - HTableDescriptor desc = region.getTableDesc(); + TableDescriptor desc = region.getTableDescriptor(); // Verify they are ROOT and hbase:meta regions since no favored nodes assertNull(favoredSocketAddress); assertTrue("User region " + - region.getTableDesc().getTableName() + - " should have favored nodes", - (desc.isRootRegion() || desc.isMetaRegion())); + region.getTableDescriptor().getTableName() + + " should have favored nodes", desc.isMetaRegion()); } else { // For user region, the favored nodes in the region server should be // identical to favored nodes in the assignmentPlan diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/cleaner/TestSnapshotFromMaster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/cleaner/TestSnapshotFromMaster.java index 8f88af76867..d3f8295a13c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/cleaner/TestSnapshotFromMaster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/cleaner/TestSnapshotFromMaster.java @@ -69,6 +69,9 @@ import org.junit.experimental.categories.Category; import org.mockito.Mockito; import com.google.common.collect.Lists; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; /** * Test the master-related aspects of a snapshot @@ -280,9 +283,11 @@ public class TestSnapshotFromMaster { // recreate test table with disabled compactions; otherwise compaction may happen before // snapshot, the call after snapshot will be a no-op and checks will fail UTIL.deleteTable(TABLE_NAME); - HTableDescriptor htd = new HTableDescriptor(TABLE_NAME); - htd.setCompactionEnabled(false); - UTIL.createTable(htd, new byte[][] { TEST_FAM }, null); + TableDescriptor td = TableDescriptorBuilder.newBuilder(TABLE_NAME) + .addColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(TEST_FAM).build()) + .setCompactionEnabled(false) + .build(); + UTIL.getAdmin().createTable(td); // load the table for (int i = 0; i < blockingStoreFiles / 2; i ++) { @@ -292,7 +297,6 @@ public class TestSnapshotFromMaster { // disable the table so we can take a snapshot admin.disableTable(TABLE_NAME); - htd.setCompactionEnabled(true); // take a snapshot of the table String snapshotName = "snapshot"; @@ -305,8 +309,11 @@ public class TestSnapshotFromMaster { // ensure we only have one snapshot SnapshotTestingUtils.assertOneSnapshotThatMatches(admin, snapshotNameBytes, TABLE_NAME); + td = TableDescriptorBuilder.newBuilder(td) + .setCompactionEnabled(true) + .build(); // enable compactions now - admin.modifyTable(TABLE_NAME, htd); + admin.modifyTable(td); // renable the table so we can compact the regions admin.enableTable(TABLE_NAME); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/NoOpScanPolicyObserver.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/NoOpScanPolicyObserver.java index c47ed689c3c..b090cddd94d 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/NoOpScanPolicyObserver.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/NoOpScanPolicyObserver.java @@ -45,7 +45,7 @@ public class NoOpScanPolicyObserver implements RegionObserver { public InternalScanner preFlushScannerOpen(final ObserverContext c, Store store, List scanners, InternalScanner s) throws IOException { ScanInfo oldSI = store.getScanInfo(); - ScanInfo scanInfo = new ScanInfo(oldSI.getConfiguration(), store.getFamily(), oldSI.getTtl(), + ScanInfo scanInfo = new ScanInfo(oldSI.getConfiguration(), store.getColumnFamilyDescriptor(), oldSI.getTtl(), oldSI.getTimeToPurgeDeletes(), oldSI.getComparator()); Scan scan = new Scan(); scan.setMaxVersions(oldSI.getMaxVersions()); @@ -62,7 +62,7 @@ public class NoOpScanPolicyObserver implements RegionObserver { InternalScanner s) throws IOException { // this demonstrates how to override the scanners default behavior ScanInfo oldSI = store.getScanInfo(); - ScanInfo scanInfo = new ScanInfo(oldSI.getConfiguration(), store.getFamily(), oldSI.getTtl(), + ScanInfo scanInfo = new ScanInfo(oldSI.getConfiguration(), store.getColumnFamilyDescriptor(), oldSI.getTtl(), oldSI.getTimeToPurgeDeletes(), oldSI.getComparator()); Scan scan = new Scan(); scan.setMaxVersions(oldSI.getMaxVersions()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java index 9b96ff25472..6a6fdb07ba9 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java @@ -40,6 +40,7 @@ import org.apache.hadoop.hbase.client.Row; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.client.coprocessor.Batch.Call; import org.apache.hadoop.hbase.client.coprocessor.Batch.Callback; import org.apache.hadoop.hbase.client.metrics.ScanMetrics; @@ -73,7 +74,7 @@ public class RegionAsTable implements Table { @Override public TableName getName() { - return this.region.getTableDesc().getTableName(); + return this.region.getTableDescriptor().getTableName(); } @Override @@ -83,7 +84,12 @@ public class RegionAsTable implements Table { @Override public HTableDescriptor getTableDescriptor() throws IOException { - return this.region.getTableDesc(); + return new HTableDescriptor(this.region.getTableDescriptor()); + } + + @Override + public TableDescriptor getDescriptor() throws IOException { + return this.region.getTableDescriptor(); } @Override diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java index ef3ce06efb7..1cef625ef86 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java @@ -59,6 +59,7 @@ import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.filter.BinaryComparator; import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp; import org.apache.hadoop.hbase.io.HeapSize; @@ -660,7 +661,7 @@ public class TestAtomicOperation { public static class MockHRegion extends HRegion { public MockHRegion(Path tableDir, WAL log, FileSystem fs, Configuration conf, - final HRegionInfo regionInfo, final HTableDescriptor htd, RegionServerServices rsServices) { + final HRegionInfo regionInfo, final TableDescriptor htd, RegionServerServices rsServices) { super(tableDir, log, fs, conf, regionInfo, htd, rsServices); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompoundBloomFilter.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompoundBloomFilter.java index 384608ca2a4..26172f5562a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompoundBloomFilter.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompoundBloomFilter.java @@ -291,7 +291,7 @@ public class TestCompoundBloomFilter { Store store = mock(Store.class); HColumnDescriptor hcd = mock(HColumnDescriptor.class); when(hcd.getName()).thenReturn(Bytes.toBytes(RandomKeyValueUtil.COLUMN_FAMILY_NAME)); - when(store.getFamily()).thenReturn(hcd); + when(store.getColumnFamilyDescriptor()).thenReturn(hcd); return scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHMobStore.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHMobStore.java index 2eb88f4d151..2cea121a055 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHMobStore.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHMobStore.java @@ -219,7 +219,7 @@ public class TestHMobStore { Scan scan = new Scan(get); InternalScanner scanner = (InternalScanner) store.getScanner(scan, - scan.getFamilyMap().get(store.getFamily().getName()), + scan.getFamilyMap().get(store.getColumnFamilyDescriptor().getName()), 0); List results = new ArrayList<>(); @@ -264,7 +264,7 @@ public class TestHMobStore { Scan scan = new Scan(get); InternalScanner scanner = (InternalScanner) store.getScanner(scan, - scan.getFamilyMap().get(store.getFamily().getName()), + scan.getFamilyMap().get(store.getColumnFamilyDescriptor().getName()), 0); List results = new ArrayList<>(); @@ -309,7 +309,7 @@ public class TestHMobStore { Scan scan = new Scan(get); scan.setAttribute(MobConstants.MOB_SCAN_RAW, Bytes.toBytes(Boolean.TRUE)); InternalScanner scanner = (InternalScanner) store.getScanner(scan, - scan.getFamilyMap().get(store.getFamily().getName()), + scan.getFamilyMap().get(store.getColumnFamilyDescriptor().getName()), 0); List results = new ArrayList<>(); @@ -354,7 +354,7 @@ public class TestHMobStore { Scan scan = new Scan(get); InternalScanner scanner = (InternalScanner) store.getScanner(scan, - scan.getFamilyMap().get(store.getFamily().getName()), + scan.getFamilyMap().get(store.getColumnFamilyDescriptor().getName()), 0); List results = new ArrayList<>(); @@ -406,7 +406,7 @@ public class TestHMobStore { Scan scan = new Scan(get); scan.setAttribute(MobConstants.MOB_SCAN_RAW, Bytes.toBytes(Boolean.TRUE)); InternalScanner scanner = (InternalScanner) store.getScanner(scan, - scan.getFamilyMap().get(store.getFamily().getName()), + scan.getFamilyMap().get(store.getColumnFamilyDescriptor().getName()), 0); List results = new ArrayList<>(); @@ -421,7 +421,7 @@ public class TestHMobStore { //this is not mob reference cell. Assert.assertFalse(MobUtils.isMobReferenceCell(cell)); Assert.assertEquals(expected.get(i), results.get(i)); - Assert.assertEquals(100, store.getFamily().getMobThreshold()); + Assert.assertEquals(100, store.getColumnFamilyDescriptor().getMobThreshold()); } } @@ -522,7 +522,7 @@ public class TestHMobStore { // Scan the values Scan scan = new Scan(get); InternalScanner scanner = (InternalScanner) store.getScanner(scan, - scan.getFamilyMap().get(store.getFamily().getName()), + scan.getFamilyMap().get(store.getColumnFamilyDescriptor().getName()), 0); List results = new ArrayList<>(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java index 4f46c88ccd8..7c4e3290a95 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java @@ -111,6 +111,7 @@ import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; import org.apache.hadoop.hbase.filter.BinaryComparator; import org.apache.hadoop.hbase.filter.ColumnCountGetFilter; @@ -812,7 +813,7 @@ public class TestHRegion { Path regiondir = region.getRegionFileSystem().getRegionDir(); FileSystem fs = region.getRegionFileSystem().getFileSystem(); byte[] regionName = region.getRegionInfo().getEncodedNameAsBytes(); - byte[][] columns = region.getTableDesc().getFamiliesKeys().toArray(new byte[0][]); + byte[][] columns = region.getTableDescriptor().getColumnFamilyNames().toArray(new byte[0][]); assertEquals(0, region.getStoreFileList(columns).size()); @@ -945,7 +946,7 @@ public class TestHRegion { writer.close(); // close the region now, and reopen again - region.getTableDesc(); + region.getTableDescriptor(); region.getRegionInfo(); region.close(); try { @@ -4157,7 +4158,7 @@ public class TestHRegion { // use the static method to compute the value, it should be the same. // static method is used by load balancer or other components HDFSBlocksDistribution blocksDistribution2 = HRegion.computeHDFSBlocksDistribution( - htu.getConfiguration(), firstRegion.getTableDesc(), firstRegion.getRegionInfo()); + htu.getConfiguration(), firstRegion.getTableDescriptor(), firstRegion.getRegionInfo()); long uniqueBlocksWeight2 = blocksDistribution2.getUniqueBlocksTotalWeight(); assertTrue(uniqueBlocksWeight1 == uniqueBlocksWeight2); @@ -5757,7 +5758,7 @@ public class TestHRegion { static class HRegionWithSeqId extends HRegion { public HRegionWithSeqId(final Path tableDir, final WAL wal, final FileSystem fs, final Configuration confParam, final HRegionInfo regionInfo, - final HTableDescriptor htd, final RegionServerServices rsServices) { + final TableDescriptor htd, final RegionServerServices rsServices) { super(tableDir, wal, fs, confParam, regionInfo, htd, rsServices); } @Override diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java index 5467c3f6a60..a1a70e8daf8 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java @@ -1134,7 +1134,7 @@ public class TestHRegionReplayEvents { secondaryRegion.replayWALFlushStartMarker(FlushDescriptor.newBuilder(). setFlushSequenceNumber(10) .setTableName(UnsafeByteOperations.unsafeWrap( - primaryRegion.getTableDesc().getTableName().getName())) + primaryRegion.getTableDescriptor().getTableName().getName())) .setAction(FlushAction.START_FLUSH) .setEncodedRegionName( UnsafeByteOperations.unsafeWrap(primaryRegion.getRegionInfo().getEncodedNameAsBytes())) @@ -1542,7 +1542,7 @@ public class TestHRegionReplayEvents { // from primary and also deleted from the archive directory secondaryRegion.replayWALFlushCommitMarker(FlushDescriptor.newBuilder(). setFlushSequenceNumber(Long.MAX_VALUE) - .setTableName(UnsafeByteOperations.unsafeWrap(primaryRegion.getTableDesc().getTableName().getName())) + .setTableName(UnsafeByteOperations.unsafeWrap(primaryRegion.getTableDescriptor().getTableName().getName())) .setAction(FlushAction.COMMIT_FLUSH) .setEncodedRegionName( UnsafeByteOperations.unsafeWrap(primaryRegion.getRegionInfo().getEncodedNameAsBytes())) @@ -1562,7 +1562,7 @@ public class TestHRegionReplayEvents { // from primary and also deleted from the archive directory secondaryRegion.replayWALCompactionMarker(CompactionDescriptor.newBuilder() .setTableName(UnsafeByteOperations.unsafeWrap( - primaryRegion.getTableDesc().getTableName().getName())) + primaryRegion.getTableDescriptor().getTableName().getName())) .setEncodedRegionName( UnsafeByteOperations.unsafeWrap(primaryRegion.getRegionInfo().getEncodedNameAsBytes())) .setFamilyName(UnsafeByteOperations.unsafeWrap(families[0])) @@ -1580,7 +1580,7 @@ public class TestHRegionReplayEvents { // from primary and also deleted from the archive directory secondaryRegion.replayWALRegionEventMarker(RegionEventDescriptor.newBuilder() .setTableName(UnsafeByteOperations.unsafeWrap( - primaryRegion.getTableDesc().getTableName().getName())) + primaryRegion.getTableDescriptor().getTableName().getName())) .setEncodedRegionName( UnsafeByteOperations.unsafeWrap(primaryRegion.getRegionInfo().getEncodedNameAsBytes())) .setRegionName(UnsafeByteOperations.unsafeWrap(primaryRegion.getRegionInfo().getRegionName())) @@ -1600,7 +1600,7 @@ public class TestHRegionReplayEvents { // tests replaying bulk load event marker, but the bulk load files have already been compacted // from primary and also deleted from the archive directory secondaryRegion.replayWALBulkLoadEventMarker(BulkLoadDescriptor.newBuilder() - .setTableName(ProtobufUtil.toProtoTableName(primaryRegion.getTableDesc().getTableName())) + .setTableName(ProtobufUtil.toProtoTableName(primaryRegion.getTableDescriptor().getTableName())) .setEncodedRegionName( UnsafeByteOperations.unsafeWrap(primaryRegion.getRegionInfo().getEncodedNameAsBytes())) .setBulkloadSeqNum(Long.MAX_VALUE) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java index 7070a801ee1..6cbe23c5774 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java @@ -210,7 +210,7 @@ public class TestHStoreFile extends HBaseTestCase { HColumnDescriptor hcd = mock(HColumnDescriptor.class); byte[] cf = Bytes.toBytes("ty"); when(hcd.getName()).thenReturn(cf); - when(store.getFamily()).thenReturn(hcd); + when(store.getColumnFamilyDescriptor()).thenReturn(hcd); StoreFileScanner scanner = new StoreFileScanner(reader, mock(HFileScanner.class), false, false, 0, 0, true); Scan scan = new Scan(); @@ -530,7 +530,7 @@ public class TestHStoreFile extends HBaseTestCase { Store store = mock(Store.class); HColumnDescriptor hcd = mock(HColumnDescriptor.class); when(hcd.getName()).thenReturn(Bytes.toBytes("family")); - when(store.getFamily()).thenReturn(hcd); + when(store.getColumnFamilyDescriptor()).thenReturn(hcd); boolean exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); if (i % 2 == 0) { if (!exists) falseNeg++; @@ -717,7 +717,7 @@ public class TestHStoreFile extends HBaseTestCase { Store store = mock(Store.class); HColumnDescriptor hcd = mock(HColumnDescriptor.class); when(hcd.getName()).thenReturn(Bytes.toBytes("family")); - when(store.getFamily()).thenReturn(hcd); + when(store.getColumnFamilyDescriptor()).thenReturn(hcd); // check false positives rate int falsePos = 0; int falseNeg = 0; @@ -861,7 +861,7 @@ public class TestHStoreFile extends HBaseTestCase { Store store = mock(Store.class); HColumnDescriptor hcd = mock(HColumnDescriptor.class); when(hcd.getName()).thenReturn(family); - when(store.getFamily()).thenReturn(hcd); + when(store.getColumnFamilyDescriptor()).thenReturn(hcd); hsf.initReader(); StoreFileReader reader = hsf.getReader(); StoreFileScanner scanner = getStoreFileScanner(reader, false, false); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMobStoreCompaction.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMobStoreCompaction.java index 155c6b6c98a..21089ed50ef 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMobStoreCompaction.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMobStoreCompaction.java @@ -45,11 +45,15 @@ import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.KeyValue; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.apache.hadoop.hbase.io.hfile.CacheConfig; import org.apache.hadoop.hbase.io.hfile.HFile; import org.apache.hadoop.hbase.io.hfile.HFileContext; @@ -171,7 +175,7 @@ public class TestMobStoreCompaction { assertEquals("Before compaction: number of mob cells", compactionThreshold, countMobCellsInMetadata()); // Change the threshold larger than the data size - region.getTableDesc().getFamily(COLUMN_FAMILY).setMobThreshold(500); + setMobThreshold(region, COLUMN_FAMILY, 500); region.initialize(); region.compactStores(); @@ -182,6 +186,20 @@ public class TestMobStoreCompaction { assertEquals("After compaction: mob rows", 0, countMobRows()); } + private static HRegion setMobThreshold(HRegion region, byte[] cfName, long modThreshold) { + ColumnFamilyDescriptor cfd = ColumnFamilyDescriptorBuilder + .newBuilder(region.getTableDescriptor().getColumnFamily(cfName)) + .setMobThreshold(modThreshold) + .build(); + TableDescriptor td = TableDescriptorBuilder + .newBuilder(region.getTableDescriptor()) + .removeColumnFamily(cfName) + .addColumnFamily(cfd) + .build(); + region.setTableDescriptor(td); + return region; + } + /** * This test will first generate store files, then bulk load them and trigger the compaction. * When compaction, the cell value will be larger than the threshold. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerAbort.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerAbort.java index 784c079495c..81dd63081dd 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerAbort.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerAbort.java @@ -33,6 +33,7 @@ import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; import org.apache.hadoop.hbase.coprocessor.ObserverContext; import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment; @@ -191,7 +192,7 @@ public class TestRegionServerAbort { */ public static class ErrorThrowingHRegion extends HRegion { public ErrorThrowingHRegion(Path tableDir, WAL wal, FileSystem fs, Configuration confParam, - HRegionInfo regionInfo, HTableDescriptor htd, + HRegionInfo regionInfo, TableDescriptor htd, RegionServerServices rsServices) { super(tableDir, wal, fs, confParam, regionInfo, htd, rsServices); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java index 3c0382701d1..f08fba0f5dd 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java @@ -41,6 +41,8 @@ import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.Append; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Get; @@ -51,6 +53,8 @@ import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.apache.hadoop.hbase.test.MetricsAssertHelper; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.RegionServerTests; @@ -452,7 +456,7 @@ public class TestRegionServerMetrics { metricsRegionServer.getRegionServerWrapper().forceRecompute(); assertCounter("mobScanCellsCount", numHfiles); - region.getTableDesc().getFamily(cf).setMobThreshold(100); + setMobThreshold(region, cf, 100); // metrics are reset by the region initialization ((HRegion) region).initialize(); region.compact(true); @@ -472,7 +476,7 @@ public class TestRegionServerMetrics { table.put(p); admin.flush(tableName); } - region.getTableDesc().getFamily(cf).setMobThreshold(0); + setMobThreshold(region, cf, 0); // closing the region forces the compaction.discharger to archive the compacted hfiles ((HRegion) region).close(); @@ -490,6 +494,20 @@ public class TestRegionServerMetrics { } } + private static Region setMobThreshold(Region region, byte[] cfName, long modThreshold) { + ColumnFamilyDescriptor cfd = ColumnFamilyDescriptorBuilder + .newBuilder(region.getTableDescriptor().getColumnFamily(cfName)) + .setMobThreshold(modThreshold) + .build(); + TableDescriptor td = TableDescriptorBuilder + .newBuilder(region.getTableDescriptor()) + .removeColumnFamily(cfName) + .addColumnFamily(cfd) + .build(); + ((HRegion)region).setTableDescriptor(td); + return region; + } + @Test @Ignore public void testRangeCountMetrics() throws Exception { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java index 89f7589cc76..cad060e5e19 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java @@ -61,7 +61,7 @@ public class TestRegionSplitPolicy { HRegionInfo hri = new HRegionInfo(TABLENAME); htd = new HTableDescriptor(TABLENAME); mockRegion = Mockito.mock(HRegion.class); - Mockito.doReturn(htd).when(mockRegion).getTableDesc(); + Mockito.doReturn(htd).when(mockRegion).getTableDescriptor(); Mockito.doReturn(hri).when(mockRegion).getRegionInfo(); stores = new ArrayList<>(); Mockito.doReturn(stores).when(mockRegion).getStores(); @@ -240,7 +240,7 @@ public class TestRegionSplitPolicy { myHtd.setValue(KeyPrefixRegionSplitPolicy.PREFIX_LENGTH_KEY, String.valueOf(2)); HRegion myMockRegion = Mockito.mock(HRegion.class); - Mockito.doReturn(myHtd).when(myMockRegion).getTableDesc(); + Mockito.doReturn(myHtd).when(myMockRegion).getTableDescriptor(); Mockito.doReturn(stores).when(myMockRegion).getStores(); HStore mockStore = Mockito.mock(HStore.class); @@ -349,7 +349,7 @@ public class TestRegionSplitPolicy { myHtd.setValue(DelimitedKeyPrefixRegionSplitPolicy.DELIMITER_KEY, ","); HRegion myMockRegion = Mockito.mock(HRegion.class); - Mockito.doReturn(myHtd).when(myMockRegion).getTableDesc(); + Mockito.doReturn(myHtd).when(myMockRegion).getTableDescriptor(); Mockito.doReturn(stores).when(myMockRegion).getStores(); HStore mockStore = Mockito.mock(HStore.class); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScannerHeartbeatMessages.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScannerHeartbeatMessages.java index bf3f1e02d21..6df4ddc4d28 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScannerHeartbeatMessages.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScannerHeartbeatMessages.java @@ -51,6 +51,7 @@ import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.ScannerCallable; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.filter.Filter; import org.apache.hadoop.hbase.filter.FilterBase; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ScanRequest; @@ -445,7 +446,7 @@ public class TestScannerHeartbeatMessages { private static volatile boolean sleepBetweenColumnFamilies = false; public HeartbeatHRegion(Path tableDir, WAL wal, FileSystem fs, Configuration confParam, - HRegionInfo regionInfo, HTableDescriptor htd, RegionServerServices rsServices) { + HRegionInfo regionInfo, TableDescriptor htd, RegionServerServices rsServices) { super(tableDir, wal, fs, confParam, regionInfo, htd, rsServices); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStore.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStore.java index 2318414d983..4a32218db0f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStore.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStore.java @@ -474,7 +474,7 @@ public class TestStore { w.close(); this.store.close(); // Reopen it... should pick up two files - this.store = new HStore(this.store.getHRegion(), this.store.getFamily(), c); + this.store = new HStore(this.store.getHRegion(), this.store.getColumnFamilyDescriptor(), c); Assert.assertEquals(2, this.store.getStorefilesCount()); result = HBaseTestingUtility.getFromStoreFile(store, diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestDateTieredCompactor.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestDateTieredCompactor.java index 2ab931e5fd2..ca7c0ae7584 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestDateTieredCompactor.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestDateTieredCompactor.java @@ -96,7 +96,7 @@ public class TestDateTieredCompactor { ScanInfo si = new ScanInfo(conf, col, Long.MAX_VALUE, 0, CellComparator.COMPARATOR); final Store store = mock(Store.class); when(store.getStorefiles()).thenReturn(storefiles); - when(store.getFamily()).thenReturn(col); + when(store.getColumnFamilyDescriptor()).thenReturn(col); when(store.getScanInfo()).thenReturn(si); when(store.areWritesEnabled()).thenReturn(true); when(store.getFileSystem()).thenReturn(mock(FileSystem.class)); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactionPolicy.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactionPolicy.java index 74279acfd74..c5097ad2f9f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactionPolicy.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactionPolicy.java @@ -773,7 +773,7 @@ public class TestStripeCompactionPolicy { Store store = mock(Store.class); HRegionInfo info = mock(HRegionInfo.class); when(info.getRegionNameAsString()).thenReturn("testRegion"); - when(store.getFamily()).thenReturn(col); + when(store.getColumnFamilyDescriptor()).thenReturn(col); when(store.getRegionInfo()).thenReturn(info); when( store.createWriterInTmp(anyLong(), any(Compression.Algorithm.class), anyBoolean(), diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactor.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactor.java index 088c9586252..e51a675adeb 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactor.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestStripeCompactor.java @@ -196,7 +196,7 @@ public class TestStripeCompactor { HColumnDescriptor col = new HColumnDescriptor(NAME_OF_THINGS); ScanInfo si = new ScanInfo(conf, col, Long.MAX_VALUE, 0, CellComparator.COMPARATOR); Store store = mock(Store.class); - when(store.getFamily()).thenReturn(col); + when(store.getColumnFamilyDescriptor()).thenReturn(col); when(store.getScanInfo()).thenReturn(si); when(store.areWritesEnabled()).thenReturn(true); when(store.getFileSystem()).thenReturn(mock(FileSystem.class)); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMasterReplication.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMasterReplication.java index 1110d1d92c5..a6f79b3a5e9 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMasterReplication.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMasterReplication.java @@ -694,7 +694,7 @@ public class TestMasterReplication { region.getWAL().registerWALActionsListener(listener); // request a roll - admin.rollWALWriter(cluster.getServerHoldingRegion(region.getTableDesc().getTableName(), + admin.rollWALWriter(cluster.getServerHoldingRegion(region.getTableDescriptor().getTableName(), region.getRegionInfo().getRegionName())); // wait diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMultiSlaveReplication.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMultiSlaveReplication.java index 6af5d8d295f..4978b179f81 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMultiSlaveReplication.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestMultiSlaveReplication.java @@ -233,7 +233,7 @@ public class TestMultiSlaveReplication { region.getWAL().registerWALActionsListener(listener); // request a roll - admin.rollWALWriter(cluster.getServerHoldingRegion(region.getTableDesc().getTableName(), + admin.rollWALWriter(cluster.getServerHoldingRegion(region.getTableDescriptor().getTableName(), region.getRegionInfo().getRegionName())); // wait diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestWithDisabledAuthorization.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestWithDisabledAuthorization.java index 040dfa6a97a..52b0423895d 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestWithDisabledAuthorization.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestWithDisabledAuthorization.java @@ -842,9 +842,9 @@ public class TestWithDisabledAuthorization extends SecureTestUtil { public Object run() throws Exception { HTableDescriptor htd = new HTableDescriptor(TEST_TABLE.getTableName()); Region region_a = mock(Region.class); - when(region_a.getTableDesc()).thenReturn(htd); + when(region_a.getTableDescriptor()).thenReturn(htd); Region region_b = mock(Region.class); - when(region_b.getTableDesc()).thenReturn(htd); + when(region_b.getTableDescriptor()).thenReturn(htd); ACCESS_CONTROLLER.preMerge(ObserverContext.createAndPrepare(RSCP_ENV, null), region_a, region_b); return null; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/util/HFileArchiveTestingUtil.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/util/HFileArchiveTestingUtil.java index bf95a9e7123..ad9d2174699 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/util/HFileArchiveTestingUtil.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/util/HFileArchiveTestingUtil.java @@ -213,7 +213,7 @@ public class HFileArchiveTestingUtil { public static Path getRegionArchiveDir(Configuration conf, HRegion region) throws IOException { return HFileArchiveUtil.getRegionArchiveDir( FSUtils.getRootDir(conf), - region.getTableDesc().getTableName(), + region.getTableDescriptor().getTableName(), region.getRegionInfo().getEncodedName()); } @@ -227,7 +227,7 @@ public class HFileArchiveTestingUtil { public static Path getStoreArchivePath(Configuration conf, HRegion region, Store store) throws IOException { return HFileArchiveUtil.getStoreArchivePath(conf, region.getRegionInfo(), - region.getRegionFileSystem().getTableDir(), store.getFamily().getName()); + region.getRegionFileSystem().getTableDir(), store.getColumnFamilyDescriptor().getName()); } public static Path getStoreArchivePath(HBaseTestingUtility util, String tableName, diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestCoprocessorScanPolicy.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestCoprocessorScanPolicy.java index 720ad291db3..920d3ac7626 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestCoprocessorScanPolicy.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestCoprocessorScanPolicy.java @@ -38,6 +38,7 @@ import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.KeyValueUtil; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Put; @@ -244,7 +245,7 @@ public class TestCoprocessorScanPolicy { } Integer newVersions = versions.get(store.getTableName()); ScanInfo oldSI = store.getScanInfo(); - HColumnDescriptor family = store.getFamily(); + ColumnFamilyDescriptor family = store.getColumnFamilyDescriptor(); ScanInfo scanInfo = new ScanInfo(TEST_UTIL.getConfiguration(), family.getName(), family.getMinVersions(), newVersions == null ? family.getMaxVersions() : newVersions, newTtl == null ? oldSI.getTtl() : newTtl, family.getKeepDeletedCells(), @@ -264,7 +265,7 @@ public class TestCoprocessorScanPolicy { Long newTtl = ttls.get(store.getTableName()); Integer newVersions = versions.get(store.getTableName()); ScanInfo oldSI = store.getScanInfo(); - HColumnDescriptor family = store.getFamily(); + ColumnFamilyDescriptor family = store.getColumnFamilyDescriptor(); ScanInfo scanInfo = new ScanInfo(TEST_UTIL.getConfiguration(), family.getName(), family.getMinVersions(), newVersions == null ? family.getMaxVersions() : newVersions, newTtl == null ? oldSI.getTtl() : newTtl, family.getKeepDeletedCells(), @@ -284,7 +285,7 @@ public class TestCoprocessorScanPolicy { Long newTtl = ttls.get(store.getTableName()); Integer newVersions = versions.get(store.getTableName()); ScanInfo oldSI = store.getScanInfo(); - HColumnDescriptor family = store.getFamily(); + ColumnFamilyDescriptor family = store.getColumnFamilyDescriptor(); ScanInfo scanInfo = new ScanInfo(TEST_UTIL.getConfiguration(), family.getName(), family.getMinVersions(), newVersions == null ? family.getMaxVersions() : newVersions, newTtl == null ? oldSI.getTtl() : newTtl, family.getKeepDeletedCells(),