Package com.alibaba.wasp.client

Source Code of com.alibaba.wasp.client.TestAdmin

/**
* Copyright 2011 The Apache Software Foundation
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.wasp.client;

import com.alibaba.wasp.DataType;
import com.alibaba.wasp.EntityGroupInfo;
import com.alibaba.wasp.FConstants;
import com.alibaba.wasp.FieldKeyWord;
import com.alibaba.wasp.NotAllChildTableDisableException;
import com.alibaba.wasp.NotServingEntityGroupException;
import com.alibaba.wasp.ServerName;
import com.alibaba.wasp.TableExistsException;
import com.alibaba.wasp.TableNotDisabledException;
import com.alibaba.wasp.TableNotEnabledException;
import com.alibaba.wasp.TableNotFoundException;
import com.alibaba.wasp.UnknownEntityGroupException;
import com.alibaba.wasp.WaspTestingUtility;
import com.alibaba.wasp.executor.EventHandler;
import com.alibaba.wasp.executor.EventHandler.EventType;
import com.alibaba.wasp.executor.ExecutorService;
import com.alibaba.wasp.fserver.EntityGroup;
import com.alibaba.wasp.fserver.FServer;
import com.alibaba.wasp.master.FMasterServices;
import com.alibaba.wasp.meta.FMetaTestUtil;
import com.alibaba.wasp.meta.FTable;
import com.alibaba.wasp.meta.Field;
import com.alibaba.wasp.zookeeper.ZKTable;
import com.alibaba.wasp.zookeeper.ZooKeeperWatcher;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;

import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

/**
* Class to test WaspAdmin. Spins up the minicluster once at test start and then
* takes it down afterward. Add any testing of WaspAdmin functionality here.
*/
public class TestAdmin {
  final Log LOG = LogFactory.getLog(getClass());
  private final static WaspTestingUtility TEST_UTIL = new WaspTestingUtility();
  private static WaspAdmin admin;
  public static final String TABLE_NAME = "TEST_TABLE";

  public static final byte[] TABLE = Bytes.toBytes(TABLE_NAME);

  @BeforeClass
  public static void setUpBeforeClass() throws Exception {
    TEST_UTIL.getConfiguration().setBoolean("wasp.online.schema.update.enable",
        true);
    TEST_UTIL.getConfiguration().set(FConstants.REDO_IMPL,
        "com.alibaba.wasp.fserver.redo.MemRedoLog");
    TEST_UTIL.getConfiguration().setInt("wasp.fserver.msginterval", 100);
    TEST_UTIL.getConfiguration().setInt("wasp.client.pause", 250);
    TEST_UTIL.getConfiguration().setInt("wasp.client.retries.number", 6);
    TEST_UTIL.getConfiguration().setBoolean(
        "wasp.master.enabletable.roundrobin", true);
    TEST_UTIL.getConfiguration().setBoolean("wasp.ipc.server.blacklist.enable",
        true);
    TEST_UTIL.startMiniCluster(3);
    admin = TEST_UTIL.getWaspAdmin();
  }

  @AfterClass
  public static void tearDownAfterClass() throws Exception {
    TEST_UTIL.shutdownMiniCluster();
  }

  @Test
  public void testSplitUnknownTable() throws InterruptedException {
    final String unknowntable = "fubar";
    Exception exception = null;
    try {
      admin.split(unknowntable, "1234");
    } catch (IOException e) {
      exception = e;
    }
    assertTrue(exception instanceof TableNotFoundException);
  }

  @Test
  public void testDisableAndEnableTable() throws IOException {
    final byte[] table = Bytes.toBytes("testDisableAndEnableTable");
    TEST_UTIL.createTable(table);
    admin.disableTable(table);
    assertTrue("Table must be disabled.",
        TEST_UTIL.getWaspCluster().getMaster().getAssignmentManager()
            .getZKTable().isDisabledTable(Bytes.toString(table)));

    admin.enableTable(table);
    assertTrue("Table must be enabled.",
        TEST_UTIL.getWaspCluster().getMaster().getAssignmentManager()
            .getZKTable().isEnabledTable(Bytes.toString(table)));
  }

  @Test
  public void testDisableEnableTableHasChilds() throws IOException, InterruptedException {
    final byte[] rootTable = Bytes.toBytes("testDisableTableHasChildsRoot");
    final byte[] childTable = Bytes.toBytes("testDisableTableHasChildsChild");
    TEST_UTIL.createTable(rootTable);
    TEST_UTIL.waitTableAvailable(rootTable);
    TEST_UTIL.createChildTable(rootTable, childTable);
    TEST_UTIL.waitTableEnabled(childTable, 5000);
    try {
      admin.disableTable(rootTable);
    } catch (Exception e) {
      assertTrue(e instanceof NotAllChildTableDisableException);
    }
    assertTrue("Table must be enabled.",
        TEST_UTIL.getWaspCluster().getMaster().getAssignmentManager()
            .getZKTable().isEnabledTable(Bytes.toString(rootTable)));
  }

  @Test
  public void testDisableAndEnableTables() throws IOException {
    final byte[] table1 = Bytes.toBytes("testDisableAndEnableTable1");
    final byte[] table2 = Bytes.toBytes("testDisableAndEnableTable2");
    TEST_UTIL.createTable(table1);
    TEST_UTIL.createTable(table2);
    admin.disableTables("testDisableAndEnableTable.*");

    assertTrue("Table must be disabled.",
        TEST_UTIL.getWaspCluster().getMaster().getAssignmentManager()
            .getZKTable().isDisabledTable(Bytes.toString(table1)));
    assertTrue("Table must be disabled.",
        TEST_UTIL.getWaspCluster().getMaster().getAssignmentManager()
            .getZKTable().isDisabledTable(Bytes.toString(table2)));

    admin.enableTables("testDisableAndEnableTable.*");

    assertTrue("Table must be enabled.",
        TEST_UTIL.getWaspCluster().getMaster().getAssignmentManager()
            .getZKTable().isEnabledTable(Bytes.toString(table1)));

    assertTrue("Table must be enabled.",
        TEST_UTIL.getWaspCluster().getMaster().getAssignmentManager()
            .getZKTable().isEnabledTable(Bytes.toString(table2)));
  }

  @Test
  public void testCreateTable() throws IOException {
    FTable[] tables = admin.listTables();
    int numTables = tables.length;
    TEST_UTIL.createTable(Bytes.toBytes("testCreateTable"));
    tables = admin.listTables();
    assertEquals(numTables + 1, tables.length);
    assertTrue("Table must be enabled.", TEST_UTIL.getWaspCluster().getMaster()
        .getAssignmentManager().getZKTable().isEnabledTable("testCreateTable"));
  }

  /**
   * Verify schema modification takes.
   *
   * @throws java.io.IOException
   * @throws InterruptedException
   */
  @Test
  public void testOnlineChangeTableSchema() throws IOException,
      InterruptedException {

  }

  // not pass
  @Test
  public void testShouldFailOnlineSchemaUpdateIfOnlineSchemaIsNotEnabled()
      throws Exception {
    final byte[] tableName = Bytes.toBytes("changeTableSchemaOnlineFailure");
    TEST_UTIL.getMiniWaspCluster().getMaster().getConfiguration()
        .setBoolean("wasp.online.schema.update.enable", false);
    FTable[] tables = admin.listTables();
    int numTables = tables.length;
    TEST_UTIL.createTable(tableName);
    tables = admin.listTables();
    assertEquals(numTables + 1, tables.length);

    // FIRST, do FTable changes.
    FTable fTable = admin.getTableDescriptor(tableName);
    // Make a copy and assert copy is good.
    FTable copy = FMetaTestUtil.makeTable(fTable.getTableName());
    assertTrue(fTable.equals(copy));

    boolean expectedException = false;
    try {
      modifyTable(tableName, copy);
    } catch (TableNotDisabledException re) {
      expectedException = true;
    }
    assertTrue("Online schema update should not happen.", expectedException);
  }

  /**
   * Modify table is async so wait on completion of the table operation in
   * master.
   *
   * @param tableName
   * @param htd
   * @throws java.io.IOException
   */
  private void modifyTable(final byte[] tableName, final FTable htd)
      throws IOException {
    FMasterServices services = TEST_UTIL.getMiniWaspCluster().getMaster();
    ExecutorService executor = services.getExecutorService();
    AtomicBoolean done = new AtomicBoolean(false);
    executor.registerListener(EventType.C_M_MODIFY_TABLE,
        new DoneListener(done));
    admin.modifyTable(tableName, htd);
    while (!done.get()) {
      synchronized (done) {
        try {
          done.wait(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
    }
    executor.unregisterListener(EventType.C_M_MODIFY_TABLE);
  }

  /**
   * Listens for when an event is done in Master.
   */
  static class DoneListener implements EventHandler.EventHandlerListener {
    private final AtomicBoolean done;

    DoneListener(final AtomicBoolean done) {
      super();
      this.done = done;
    }

    @Override
    public void afterProcess(EventHandler event) {
      this.done.set(true);
      synchronized (this.done) {
        // Wake anyone waiting on this value to change.
        this.done.notifyAll();
      }
    }

    @Override
    public void beforeProcess(EventHandler event) {
      // continue
    }
  }

  @Test
  public void testCreateTableWithEntityGroups() throws IOException,
      InterruptedException {

    byte[] tableName = Bytes.toBytes("testCreateTableWithEntityGroups");

    byte[][] splitKeys = { new byte[] { 1, 1, 1 }, new byte[] { 2, 2, 2 },
        new byte[] { 3, 3, 3 }, new byte[] { 4, 4, 4 }, new byte[] { 5, 5, 5 },
        new byte[] { 6, 6, 6 }, new byte[] { 7, 7, 7 }, new byte[] { 8, 8, 8 },
        new byte[] { 9, 9, 9 }, };
    int expectedEntityGroups = splitKeys.length + 1;

    FTable desc = FMetaTestUtil.makeTable(Bytes.toString(tableName));
    admin.createTable(desc, splitKeys);

    Map<EntityGroupInfo, ServerName> entityGroups = admin
        .getEntityGroupLocations(tableName);
    assertEquals("Tried to create " + expectedEntityGroups + " entityGroups "
        + "but only found " + entityGroups.size(), expectedEntityGroups,
        entityGroups.size());
    System.err.println("Found " + entityGroups.size() + " entityGroups");

    Iterator<EntityGroupInfo> egis = entityGroups.keySet().iterator();
    EntityGroupInfo egi = egis.next();
    assertTrue(egi.getStartKey() == null || egi.getStartKey().length == 0);
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[0]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[0]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[1]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[1]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[2]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[2]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[3]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[3]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[4]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[4]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[5]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[5]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[6]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[6]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[7]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[7]));
    assertTrue(Bytes.equals(egi.getEndKey(), splitKeys[8]));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), splitKeys[8]));
    assertTrue(egi.getEndKey() == null || egi.getEndKey().length == 0);

    // Now test using start/end with a number of entityGroups

    // Use 80 bit numbers to make sure we aren't limited
    byte[] startKey = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
    byte[] endKey = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };

    // Splitting into 10 entityGroups, we expect (null,1) ... (9, null)
    // with (1,2) (2,3) (3,4) (4,5) (5,6) (6,7) (7,8) (8,9) in the middle

    expectedEntityGroups = 10;

    byte[] TABLE_2 = Bytes.add(tableName, Bytes.toBytes("_2"));

    desc = FMetaTestUtil.makeTable(Bytes.toString(TABLE_2));
    admin = new WaspAdmin(TEST_UTIL.getConfiguration());
    admin.createTable(desc, startKey, endKey, expectedEntityGroups);

    entityGroups = admin.getEntityGroupLocations(TABLE_2);
    assertEquals("Tried to create " + expectedEntityGroups + " entityGroups "
        + "but only found " + entityGroups.size(), expectedEntityGroups,
        entityGroups.size());
    System.err.println("Found " + entityGroups.size() + " entityGroups");

    egis = entityGroups.keySet().iterator();
    egi = egis.next();
    assertTrue(egi.getStartKey() == null || egi.getStartKey().length == 0);
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{1, 1, 1, 1, 1, 1, 1,
        1, 1, 1}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{1, 1, 1, 1, 1, 1,
        1, 1, 1, 1}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{2, 2, 2, 2, 2, 2, 2,
        2, 2, 2}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{2, 2, 2, 2, 2, 2,
        2, 2, 2, 2}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{3, 3, 3, 3, 3, 3, 3,
        3, 3, 3}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{3, 3, 3, 3, 3, 3,
        3, 3, 3, 3}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{4, 4, 4, 4, 4, 4, 4,
        4, 4, 4}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{4, 4, 4, 4, 4, 4,
        4, 4, 4, 4}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{5, 5, 5, 5, 5, 5, 5,
        5, 5, 5}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{5, 5, 5, 5, 5, 5,
        5, 5, 5, 5}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{6, 6, 6, 6, 6, 6, 6,
        6, 6, 6}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{6, 6, 6, 6, 6, 6,
        6, 6, 6, 6}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{7, 7, 7, 7, 7, 7, 7,
        7, 7, 7}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{7, 7, 7, 7, 7, 7,
        7, 7, 7, 7}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{8, 8, 8, 8, 8, 8, 8,
        8, 8, 8}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{8, 8, 8, 8, 8, 8,
        8, 8, 8, 8}));
    assertTrue(Bytes.equals(egi.getEndKey(), new byte[]{9, 9, 9, 9, 9, 9, 9,
        9, 9, 9}));
    egi = egis.next();
    assertTrue(Bytes.equals(egi.getStartKey(), new byte[]{9, 9, 9, 9, 9, 9,
        9, 9, 9, 9}));
    assertTrue(egi.getEndKey() == null || egi.getEndKey().length == 0);

    // Try once more with something that divides into something infinite

    startKey = new byte[] { 0, 0, 0, 0, 0, 0 };
    endKey = new byte[] { 1, 0, 0, 0, 0, 0 };

    expectedEntityGroups = 5;

    byte[] TABLE_3 = Bytes.add(tableName, Bytes.toBytes("_3"));

    desc = FMetaTestUtil.makeTable(Bytes.toString(TABLE_3));
    admin = new WaspAdmin(TEST_UTIL.getConfiguration());
    admin.createTable(desc, startKey, endKey, expectedEntityGroups);

    entityGroups = admin.getEntityGroupLocations(TABLE_3);
    assertEquals("Tried to create " + expectedEntityGroups + " entityGroups "
        + "but only found " + entityGroups.size(), expectedEntityGroups,
        entityGroups.size());
    System.err.println("Found " + entityGroups.size() + " entityGroups");

    // Try an invalid case where there are duplicate split keys
    splitKeys = new byte[][] { new byte[] { 1, 1, 1 }, new byte[] { 2, 2, 2 },
        new byte[] { 3, 3, 3 }, new byte[] { 2, 2, 2 } };

    byte[] TABLE_4 = Bytes.add(tableName, Bytes.toBytes("_4"));
    desc = FMetaTestUtil.makeTable(Bytes.toString(TABLE_4));
    WaspAdmin ladmin = new WaspAdmin(TEST_UTIL.getConfiguration());
    try {
      ladmin.createTable(desc, splitKeys);
      assertTrue("Should not be able to create this table because of "
          + "duplicate split keys", false);
    } catch (IllegalArgumentException iae) {
      // Expected
    }
    ladmin.close();
  }

  @Test
  public void testCreateTableWithOnlyEmptyStartRow() throws IOException {
    byte[][] splitKeys = new byte[1][];
    splitKeys[0] = FConstants.EMPTY_BYTE_ARRAY;
    FTable desc = FMetaTestUtil
        .makeTable("testCreateTableWithOnlyEmptyStartRow");
    try {
      admin.createTable(desc, splitKeys);
      fail("Test case should fail as empty split key is passed.");
    } catch (IllegalArgumentException e) {
    }
  }

  @Test
  public void testCreateTableWithEmptyRowInTheSplitKeys() throws IOException {
    byte[][] splitKeys = new byte[3][];
    splitKeys[0] = "entityGroup1".getBytes();
    splitKeys[1] = FConstants.EMPTY_BYTE_ARRAY;
    splitKeys[2] = "entityGroup2".getBytes();
    FTable desc = FMetaTestUtil
        .makeTable("testCreateTableWithEmptyRowInTheSplitKeys");
    try {
      admin.createTable(desc, splitKeys);
      fail("Test case should fail as empty split key is passed.");
    } catch (IllegalArgumentException e) {
    }
  }

  @Test
  public void testTableExist() throws IOException {
    final byte[] table = Bytes.toBytes("testTableExist");
    boolean exist = false;
    exist = admin.tableExists(table);
    assertEquals(false, exist);
    TEST_UTIL.createTable(table);
    exist = admin.tableExists(table);
    assertEquals(true, exist);
  }

  /**
   *
   * @throws java.io.IOException
   */
  @Test(expected = IllegalArgumentException.class)
  public void testEmptyFTable() throws IOException {
    admin.createTable(new FTable());
  }

  /**
   *
   * @throws Exception
   */
  @Test
  public void testTableNameClash() throws Exception {
    String name = "testTableNameClash";
    admin.createTable(FMetaTestUtil.makeTable(name + "SOMEUPPERCASE"));
    admin.createTable(FMetaTestUtil.makeTable(name));
    // Before fix, below would fail throwing a NoServerForEntityGroupException.
  }

  /**
   *
   * @throws java.io.IOException
   */
  @Test(expected = TableExistsException.class)
  public void testTableExistsExceptionWithATable() throws IOException {
    final byte[] name = Bytes.toBytes("testTableExistsExceptionWithATable");
    TEST_UTIL.createTable(name);
    TEST_UTIL.createTable(name);
  }

  /**
   * Can't disable a table if the table isn't in enabled state
   *
   * @throws java.io.IOException
   */
  @Test(expected = TableNotEnabledException.class)
  public void testTableNotEnabledExceptionWithATable() throws IOException {
    final byte[] name = Bytes.toBytes("testTableNotEnabledExceptionWithATable");
    TEST_UTIL.createTable(name);
    admin.disableTable(name);
    admin.disableTable(name);
  }

  /**
   * Can't enable a table if the table isn't in disabled state
   *
   * @throws java.io.IOException
   */
  // @Test(expected = TableNotDisabledException.class)
  @Test
  public void testTableNotDisabledExceptionWithATable() throws IOException {
    try {
      final byte[] name = Bytes
          .toBytes("testTableNotDisabledExceptionWithATable");
      TEST_UTIL.createTable(name);
      admin.enableTable(name);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  // not pass
  @Test
  public void testShouldCloseTheEntityGroupBasedOnTheEncodedEntityGroupName()
      throws Exception {
    byte[] TABLENAME = Bytes.toBytes("TestWASPCloseEntityGroup");
    createTableWithDefaultConf(TABLENAME);
    EntityGroup eg = null;
    FServer fs = TEST_UTIL.getFSForFirstEntityGroupInTable(TABLENAME);
    for (EntityGroup entityGroup : fs.getOnlineEntityGroups()) {
      eg = entityGroup;
      admin.closeEntityGroupWithEncodedEntityGroupName(entityGroup
          .getEntityGroupInfo().getEncodedName(), fs.getServerName()
          .getServerName());
    }
    Thread.sleep(1000);
    assertFalse(
        "The entityGroup should not be present in online entityGroups list.",
        fs.getOnlineEntityGroups().contains(eg));
  }

  //
  @Test
  public void testCloseEntityGroupIfInvalidEntityGroupNameIsPassed()
      throws Exception {
    byte[] TABLENAME = Bytes.toBytes("TestWASPCloseEntityGroup1");
    createTableWithDefaultConf(TABLENAME);
    EntityGroup eg = null;
    FServer fs = TEST_UTIL.getFSForFirstEntityGroupInTable(TABLENAME);
    for (EntityGroup entityGroup : fs.getOnlineEntityGroups()) {
      if (entityGroup.getEntityGroupNameAsString().contains(
          "TestWASPCloseEntityGroup1")) {
        eg = entityGroup;
        try {
          admin.closeEntityGroup("sample", fs.getServerName().getServerName());
        } catch (UnknownEntityGroupException nsege) {
          // expected, ignore it
        }
      }
    }
    assertTrue(
        "The entityGroup should be present in online entityGroups list.", fs
            .getOnlineEntityGroups().contains(eg));
  }

  @Test(timeout = 36000)
  public void testEnableDisableAddColumnDeleteColumn() throws Exception {
    ZooKeeperWatcher zkw = WaspTestingUtility.getZooKeeperWatcher(TEST_UTIL);
    byte[] tableName = Bytes.toBytes("testMasterAdmin");
    TEST_UTIL.createTable(tableName);
    ZKTable zkTable = new ZKTable(zkw);
    while (!zkTable.isEnabledTable("testMasterAdmin")) {
      Thread.sleep(10);
    }
    admin.disableTable(tableName);
    admin.addColumn(tableName, new Field(FieldKeyWord.REQUIRED, "cf", "col2",
        DataType.STRING, null));
    admin.enableTable(tableName);
    try {
      admin.deleteColumn(tableName, Bytes.toBytes("col2"));
    } catch (TableNotDisabledException e) {
      LOG.info(e);
    }
    admin.disableTable(tableName);
    admin.deleteTable(tableName);
  }

  @Test
  public void testCloseEntityGroupThatFetchesTheEGIFromMeta() throws Exception {
    byte[] TABLENAME = Bytes.toBytes("TestWASPCloseEntityGroup2");
    createTableWithDefaultConf(TABLENAME);
    EntityGroup eg = null;
    FServer fs = TEST_UTIL.getFSForFirstEntityGroupInTable(TABLENAME);
    for (EntityGroup entityGroup : fs.getOnlineEntityGroups()) {
      if (entityGroup.getEntityGroupNameAsString().contains(
          "TestWASPCloseEntityGroup2")) {
        eg = entityGroup;
        admin.closeEntityGroup(entityGroup.getEntityGroupNameAsString(), fs
            .getServerName().getServerName());
      }
    }
    boolean isInList = fs.getOnlineEntityGroups().contains(eg);
    long timeout = System.currentTimeMillis() + 2000;
    while ((System.currentTimeMillis() < timeout) && (isInList)) {
      Thread.sleep(100);
      isInList = fs.getOnlineEntityGroups().contains(eg);
    }
    assertFalse(
        "The EntityGroup should not be present in online EntityGroups list.",
        isInList);
  }

  @Test
  public void testCloseEntityGroupWhenServerNameIsEmpty() throws Exception {
    byte[] TABLENAME = Bytes
        .toBytes("TestWASPCloseEntityGroupWhenServerNameIsEmpty");
    createTableWithDefaultConf(TABLENAME);
    FServer fs = TEST_UTIL.getFSForFirstEntityGroupInTable(TABLENAME);
    try {
      for (EntityGroup entityGroup : fs.getOnlineEntityGroups()) {
        if (entityGroup.getEntityGroupNameAsString().contains(
            "TestWASPCloseEntityGroupWhenServerNameIsEmpty")) {
          admin.closeEntityGroup(entityGroup.getEntityGroupInfo()
              .getEncodedName(), " ");
        }
      }
      fail("The test should throw exception if the servername passed is empty.");
    } catch (IllegalArgumentException e) {
    }
  }

  @Test
  public void testCloseEntityGroupWhenEncodedEntityGroupNameIsNotGiven()
      throws Exception {
    byte[] TABLENAME = Bytes.toBytes("TestWASPCloseEntityGroup4");
    createTableWithDefaultConf(TABLENAME);
    EntityGroup eg = null;
    FServer fs = TEST_UTIL.getFSForFirstEntityGroupInTable(TABLENAME);

    for (EntityGroup entityGroup : fs.getOnlineEntityGroups()) {
      if (entityGroup.getEntityGroupNameAsString().contains(
          "TestWASPCloseEntityGroup4")) {
        eg = entityGroup;
        try{
          admin.closeEntityGroupWithEncodedEntityGroupName(entityGroup.getEntityGroupNameAsString(), fs
              .getServerName().getServerName());
        } catch (NotServingEntityGroupException nseg) {
          // expected, ignore it.
        }
      }
    }
    assertTrue(
        "The entityGroup should be present in online entityGroups list.", fs
            .getOnlineEntityGroups().contains(eg));
  }

  private void createTableWithDefaultConf(byte[] TABLENAME) throws IOException {
    TEST_UTIL.createTable(TABLENAME);
  }

  /**
   *
   * @throws java.io.IOException
   */
  @Test
  public void testGetTableEntityGroups() throws IOException {
    byte[] tableName = Bytes.toBytes("testGetTableEntityGroups");
    int expectedEntityGroups = 10;
    // Use 80 bit numbers to make sure we aren't limited
    byte[] startKey = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
    byte[] endKey = { 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
    FTable desc = FMetaTestUtil.makeTable("testGetTableEntityGroups");
    admin.createTable(desc, startKey, endKey, expectedEntityGroups);
    List<EntityGroupInfo> egis = admin.getTableEntityGroups(tableName);
    assertEquals("Tried to create " + expectedEntityGroups + " EntityGroups "
        + "but only found " + egis.size(), expectedEntityGroups, egis.size());
  }

  /**
   * checkWaspAvailable() doesn't close zk connections
   */
  @Test
  public void testCheckWaspAvailableClosesConnection() throws Exception {
    Configuration conf = TEST_UTIL.getConfiguration();
    int initialCount = TestFConnectionUtility.getConnectionCount();
    WaspAdmin.checkWaspAvailable(conf);
    int finalCount = TestFConnectionUtility.getConnectionCount();
    Assert.assertEquals(initialCount, finalCount);
  }

  /**
   * Check if table locked
   *
   * @throws java.io.IOException
   */
  @Test
  public void testTableLocked() throws IOException {
    try {
      final byte[] name = Bytes.toBytes("testTableLocked");
      TEST_UTIL.createTable(name);
      admin.isTableLocked(name);
    } catch (Exception e) {
      e.printStackTrace();
      assertTrue(false);
    }
  }
}
TOP

Related Classes of com.alibaba.wasp.client.TestAdmin

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.