diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java index 6bad4af489c..5c3e2d4b24c 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftHBaseServiceHandler.java @@ -21,25 +21,36 @@ package org.apache.hadoop.hbase.thrift2; import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_READONLY_ENABLED; import static org.apache.hadoop.hbase.thrift.Constants.THRIFT_READONLY_ENABLED_DEFAULT; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.appendFromThrift; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.columnDescriptorFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.deleteFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.deletesFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.getFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.getsFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.incrementFromThrift; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.namespaceDescriptorFromHBase; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.namespaceDescriptorFromThrift; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.namespaceDescriptorsFromHBase; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.putFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.putsFromThrift; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.regionLocationFromHBase; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.regionLocationsFromHBase; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.resultFromHBase; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.resultsFromHBase; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.rowMutationsFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.scanFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.splitKeyFromThrift; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableDescriptorFromHBase; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableDescriptorFromThrift; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableDescriptorsFromHBase; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableNameFromThrift; import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableNamesFromHBase; +import static org.apache.hadoop.hbase.thrift2.ThriftUtilities.tableNamesFromThrift; import static org.apache.thrift.TBaseHelper.byteBufferToByteArray; import java.io.IOException; import java.nio.ByteBuffer; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Map; @@ -53,7 +64,10 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.DoNotRetryIOException; +import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HRegionLocation; +import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.classification.InterfaceAudience; import org.apache.hadoop.hbase.client.RegionLocator; @@ -345,14 +359,28 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH } } - @Override public TTableDescriptor getTableDescriptor(TTableName table) + @Override + public TTableDescriptor getTableDescriptor(TTableName table) throws TIOError, TException { - return null; + try { + TableName tableName = tableNameFromThrift(table); + HTableDescriptor tableDescriptor = connectionCache.getAdmin().getTableDescriptor(tableName); + return tableDescriptorFromHBase(tableDescriptor); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public List getTableDescriptors(List tables) + @Override + public List getTableDescriptors(List tables) throws TIOError, TException { - return null; + try { + List tableNames = tableNamesFromThrift(tables); + return tableDescriptorsFromHBase( + Arrays.asList(connectionCache.getAdmin().getTableDescriptorsByTableName(tableNames))); + } catch (IOException e) { + throw getTIOError(e); + } } @Override @@ -448,8 +476,6 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH return results; } - - @Override public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, TException { LOG.debug("scannerClose: id=" + scannerId); @@ -484,8 +510,7 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH RegionLocator locator = null; try { locator = getLocator(table); - return ThriftUtilities.regionLocationsFromHBase(locator.getAllRegionLocations()); - + return regionLocationsFromHBase(locator.getAllRegionLocations()); } catch (IOException e) { throw getTIOError(e); } finally { @@ -508,8 +533,7 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH locator = getLocator(table); byte[] rowBytes = byteBufferToByteArray(row); HRegionLocation hrl = locator.getRegionLocation(rowBytes, reload); - return ThriftUtilities.regionLocationFromHBase(hrl); - + return regionLocationFromHBase(hrl); } catch (IOException e) { throw getTIOError(e); } finally { @@ -546,12 +570,25 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH @Override public List getTableDescriptorsByPattern(String regex, boolean includeSysTables) throws TIOError, TException { - return null; + try { + Pattern pattern = (regex == null ? null : Pattern.compile(regex)); + List tableDescriptors = + Arrays.asList(connectionCache.getAdmin().listTables(pattern)); + return tableDescriptorsFromHBase(tableDescriptors); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public List getTableDescriptorsByNamespace(String name) + @Override + public List getTableDescriptorsByNamespace(String name) throws TIOError, TException { - return null; + try { + HTableDescriptor[] tables = connectionCache.getAdmin().listTableDescriptorsByNamespace(name); + return tableDescriptorsFromHBase(Arrays.asList(tables)); + } catch (IOException e) { + throw getTIOError(e); + } } @Override @@ -577,26 +614,57 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH } } - @Override public void createTable(TTableDescriptor desc, List splitKeys) + @Override + public void createTable(TTableDescriptor desc, List splitKeys) throws TIOError, TException { - + try { + HTableDescriptor descriptor = tableDescriptorFromThrift(desc); + byte[][] split = splitKeyFromThrift(splitKeys); + connectionCache.getAdmin().createTable(descriptor, split); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void deleteTable(TTableName tableName) throws TIOError, TException { - + @Override + public void deleteTable(TTableName tableName) throws TIOError, TException { + try { + TableName table = tableNameFromThrift(tableName); + connectionCache.getAdmin().deleteTable(table); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void truncateTable(TTableName tableName, boolean preserveSplits) + @Override + public void truncateTable(TTableName tableName, boolean preserveSplits) throws TIOError, TException { - + try { + TableName table = tableNameFromThrift(tableName); + connectionCache.getAdmin().truncateTable(table, preserveSplits); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void enableTable(TTableName tableName) throws TIOError, TException { - + @Override + public void enableTable(TTableName tableName) throws TIOError, TException { + try { + TableName table = tableNameFromThrift(tableName); + connectionCache.getAdmin().enableTable(table); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void disableTable(TTableName tableName) throws TIOError, TException { - + @Override + public void disableTable(TTableName tableName) throws TIOError, TException { + try { + TableName table = tableNameFromThrift(tableName); + connectionCache.getAdmin().disableTable(table); + } catch (IOException e) { + throw getTIOError(e); + } } @Override @@ -641,51 +709,113 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH } } - @Override public void addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) + @Override + public void addColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws TIOError, TException { - throw new NotImplementedException(); + try { + TableName table = tableNameFromThrift(tableName); + HColumnDescriptor columnFamilyDescriptor = columnDescriptorFromThrift(column); + connectionCache.getAdmin().addColumn(table, columnFamilyDescriptor); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void deleteColumnFamily(TTableName tableName, ByteBuffer column) + @Override + public void deleteColumnFamily(TTableName tableName, ByteBuffer column) throws TIOError, TException { - throw new NotImplementedException(); + try { + TableName table = tableNameFromThrift(tableName); + connectionCache.getAdmin().deleteColumn(table, column.array()); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) + @Override + public void modifyColumnFamily(TTableName tableName, TColumnFamilyDescriptor column) throws TIOError, TException { - throw new NotImplementedException(); + try { + TableName table = tableNameFromThrift(tableName); + HColumnDescriptor columnFamilyDescriptor = columnDescriptorFromThrift(column); + connectionCache.getAdmin().modifyColumn(table, columnFamilyDescriptor); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void modifyTable(TTableDescriptor desc) throws TIOError, TException { - throw new NotImplementedException(); + @Override + public void modifyTable(TTableDescriptor desc) throws TIOError, TException { + try { + HTableDescriptor descriptor = tableDescriptorFromThrift(desc); + connectionCache.getAdmin().modifyTable(descriptor.getTableName(), descriptor); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void createNamespace(TNamespaceDescriptor namespaceDesc) + @Override + public void createNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, TException { - throw new NotImplementedException(); + try { + NamespaceDescriptor descriptor = namespaceDescriptorFromThrift(namespaceDesc); + connectionCache.getAdmin().createNamespace(descriptor); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void modifyNamespace(TNamespaceDescriptor namespaceDesc) + @Override + public void modifyNamespace(TNamespaceDescriptor namespaceDesc) throws TIOError, TException { - throw new NotImplementedException(); + try { + NamespaceDescriptor descriptor = namespaceDescriptorFromThrift(namespaceDesc); + connectionCache.getAdmin().modifyNamespace(descriptor); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public void deleteNamespace(String name) throws TIOError, TException { - throw new NotImplementedException(); + @Override + public void deleteNamespace(String name) throws TIOError, TException { + try { + connectionCache.getAdmin().deleteNamespace(name); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public TNamespaceDescriptor getNamespaceDescriptor(String name) + @Override + public TNamespaceDescriptor getNamespaceDescriptor(String name) throws TIOError, TException { - throw new NotImplementedException(); + try { + return namespaceDescriptorFromHBase(connectionCache.getAdmin().getNamespaceDescriptor(name)); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public List listNamespaceDescriptors() + @Override + public List listNamespaceDescriptors() throws TIOError, TException { - throw new NotImplementedException(); + try { + return namespaceDescriptorsFromHBase(connectionCache.getAdmin().listNamespaceDescriptors()); + } catch (IOException e) { + throw getTIOError(e); + } } - @Override public List listNamespaces() throws TIOError, TException { - throw new NotImplementedException(); + @Override + public List listNamespaces() throws TIOError, TException { + List result = new ArrayList<>(); + try { + for (NamespaceDescriptor nd : connectionCache.getAdmin().listNamespaceDescriptors()) { + result.add(nd.getName()); + } + } catch (IOException e) { + throw getTIOError(e); + } + return result; } @Override @@ -693,12 +823,14 @@ public class ThriftHBaseServiceHandler extends HBaseServiceHandler implements TH return TThriftServerType.TWO; } - @Override public List getSlowLogResponses(Set serverNames, + @Override + public List getSlowLogResponses(Set serverNames, TLogQueryFilter logQueryFilter) throws TIOError, TException { throw new NotImplementedException(); } - @Override public List clearSlowLogResponses(Set serverNames) + @Override + public List clearSlowLogResponses(Set serverNames) throws TIOError, TException { throw new NotImplementedException(); } diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java index f6df35b3544..b310fd1ff0c 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/ThriftUtilities.java @@ -31,9 +31,11 @@ import java.util.Set; import org.apache.commons.collections.MapUtils; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellUtil; +import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.HRegionInfo; import org.apache.hadoop.hbase.HRegionLocation; +import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.KeepDeletedCells; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.NamespaceDescriptor; @@ -57,6 +59,7 @@ import org.apache.hadoop.hbase.exceptions.DeserializationException; import org.apache.hadoop.hbase.filter.CompareFilter; import org.apache.hadoop.hbase.filter.Filter; import org.apache.hadoop.hbase.filter.ParseFilter; +import org.apache.hadoop.hbase.io.ImmutableBytesWritable; import org.apache.hadoop.hbase.io.TimeRange; import org.apache.hadoop.hbase.io.compress.Compression; import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding; @@ -70,6 +73,7 @@ import org.apache.hadoop.hbase.thrift2.generated.TAuthorization; import org.apache.hadoop.hbase.thrift2.generated.TBloomFilterType; import org.apache.hadoop.hbase.thrift2.generated.TCellVisibility; import org.apache.hadoop.hbase.thrift2.generated.TColumn; +import org.apache.hadoop.hbase.thrift2.generated.TColumnFamilyDescriptor; import org.apache.hadoop.hbase.thrift2.generated.TColumnIncrement; import org.apache.hadoop.hbase.thrift2.generated.TColumnValue; import org.apache.hadoop.hbase.thrift2.generated.TCompareOp; @@ -92,6 +96,7 @@ import org.apache.hadoop.hbase.thrift2.generated.TResult; import org.apache.hadoop.hbase.thrift2.generated.TRowMutations; import org.apache.hadoop.hbase.thrift2.generated.TScan; import org.apache.hadoop.hbase.thrift2.generated.TServerName; +import org.apache.hadoop.hbase.thrift2.generated.TTableDescriptor; import org.apache.hadoop.hbase.thrift2.generated.TTableName; import org.apache.hadoop.hbase.thrift2.generated.TTimeRange; import org.apache.hadoop.hbase.util.Bytes; @@ -104,8 +109,6 @@ public class ThriftUtilities { private final static Result EMPTY_RESULT = Result.create(EMPTY_CELL_ARRAY); private final static Result EMPTY_RESULT_STALE = Result.create(EMPTY_CELL_ARRAY, null, true); - - private ThriftUtilities() { throw new UnsupportedOperationException("Can't initialize class"); } @@ -930,8 +933,6 @@ public class ThriftUtilities { } } - - public static TBloomFilterType bloomFilterFromHBase(BloomType in) { switch (in) { case NONE: return TBloomFilterType.NONE; @@ -1293,4 +1294,138 @@ public class ThriftUtilities { } return result; } + + public static HColumnDescriptor columnDescriptorFromThrift(TColumnFamilyDescriptor in) { + HColumnDescriptor out = new HColumnDescriptor(in.getName()); + if (in.isSetAttributes()) { + for (Map.Entry attribute : in.getAttributes().entrySet()) { + out.setValue(attribute.getKey().array(), attribute.getValue().array()); + } + } + if (in.isSetConfiguration()) { + for (Map.Entry conf : in.getConfiguration().entrySet()) { + out.setConfiguration(conf.getKey(), conf.getValue()); + } + } + if (in.isSetBlockSize()) { + out.setBlocksize(in.getBlockSize()); + } + if (in.isSetBloomnFilterType()) { + out.setBloomFilterType(bloomFilterFromThrift(in.getBloomnFilterType())); + } + if (in.isSetCompressionType()) { + out.setCompressionType(compressionAlgorithmFromThrift(in.getCompressionType())); + } + if (in.isSetDfsReplication()) { + out.setDFSReplication(in.getDfsReplication()); + } + if (in.isSetDataBlockEncoding()) { + out.setDataBlockEncoding(dataBlockEncodingFromThrift(in.getDataBlockEncoding())); + } + if (in.isSetKeepDeletedCells()) { + out.setKeepDeletedCells(keepDeletedCellsFromThrift(in.getKeepDeletedCells())); + } + if (in.isSetMaxVersions()) { + out.setMaxVersions(in.getMaxVersions()); + } + if (in.isSetMinVersions()) { + out.setMinVersions(in.getMinVersions()); + } + if (in.isSetScope()) { + out.setScope(in.getScope()); + } + if (in.isSetTimeToLive()) { + out.setTimeToLive(in.getTimeToLive()); + } + if (in.isSetBlockCacheEnabled()) { + out.setBlockCacheEnabled(in.isBlockCacheEnabled()); + } + if (in.isSetCacheBloomsOnWrite()) { + out.setCacheBloomsOnWrite(in.isCacheBloomsOnWrite()); + } + if (in.isSetCacheDataOnWrite()) { + out.setCacheDataOnWrite(in.isCacheDataOnWrite()); + } + if (in.isSetCacheIndexesOnWrite()) { + out.setCacheIndexesOnWrite(in.isCacheIndexesOnWrite()); + } + if (in.isSetCompressTags()) { + out.setCompressTags(in.isCompressTags()); + } + if (in.isSetEvictBlocksOnClose()) { + out.setEvictBlocksOnClose(in.isEvictBlocksOnClose()); + } + if (in.isSetInMemory()) { + out.setInMemory(in.isInMemory()); + } + return out; + } + + public static TColumnFamilyDescriptor columnDescriptorFromHBase(HColumnDescriptor in) { + TColumnFamilyDescriptor out = new TColumnFamilyDescriptor(); + out.setName(in.getName()); + for (Map.Entry attribute : + in.getValues().entrySet()) { + out.putToAttributes(ByteBuffer.wrap(attribute.getKey().get()), + ByteBuffer.wrap(attribute.getValue().get())); + } + for (Map.Entry conf : in.getConfiguration().entrySet()) { + out.putToConfiguration(conf.getKey(), conf.getValue()); + } + out.setBlockSize(in.getBlocksize()); + out.setBloomnFilterType(bloomFilterFromHBase(in.getBloomFilterType())); + out.setCompressionType(compressionAlgorithmFromHBase(in.getCompressionType())); + out.setDfsReplication(in.getDFSReplication()); + out.setDataBlockEncoding(dataBlockEncodingFromHBase(in.getDataBlockEncoding())); + out.setKeepDeletedCells(keepDeletedCellsFromHBase(in.getKeepDeletedCells())); + out.setMaxVersions(in.getMaxVersions()); + out.setMinVersions(in.getMinVersions()); + out.setScope(in.getScope()); + out.setTimeToLive(in.getTimeToLive()); + out.setBlockCacheEnabled(in.isBlockCacheEnabled()); + out.setCacheBloomsOnWrite(in.isCacheBloomsOnWrite()); + out.setCacheDataOnWrite(in.isCacheDataOnWrite()); + out.setCacheIndexesOnWrite(in.isCacheIndexesOnWrite()); + out.setCompressTags(in.isCompressTags()); + out.setEvictBlocksOnClose(in.isEvictBlocksOnClose()); + out.setInMemory(in.isInMemory()); + return out; + } + + public static HTableDescriptor tableDescriptorFromThrift(TTableDescriptor in) { + HTableDescriptor out = new HTableDescriptor(tableNameFromThrift(in.getTableName())); + for (TColumnFamilyDescriptor col : in.getColumns()) { + out.addFamily(columnDescriptorFromThrift(col)); + } + + Map map = in.getAttributes(); + for (Map.Entry e : map.entrySet()) { + out.setValue(e.getKey().array(), e.getValue().array()); + } + return out; + } + + public static TTableDescriptor tableDescriptorFromHBase(HTableDescriptor in) { + TTableDescriptor out = new TTableDescriptor(); + out.setTableName(tableNameFromHBase(in.getTableName())); + Map attributes = in.getValues(); + for (Map.Entry attribute + : attributes.entrySet()) { + out.putToAttributes(ByteBuffer.wrap(attribute.getKey().get()), + ByteBuffer.wrap(attribute.getValue().get())); + } + for (HColumnDescriptor column : in.getColumnFamilies()) { + out.addToColumns(columnDescriptorFromHBase(column)); + } + out.setDurability(durabilityFromHBase(in.getDurability())); + return out; + } + + public static List tableDescriptorsFromHBase(List in) { + List out = new ArrayList<>(in.size()); + for (HTableDescriptor descriptor : in) { + out.add(tableDescriptorFromHBase(descriptor)); + } + return out; + } }