@Test
public void testDeleteTable() throws Exception {
String namespace = prefix + "_dummy";
NamespaceDescriptor nspDesc =
NamespaceDescriptor.create(namespace)
.addConfiguration(TableNamespaceManager.KEY_MAX_REGIONS, "100")
.addConfiguration(TableNamespaceManager.KEY_MAX_TABLES, "3")
.build();
ADMIN.createNamespace(nspDesc);
assertNotNull("Namespace descriptor found null.", ADMIN.getNamespaceDescriptor(namespace));
NamespaceTableAndRegionInfo stateInfo = getNamespaceState(nspDesc.getName());
assertNotNull("Namespace state found null for " + namespace, stateInfo);
HTableDescriptor tableDescOne =
new HTableDescriptor(TableName.valueOf(namespace + TableName.NAMESPACE_DELIM + "table1"));
HTableDescriptor tableDescTwo =
new HTableDescriptor(TableName.valueOf(namespace + TableName.NAMESPACE_DELIM + "table2"));
ADMIN.createTable(tableDescOne);
ADMIN.createTable(tableDescTwo, Bytes.toBytes("AAA"), Bytes.toBytes("ZZZ"), 5);
stateInfo = getNamespaceState(nspDesc.getName());
assertNotNull("Namespace state found to be null.", stateInfo);
assertEquals(2, stateInfo.getTables().size());
assertEquals(5, stateInfo.getRegionCountOfTable(tableDescTwo.getTableName()));
assertEquals(6, stateInfo.getRegionCount());
ADMIN.disableTable(tableDescOne.getTableName());
deleteTable(tableDescOne.getTableName());
stateInfo = getNamespaceState(nspDesc.getName());
assertNotNull("Namespace state found to be null.", stateInfo);
assertEquals(5, stateInfo.getRegionCount());
assertEquals(1, stateInfo.getTables().size());
ADMIN.disableTable(tableDescTwo.getTableName());
deleteTable(tableDescTwo.getTableName());
ADMIN.deleteNamespace(namespace);
stateInfo = getNamespaceState(namespace);
assertNull("Namespace state not found to be null.", stateInfo);
}
private void ensureColumnFamilyExists(String tableName, String columnFamily)
throws StorageException {
HBaseAdmin adm = getAdminInterface();
HTableDescriptor desc = ensureTableExists(tableName);
Preconditions.checkNotNull(desc);
HColumnDescriptor cf = desc.getFamily(columnFamily.getBytes());
// Create our column family, if necessary
if (cf == null) {
try {
adm.disableTable(tableName);
desc.addFamily(
new HColumnDescriptor(columnFamily).setCompressionType(Compression.Algorithm.GZ));
adm.modifyTable(tableName.getBytes(), desc);
try {
logger.debug(
"Added HBase ColumnFamily {}, waiting for 1 sec. to propogate.", columnFamily);
Thread.sleep(1000L);
} catch (InterruptedException ie) {
throw new TemporaryStorageException(ie);
}
adm.enableTable(tableName);
} catch (TableNotFoundException ee) {
logger.error("TableNotFoundException", ee);
throw new PermanentStorageException(ee);
} catch (org.apache.hadoop.hbase.TableExistsException ee) {
logger.debug("Swallowing exception {}", ee);
} catch (IOException ee) {
throw new TemporaryStorageException(ee);
}
} else { // check if compression was enabled, if not - enable it
if (cf.getCompressionType() == null
|| cf.getCompressionType() == Compression.Algorithm.NONE) {
try {
adm.disableTable(tableName);
adm.modifyColumn(tableName, cf.setCompressionType(Compression.Algorithm.GZ));
adm.enableTable(tableName);
} catch (IOException e) {
throw new TemporaryStorageException(e);
}
}
}
}
/** alter用于修改表明。需要新旧两个表明作为参数。 */
@Override
public Builder alter() {
if (type == 2) {
// 修改表名。snapshot
final String snapshotName = "snapShotName";
try {
if (!hBaseAdmin.tableExists(tableName)
|| tableName == null
|| tableName.trim().equals("")) {
Log.error("=== LiMingji Debug Info === TableName is invalid");
return this;
}
if (newTableName == null || newTableName.trim().equals("")) {
Log.error("=== LiMingji error Info === newTableName is invalid");
return this;
}
if (!hBaseAdmin.isTableDisabled(tableName)) hBaseAdmin.disableTable(tableName);
// 删除可能存在的snapShotName
try {
hBaseAdmin.deleteSnapshot(snapshotName);
} catch (IOException e) {
// Do nothing.
}
hBaseAdmin.snapshot(snapshotName, tableName);
hBaseAdmin.cloneSnapshot(snapshotName, newTableName);
hBaseAdmin.deleteSnapshot(snapshotName);
hBaseAdmin.deleteTable(tableName);
} catch (InterruptedException e) {
Log.info("=== LiMingji error Info === alter@DTL interrupt");
} catch (IOException e) {
Log.error("=== LiMingji error Info === alter@DTL IOException");
}
}
return this;
}
/**
* Drops table in HBase when it exists.
*
* @param conf
* @throws IOException
*/
public void dropTable() throws IOException {
if (exists()) {
HBaseAdmin admin = new HBaseAdmin(getConfiguration());
admin.disableTable(getStringName());
admin.deleteTable(getStringName());
}
}
/**
* @param rawAttributeName is the attribute name viewed by applications, it allows multiple
* values. For example, secondaryIndex in secondaryIndex$1 and coprocessor in corpcessor$2
* @param indexOfAttribute is of the same raw attribute name, for example 2 in secondary$2
*/
static void updateTableAttribute(
Configuration conf,
byte[] tableName,
String rawAttributeName,
int indexOfAttribute,
boolean ifUpdateorRemove,
String value)
throws IOException {
HBaseAdmin admin = new HBaseAdmin(conf);
HTableDescriptor desc = admin.getTableDescriptor(tableName);
admin.disableTable(tableName);
// System.out.println("TTDEBUG: disable table " + Bytes.toString(tableName));
String coprocessorKey = rawAttributeName + indexOfAttribute;
if (!ifUpdateorRemove) {
desc.remove(Bytes.toBytes(coprocessorKey));
} else {
desc.setValue(coprocessorKey, value);
}
admin.modifyTable(tableName, desc);
// System.out.println("TTDEBUG: modify table " + Bytes.toString(tableName));
admin.enableTable(tableName);
// System.out.println("TTDEBUG: enable table " + Bytes.toString(tableName));
HTableDescriptor descNew = admin.getTableDescriptor(tableName);
// modify table is asynchronous, has to loop over to check
while (!desc.equals(descNew)) {
System.err.println(
"TTDEBUG: waiting for descriptor to change: from " + descNew + " to " + desc);
try {
Thread.sleep(500);
} catch (InterruptedException ex) {
}
descNew = admin.getTableDescriptor(tableName);
}
}
/**
* 删除指定表名
*
* @param rowKey
*/
public void deleteTable(byte[] rowKey) {
Connection conn = null;
HBaseAdmin admin = null;
try {
conn = ConnectionFactory.createConnection(conf);
admin = (HBaseAdmin) conn.getAdmin();
// 在删除一张表前，要使其失效
admin.disableTable(rowKey);
admin.deleteTable(rowKey);
admin.enableTable(rowKey);
} catch (Exception e) {
logger.error("HBaseAdmin deleteTable exception, errMsg:{}", e.getMessage());
} finally {
try {
if (null != admin) {
admin.close();
}
} catch (IOException e) {
logger.error("HBaseAdmin close exception, errMsg:{}", e.getMessage());
}
try {
if (null != conn) {
conn.close();
}
} catch (Exception e) {
logger.error("Connection close exception, errMsg:{}", e.getMessage());
}
}
}
public void fixInconsistent() throws IOException {
if (ifFix == true) {
for (String segFullName : inconsistentHTables) {
String[] sepNameList = segFullName.split(",");
HTableDescriptor desc = hbaseAdmin.getTableDescriptor(TableName.valueOf(sepNameList[0]));
logger.info(
"Change the host of htable "
+ sepNameList[0]
+ "belonging to cube "
+ sepNameList[1]
+ " from "
+ desc.getValue(IRealizationConstants.HTableTag)
+ " to "
+ dstCfg.getMetadataUrlPrefix());
hbaseAdmin.disableTable(sepNameList[0]);
desc.setValue(IRealizationConstants.HTableTag, dstCfg.getMetadataUrlPrefix());
hbaseAdmin.modifyTable(sepNameList[0], desc);
hbaseAdmin.enableTable(sepNameList[0]);
}
} else {
logger.info("------ Inconsistent HTables Needed To Be Fixed ------");
for (String hTable : inconsistentHTables) {
String[] sepNameList = hTable.split(",");
logger.info(sepNameList[0] + " belonging to cube " + sepNameList[1]);
}
logger.info("----------------------------------------------------");
}
}
/**
* @param table
* @return
*/
public boolean createTable(JSONObject table) {
try {
String table_name = "";
if (!table.has(XHBaseConstant.TABLE_DESC_NAME)) return false;
table_name = (String) table.get(XHBaseConstant.TABLE_DESC_NAME);
if (table_name.isEmpty()) return false;
if (admin.tableExists(table_name)) {
admin.disableTable(table_name);
admin.deleteTable(table_name);
}
HTableDescriptor td = this.createTableDescription(table);
this.admin.createTable(td);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
@Test(timeout = 180000)
public void testRestoreSnapshot() throws Exception {
String nsp = prefix + "_testRestoreSnapshot";
NamespaceDescriptor nspDesc =
NamespaceDescriptor.create(nsp)
.addConfiguration(TableNamespaceManager.KEY_MAX_REGIONS, "10")
.build();
ADMIN.createNamespace(nspDesc);
assertNotNull("Namespace descriptor found null.", ADMIN.getNamespaceDescriptor(nsp));
TableName tableName1 = TableName.valueOf(nsp + TableName.NAMESPACE_DELIM + "table1");
HTableDescriptor tableDescOne = new HTableDescriptor(tableName1);
ADMIN.createTable(tableDescOne, Bytes.toBytes("AAA"), Bytes.toBytes("ZZZ"), 4);
NamespaceTableAndRegionInfo nstate = getNamespaceState(nsp);
assertEquals("Intial region count should be 4.", 4, nstate.getRegionCount());
String snapshot = "snapshot_testRestoreSnapshot";
ADMIN.snapshot(snapshot, tableName1);
List<HRegionInfo> regions = ADMIN.getTableRegions(tableName1);
Collections.sort(regions);
ADMIN.split(tableName1, Bytes.toBytes("JJJ"));
Thread.sleep(2000);
assertEquals("Total regions count should be 5.", 5, nstate.getRegionCount());
ADMIN.disableTable(tableName1);
ADMIN.restoreSnapshot(snapshot);
assertEquals("Total regions count should be 4 after restore.", 4, nstate.getRegionCount());
ADMIN.enableTable(tableName1);
ADMIN.deleteSnapshot(snapshot);
}
/** Apply column family options such as Bloom filters, compression, and data block encoding. */
protected void applyColumnFamilyOptions(byte[] tableName, byte[][] columnFamilies)
throws IOException {
HBaseAdmin admin = new HBaseAdmin(conf);
HTableDescriptor tableDesc = admin.getTableDescriptor(tableName);
LOG.info("Disabling table " + Bytes.toString(tableName));
admin.disableTable(tableName);
for (byte[] cf : columnFamilies) {
HColumnDescriptor columnDesc = tableDesc.getFamily(cf);
boolean isNewCf = columnDesc == null;
if (isNewCf) {
columnDesc = new HColumnDescriptor(cf);
}
if (bloomType != null) {
columnDesc.setBloomFilterType(bloomType);
}
if (compressAlgo != null) {
columnDesc.setCompressionType(compressAlgo);
}
if (dataBlockEncodingAlgo != null) {
columnDesc.setDataBlockEncoding(dataBlockEncodingAlgo);
columnDesc.setEncodeOnDisk(!encodeInCacheOnly);
}
if (inMemoryCF) {
columnDesc.setInMemory(inMemoryCF);
}
if (isNewCf) {
admin.addColumn(tableName, columnDesc);
} else {
admin.modifyColumn(tableName, columnDesc);
}
}
LOG.info("Enabling table " + Bytes.toString(tableName));
admin.enableTable(tableName);
}
public static synchronized void dropTableIfExists() throws Exception {
HBaseAdmin admin = HBaseUtils.getHBaseAdmin();
if (admin.tableExists(TABLE_NAME)) {
admin.disableTable(TABLE_NAME);
admin.deleteTable(TABLE_NAME);
}
}
/*
* 删除表
*
* @tableName 表名
*/
public static void deleteTable(String tableName) throws IOException {
@SuppressWarnings("resource")
HBaseAdmin admin = new HBaseAdmin(conf);
admin.disableTable(tableName);
admin.deleteTable(tableName);
System.out.println(tableName + "is deleted!");
}
protected void dropTable(String tableName) throws IOException {
if (admin.tableExists(tableName)) {
try {
admin.disableTable(tableName);
} catch (TableNotEnabledException ignored) {
}
admin.deleteTable(tableName);
}
}
/**
* delete table in preparation for next test
*
* @param tablename
* @throws IOException
*/
void deleteTable(HBaseAdmin admin, String tablename) throws IOException {
try {
byte[] tbytes = Bytes.toBytes(tablename);
admin.disableTable(tbytes);
admin.deleteTable(tbytes);
} catch (Exception e) {
// Do nothing.
}
}
public static void main(String... args)
throws IOException, ClassNotFoundException, InterruptedException {
UserGroupInformation.loginUserFromKeytab("web_dp", "web_dp.keytab");
Configuration conf = HBaseConfiguration.create();
HBaseAdmin admin = new HBaseAdmin(conf);
if (admin.tableExists(QueryDataListener.TN_BYTES_DOMAIN)) {
admin.disableTable(QueryDataListener.TN_BYTES_DOMAIN);
admin.deleteTable(QueryDataListener.TN_BYTES_DOMAIN);
}
if (admin.tableExists(QueryDataListener.TN_BYTES_URL)) {
admin.disableTable(QueryDataListener.TN_BYTES_URL);
admin.deleteTable(QueryDataListener.TN_BYTES_URL);
}
if (admin.tableExists(QueryDataListener.TN_BYTES_QUERY)) {
admin.disableTable(QueryDataListener.TN_BYTES_QUERY);
admin.deleteTable(QueryDataListener.TN_BYTES_QUERY);
}
}
/**
* 删除表
*
* @param tableName 表名
*/
public void deleteTable(String tableName) {
try {
HBaseAdmin admin = new HBaseAdmin(conf);
admin.disableTable(tableName);
admin.deleteTable(tableName);
} catch (Exception e) {
logger.error("deleteTable failed", e);
}
}
/*
* Create a table and make sure that the table creation fails after adding this table entry into
* namespace quota cache. Now correct the failure and recreate the table with same name.
* HBASE-13394
*/
@Test(timeout = 180000)
public void testRecreateTableWithSameNameAfterFirstTimeFailure() throws Exception {
String nsp1 = prefix + "_testRecreateTable";
NamespaceDescriptor nspDesc =
NamespaceDescriptor.create(nsp1)
.addConfiguration(TableNamespaceManager.KEY_MAX_REGIONS, "20")
.addConfiguration(TableNamespaceManager.KEY_MAX_TABLES, "1")
.build();
ADMIN.createNamespace(nspDesc);
final TableName tableOne = TableName.valueOf(nsp1 + TableName.NAMESPACE_DELIM + "table1");
byte[] columnFamily = Bytes.toBytes("info");
HTableDescriptor tableDescOne = new HTableDescriptor(tableOne);
tableDescOne.addFamily(new HColumnDescriptor(columnFamily));
MasterSyncObserver.throwExceptionInPreCreateTableHandler = true;
try {
try {
ADMIN.createTable(tableDescOne);
fail("Table " + tableOne.toString() + "creation should fail.");
} catch (Exception exp) {
LOG.error(exp);
}
assertFalse(ADMIN.tableExists(tableOne));
NamespaceTableAndRegionInfo nstate = getNamespaceState(nsp1);
assertEquals(
"First table creation failed in namespace so number of tables in namespace "
+ "should be 0.",
0,
nstate.getTables().size());
MasterSyncObserver.throwExceptionInPreCreateTableHandler = false;
try {
ADMIN.createTable(tableDescOne);
} catch (Exception e) {
fail("Table " + tableOne.toString() + "creation should succeed.");
LOG.error(e);
}
assertTrue(ADMIN.tableExists(tableOne));
nstate = getNamespaceState(nsp1);
assertEquals(
"First table was created successfully so table size in namespace should " + "be one now.",
1,
nstate.getTables().size());
} finally {
MasterSyncObserver.throwExceptionInPreCreateTableHandler = false;
if (ADMIN.tableExists(tableOne)) {
ADMIN.disableTable(tableOne);
deleteTable(tableOne);
}
ADMIN.deleteNamespace(nsp1);
}
}
private static void deleteTables() {
if (admin != null) {
for (TableName tableName : createdTables) {
try {
if (admin.tableExists(tableName)) {
admin.disableTable(tableName);
admin.deleteTable(tableName);
}
} catch (IOException e) {
assertNull("Exception found deleting the table", e);
}
}
}
}
@Test
public void testTableExists() throws IOException {
final String name = "testTableExists";
final byte[] nameBytes = Bytes.toBytes(name);
assertFalse(MetaReader.tableExists(ct, name));
UTIL.createTable(nameBytes, HConstants.CATALOG_FAMILY);
assertTrue(MetaReader.tableExists(ct, name));
HBaseAdmin admin = UTIL.getHBaseAdmin();
admin.disableTable(name);
admin.deleteTable(name);
assertFalse(MetaReader.tableExists(ct, name));
assertTrue(MetaReader.tableExists(ct, Bytes.toString(HConstants.META_TABLE_NAME)));
assertTrue(MetaReader.tableExists(ct, Bytes.toString(HConstants.ROOT_TABLE_NAME)));
}
@BeforeClass
public static void doBeforeTestSetup() throws Exception {
HBaseAdmin admin = driver.getConnectionQueryServices(getUrl(), TEST_PROPERTIES).getAdmin();
try {
try {
admin.disableTable(HBASE_DYNAMIC_COLUMNS_BYTES);
admin.deleteTable(HBASE_DYNAMIC_COLUMNS_BYTES);
} catch (org.apache.hadoop.hbase.TableNotFoundException e) {
}
ensureTableCreated(getUrl(), HBASE_DYNAMIC_COLUMNS);
initTableValues();
} finally {
admin.close();
}
}
@After
public void cleanup() throws Exception, KeeperException {
for (HTableDescriptor table : ADMIN.listTables()) {
ADMIN.disableTable(table.getTableName());
deleteTable(table.getTableName());
}
for (NamespaceDescriptor ns : ADMIN.listNamespaceDescriptors()) {
if (ns.getName().startsWith(prefix)) {
ADMIN.deleteNamespace(ns.getName());
}
}
assertTrue(
"Quota manager not enabled",
UTIL.getHBaseCluster().getMaster().getMasterQuotaManager().isQuotaEnabled());
}
private static void clearHBase(Configuration conf) throws IOException {
HBaseAdmin admin = new HBaseAdmin(conf);
if (admin.tableExists(table_bytes)) {
try {
admin.disableTable(table_bytes);
} catch (Exception ex) {
}
try {
admin.deleteTable(table_bytes);
} catch (Exception ex) {
}
}
HTableDescriptor tdesc = new HTableDescriptor(table_bytes);
HColumnDescriptor cdesc = new HColumnDescriptor(colfam0_bytes);
tdesc.addFamily(cdesc);
admin.createTable(tdesc);
}
// 创建一张表，通过HBaseAdmin HTableDescriptor来创建
public static void creat(String tablename, String columnFamily) throws Exception {
HBaseAdmin admin = new HBaseAdmin(configuration);
if (admin.tableExists(tablename)) {
try {
admin.disableTable(tablename);
admin.deleteTable(tablename);
} catch (Exception ex) {
ex.printStackTrace();
}
}
HTableDescriptor tableDesc = new HTableDescriptor(tablename.valueOf(tablename));
tableDesc.addFamily(new HColumnDescriptor(columnFamily));
admin.createTable(tableDesc);
admin.close();
System.out.println("create table success!");
}
@Before
public void before() throws IOException {
HBaseAdmin admin = new HBaseAdmin(configuration);
boolean exists = admin.tableExists(TABLE_NAME);
if (exists) {
admin.disableTable(TABLE_NAME);
admin.deleteTable(TABLE_NAME);
}
// tworzenie tabeli HBase
HTableDescriptor table = new HTableDescriptor(TABLE_NAME);
table.addFamily(new HColumnDescriptor(FAMILY_NAME));
table.addFamily(new HColumnDescriptor(LoadMovieData.FAMILY_NAME));
table.addFamily(new HColumnDescriptor(LoadMovieRatingData.FAMILY_NAME));
admin.createTable(table);
}
/**
* Uses SchemaTool to register the required schemas and create the required tables.
*
* @param conf The HBaseConfiguration.
* @param schemaManager The schema manager SchemaTool needs to create the schemas.
*/
private void registerSchemas(Configuration conf, SchemaManager schemaManager) {
HBaseAdmin admin;
try {
// Construct an HBaseAdmin object (required by schema tool), and delete it
// if it exists so we start fresh.
admin = new HBaseAdmin(conf);
if (admin.tableExists("cdk_example_user_profiles")) {
admin.disableTable("cdk_example_user_profiles");
admin.deleteTable("cdk_example_user_profiles");
}
} catch (IOException e) {
throw new RuntimeException(e);
}
// Use the SchemaTool to create the schemas that are in the example-models
// directory, and create the table and column families required by those
// schemas.
SchemaTool tool = new SchemaTool(admin, schemaManager);
tool.createOrMigrateSchemaDirectory("classpath:example-models", true);
}
public static void deleteTableTest(String tableStr) {
try {
Configuration conf = HBaseConfiguration.create();
byte[] tableName = Bytes.toBytes(tableStr);
if (conf == null) {
throw new IOException("conf not set.");
} else {
HBaseAdmin admin = new HBaseAdmin(conf);
if (admin.tableExists(tableName)) {
admin.disableTable(tableName); // 关闭一个表
admin.deleteTable(tableName); // 删除一个表
} else {
throw new IOException("no such table.");
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
@BeforeClass
public static void doBeforeTestSetup() throws Exception {
HBaseAdmin admin = driver.getConnectionQueryServices(getUrl(), TEST_PROPERTIES).getAdmin();
try {
try {
admin.disableTable(HBASE_NATIVE_BYTES);
admin.deleteTable(HBASE_NATIVE_BYTES);
} catch (org.apache.hadoop.hbase.TableNotFoundException e) {
}
HTableDescriptor descriptor = new HTableDescriptor(HBASE_NATIVE_BYTES);
HColumnDescriptor columnDescriptor = new HColumnDescriptor(FAMILY_NAME);
columnDescriptor.setKeepDeletedCells(true);
descriptor.addFamily(columnDescriptor);
admin.createTable(descriptor, SPLITS);
initTableValues();
} finally {
admin.close();
}
}
@Override
public void setConfigurationProperty(final String key, final String value)
throws StorageException {
byte[] name = tableName.getBytes();
HTableDescriptor desc = ensureTableExists(tableName);
try {
HBaseAdmin adm = getAdminInterface();
adm.disableTable(tableName);
desc.setValue(key, value);
adm.modifyTable(name, desc);
adm.enableTable(tableName);
} catch (IOException e) {
throw new PermanentStorageException(e);
}
}
public HTable createTable(String tableName, String[] metrics, int[] max_version)
throws IOException {
System.out.println("create table for " + tableName);
try {
if (admin.tableExists(tableName)) {
System.out.println(admin.listTables());
admin.disableTable(tableName);
admin.deleteTable(tableName);
}
HTableDescriptor td = this.createTableDescription(tableName, metrics, max_version);
System.out.println(tableName + ": <=>table descirption : " + td.toString());
this.admin.createTable(td);
// this.admin.createTable(td, ("0-").getBytes(), ("2-"+Long.MAX_VALUE).getBytes(),80);
} catch (Exception e) {
e.printStackTrace();
// log.info(e.fillInStackTrace());
}
return new HTable(conf, tableName);
}
@Test(timeout = 180000)
public void testRestoreSnapshotQuotaExceed() throws Exception {
String nsp = prefix + "_testRestoreSnapshotQuotaExceed";
NamespaceDescriptor nspDesc =
NamespaceDescriptor.create(nsp)
.addConfiguration(TableNamespaceManager.KEY_MAX_REGIONS, "10")
.build();
ADMIN.createNamespace(nspDesc);
NamespaceDescriptor ndesc = ADMIN.getNamespaceDescriptor(nsp);
assertNotNull("Namespace descriptor found null.", ndesc);
TableName tableName1 = TableName.valueOf(nsp + TableName.NAMESPACE_DELIM + "table1");
HTableDescriptor tableDescOne = new HTableDescriptor(tableName1);
ADMIN.createTable(tableDescOne, Bytes.toBytes("AAA"), Bytes.toBytes("ZZZ"), 4);
NamespaceTableAndRegionInfo nstate = getNamespaceState(nsp);
assertEquals("Intial region count should be 4.", 4, nstate.getRegionCount());
String snapshot = "snapshot_testRestoreSnapshotQuotaExceed";
ADMIN.snapshot(snapshot, tableName1);
List<HRegionInfo> regions = ADMIN.getTableRegions(tableName1);
Collections.sort(regions);
ADMIN.split(tableName1, Bytes.toBytes("JJJ"));
Thread.sleep(2000);
assertEquals("Total regions count should be 5.", 5, nstate.getRegionCount());
ndesc.setConfiguration(TableNamespaceManager.KEY_MAX_REGIONS, "2");
ADMIN.modifyNamespace(ndesc);
ADMIN.disableTable(tableName1);
try {
ADMIN.restoreSnapshot(snapshot);
fail(
"Region quota is exceeded so QuotaExceededException should be thrown but HBaseAdmin"
+ " wraps IOException into RestoreSnapshotException");
} catch (RestoreSnapshotException ignore) {
}
ADMIN.enableTable(tableName1);
ADMIN.deleteSnapshot(snapshot);
}