hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From st...@apache.org
Subject svn commit: r1167003 - in /hbase/trunk: CHANGES.txt src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsck.java
Date Fri, 09 Sep 2011 04:53:05 GMT
Author: stack
Date: Fri Sep  9 04:53:04 2011
New Revision: 1167003

URL: http://svn.apache.org/viewvc?rev=1167003&view=rev
Log:
HBASE-4313 Refactor TestHBaseFsck to make adding individual hbck tests easier

Modified:
    hbase/trunk/CHANGES.txt
    hbase/trunk/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsck.java

Modified: hbase/trunk/CHANGES.txt
URL: http://svn.apache.org/viewvc/hbase/trunk/CHANGES.txt?rev=1167003&r1=1167002&r2=1167003&view=diff
==============================================================================
--- hbase/trunk/CHANGES.txt (original)
+++ hbase/trunk/CHANGES.txt Fri Sep  9 04:53:04 2011
@@ -570,6 +570,8 @@ Release 0.90.5 - Unreleased
                META/ROOT regions (todd)
    HBASE-4323  Add debug logging when AssignmentManager can't make a plan
                for a region (todd)
+   HBASE-4313  Refactor TestHBaseFsck to make adding individual hbck tests
+               easier (Jonathan Hsieh)
 
 Release 0.90.4 - August 10, 2011
 

Modified: hbase/trunk/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsck.java
URL: http://svn.apache.org/viewvc/hbase/trunk/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsck.java?rev=1167003&r1=1167002&r2=1167003&view=diff
==============================================================================
--- hbase/trunk/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsck.java (original)
+++ hbase/trunk/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsck.java Fri Sep  9 04:53:04
2011
@@ -20,72 +20,76 @@
 package org.apache.hadoop.hbase.util;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
 
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.Map;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.fs.FileSystem;
-import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.hbase.HBaseTestingUtility;
+import org.apache.hadoop.hbase.HColumnDescriptor;
 import org.apache.hadoop.hbase.HConstants;
 import org.apache.hadoop.hbase.HRegionInfo;
-import org.apache.hadoop.hbase.HServerAddress;
 import org.apache.hadoop.hbase.HTableDescriptor;
-import org.apache.hadoop.hbase.RemoteExceptionHandler;
 import org.apache.hadoop.hbase.ServerName;
-import org.apache.hadoop.hbase.UnknownRegionException;
+import org.apache.hadoop.hbase.client.HBaseAdmin;
 import org.apache.hadoop.hbase.client.HTable;
 import org.apache.hadoop.hbase.client.Put;
 import org.apache.hadoop.hbase.client.Result;
 import org.apache.hadoop.hbase.client.ResultScanner;
 import org.apache.hadoop.hbase.client.Scan;
 import org.apache.hadoop.hbase.util.HBaseFsck.ErrorReporter.ERROR_CODE;
+import org.apache.zookeeper.KeeperException;
+import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
+/**
+ * This tests HBaseFsck's ability to detect reasons for inconsistent tables.
+ */
 public class TestHBaseFsck {
-
   final Log LOG = LogFactory.getLog(getClass());
-  private final static HBaseTestingUtility TEST_UTIL =
-      new HBaseTestingUtility();
+  private final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
   private final static Configuration conf = TEST_UTIL.getConfiguration();
-  private final static byte[] TABLE = Bytes.toBytes("table");
   private final static byte[] FAM = Bytes.toBytes("fam");
 
+  // for the instance, reset every test run
+  private HTable tbl;
+
   @BeforeClass
   public static void setUpBeforeClass() throws Exception {
     TEST_UTIL.startMiniCluster(3);
   }
 
-  private List doFsck(boolean fix) throws Exception {
+  @AfterClass
+  public static void tearDownAfterClass() throws Exception {
+    TEST_UTIL.shutdownMiniCluster();
+  }
+
+  private List<ERROR_CODE> doFsck(boolean fix) throws Exception {
     HBaseFsck fsck = new HBaseFsck(conf);
-    fsck.displayFullReport();  // i.e. -details
+    fsck.displayFullReport(); // i.e. -details
     fsck.setTimeLag(0);
     fsck.setFixErrors(fix);
     fsck.doWork();
     return fsck.getErrors().getErrorList();
   }
 
-  private void assertNoErrors(List errs) throws Exception {
+  private void assertNoErrors(List<ERROR_CODE> errs) throws Exception {
     assertEquals(0, errs.size());
   }
 
-  private void assertErrors(List errs, ERROR_CODE[] expectedErrors) {
+  private void assertErrors(List<ERROR_CODE> errs, ERROR_CODE[] expectedErrors) {
     assertEquals(Arrays.asList(expectedErrors), errs);
   }
 
   @Test
   public void testHBaseFsck() throws Exception {
     assertNoErrors(doFsck(false));
-
-    TEST_UTIL.createTable(TABLE, FAM);
+    String table = "tableBadMetaAssign"; 
+    TEST_UTIL.createTable(Bytes.toBytes(table), FAM);
 
     // We created 1 table, should be fine
     assertNoErrors(doFsck(false));
@@ -127,7 +131,7 @@ public class TestHBaseFsck {
     assertNoErrors(doFsck(false));
 
     // comment needed - what is the purpose of this line
-    new HTable(conf, TABLE).getScanner(new Scan());
+    new HTable(conf, Bytes.toBytes(table)).getScanner(new Scan());;
   }
 
   private HRegionInfo createRegion(Configuration conf, final HTableDescriptor
@@ -142,76 +146,122 @@ public class TestHBaseFsck {
     return hri;
   }
 
-  @Test
   /**
-   * Tests for inconsistencies in the META data (duplicate start keys, or holes)
+   * Setup a clean table before we start mucking with it.
+   * 
+   * @throws IOException
+   * @throws InterruptedException
+   * @throws KeeperException
+   */
+  void setupTable(String tablename) throws Exception {
+    byte[][] startKeys = new byte[][] { Bytes.toBytes("A"), Bytes.toBytes("B"),
+        Bytes.toBytes("C") };
+    HTableDescriptor desc = new HTableDescriptor(tablename);
+    HColumnDescriptor hcd = new HColumnDescriptor(Bytes.toString(FAM));
+    desc.addFamily(hcd); // If a table has no CF's it doesn't get checked
+    TEST_UTIL.getHBaseAdmin().createTable(desc, startKeys);
+    tbl = new HTable(TEST_UTIL.getConfiguration(), tablename);
+  }
+
+  /**
+   * delete table in preparation for next test
+   * 
+   * @param tablename
+   * @throws IOException
    */
-  public void testHBaseFsckMeta() throws Exception {
+  void deleteTable(String tablename) throws IOException {
+    HBaseAdmin admin = TEST_UTIL.getHBaseAdmin();
+    byte[] tbytes = Bytes.toBytes(tablename);
+    admin.disableTable(tbytes);
+    admin.deleteTable(tbytes);
+  }
+
+
+  
+  /**
+   * This creates a clean table and confirms that the table is clean.
+   */
+  @Test
+  public void testHBaseFsckClean() throws Exception {
     assertNoErrors(doFsck(false));
+    String table = "tableClean";
+    try {
+      setupTable(table);
 
-    HTable tbl = TEST_UTIL.createTable(Bytes.toBytes("table2"), FAM);
+      // We created 1 table, should be fine
+      assertNoErrors(doFsck(false));
+    } finally {
+      deleteTable(table);
+    }
+  }
 
-    Map<HRegionInfo, HServerAddress> hris = tbl.getRegionsInfo();
-    HRegionInfo hriOrig = hris.keySet().iterator().next();
-    Map<HRegionInfo, ServerName> locations = tbl.getRegionLocations();
-    ServerName rsAddressOrig = locations.get(hriOrig);
-
-    byte[][] startKeys = new byte[][]{
-        HConstants.EMPTY_BYTE_ARRAY,
-        Bytes.toBytes("A"),
-        Bytes.toBytes("B"),
-        Bytes.toBytes("C")
-    };
-    TEST_UTIL.createMultiRegions(conf, tbl, FAM, startKeys);
-    Path rootDir = new Path(conf.get(HConstants.HBASE_DIR));
-    FileSystem fs = rootDir.getFileSystem(conf);
-    Path p = new Path(rootDir + "/table2", hriOrig.getEncodedName());
-    fs.delete(p, true);
-
-    Thread.sleep(1 * 1000);
-    ArrayList servers = new ArrayList();
-    servers.add(rsAddressOrig);
+  /**
+   * This creates a bad table with regions that have a duplicate start key
+   */
+  @Test
+  public void testDupeStartKey() throws Exception {
+    String table = "tableDupeStartKey";
     try {
-      HBaseFsckRepair.fixDupeAssignment(TEST_UTIL.getHBaseAdmin(), hriOrig, servers);
-    } catch (IOException ex) {
-      ex = RemoteExceptionHandler.checkIOException(ex);
-      if (!(ex instanceof UnknownRegionException)) {
-        fail("Unexpected exception: " + ex);
-      }
+      setupTable(table);
+      assertNoErrors(doFsck(false));
+
+      // Now let's mess it up, by adding a region with a duplicate startkey
+      HRegionInfo hriDupe = createRegion(conf, tbl.getTableDescriptor(),
+          Bytes.toBytes("A"), Bytes.toBytes("A2"));
+      TEST_UTIL.getHBaseCluster().getMaster().assignRegion(hriDupe);
+      TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager()
+          .waitForAssignment(hriDupe);
+
+      assertErrors(doFsck(false),
+          new ERROR_CODE[] { ERROR_CODE.DUPE_STARTKEYS });
+    } finally {
+      deleteTable(table);
     }
+  }
 
-    // We created 1 table, should be fine
-    assertNoErrors(doFsck(false));
+  /**
+   * This creates a bad table where a start key contained in another region.
+   */
+  @Test
+  public void testCoveredStartKey() throws Exception {
+    String table = "tableCoveredStartKey";
+    try {
+      setupTable(table);
 
-    // Now let's mess it up, by adding a region with a duplicate startkey
-    HRegionInfo hriDupe = createRegion(conf, tbl.getTableDescriptor(),
-        Bytes.toBytes("A"), Bytes.toBytes("A2"));
-    TEST_UTIL.getHBaseCluster().getMaster().assignRegion(hriDupe);
-    TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager()
-        .waitForAssignment(hriDupe);
-    assertErrors(doFsck(false), new ERROR_CODE[]{ERROR_CODE.DUPE_STARTKEYS});
-
-    // Mess it up by creating an overlap in the metadata
-    HRegionInfo hriOverlap = createRegion(conf, tbl.getTableDescriptor(),
-        Bytes.toBytes("A2"), Bytes.toBytes("B2"));
-    TEST_UTIL.getHBaseCluster().getMaster().assignRegion(hriOverlap);
-    TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager()
-        .waitForAssignment(hriOverlap);
-    assertErrors(doFsck(false), new ERROR_CODE[]{
-        ERROR_CODE.DUPE_STARTKEYS, ERROR_CODE.OVERLAP_IN_REGION_CHAIN,
-        ERROR_CODE.OVERLAP_IN_REGION_CHAIN});
-
-    // Mess it up by leaving a hole in the meta data
-    HRegionInfo hriHole = createRegion(conf, tbl.getTableDescriptor(),
-        Bytes.toBytes("D"), Bytes.toBytes("E"));
-    TEST_UTIL.getHBaseCluster().getMaster().assignRegion(hriHole);
-    TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager()
-        .waitForAssignment(hriHole);
-//    assertError(doFsck(false), ERROR_CODE.OVERLAP_IN_REGION_CHAIN);
-    assertErrors(doFsck(false), new ERROR_CODE[]{ ERROR_CODE.DUPE_STARTKEYS,
-        ERROR_CODE.OVERLAP_IN_REGION_CHAIN, ERROR_CODE.OVERLAP_IN_REGION_CHAIN,
-        ERROR_CODE.HOLE_IN_REGION_CHAIN });
+      // Mess it up by creating an overlap in the metadata
+      HRegionInfo hriOverlap = createRegion(conf, tbl.getTableDescriptor(),
+          Bytes.toBytes("A2"), Bytes.toBytes("B2"));
+      TEST_UTIL.getHBaseCluster().getMaster().assignRegion(hriOverlap);
+      TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager()
+          .waitForAssignment(hriOverlap);
+      assertErrors(doFsck(false), new ERROR_CODE[] {
+          ERROR_CODE.OVERLAP_IN_REGION_CHAIN,
+          ERROR_CODE.OVERLAP_IN_REGION_CHAIN });
+    } finally {
+      deleteTable(table);
+    }
+  }
 
+  /**
+   * This creates a bad table with a hole in meta.
+   */
+  @Test
+  public void testMetaHole() throws Exception {
+    String table = "tableMetaHole";
+    try {
+      setupTable(table);
+
+      // Mess it up by leaving a hole in the meta data
+      HRegionInfo hriHole = createRegion(conf, tbl.getTableDescriptor(),
+          Bytes.toBytes("D"), Bytes.toBytes("E"));
+      TEST_UTIL.getHBaseCluster().getMaster().assignRegion(hriHole);
+      TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager()
+          .waitForAssignment(hriHole);
+      assertErrors(doFsck(false),
+          new ERROR_CODE[] { ERROR_CODE.HOLE_IN_REGION_CHAIN });
+    } finally {
+      deleteTable(table);
+    }
   }
 
 }



Mime
View raw message