Index: src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java =================================================================== --- src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java (revision 1300457) +++ src/main/java/org/apache/hadoop/hbase/master/AssignmentManager.java (working copy) @@ -1564,6 +1564,7 @@ if (isDisabledorDisablingRegionInRIT(region)) { return; } + setEnabledTable(region); } } @@ -1648,6 +1649,26 @@ } } + private void setEnabledTable(HRegionInfo hri) { + String tableName = hri.getTableNameAsString(); + boolean isTableEnabled = this.zkTable.isEnabledTable(tableName); + if (!isTableEnabled) { + setEnabledTable(tableName); + } + } + + protected void setEnabledTable(String tableName) { + try { + this.zkTable.setEnabledTable(tableName); + } catch (KeeperException e) { + // here we can abort as it is the start up flow + String errorMsg = "Unable to ensure that the table " + tableName + + " will be" + " enabled because of a ZooKeeper issue"; + LOG.error(errorMsg); + this.master.abort(errorMsg, e); + } + } + private boolean isDisabledorDisablingRegionInRIT(final HRegionInfo region) { String tableName = region.getTableNameAsString(); boolean disabled = this.zkTable.isDisabledTable(tableName); @@ -2125,6 +2146,9 @@ } else { // assign regions in round-robin fashion assignUserRegions(new ArrayList(allRegions.keySet()), servers); + for (HRegionInfo hri : allRegions.keySet()) { + setEnabledTable(hri); + } return; } LOG.info("Bulk assigning " + allRegions.size() + " region(s) across " + @@ -2133,6 +2157,9 @@ // Use fixed count thread pool assigning. BulkAssigner ba = new StartupBulkAssigner(this.master, bulkPlan, this); ba.bulkAssign(); + for (HRegionInfo hri : allRegions.keySet()) { + setEnabledTable(hri); + } LOG.info("Bulk assigning done"); } @@ -2322,6 +2349,8 @@ new TreeMap>>(); // Iterate regions in META for (Result result : results) { + boolean disabled = false; + boolean disablingOrEnabling = false; Pair region = MetaReader.parseCatalogResult(result); if (region == null) continue; HRegionInfo regionInfo = region.getFirst(); @@ -2355,6 +2384,13 @@ offlineServers.put(regionLocation, offlineRegions); } offlineRegions.add(new Pair(regionInfo, result)); + disabled = checkIfRegionBelongsToDisabled(regionInfo); + disablingOrEnabling = addTheTablesInPartialState(this.disablingTables, + this.enablingTables, regionInfo, tableName); + // need to enable the table if not disabled or disabling or enabling + // this will be used in rolling restarts + enableTableIfNotDisabledOrDisablingOrEnabling(disabled, + disablingOrEnabling, tableName); } else { // Region is being served and on an active server // add only if region not in disabled and enabling table @@ -2363,21 +2399,37 @@ regions.put(regionInfo, regionLocation); addToServers(regionLocation, regionInfo); } - addTheTablesInPartialState(this.disablingTables, this.enablingTables, regionInfo, - tableName); + disabled = checkIfRegionBelongsToDisabled(regionInfo); + disablingOrEnabling = addTheTablesInPartialState(this.disablingTables, + this.enablingTables, regionInfo, tableName); + // need to enable the table if not disabled or disabling or enabling + // this will be used in rolling restarts + enableTableIfNotDisabledOrDisablingOrEnabling(disabled, + disablingOrEnabling, tableName); } } return offlineServers; } - private void addTheTablesInPartialState(Set disablingTables, + private void enableTableIfNotDisabledOrDisablingOrEnabling(boolean disabled, + boolean disablingOrEnabling, String tableName) { + if (!disabled && !disablingOrEnabling + && !getZKTable().isEnabledTable(tableName)) { + setEnabledTable(tableName); + } + } + + private Boolean addTheTablesInPartialState(Set disablingTables, Set enablingTables, HRegionInfo regionInfo, String disablingTableName) { if (checkIfRegionBelongsToDisabling(regionInfo)) { disablingTables.add(disablingTableName); + return true; } else if (checkIfRegionsBelongsToEnabling(regionInfo)) { enablingTables.add(disablingTableName); - } + return true; + } + return false; } /** Index: src/main/java/org/apache/hadoop/hbase/master/handler/DeleteTableHandler.java =================================================================== --- src/main/java/org/apache/hadoop/hbase/master/handler/DeleteTableHandler.java (revision 1300457) +++ src/main/java/org/apache/hadoop/hbase/master/handler/DeleteTableHandler.java (working copy) @@ -76,8 +76,8 @@ this.masterServices.getTableDescriptors().remove(Bytes.toString(tableName)); // If entry for this table in zk, and up in AssignmentManager, remove it. - // Call to undisableTable does this. TODO: Make a more formal purge table. - am.getZKTable().setEnabledTable(Bytes.toString(tableName)); + + am.getZKTable().setDeletedTable(Bytes.toString(tableName)); } @Override Index: src/main/java/org/apache/hadoop/hbase/master/handler/ServerShutdownHandler.java =================================================================== --- src/main/java/org/apache/hadoop/hbase/master/handler/ServerShutdownHandler.java (revision 1300457) +++ src/main/java/org/apache/hadoop/hbase/master/handler/ServerShutdownHandler.java (working copy) @@ -324,13 +324,27 @@ public static boolean processDeadRegion(HRegionInfo hri, Result result, AssignmentManager assignmentManager, CatalogTracker catalogTracker) throws IOException { + boolean tablePresent = assignmentManager.getZKTable().isTablePresent( + hri.getTableNameAsString()); + if (!tablePresent) { + LOG.info("The table " + hri.getTableNameAsString() + + " was deleted. Hence not proceeding."); + return false; + } // If table is not disabled but the region is offlined, boolean disabled = assignmentManager.getZKTable().isDisabledTable( hri.getTableNameAsString()); - if (disabled) return false; + if (disabled){ + LOG.info("The table " + hri.getTableNameAsString() + + " was disabled. Hence not proceeding."); + return false; + } if (hri.isOffline() && hri.isSplit()) { LOG.debug("Offlined and split region " + hri.getRegionNameAsString() + "; checking daughter presence"); + if (MetaReader.getRegion(catalogTracker, hri.getRegionName()) == null) { + return false; + } fixupDaughters(result, assignmentManager, catalogTracker); return false; } Index: src/main/java/org/apache/hadoop/hbase/master/HMaster.java =================================================================== --- src/main/java/org/apache/hadoop/hbase/master/HMaster.java (revision 1300457) +++ src/main/java/org/apache/hadoop/hbase/master/HMaster.java (working copy) @@ -577,6 +577,9 @@ this.assignmentManager.regionOnline(HRegionInfo.ROOT_REGIONINFO, this.catalogTracker.getRootLocation()); } + // Enable the ROOT table if on process fail over the RS containing ROOT + // was active. + enableCatalogTables(Bytes.toString(HConstants.ROOT_TABLE_NAME)); LOG.info("-ROOT- assigned=" + assigned + ", rit=" + rit + ", location=" + catalogTracker.getRootLocation()); @@ -604,11 +607,18 @@ this.assignmentManager.regionOnline(HRegionInfo.FIRST_META_REGIONINFO, this.catalogTracker.getMetaLocation()); } + enableCatalogTables(Bytes.toString(HConstants.META_TABLE_NAME)); LOG.info(".META. assigned=" + assigned + ", rit=" + rit + ", location=" + catalogTracker.getMetaLocation()); status.setStatus("META and ROOT assigned."); return assigned; } + + private void enableCatalogTables(String catalogTableName) { + if (!this.assignmentManager.getZKTable().isEnabledTable(catalogTableName)){ + this.assignmentManager.setEnabledTable(catalogTableName); + } + } void fixupDaughters(final MonitoredTask status) throws IOException { final Map offlineSplitParents = Index: src/main/java/org/apache/hadoop/hbase/zookeeper/ZKTable.java =================================================================== --- src/main/java/org/apache/hadoop/hbase/zookeeper/ZKTable.java (revision 1300457) +++ src/main/java/org/apache/hadoop/hbase/zookeeper/ZKTable.java (working copy) @@ -216,7 +216,7 @@ public boolean checkEnabledAndSetDisablingTable(final String tableName) throws KeeperException { synchronized (this.cache) { - if (!isEnabledTable(tableName)) { + if (this.cache.get(tableName) != null && !isEnabledTable(tableName)) { return false; } setTableState(tableName, TableState.DISABLING); @@ -265,10 +265,7 @@ } public boolean isEnabledTable(String tableName) { - synchronized (this.cache) { - // No entry in cache means enabled table. - return !this.cache.containsKey(tableName); - } + return isTableState(tableName, TableState.ENABLED); } /** @@ -283,7 +280,7 @@ public static boolean isEnabledTable(final ZooKeeperWatcher zkw, final String tableName) throws KeeperException { - return getTableState(zkw, tableName) == null; + return getTableState(zkw, tableName) == TableState.ENABLED; } public boolean isDisablingOrDisabledTable(final String tableName) { @@ -335,24 +332,48 @@ } /** - * Enables the table in zookeeper. Fails silently if the + * Deletes the table in zookeeper. Fails silently if the * table is not currently disabled in zookeeper. Sets no watches. * @param tableName * @throws KeeperException unexpected zookeeper exception */ - public void setEnabledTable(final String tableName) + public void setDeletedTable(final String tableName) throws KeeperException { synchronized (this.cache) { if (this.cache.remove(tableName) == null) { - LOG.warn("Moving table " + tableName + " state to enabled but was " + - "already enabled"); + LOG.warn("Moving table " + tableName + " state to deleted but was " + + "already deleted"); } ZKUtil.deleteNodeFailSilent(this.watcher, ZKUtil.joinZNode(this.watcher.tableZNode, tableName)); } } - + /** + * Sets the ENABLED state in the cache and deletes the zookeeper node. Fails + * silently if the node is not in enabled in zookeeper + * + * @param tableName + * @throws KeeperException + */ + public void setEnabledTable(final String tableName) throws KeeperException { + setTableState(tableName, TableState.ENABLED); + } + + /** + * check if table is present . + * + * @param tableName + * @return True if the table is present + */ + public boolean isTablePresent(final String tableName) { + synchronized (this.cache) { + TableState state = this.cache.get(tableName); + return !(state == null); + } + } + + /** * Gets a list of all the tables set as disabled in zookeeper. * @return Set of disabled tables, empty Set if none */ Index: src/test/java/org/apache/hadoop/hbase/client/TestAdmin.java =================================================================== --- src/test/java/org/apache/hadoop/hbase/client/TestAdmin.java (revision 1300457) +++ src/test/java/org/apache/hadoop/hbase/client/TestAdmin.java (working copy) @@ -238,6 +238,9 @@ ht.get(get); this.admin.disableTable(table); + assertTrue("Table must be disabled.", TEST_UTIL.getHBaseCluster() + .getMaster().getAssignmentManager().getZKTable().isDisabledTable( + Bytes.toString(table))); // Test that table is disabled get = new Get(row); @@ -252,6 +255,9 @@ } assertTrue(ok); this.admin.enableTable(table); + assertTrue("Table must be enabled.", TEST_UTIL.getHBaseCluster() + .getMaster().getAssignmentManager().getZKTable().isEnabledTable( + Bytes.toString(table))); // Test that table is enabled try { @@ -323,6 +329,9 @@ HConstants.CATALOG_FAMILY).close(); tables = this.admin.listTables(); assertEquals(numTables + 1, tables.length); + assertTrue("Table must be enabled.", TEST_UTIL.getHBaseCluster() + .getMaster().getAssignmentManager().getZKTable().isEnabledTable( + "testCreateTable")); } @Test Index: src/test/java/org/apache/hadoop/hbase/master/TestMaster.java =================================================================== --- src/test/java/org/apache/hadoop/hbase/master/TestMaster.java (revision 1300457) +++ src/test/java/org/apache/hadoop/hbase/master/TestMaster.java (working copy) @@ -72,6 +72,8 @@ HBaseAdmin admin = TEST_UTIL.getHBaseAdmin(); TEST_UTIL.createTable(TABLENAME, FAMILYNAME); + assertTrue(m.assignmentManager.getZKTable().isEnabledTable + (Bytes.toString(TABLENAME))); TEST_UTIL.loadTable(new HTable(TEST_UTIL.getConfiguration(), TABLENAME), FAMILYNAME); @@ -143,4 +145,4 @@ public void beforeProcess(EventHandler event) { } } -} \ No newline at end of file +} Index: src/test/java/org/apache/hadoop/hbase/master/TestMasterFailover.java =================================================================== --- src/test/java/org/apache/hadoop/hbase/master/TestMasterFailover.java (revision 1300457) +++ src/test/java/org/apache/hadoop/hbase/master/TestMasterFailover.java (working copy) @@ -752,6 +752,8 @@ master.assignRegion(hri); } + assertTrue(" Table must be enabled.", master.getAssignmentManager() + .getZKTable().isEnabledTable("enabledTable")); // we also need regions assigned out on the dead server List enabledAndOnDeadRegions = new ArrayList(); enabledAndOnDeadRegions.add(enabledRegions.remove(0)); @@ -796,6 +798,9 @@ // Disable the disabledTable in ZK ZKTable zktable = new ZKTable(zkw); zktable.setDisabledTable(Bytes.toString(disabledTable)); + + assertTrue(" The enabled table should be identified on master fail over.", + zktable.isEnabledTable("enabledTable")); /* * ZK = CLOSING Index: src/test/java/org/apache/hadoop/hbase/master/TestMasterRestartAfterDisablingTable.java =================================================================== --- src/test/java/org/apache/hadoop/hbase/master/TestMasterRestartAfterDisablingTable.java (revision 1300457) +++ src/test/java/org/apache/hadoop/hbase/master/TestMasterRestartAfterDisablingTable.java (working copy) @@ -20,6 +20,7 @@ package org.apache.hadoop.hbase.master; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import java.io.IOException; import java.util.List; @@ -96,6 +97,9 @@ cluster.hbaseCluster.waitOnMaster(activeMaster); cluster.waitForActiveAndReadyMaster(); + assertTrue("The table should not be in enabled state", cluster.getMaster() + .getAssignmentManager().getZKTable().isDisablingOrDisabledTable( + "tableRestart")); log("Enabling table\n"); TEST_UTIL.getHBaseAdmin().enableTable(table); log("Waiting for no more RIT\n"); @@ -105,6 +109,8 @@ assertEquals( "The assigned regions were not onlined after master switch except for the catalog tables.", 6, regions.size()); + assertTrue("The table should be in enabled state", cluster.getMaster() + .getAssignmentManager().getZKTable().isEnabledTable("tableRestart")); TEST_UTIL.shutdownMiniCluster(); } Index: src/test/java/org/apache/hadoop/hbase/zookeeper/TestZKTable.java =================================================================== --- src/test/java/org/apache/hadoop/hbase/zookeeper/TestZKTable.java (revision 1300457) +++ src/test/java/org/apache/hadoop/hbase/zookeeper/TestZKTable.java (working copy) @@ -68,28 +68,41 @@ ZooKeeperWatcher zkw = new ZooKeeperWatcher(TEST_UTIL.getConfiguration(), name, abortable, true); ZKTable zkt = new ZKTable(zkw); - assertTrue(zkt.isEnabledTable(name)); + assertFalse(zkt.isEnabledTable(name)); assertFalse(zkt.isDisablingTable(name)); assertFalse(zkt.isDisabledTable(name)); assertFalse(zkt.isEnablingTable(name)); assertFalse(zkt.isDisablingOrDisabledTable(name)); assertFalse(zkt.isDisabledOrEnablingTable(name)); + assertFalse(zkt.isTablePresent(name)); zkt.setDisablingTable(name); assertTrue(zkt.isDisablingTable(name)); assertTrue(zkt.isDisablingOrDisabledTable(name)); assertFalse(zkt.getDisabledTables().contains(name)); + assertTrue(zkt.isTablePresent(name)); zkt.setDisabledTable(name); assertTrue(zkt.isDisabledTable(name)); assertTrue(zkt.isDisablingOrDisabledTable(name)); assertFalse(zkt.isDisablingTable(name)); assertTrue(zkt.getDisabledTables().contains(name)); + assertTrue(zkt.isTablePresent(name)); zkt.setEnablingTable(name); assertTrue(zkt.isEnablingTable(name)); assertTrue(zkt.isDisabledOrEnablingTable(name)); assertFalse(zkt.isDisabledTable(name)); assertFalse(zkt.getDisabledTables().contains(name)); + assertTrue(zkt.isTablePresent(name)); zkt.setEnabledTable(name); assertTrue(zkt.isEnabledTable(name)); assertFalse(zkt.isEnablingTable(name)); + assertTrue(zkt.isTablePresent(name)); + zkt.setDeletedTable(name); + assertFalse(zkt.isEnabledTable(name)); + assertFalse(zkt.isDisablingTable(name)); + assertFalse(zkt.isDisabledTable(name)); + assertFalse(zkt.isEnablingTable(name)); + assertFalse(zkt.isDisablingOrDisabledTable(name)); + assertFalse(zkt.isDisabledOrEnablingTable(name)); + assertFalse(zkt.isTablePresent(name)); } }