From 233e40c07bcd97de795fac74bd1532ba3c6e43fb Mon Sep 17 00:00:00 2001 From: emeroad Date: Thu, 20 Jul 2023 11:30:07 +0900 Subject: [PATCH] [#10131] Migrate HBase1 API to HBase2 API --- .../common/hbase/HBaseAdminTemplate.java | 63 ++++++------- .../common/hbase/HbaseAdminOperation.java | 18 ++-- .../hbase/manager/config/AppConfig.java | 6 +- .../manager/hbase/ReadOnlyAdminTemplate.java | 32 +++---- .../schema/core/HtdHbaseSchemaVerifier.java | 21 +++-- .../core/command/CreateTableCommand.java | 18 ++-- .../command/HbaseSchemaCommandManager.java | 17 ++-- .../core/command/ModifyTableCommand.java | 34 +++---- .../schema/core/command/TableCommand.java | 73 ++++++++------- .../service/HbaseSchemaServiceImpl.java | 22 ++--- .../core/HtdHbaseSchemaVerifierTest.java | 91 ++++++++++++------- .../HbaseSchemaCommandManagerTest.java | 73 +++++++++------ .../service/HbaseSchemaServiceImplTest.java | 4 +- 13 files changed, 250 insertions(+), 222 deletions(-) diff --git a/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HBaseAdminTemplate.java b/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HBaseAdminTemplate.java index 03a8bae566d4..a71988205b60 100644 --- a/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HBaseAdminTemplate.java +++ b/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HBaseAdminTemplate.java @@ -16,21 +16,19 @@ package com.navercorp.pinpoint.common.hbase; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Objects; - -import com.navercorp.pinpoint.common.util.ArrayUtils; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HTableDescriptor; +import com.navercorp.pinpoint.common.util.BytesUtils; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.NamespaceExistException; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; -import org.apache.logging.log4j.Logger; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import java.util.List; +import java.util.Map; +import java.util.Objects; /** * @author emeroad @@ -78,46 +76,42 @@ public boolean createNamespaceIfNotExists(String namespace, Map } @Override - public List getTableDescriptors(String namespace) { + public List getTableDescriptors(String namespace) { return execute(admin -> { - HTableDescriptor[] htds = admin.listTableDescriptorsByNamespace(namespace); - if (ArrayUtils.isEmpty(htds)) { - return Collections.emptyList(); - } - return Arrays.asList(htds); + return admin.listTableDescriptorsByNamespace(BytesUtils.toBytes(namespace)); }); } @Override - public HTableDescriptor getTableDescriptor(TableName tableName) { - return execute(admin -> admin.getTableDescriptor(tableName)); + public TableDescriptor getTableDescriptor(TableName tableName) { + return execute(admin -> admin.getDescriptor(tableName)); } @Override - public void createTable(HTableDescriptor htd) { + public void createTable(TableDescriptor tableDescriptor) { execute(admin -> { - admin.createTable(htd); - logger.info("{} table created, htd : {}", htd.getTableName(), htd); + admin.createTable(tableDescriptor); + logger.info("{} table created, tableDescriptor : {}", tableDescriptor.getTableName(), tableDescriptor); return null; }); } @Override - public void createTable(HTableDescriptor htd, byte[][] splitKeys) { + public void createTable(TableDescriptor tableDescriptor, byte[][] splitKeys) { execute(admin -> { - admin.createTable(htd, splitKeys); - logger.info("{} table created with {} split keys, htd : {}", htd.getTableName(), splitKeys.length + 1, htd); + admin.createTable(tableDescriptor, splitKeys); + logger.info("{} table created with {} split keys, tableDescriptor : {}", tableDescriptor.getTableName(), splitKeys.length + 1, tableDescriptor); return null; }); } @Override - public boolean createTableIfNotExists(HTableDescriptor htd) { + public boolean createTableIfNotExists(TableDescriptor tableDescriptor) { return execute(admin -> { - TableName tableName = htd.getTableName(); + TableName tableName = tableDescriptor.getTableName(); if (!admin.tableExists(tableName)) { - admin.createTable(htd); - logger.info("{} table created, htd : {}", htd.getTableName(), htd); + admin.createTable(tableDescriptor); + logger.info("{} table created, tableDescriptor : {}", tableDescriptor.getTableName(), tableDescriptor); return true; } return false; @@ -166,20 +160,19 @@ public void dropTable(TableName tableName) { } @Override - public void modifyTable(HTableDescriptor htd) { - final TableName tableName = htd.getTableName(); + public void modifyTable(TableDescriptor tableDescriptor) { execute(admin -> { - admin.modifyTable(tableName, htd); - logger.info("{} table modified, htd : {}", tableName, htd); + admin.modifyTable(tableDescriptor); + logger.info("table modified, tableDescriptor : {}", tableDescriptor); return null; }); } @Override - public void addColumn(TableName tableName, HColumnDescriptor hcd) { + public void addColumn(TableName tableName, ColumnFamilyDescriptor columnDescriptor) { execute(admin -> { - admin.addColumn(tableName, hcd); - logger.info("{} table added column : {}", tableName, hcd); + admin.addColumnFamily(tableName, columnDescriptor); + logger.info("{} table added column : {}", tableName, columnDescriptor); return null; }); } diff --git a/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HbaseAdminOperation.java b/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HbaseAdminOperation.java index 6e21fba22953..df37f458af85 100644 --- a/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HbaseAdminOperation.java +++ b/commons-hbase/src/main/java/com/navercorp/pinpoint/common/hbase/HbaseAdminOperation.java @@ -16,9 +16,9 @@ package com.navercorp.pinpoint.common.hbase; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import java.util.List; import java.util.Map; @@ -32,15 +32,15 @@ public interface HbaseAdminOperation { boolean createNamespaceIfNotExists(String namespace, Map configurations); - List getTableDescriptors(String namespace); + List getTableDescriptors(String namespace); - HTableDescriptor getTableDescriptor(TableName tableName); + TableDescriptor getTableDescriptor(TableName tableName); - void createTable(HTableDescriptor hTableDescriptor); + void createTable(TableDescriptor tableDescriptor); - void createTable(HTableDescriptor hTableDescriptor, byte[][] splitKeys); + void createTable(TableDescriptor tableDescriptor, byte[][] splitKeys); - boolean createTableIfNotExists(HTableDescriptor hTableDescriptor); + boolean createTableIfNotExists(TableDescriptor tableDescriptor); boolean tableExists(TableName tableName); @@ -50,9 +50,9 @@ public interface HbaseAdminOperation { void dropTable(TableName tableName); - void modifyTable(HTableDescriptor hTableDescriptor); + void modifyTable(TableDescriptor tableDescriptor); - void addColumn(TableName tableName, HColumnDescriptor hColumnDescriptor); + void addColumn(TableName tableName, ColumnFamilyDescriptor columnDescriptor); T execute(AdminCallback action); } diff --git a/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/config/AppConfig.java b/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/config/AppConfig.java index 541f40fe4a83..e6daea91a32c 100644 --- a/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/config/AppConfig.java +++ b/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/config/AppConfig.java @@ -27,7 +27,7 @@ import com.navercorp.pinpoint.hbase.schema.service.HbaseSchemaServiceImpl; import com.navercorp.pinpoint.hbase.schema.service.SchemaChangeLogService; import com.navercorp.pinpoint.hbase.schema.service.SchemaChangeLogServiceImpl; -import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @@ -43,7 +43,7 @@ public HbaseSchemaReader hbaseSchemaReader() { } @Bean - public HbaseSchemaVerifier hbaseSchemaVerifier() { + public HbaseSchemaVerifier hbaseSchemaVerifier() { return new HtdHbaseSchemaVerifier(); } @@ -60,7 +60,7 @@ public SchemaChangeLogService schemaChangeLogService(SchemaChangeLogDao schemaCh @Bean public HbaseSchemaService hbaseSchemaService(HbaseAdminOperation hbaseAdminOperation, SchemaChangeLogService schemaChangeLogService, - HbaseSchemaVerifier hBaseSchemaVerifier) { + HbaseSchemaVerifier hBaseSchemaVerifier) { return new HbaseSchemaServiceImpl(hbaseAdminOperation, schemaChangeLogService, hBaseSchemaVerifier); } } diff --git a/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/hbase/ReadOnlyAdminTemplate.java b/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/hbase/ReadOnlyAdminTemplate.java index 4795d9f3be34..c4b2e144f745 100644 --- a/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/hbase/ReadOnlyAdminTemplate.java +++ b/hbase/hbase-schema-manager/src/main/java/com/navercorp/pinpoint/hbase/manager/hbase/ReadOnlyAdminTemplate.java @@ -18,11 +18,11 @@ import com.navercorp.pinpoint.common.hbase.AdminCallback; import com.navercorp.pinpoint.common.hbase.HbaseAdminOperation; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; -import org.apache.logging.log4j.Logger; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import java.util.List; import java.util.Map; @@ -60,33 +60,33 @@ public boolean createNamespaceIfNotExists(String namespace, Map } @Override - public List getTableDescriptors(String namespace) { + public List getTableDescriptors(String namespace) { return delegate.getTableDescriptors(namespace); } @Override - public HTableDescriptor getTableDescriptor(TableName tableName) { + public TableDescriptor getTableDescriptor(TableName tableName) { return delegate.getTableDescriptor(tableName); } @Override - public void createTable(HTableDescriptor htd) { - logger.info("Creating table : {}.", htd); + public void createTable(TableDescriptor tableDescriptor) { + logger.info("Creating table : {}.", tableDescriptor); } @Override - public void createTable(HTableDescriptor htd, byte[][] splitKeys) { - logger.info("Creating table : {} with {} splitKeys.", htd, splitKeys.length); + public void createTable(TableDescriptor tableDescriptor, byte[][] splitKeys) { + logger.info("Creating table : {} with {} splitKeys.", tableDescriptor, splitKeys.length); } @Override - public boolean createTableIfNotExists(HTableDescriptor htd) { - TableName tableName = htd.getTableName(); + public boolean createTableIfNotExists(TableDescriptor tableDescriptor) { + TableName tableName = tableDescriptor.getTableName(); boolean tableExists = delegate.tableExists(tableName); if (tableExists) { return false; } - this.createTable(htd); + this.createTable(tableDescriptor); return true; } @@ -127,13 +127,13 @@ public void dropTable(TableName tableName) { } @Override - public void modifyTable(HTableDescriptor htd) { - logger.info("Modifying table : {}, desc : {}", htd.getTableName(), htd); + public void modifyTable(TableDescriptor tableDescriptor) { + logger.info("Modifying table : {}, desc : {}", tableDescriptor.getTableName(), tableDescriptor); } @Override - public void addColumn(TableName tableName, HColumnDescriptor hcd) { - logger.info("Adding column to table : {}, column : {}", tableName, hcd); + public void addColumn(TableName tableName, ColumnFamilyDescriptor columnDescriptor) { + logger.info("Adding column to table : {}, column : {}", tableName, columnDescriptor); } @Override diff --git a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/HtdHbaseSchemaVerifier.java b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/HtdHbaseSchemaVerifier.java index 1701f413986a..470d9c697fc1 100644 --- a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/HtdHbaseSchemaVerifier.java +++ b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/HtdHbaseSchemaVerifier.java @@ -16,9 +16,10 @@ package com.navercorp.pinpoint.hbase.schema.core; -import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.springframework.util.CollectionUtils; import java.util.HashMap; @@ -28,7 +29,7 @@ /** * @author HyunGil Jeong */ -public class HtdHbaseSchemaVerifier implements HbaseSchemaVerifier { +public class HtdHbaseSchemaVerifier implements HbaseSchemaVerifier { /** * Returns {@code true} if the schema definitions specified by {@code expectedSchemas} matches those @@ -43,7 +44,7 @@ public class HtdHbaseSchemaVerifier implements HbaseSchemaVerifier expectedSchemas, List actualSchemas) { + public boolean verifySchemas(List expectedSchemas, List actualSchemas) { if (CollectionUtils.isEmpty(expectedSchemas)) { return true; } @@ -51,14 +52,14 @@ public boolean verifySchemas(List expectedSchemas, List actualSchemaMap = new HashMap<>(); - for (HTableDescriptor actualSchema : actualSchemas) { + Map actualSchemaMap = new HashMap<>(); + for (TableDescriptor actualSchema : actualSchemas) { actualSchemaMap.put(actualSchema.getTableName(), actualSchema); } - for (HTableDescriptor expectedSchema : expectedSchemas) { + for (TableDescriptor expectedSchema : expectedSchemas) { TableName tableName = expectedSchema.getTableName(); - HTableDescriptor actualSchema = actualSchemaMap.get(tableName); + TableDescriptor actualSchema = actualSchemaMap.get(tableName); if (actualSchema == null) { return false; } @@ -69,12 +70,12 @@ public boolean verifySchemas(List expectedSchemas, List filterTablesByNamespace(List htds) { + private List filterTablesByNamespace(List htds) { if (CollectionUtils.isEmpty(htds)) { return Collections.emptyList(); } - List filteredHtds = new ArrayList<>(); - for (HTableDescriptor htd : htds) { + List filteredHtds = new ArrayList<>(); + for (TableDescriptor htd : htds) { TableName tableName = htd.getTableName(); String namespace = tableName.getNamespaceAsString(); if (this.namespace.equalsIgnoreCase(namespace)) { @@ -138,12 +138,11 @@ public List getCommands() { .collect(Collectors.toList()); } - public List getSchemaSnapshot() { + public List getSchemaSnapshot() { return tableCommandMap.entrySet().stream() .filter(e -> affectedTables.contains(e.getKey())) .map(Map.Entry::getValue) - .map(TableCommand::getHtd) - .map(HTableDescriptor::new) + .map(TableCommand::buildDescriptor) .collect(Collectors.toList()); } } diff --git a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/ModifyTableCommand.java b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/ModifyTableCommand.java index fa1a46ab6b57..11d79a93c1d8 100644 --- a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/ModifyTableCommand.java +++ b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/ModifyTableCommand.java @@ -17,13 +17,12 @@ package com.navercorp.pinpoint.hbase.schema.core.command; import com.navercorp.pinpoint.common.hbase.HbaseAdminOperation; -import com.navercorp.pinpoint.common.util.ArrayUtils; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.io.compress.Compression; -import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; /** * This command is solely for adding new column families to an existing table. @@ -35,30 +34,27 @@ public class ModifyTableCommand extends TableCommand { private final Logger logger = LogManager.getLogger(this.getClass()); - ModifyTableCommand(HTableDescriptor htd, Compression.Algorithm compressionAlgorithm) { + ModifyTableCommand(TableDescriptor htd, Compression.Algorithm compressionAlgorithm) { super(htd, compressionAlgorithm); } @Override public boolean execute(HbaseAdminOperation hbaseAdminOperation) { - HTableDescriptor htd = getHtd(); - HColumnDescriptor[] hcds = htd.getColumnFamilies(); - if (ArrayUtils.isEmpty(hcds)) { - return false; - } + TableDescriptor htd = buildDescriptor(); + ColumnFamilyDescriptor[] cfDescriptors = htd.getColumnFamilies(); TableName tableName = htd.getTableName(); - HTableDescriptor currentHtd = hbaseAdminOperation.getTableDescriptor(tableName); + TableDescriptor currentHtd = hbaseAdminOperation.getTableDescriptor(tableName); // Filter existing column families as column family modification is not supported. // We could use modifyTable(HTableDescriptor) to add column families, but this deletes existing column families // if they are not specified in HTableDescriptor and this may be dangerous. // Instead, use addColumn. boolean changesMade = false; - for (HColumnDescriptor hcd : hcds) { - if (!currentHtd.hasFamily(hcd.getName())) { - logger.info("Adding {} to {} table.", hcd, tableName); - hbaseAdminOperation.addColumn(tableName, hcd); + for (ColumnFamilyDescriptor cf : cfDescriptors) { + if (!currentHtd.hasColumnFamily(cf.getName())) { + logger.info("Adding {} to {} table.", cf, tableName); + hbaseAdminOperation.addColumn(tableName, cf); changesMade = true; } } @@ -67,10 +63,8 @@ public boolean execute(HbaseAdminOperation hbaseAdminOperation) { @Override public String toString() { - final StringBuilder sb = new StringBuilder("ModifyTableCommand{"); - sb.append("htd=").append(getHtd()); - sb.append(", compressionAlgorithm=").append(getCompressionAlgorithm()); - sb.append('}'); - return sb.toString(); + return "ModifyTableCommand{TableDesc=" + buildDescriptor() + + ", compressionAlgorithm=" + getCompressionAlgorithm() + + '}'; } } diff --git a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/TableCommand.java b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/TableCommand.java index 9924a8cdf2b7..54523869e1d9 100644 --- a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/TableCommand.java +++ b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/core/command/TableCommand.java @@ -16,15 +16,18 @@ package com.navercorp.pinpoint.hbase.schema.core.command; +import com.navercorp.pinpoint.common.util.BytesUtils; import com.navercorp.pinpoint.common.util.CollectionUtils; import com.navercorp.pinpoint.hbase.schema.reader.core.ChangeType; import com.navercorp.pinpoint.hbase.schema.reader.core.ColumnFamilyChange; import com.navercorp.pinpoint.hbase.schema.reader.core.ColumnFamilyConfiguration; import com.navercorp.pinpoint.hbase.schema.reader.core.TableConfiguration; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.Durability; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.apache.hadoop.hbase.io.compress.Compression; import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding; import org.apache.hadoop.hbase.regionserver.BloomType; @@ -37,21 +40,23 @@ */ public abstract class TableCommand implements HbaseSchemaCommand { - private final HTableDescriptor htd; + protected final TableDescriptorBuilder builder; private final Compression.Algorithm compressionAlgorithm; - TableCommand(HTableDescriptor htd, Compression.Algorithm compressionAlgorithm) { - this.htd = Objects.requireNonNull(htd, "htd"); + TableCommand(TableDescriptor tableDescriptor, Compression.Algorithm compressionAlgorithm) { + Objects.requireNonNull(tableDescriptor, "tableDescriptor"); + this.builder = TableDescriptorBuilder.newBuilder(tableDescriptor); this.compressionAlgorithm = Objects.requireNonNull(compressionAlgorithm, "compressionAlgorithm"); - } - public TableName getTableName() { - return htd.getTableName(); + TableCommand(TableName tableName, Compression.Algorithm compressionAlgorithm) { + Objects.requireNonNull(tableName, "tableName"); + this.builder = TableDescriptorBuilder.newBuilder(tableName); + this.compressionAlgorithm = Objects.requireNonNull(compressionAlgorithm, "compressionAlgorithm"); } - protected final HTableDescriptor getHtd() { - return htd; + protected final TableDescriptor buildDescriptor() { + return builder.build(); } protected final Compression.Algorithm getCompressionAlgorithm() { @@ -61,23 +66,23 @@ protected final Compression.Algorithm getCompressionAlgorithm() { void applyConfiguration(TableConfiguration tableConfiguration) { Long maxFileSize = tableConfiguration.getMaxFileSize(); if (maxFileSize != null) { - htd.setMaxFileSize(maxFileSize); + builder.setMaxFileSize(maxFileSize); } Boolean readOnly = tableConfiguration.getReadOnly(); if (readOnly != null) { - htd.setReadOnly(readOnly); + builder.setReadOnly(readOnly); } Boolean compactionEnabled = tableConfiguration.getCompactionEnabled(); if (compactionEnabled != null) { - htd.setCompactionEnabled(compactionEnabled); + builder.setCompactionEnabled(compactionEnabled); } Long memstoreFlushSize = tableConfiguration.getMemstoreFlushSize(); if (memstoreFlushSize != null) { - htd.setMemStoreFlushSize(memstoreFlushSize); + builder.setMemStoreFlushSize(memstoreFlushSize); } TableConfiguration.Durability durability = tableConfiguration.getDurability(); if (durability != null) { - htd.setDurability(Durability.valueOf(durability.name())); + builder.setDurability(Durability.valueOf(durability.name())); } } @@ -85,63 +90,67 @@ void applyColumnFamilyChanges(List columnFamilyChanges) { if (CollectionUtils.isEmpty(columnFamilyChanges)) { return; } + TableDescriptor tableDescriptor = builder.build(); + for (ColumnFamilyChange columnFamilyChange : columnFamilyChanges) { ChangeType changeType = columnFamilyChange.getType(); if (changeType == ChangeType.CREATE) { - HColumnDescriptor family = newColumnDescriptor(columnFamilyChange); - if (htd.hasFamily(family.getName())) { - throw new IllegalArgumentException("Cannot add an existing column family : " + htd.getNameAsString()); + ColumnFamilyDescriptor family = newColumnDescriptor(columnFamilyChange); + if (tableDescriptor.hasColumnFamily(family.getName())) { + throw new IllegalArgumentException("Cannot add an existing column family : " + tableDescriptor.getTableName().getNameAsString()); } - htd.addFamily(family); + builder.setColumnFamily(family); } else { throw new UnsupportedOperationException("Unknown change type : " + changeType); } } } - private HColumnDescriptor newColumnDescriptor(ColumnFamilyChange columnFamilyChange) { - HColumnDescriptor hcd = new HColumnDescriptor(columnFamilyChange.getName()); + private ColumnFamilyDescriptor newColumnDescriptor(ColumnFamilyChange columnFamilyChange) { + byte[] name = BytesUtils.toBytes(columnFamilyChange.getName()); + ColumnFamilyDescriptorBuilder builder = ColumnFamilyDescriptorBuilder.newBuilder(name); + ColumnFamilyConfiguration columnFamilyConfiguration = columnFamilyChange.getColumnFamilyConfiguration(); Boolean blockCacheEnabled = columnFamilyConfiguration.getBlockCacheEnabled(); if (blockCacheEnabled != null) { - hcd.setBlockCacheEnabled(blockCacheEnabled); + builder.setBlockCacheEnabled(blockCacheEnabled); } Integer replicationScope = columnFamilyConfiguration.getReplicationScope(); if (replicationScope != null) { - hcd.setScope(replicationScope); + builder.setScope(replicationScope); } Boolean inMemory = columnFamilyConfiguration.getInMemory(); if (inMemory != null) { - hcd.setInMemory(inMemory); + builder.setInMemory(inMemory); } Integer timeToLive = columnFamilyConfiguration.getTimeToLive(); if (timeToLive != null) { - hcd.setTimeToLive(timeToLive); + builder.setTimeToLive(timeToLive); } ColumnFamilyConfiguration.DataBlockEncoding dataBlockEncoding = columnFamilyConfiguration.getDataBlockEncoding(); if (dataBlockEncoding != null) { - hcd.setDataBlockEncoding(DataBlockEncoding.valueOf(dataBlockEncoding.name())); + builder.setDataBlockEncoding(DataBlockEncoding.valueOf(dataBlockEncoding.name())); } Integer blockSize = columnFamilyConfiguration.getBlockSize(); if (blockSize != null) { - hcd.setBlocksize(blockSize); + builder.setBlocksize(blockSize); } Integer maxVersions = columnFamilyConfiguration.getMaxVersions(); if (maxVersions != null) { - hcd.setMaxVersions(maxVersions); + builder.setMaxVersions(maxVersions); } Integer minVersions = columnFamilyConfiguration.getMinVersions(); if (minVersions != null) { - hcd.setMinVersions(minVersions); + builder.setMinVersions(minVersions); } ColumnFamilyConfiguration.BloomFilter bloomFilter = columnFamilyConfiguration.getBloomFilter(); if (bloomFilter != null) { - hcd.setBloomFilterType(BloomType.valueOf(bloomFilter.name())); + builder.setBloomFilterType(BloomType.valueOf(bloomFilter.name())); } if (compressionAlgorithm != Compression.Algorithm.NONE) { - hcd.setCompressionType(compressionAlgorithm); + builder.setCompressionType(compressionAlgorithm); } - return hcd; + return builder.build(); } } diff --git a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImpl.java b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImpl.java index 82032a4a819b..24f160fbac3a 100644 --- a/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImpl.java +++ b/hbase/hbase-schema/src/main/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImpl.java @@ -20,14 +20,14 @@ import com.navercorp.pinpoint.hbase.schema.core.ChangeSetManager; import com.navercorp.pinpoint.hbase.schema.core.HbaseSchemaStatus; import com.navercorp.pinpoint.hbase.schema.core.HbaseSchemaVerifier; +import com.navercorp.pinpoint.hbase.schema.core.command.HbaseSchemaCommandManager; import com.navercorp.pinpoint.hbase.schema.core.command.TableCommand; import com.navercorp.pinpoint.hbase.schema.domain.SchemaChangeLog; -import com.navercorp.pinpoint.hbase.schema.core.command.HbaseSchemaCommandManager; import com.navercorp.pinpoint.hbase.schema.reader.core.ChangeSet; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; -import org.apache.logging.log4j.Logger; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; import org.springframework.util.Assert; import org.springframework.util.CollectionUtils; @@ -48,11 +48,11 @@ public class HbaseSchemaServiceImpl implements HbaseSchemaService { private final SchemaChangeLogService schemaChangeLogService; - private final HbaseSchemaVerifier hbaseSchemaVerifier; + private final HbaseSchemaVerifier hbaseSchemaVerifier; public HbaseSchemaServiceImpl(HbaseAdminOperation hbaseAdminOperation, SchemaChangeLogService schemaChangeLogService, - HbaseSchemaVerifier hbaseSchemaVerifier) { + HbaseSchemaVerifier hbaseSchemaVerifier) { this.hbaseAdminOperation = Objects.requireNonNull(hbaseAdminOperation, "hbaseAdminOperation"); this.schemaChangeLogService = Objects.requireNonNull(schemaChangeLogService, "schemaChangeLogService"); this.hbaseSchemaVerifier = Objects.requireNonNull(hbaseSchemaVerifier, "hbaseSchemaVerifier"); @@ -124,7 +124,7 @@ public boolean update(String namespace, String compression, List chan logger.info("[{}] Hbase schema update started.", namespace); assertInitialization(namespace); - List currentHtds = getCurrentSchema(namespace); + List currentHtds = getCurrentSchema(namespace); List schemaChangeLogs = schemaChangeLogService.getSchemaChangeLogs(namespace); if (CollectionUtils.isEmpty(currentHtds)) { @@ -143,8 +143,8 @@ public boolean update(String namespace, String compression, List chan return updateExistingSchemas(namespace, compression, changeSets, currentHtds, schemaChangeLogs); } - private List getCurrentSchema(String namespace) { - List currentHtds = hbaseAdminOperation.getTableDescriptors(namespace); + private List getCurrentSchema(String namespace) { + List currentHtds = hbaseAdminOperation.getTableDescriptors(namespace); TableName schemaChangeLogTableName = TableName.valueOf(namespace, schemaChangeLogService.getTableName()); return currentHtds.stream() .filter((currentHtd) -> !schemaChangeLogTableName.equals(currentHtd.getTableName())) @@ -158,7 +158,7 @@ private boolean init(String namespace, String compression, List chang return applyChangeSets(commandManager, changeSets, Collections.emptyList()); } - private boolean initFromExistingTables(String namespace, String compression, List changeSets, List currentHtds) { + private boolean initFromExistingTables(String namespace, String compression, List changeSets, List currentHtds) { logger.info("[{}] Initializing hbase schema from existing tables.", namespace); // Replay change sets one by one and compare it against the current hbase schema. @@ -193,7 +193,7 @@ private boolean initFromExistingTables(String namespace, String compression, Lis return applyChangeSets(updateCommandManager, changeSetsToApply, executedLogs); } - private boolean updateExistingSchemas(String namespace, String compression, List changeSets, List currentHtds, List executedLogs) { + private boolean updateExistingSchemas(String namespace, String compression, List changeSets, List currentHtds, List executedLogs) { logger.info("[{}] Updating hbase schema.", namespace); List executedChangeLogIds = executedLogs.stream() @@ -247,7 +247,7 @@ private boolean applyChangeSets(HbaseSchemaCommandManager commandManager, List verifier = new HtdHbaseSchemaVerifier(); + private final HbaseSchemaVerifier verifier = new HtdHbaseSchemaVerifier(); @Test public void emptyExpectedSchemas_shouldReturnTrue() { - List emptyExpectedSchemas = Collections.emptyList(); - List actualSchemas = List.of(createHtd("table1", "table1_1")); + List emptyExpectedSchemas = Collections.emptyList(); + List actualSchemas = List.of(createHtd("table1", "table1_1")); assertThat(verifier.verifySchemas(null, actualSchemas)).isTrue(); assertThat(verifier.verifySchemas(emptyExpectedSchemas, actualSchemas)).isTrue(); } @Test public void emptyActualSchemas_shouldReturnFalse() { - List emptyActualSchemas = Collections.emptyList(); - List expectedSchemas = List.of(createHtd("table1", "table1_1")); + List emptyActualSchemas = Collections.emptyList(); + List expectedSchemas = List.of(createHtd("table1", "table1_1")); assertThat(verifier.verifySchemas(expectedSchemas, null)).isFalse(); assertThat(verifier.verifySchemas(expectedSchemas, emptyActualSchemas)).isFalse(); } @Test public void exactMatch_shouldReturnTrue() { - List expectedSchemas = List.of( + List expectedSchemas = List.of( createHtd("table1", "table1_1"), createHtd("table2", "table2_1", "table2_2", "table2_3"), createHtd("table3")); - List actualSchemas = copySchema(expectedSchemas); + List actualSchemas = copySchema(expectedSchemas); assertThat(verifier.verifySchemas(expectedSchemas, actualSchemas)).isTrue(); } @Test public void excessiveTableNameMatch_shouldReturnTrue() { - List expectedSchemas = List.of( + List expectedSchemas = List.of( createHtd("table1", "table1_1"), createHtd("table2", "table2_1", "table2_2", "table2_3"), createHtd("table3")); - List actualSchemas = copySchema(expectedSchemas); + List actualSchemas = copySchema(expectedSchemas); actualSchemas.add(createHtd("table4", "table4_1")); assertThat(verifier.verifySchemas(expectedSchemas, actualSchemas)).isTrue(); } @Test public void excessiveColumnFamilyMatch_shouldReturnTrue() { - List expectedSchemas = List.of( + List expectedSchemas = List.of( createHtd("table1", "table1_1"), createHtd("table2", "table2_1", "table2_2", "table2_3"), createHtd("table3")); - List actualSchemas = copySchema(expectedSchemas); - for (HTableDescriptor htd : actualSchemas) { - htd.addFamily(new HColumnDescriptor("newCF")); + List actualSchemas = copyToBuilder(expectedSchemas); + for (TableDescriptorBuilder htd : actualSchemas) { + htd.setColumnFamily(ColumnFamilyDescriptorBuilder.of("newCF")); } - assertThat(verifier.verifySchemas(expectedSchemas, actualSchemas)).isTrue(); + assertThat(verifier.verifySchemas(expectedSchemas, build(actualSchemas))).isTrue(); } @Test public void partialTableNameMatch_shouldReturnFalse() { - List actualSchemas = List.of( + List actualSchemas = List.of( createHtd("table1", "table1_1"), createHtd("table2", "table2_1", "table2_2", "table2_3"), createHtd("table3")); - List expectedSchemas = copySchema(actualSchemas); - expectedSchemas.add(createHtd("table4", "table4_1")); - assertThat(verifier.verifySchemas(expectedSchemas, actualSchemas)).isFalse(); + List expectedSchemas = copyToBuilder(actualSchemas); + expectedSchemas.add(TableDescriptorBuilder.newBuilder(createHtd("table4", "table4_1"))); + assertThat(verifier.verifySchemas(build(expectedSchemas), actualSchemas)).isFalse(); } @Test public void partialColumnFamilyMatch_shouldReturnFalse() { - List actualSchemas = List.of( + List actualSchemas = List.of( createHtd("table1", "table1_1"), createHtd("table2", "table2_1", "table2_2", "table2_3"), createHtd("table3")); - List expectedSchemas = copySchema(actualSchemas); - for (HTableDescriptor htd : expectedSchemas) { - htd.addFamily(new HColumnDescriptor("newCF")); + List expectedSchemas = copyToBuilder(actualSchemas); + for (TableDescriptorBuilder htd : expectedSchemas) { + htd.setColumnFamily(ColumnFamilyDescriptorBuilder.of("newCF")); } - assertThat(verifier.verifySchemas(expectedSchemas, actualSchemas)).isFalse(); + assertThat(verifier.verifySchemas(build(expectedSchemas), actualSchemas)).isFalse(); } @Test public void tableNameMismatch_shouldReturnFalse() { - List expectedSchemas = List.of(createHtd("table1", "CF1")); - List actualSchemas = List.of(createHtd("table2", "CF1")); + List expectedSchemas = List.of(createHtd("table1", "CF1")); + List actualSchemas = List.of(createHtd("table2", "CF1")); assertThat(verifier.verifySchemas(expectedSchemas, actualSchemas)).isFalse(); } @Test public void columnFamilyMismatch_shouldReturnFalse() { - List expectedSchemas = List.of(createHtd("table1", "CF1")); - List actualSchemas = List.of(createHtd("table1", "CF2")); + List expectedSchemas = List.of(createHtd("table1", "CF1")); + List actualSchemas = List.of(createHtd("table1", "CF2")); assertThat(verifier.verifySchemas(expectedSchemas, actualSchemas)).isFalse(); } - private HTableDescriptor createHtd(String tableQualifier, String... columnFamilyNames) { + private TableDescriptor createHtd(String tableQualifier, String... columnFamilyNames) { TableName tableName = TableName.valueOf(NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR, tableQualifier); - HTableDescriptor htd = new HTableDescriptor(tableName); + + TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName); for (String columnFamilyName : columnFamilyNames) { - htd.addFamily(new HColumnDescriptor(columnFamilyName)); + builder.setColumnFamily(ColumnFamilyDescriptorBuilder.of(columnFamilyName)); + } + return builder.build(); + } + + private List copySchema(List htds) { + if (CollectionUtils.isEmpty(htds)) { + return Collections.emptyList(); + } + return new ArrayList<>(htds); + } + + private List copyToBuilder(List htds) { + if (CollectionUtils.isEmpty(htds)) { + return Collections.emptyList(); } - return htd; + return htds.stream() + .map(TableDescriptorBuilder::newBuilder) + .collect(Collectors.toList()); } - private List copySchema(List htds) { + private List build(List htds) { if (CollectionUtils.isEmpty(htds)) { return Collections.emptyList(); } - return htds.stream().map(HTableDescriptor::new).collect(Collectors.toList()); + return htds.stream() + .map(TableDescriptorBuilder::build) + .collect(Collectors.toList()); } } diff --git a/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/core/command/HbaseSchemaCommandManagerTest.java b/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/core/command/HbaseSchemaCommandManagerTest.java index c3416de90e8c..03eef98019e8 100644 --- a/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/core/command/HbaseSchemaCommandManagerTest.java +++ b/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/core/command/HbaseSchemaCommandManagerTest.java @@ -27,13 +27,16 @@ import com.navercorp.pinpoint.hbase.schema.reader.core.ModifyTableChange; import com.navercorp.pinpoint.hbase.schema.reader.core.TableChange; import com.navercorp.pinpoint.hbase.schema.reader.core.TableConfiguration; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.mockito.Mockito; +import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; @@ -56,9 +59,9 @@ public void shouldFilterTablesFromDifferentNamespace() { String namespace = "namespace"; String differentNamespace = "differentNamespace"; String tableName = "table1"; - HTableDescriptor sameNamespaceHtd = createHtd(namespace, tableName, "CF1"); - HTableDescriptor differentNamespaceHtd = createHtd(differentNamespace, tableName, "CF1"); - List htds = List.of(sameNamespaceHtd, differentNamespaceHtd); + TableDescriptor sameNamespaceHtd = createHtd(namespace, tableName, "CF1"); + TableDescriptor differentNamespaceHtd = createHtd(differentNamespace, tableName, "CF1"); + List htds = List.of(sameNamespaceHtd, differentNamespaceHtd); HbaseSchemaCommandManager manager = new HbaseSchemaCommandManager(namespace, null, htds); ColumnFamilyChange createColumnFamilyChange = newColumnFamilyChange("CF2"); @@ -66,18 +69,26 @@ public void shouldFilterTablesFromDifferentNamespace() { ChangeSet modifyTableChangeSet = newChangeSet(modifyTableChange); manager.applyChangeSet(modifyTableChangeSet); - List schemaSnapshot = manager.getSchemaSnapshot(); + sameNamespaceHtd = addColumnFamily(sameNamespaceHtd, "CF2"); + differentNamespaceHtd = addColumnFamily(differentNamespaceHtd, "CF2"); + List schemaSnapshot = manager.getSchemaSnapshot(); assertThat(schemaSnapshot) .contains(sameNamespaceHtd) .doesNotContain(differentNamespaceHtd); } + private TableDescriptor addColumnFamily(TableDescriptor tableDesc, String cf) { + TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableDesc); + builder.setColumnFamily(ColumnFamilyDescriptorBuilder.of(cf)); + return builder.build(); + } + @Test public void creatingExistingTableShouldFail() { Assertions.assertThrows(InvalidHbaseSchemaException.class, () -> { String namespace = "namespace"; String tableName = "table"; - HTableDescriptor existingTable = createHtd(namespace, tableName, "CF"); + TableDescriptor existingTable = createHtd(namespace, tableName, "CF"); HbaseSchemaCommandManager manager = new HbaseSchemaCommandManager(namespace, null, List.of(existingTable)); TableChange createTableChange = newTableChange(ChangeType.CREATE, tableName); @@ -93,7 +104,7 @@ public void modifyingNonExistingTableShouldFail() { String namespace = "namespace"; String tableName = "table"; String nonExistingTableName = "anotherTable"; - HTableDescriptor existingTable = createHtd(namespace, tableName, "CF"); + TableDescriptor existingTable = createHtd(namespace, tableName, "CF"); HbaseSchemaCommandManager manager = new HbaseSchemaCommandManager(namespace, null, List.of(existingTable)); TableChange modifyTableChange = newTableChange(ChangeType.MODIFY, nonExistingTableName); @@ -114,7 +125,7 @@ public void failedChangesShouldNotAffectTheSchema() { TableChange createTableChange = newTableChange(ChangeType.CREATE, tableName, columnFamilyChange); ChangeSet createTableChangeSet = newChangeSet(createTableChange); manager.applyChangeSet(createTableChangeSet); - List initialSnapshot = manager.getSchemaSnapshot(); + List initialSnapshot = manager.getSchemaSnapshot(); // modify non-existing table TableChange modifyNonExistingTableChange = newTableChange(ChangeType.MODIFY, "nonExistingTable", newColumnFamilyChange("newCF")); @@ -123,7 +134,7 @@ public void failedChangesShouldNotAffectTheSchema() { manager.applyChangeSet(modifyNonExistingTableChangeSet); fail("Expected an InvalidHbaseSchemaException to be thrown"); } catch (InvalidHbaseSchemaException expected) { - List currentSnapshot = manager.getSchemaSnapshot(); + List currentSnapshot = manager.getSchemaSnapshot(); assertThat(currentSnapshot).isEqualTo(initialSnapshot); } @@ -134,7 +145,7 @@ public void failedChangesShouldNotAffectTheSchema() { manager.applyChangeSet(createExistingTableChangeSet); fail("Expected an InvalidHbaseSchemaException to be thrown"); } catch (InvalidHbaseSchemaException expected) { - List currentSnapshot = manager.getSchemaSnapshot(); + List currentSnapshot = manager.getSchemaSnapshot(); assertThat(currentSnapshot).isEqualTo(initialSnapshot); } @@ -146,7 +157,7 @@ public void failedChangesShouldNotAffectTheSchema() { manager.applyChangeSet(createExistingColumnFamilyChangeSet); fail("Expected an InvalidHbaseSchemaException to be thrown"); } catch (InvalidHbaseSchemaException expected) { - List currentSnapshot = manager.getSchemaSnapshot(); + List currentSnapshot = manager.getSchemaSnapshot(); assertThat(currentSnapshot).isEqualTo(initialSnapshot); } } @@ -159,8 +170,8 @@ public void modifyingTheSameTableMultipleTimesShouldBeMerged() { String newColumnFamily1 = "CF1"; String newColumnFamily2 = "CF2"; - HTableDescriptor existingHtd = createHtd(namespace, tableName, existingColumnFamily); - HbaseSchemaCommandManager manager = new HbaseSchemaCommandManager(namespace, null, List.of(new HTableDescriptor(existingHtd))); + TableDescriptor existingHtd = createHtd(namespace, tableName, existingColumnFamily); + HbaseSchemaCommandManager manager = new HbaseSchemaCommandManager(namespace, null, List.of(TableDescriptorBuilder.newBuilder(existingHtd).build())); ChangeSet createColumnFamilyChangeSet1 = newChangeSet(newTableChange(ChangeType.MODIFY, tableName, newColumnFamilyChange(newColumnFamily1))); ChangeSet createColumnFamilyChangeSet2 = newChangeSet(newTableChange(ChangeType.MODIFY, tableName, newColumnFamilyChange(newColumnFamily2))); @@ -168,23 +179,23 @@ public void modifyingTheSameTableMultipleTimesShouldBeMerged() { manager.applyChangeSet(createColumnFamilyChangeSet2); // verify schema snapshot - List schemaSnapshot = manager.getSchemaSnapshot(); + List schemaSnapshot = manager.getSchemaSnapshot(); assertThat(schemaSnapshot).hasSize(1); - HTableDescriptor snapshotTable = schemaSnapshot.get(0); + TableDescriptor snapshotTable = schemaSnapshot.get(0); assertThat(snapshotTable.getTableName()).isEqualTo(TableName.valueOf(namespace, tableName)); - List snapshotColumnFamilies = snapshotTable.getFamilies().stream().map(HColumnDescriptor::getNameAsString).collect(Collectors.toList()); + List snapshotColumnFamilies = Arrays.stream(snapshotTable.getColumnFamilies()).map(ColumnFamilyDescriptor::getNameAsString).collect(Collectors.toList()); assertThat(snapshotColumnFamilies).contains(existingColumnFamily, newColumnFamily1, newColumnFamily2); // verify command - should add 2 column families HbaseAdminOperation mockHbaseAdminOperation = Mockito.mock(HbaseAdminOperation.class); when(mockHbaseAdminOperation.getTableDescriptor(existingHtd.getTableName())).thenReturn(existingHtd); - doNothing().when(mockHbaseAdminOperation).addColumn(any(TableName.class), any(HColumnDescriptor.class)); - doNothing().when(mockHbaseAdminOperation).createTable(any(HTableDescriptor.class)); + doNothing().when(mockHbaseAdminOperation).addColumn(any(TableName.class), any(ColumnFamilyDescriptor.class)); + doNothing().when(mockHbaseAdminOperation).createTable(any(TableDescriptor.class)); for (TableCommand tableCommand : manager.getCommands()) { tableCommand.execute(mockHbaseAdminOperation); } - verify(mockHbaseAdminOperation, times(2)).addColumn(any(TableName.class), any(HColumnDescriptor.class)); - verify(mockHbaseAdminOperation, never()).createTable(any(HTableDescriptor.class)); + verify(mockHbaseAdminOperation, times(2)).addColumn(any(TableName.class), any(ColumnFamilyDescriptor.class)); + verify(mockHbaseAdminOperation, never()).createTable(any(TableDescriptor.class)); } @Test @@ -206,21 +217,21 @@ public void creatingAndModifyingTheSameTableShouldBeMerged() { manager.applyChangeSet(addColumnFamilyChangeSet2); // verify schema snapshot - List schemaSnapshot = manager.getSchemaSnapshot(); + List schemaSnapshot = manager.getSchemaSnapshot(); assertThat(schemaSnapshot).hasSize(1); - HTableDescriptor snapshotTable = schemaSnapshot.get(0); + TableDescriptor snapshotTable = schemaSnapshot.get(0); assertThat(snapshotTable.getTableName()).isEqualTo(TableName.valueOf(namespace, tableName)); - List snapshotColumnFamilies = snapshotTable.getFamilies().stream().map(HColumnDescriptor::getNameAsString).collect(Collectors.toList()); + List snapshotColumnFamilies = Arrays.stream(snapshotTable.getColumnFamilies()).map(ColumnFamilyDescriptor::getNameAsString).collect(Collectors.toList()); assertThat(snapshotColumnFamilies).contains(columnFamily1, columnFamily2, columnFamily3); // verify command - should create 1 table (with all 3 column families) HbaseAdminOperation mockHbaseAdminOperation = Mockito.mock(HbaseAdminOperation.class); when(mockHbaseAdminOperation.tableExists(TableName.valueOf(namespace, tableName))).thenReturn(false); - doNothing().when(mockHbaseAdminOperation).createTable(any(HTableDescriptor.class)); + doNothing().when(mockHbaseAdminOperation).createTable(any(TableDescriptor.class)); for (TableCommand tableCommand : manager.getCommands()) { tableCommand.execute(mockHbaseAdminOperation); } - verify(mockHbaseAdminOperation).createTable(any(HTableDescriptor.class)); + verify(mockHbaseAdminOperation).createTable(any(TableDescriptor.class)); } private ColumnFamilyChange newColumnFamilyChange(String cfName) { @@ -243,12 +254,14 @@ private ChangeSet newChangeSet(TableChange... tableChanges) { return new ChangeSet("id", "value", List.of(tableChanges)); } - private HTableDescriptor createHtd(String namespace, String tableQualifier, String... columnFamilyNames) { + private TableDescriptor createHtd(String namespace, String tableQualifier, String... columnFamilyNames) { TableName tableName = TableName.valueOf(namespace, tableQualifier); - HTableDescriptor htd = new HTableDescriptor(tableName); + TableDescriptorBuilder builder = TableDescriptorBuilder.newBuilder(tableName); + for (String columnFamilyName : columnFamilyNames) { - htd.addFamily(new HColumnDescriptor(columnFamilyName)); + builder.setColumnFamily(ColumnFamilyDescriptorBuilder.of(columnFamilyName)); } - return htd; + + return builder.build(); } } diff --git a/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImplTest.java b/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImplTest.java index e6aaaddab2d4..3420aeb25d00 100644 --- a/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImplTest.java +++ b/hbase/hbase-schema/src/test/java/com/navercorp/pinpoint/hbase/schema/service/HbaseSchemaServiceImplTest.java @@ -23,7 +23,7 @@ import com.navercorp.pinpoint.hbase.schema.domain.SchemaChangeLog; import com.navercorp.pinpoint.hbase.schema.reader.core.ChangeSet; import com.navercorp.pinpoint.hbase.schema.reader.core.TableChange; -import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -53,7 +53,7 @@ public class HbaseSchemaServiceImplTest { private SchemaChangeLogService schemaChangeLogService; @Mock - private HbaseSchemaVerifier hbaseSchemaVerifier; + private HbaseSchemaVerifier hbaseSchemaVerifier; private HbaseSchemaService hbaseSchemaService;