@Override
void perform() throws IOException {
HTableDescriptor selected = selectTable(disabledTables);
if (selected == null) {
return;
}
Admin admin = connection.getAdmin();
try {
HColumnDescriptor cfd = createFamilyDesc();
if (selected.hasFamily(cfd.getName())) {
LOG.info(
new String(cfd.getName()) + " already exists in table " + selected.getTableName());
return;
}
TableName tableName = selected.getTableName();
LOG.info("Adding column family: " + cfd + " to table: " + tableName);
admin.addColumn(tableName, cfd);
// assertion
HTableDescriptor freshTableDesc = admin.getTableDescriptor(tableName);
Assert.assertTrue(
"Column family: " + cfd + " was not added", freshTableDesc.hasFamily(cfd.getName()));
LOG.info("Added column family: " + cfd + " to table: " + tableName);
disabledTables.put(tableName, freshTableDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyTables();
}
@Override
void perform() throws IOException {
HTableDescriptor selected = selectTable(disabledTables);
HColumnDescriptor cfd = selectFamily(selected);
if (selected == null || cfd == null) {
return;
}
Admin admin = connection.getAdmin();
try {
if (selected.getColumnFamilies().length < 2) {
LOG.info("No enough column families to delete in table " + selected.getTableName());
return;
}
TableName tableName = selected.getTableName();
LOG.info("Deleting column family: " + cfd + " from table: " + tableName);
admin.deleteColumnFamily(tableName, cfd.getName());
// assertion
HTableDescriptor freshTableDesc = admin.getTableDescriptor(tableName);
Assert.assertFalse(
"Column family: " + cfd + " was not added", freshTableDesc.hasFamily(cfd.getName()));
LOG.info("Deleted column family: " + cfd + " from table: " + tableName);
disabledTables.put(tableName, freshTableDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyTables();
}
@Override
void perform() throws IOException {
Admin admin = connection.getAdmin();
try {
HTableDescriptor htd = createTableDesc();
TableName tableName = htd.getTableName();
if (admin.tableExists(tableName)) {
return;
}
String numRegionKey = String.format(NUM_REGIONS_KEY, this.getClass().getSimpleName());
numRegions = getConf().getInt(numRegionKey, DEFAULT_NUM_REGIONS);
byte[] startKey = Bytes.toBytes("row-0000000000");
byte[] endKey = Bytes.toBytes("row-" + Integer.MAX_VALUE);
LOG.info("Creating table:" + htd);
admin.createTable(htd, startKey, endKey, numRegions);
Assert.assertTrue("Table: " + htd + " was not created", admin.tableExists(tableName));
HTableDescriptor freshTableDesc = admin.getTableDescriptor(tableName);
enabledTables.put(tableName, freshTableDesc);
LOG.info("Created table:" + freshTableDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyTables();
}
@Override
void perform() throws IOException {
NamespaceDescriptor selected = selectNamespace(namespaceMap);
if (selected == null) {
return;
}
Admin admin = connection.getAdmin();
try {
String namespaceName = selected.getName();
LOG.info("Deleting namespace :" + selected);
admin.deleteNamespace(namespaceName);
try {
if (admin.getNamespaceDescriptor(namespaceName) != null) {
// the namespace still exists.
Assert.assertTrue("Namespace: " + selected + " was not deleted", false);
} else {
LOG.info("Deleted namespace :" + selected);
}
} catch (NamespaceNotFoundException nsnfe) {
// This is expected result
LOG.info("Deleted namespace :" + selected);
}
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyNamespaces();
}
@Override
void perform() throws IOException {
NamespaceDescriptor selected = selectNamespace(namespaceMap);
if (selected == null) {
return;
}
Admin admin = connection.getAdmin();
try {
String namespaceName = selected.getName();
LOG.info("Modifying namespace :" + selected);
NamespaceDescriptor modifiedNsd = NamespaceDescriptor.create(namespaceName).build();
String nsValueNew;
do {
nsValueNew = String.format("%010d", RandomUtils.nextInt(Integer.MAX_VALUE));
} while (selected.getConfigurationValue(nsTestConfigKey).equals(nsValueNew));
modifiedNsd.setConfiguration(nsTestConfigKey, nsValueNew);
admin.modifyNamespace(modifiedNsd);
NamespaceDescriptor freshNamespaceDesc = admin.getNamespaceDescriptor(namespaceName);
Assert.assertTrue(
"Namespace: " + selected + " was not modified",
freshNamespaceDesc.getConfigurationValue(nsTestConfigKey).equals(nsValueNew));
LOG.info("Modified namespace :" + freshNamespaceDesc);
namespaceMap.put(namespaceName, freshNamespaceDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyNamespaces();
}
@Override
void perform() throws IOException {
HTableDescriptor selected = selectTable(disabledTables);
if (selected == null) {
return;
}
HColumnDescriptor columnDesc = selectFamily(selected);
if (columnDesc == null) {
return;
}
Admin admin = connection.getAdmin();
int versions = RandomUtils.nextInt(10) + 3;
try {
TableName tableName = selected.getTableName();
LOG.info(
"Altering versions of column family: "
+ columnDesc
+ " to: "
+ versions
+ " in table: "
+ tableName);
columnDesc.setMinVersions(versions);
columnDesc.setMaxVersions(versions);
admin.modifyTable(tableName, selected);
// assertion
HTableDescriptor freshTableDesc = admin.getTableDescriptor(tableName);
HColumnDescriptor freshColumnDesc = freshTableDesc.getFamily(columnDesc.getName());
Assert.assertEquals(
"Column family: " + columnDesc + " was not altered",
freshColumnDesc.getMaxVersions(),
versions);
Assert.assertEquals(
"Column family: " + freshColumnDesc + " was not altered",
freshColumnDesc.getMinVersions(),
versions);
LOG.info(
"Altered versions of column family: "
+ columnDesc
+ " to: "
+ versions
+ " in table: "
+ tableName);
disabledTables.put(tableName, freshTableDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyTables();
}
@Override
void perform() throws IOException {
HTableDescriptor selected = selectTable(disabledTables);
if (selected == null) {
return;
}
HColumnDescriptor columnDesc = selectFamily(selected);
if (columnDesc == null) {
return;
}
Admin admin = connection.getAdmin();
try {
TableName tableName = selected.getTableName();
// possible DataBlockEncoding ids
int[] possibleIds = {0, 2, 3, 4, 6};
short id = (short) possibleIds[RandomUtils.nextInt(possibleIds.length)];
LOG.info(
"Altering encoding of column family: "
+ columnDesc
+ " to: "
+ id
+ " in table: "
+ tableName);
columnDesc.setDataBlockEncoding(DataBlockEncoding.getEncodingById(id));
admin.modifyTable(tableName, selected);
// assertion
HTableDescriptor freshTableDesc = admin.getTableDescriptor(tableName);
HColumnDescriptor freshColumnDesc = freshTableDesc.getFamily(columnDesc.getName());
Assert.assertEquals(
"Encoding of column family: " + columnDesc + " was not altered",
freshColumnDesc.getDataBlockEncoding().getId(),
id);
LOG.info(
"Altered encoding of column family: "
+ freshColumnDesc
+ " to: "
+ id
+ " in table: "
+ tableName);
disabledTables.put(tableName, freshTableDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyTables();
}
// populate tables
@Override
void perform() throws IOException {
HTableDescriptor selected = selectTable(enabledTables);
if (selected == null) {
return;
}
Admin admin = connection.getAdmin();
TableName tableName = selected.getTableName();
try (Table table = connection.getTable(tableName)) {
ArrayList<HRegionInfo> regionInfos =
new ArrayList<HRegionInfo>(admin.getTableRegions(selected.getTableName()));
int numRegions = regionInfos.size();
// average number of rows to be added per action to each region
int average_rows = 1;
int numRows = average_rows * numRegions;
LOG.info("Adding " + numRows + " rows to table: " + selected);
for (int i = 0; i < numRows; i++) {
// nextInt(Integer.MAX_VALUE)) to return positive numbers only
byte[] rowKey =
Bytes.toBytes(
"row-" + String.format("%010d", RandomUtils.nextInt(Integer.MAX_VALUE)));
HColumnDescriptor cfd = selectFamily(selected);
if (cfd == null) {
return;
}
byte[] family = cfd.getName();
byte[] qualifier = Bytes.toBytes("col-" + RandomUtils.nextInt(Integer.MAX_VALUE) % 10);
byte[] value = Bytes.toBytes("val-" + RandomStringUtils.randomAlphanumeric(10));
Put put = new Put(rowKey);
put.addColumn(family, qualifier, value);
table.put(put);
}
HTableDescriptor freshTableDesc = admin.getTableDescriptor(tableName);
enabledTables.put(tableName, freshTableDesc);
LOG.info("Added " + numRows + " rows to table: " + selected);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyTables();
}
@Override
void perform() throws IOException {
HTableDescriptor selected = selectTable(disabledTables);
if (selected == null) {
return;
}
Admin admin = connection.getAdmin();
try {
TableName tableName = selected.getTableName();
LOG.info("Enabling table :" + selected);
admin.enableTable(tableName);
Assert.assertTrue(
"Table: " + selected + " was not enabled", admin.isTableEnabled(tableName));
HTableDescriptor freshTableDesc = admin.getTableDescriptor(tableName);
enabledTables.put(tableName, freshTableDesc);
LOG.info("Enabled table :" + freshTableDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
// TODO workaround
// loose restriction for TableNotDisabledException/TableNotEnabledException thrown in sync
// operations 1) when enable/disable starts, the table state is changed to
// ENABLING/DISABLING (ZK node in 1.x), which will be further changed to ENABLED/DISABLED
// once the operation completes 2) if master failover happens in the middle of the
// enable/disable operation, the new master will try to recover the tables in
// ENABLING/DISABLING state, as programmed in
// AssignmentManager#recoverTableInEnablingState() and
// AssignmentManager#recoverTableInDisablingState()
// 3) after the new master initialization completes, the procedure tries to re-do the
// enable/disable operation, which was already done. Ignore those exceptions before
// change of behaviors of AssignmentManager in presence of PV2
if (e instanceof TableNotDisabledException) {
LOG.warn("Caught TableNotDisabledException in action: " + this.getClass());
e.printStackTrace();
} else {
throw e;
}
} finally {
admin.close();
}
verifyTables();
}
// ColumnAction has implemented selectFamily() shared by multiple family Actions
protected HColumnDescriptor selectFamily(HTableDescriptor htd) {
if (htd == null) {
return null;
}
HColumnDescriptor[] families = htd.getColumnFamilies();
if (families.length == 0) {
LOG.info("No column families in table: " + htd);
return null;
}
HColumnDescriptor randomCfd = families[RandomUtils.nextInt(families.length)];
return randomCfd;
}
@Override
void perform() throws IOException {
Admin admin = connection.getAdmin();
try {
NamespaceDescriptor nsd;
while (true) {
nsd = createNamespaceDesc();
try {
if (admin.getNamespaceDescriptor(nsd.getName()) != null) {
// the namespace has already existed.
continue;
} else {
// currently, the code never return null - always throws exception if
// namespace is not found - this just a defensive programming to make
// sure null situation is handled in case the method changes in the
// future.
break;
}
} catch (NamespaceNotFoundException nsnfe) {
// This is expected for a random generated NamespaceDescriptor
break;
}
}
LOG.info("Creating namespace:" + nsd);
admin.createNamespace(nsd);
NamespaceDescriptor freshNamespaceDesc = admin.getNamespaceDescriptor(nsd.getName());
Assert.assertTrue("Namespace: " + nsd + " was not created", freshNamespaceDesc != null);
LOG.info("Created namespace:" + freshNamespaceDesc);
namespaceMap.put(nsd.getName(), freshNamespaceDesc);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyNamespaces();
}
@Override
void perform() throws IOException {
HTableDescriptor selected = selectTable(disabledTables);
if (selected == null) {
return;
}
Admin admin = connection.getAdmin();
try {
TableName tableName = selected.getTableName();
LOG.info("Deleting table :" + selected);
admin.deleteTable(tableName);
Assert.assertFalse("Table: " + selected + " was not deleted", admin.tableExists(tableName));
deletedTables.put(tableName, selected);
LOG.info("Deleted table :" + selected);
} catch (Exception e) {
LOG.warn("Caught exception in action: " + this.getClass());
throw e;
} finally {
admin.close();
}
verifyTables();
}
@Override
public void run() {
while (running.get()) {
// select random action
ACTION selectedAction = ACTION.values()[RandomUtils.nextInt() % ACTION.values().length];
this.action = selectedAction;
LOG.info("Performing Action: " + selectedAction);
try {
switch (selectedAction) {
case CREATE_NAMESPACE:
new CreateNamespaceAction().perform();
break;
case MODIFY_NAMESPACE:
new ModifyNamespaceAction().perform();
break;
case DELETE_NAMESPACE:
new DeleteNamespaceAction().perform();
break;
case CREATE_TABLE:
// stop creating new tables in the later stage of the test to avoid too many empty
// tables
if (create_table.get()) {
new CreateTableAction().perform();
}
break;
case ADD_ROW:
new AddRowAction().perform();
break;
case DISABLE_TABLE:
new DisableTableAction().perform();
break;
case ENABLE_TABLE:
new EnableTableAction().perform();
break;
case DELETE_TABLE:
// reduce probability of deleting table to 20%
if (RandomUtils.nextInt(100) < 20) {
new DeleteTableAction().perform();
}
break;
case ADD_COLUMNFAMILY:
new AddColumnFamilyAction().perform();
break;
case DELETE_COLUMNFAMILY:
// reduce probability of deleting column family to 20%
if (RandomUtils.nextInt(100) < 20) {
new DeleteColumnFamilyAction().perform();
}
break;
case ALTER_FAMILYVERSIONS:
new AlterFamilyVersionsAction().perform();
break;
case ALTER_FAMILYENCODING:
new AlterFamilyEncodingAction().perform();
break;
}
} catch (Exception ex) {
this.savedException = ex;
return;
}
}
LOG.info(this.getName() + " stopped");
}
