/**
    * Copyright 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 org.apache.hadoop.hbase.rsgroup;
  
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertFalse;
  import static org.junit.Assert.assertTrue;
  
  import com.google.common.collect.Lists;
  
  import java.io.IOException;
  import java.util.Set;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.hadoop.hbase.HColumnDescriptor;
  import org.apache.hadoop.hbase.HTableDescriptor;
  import org.apache.hadoop.hbase.NamespaceDescriptor;
  import org.apache.hadoop.hbase.ServerName;
  import org.apache.hadoop.hbase.TableName;
  import org.apache.hadoop.hbase.Waiter;
  import org.apache.hadoop.hbase.client.ClusterConnection;
  import org.apache.hadoop.hbase.master.HMaster;
  import org.apache.hadoop.hbase.net.Address;
  import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
  import org.apache.hadoop.hbase.protobuf.generated.AdminProtos;
  import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetServerInfoRequest;
  import org.apache.hadoop.hbase.testclassification.MediumTests;
  import org.apache.hadoop.hbase.util.Bytes;
  import org.junit.After;
  import org.junit.AfterClass;
  import org.junit.Assert;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import org.junit.Test;
  import org.junit.experimental.categories.Category;
  
  @Category({MediumTests.class})
  public class TestRSGroupsBasics extends TestRSGroupsBase {
    protected static final Log LOG = LogFactory.getLog(TestRSGroupsBasics.class);
  
    @BeforeClass
    public static void setUp() throws Exception {
      setUpTestBeforeClass();
    }
  
    @AfterClass
    public static void tearDown() throws Exception {
      tearDownAfterClass();
    }
  
    @Before
    public void beforeMethod() throws Exception {
      setUpBeforeMethod();
    }
  
    @After
    public void afterMethod() throws Exception {
      tearDownAfterMethod();
    }
  
    @Test
    public void testBasicStartUp() throws IOException {
      RSGroupInfo defaultInfo = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP);
      assertEquals(NUM_SLAVES_BASE, defaultInfo.getServers().size());
      // Assignment of meta, namespace and rsgroup regions.
      int count = master.getAssignmentManager().getRegionStates().getRegionAssignments().size();
      // 3 (meta, namespace and rsgroup)
      assertEquals(3, count);
    }
  
    @Test
    public void testCreateAndDrop() throws Exception {
      LOG.info("testCreateAndDrop");
      final TableName tableName = TableName.valueOf(tablePrefix + "_testCreateAndDrop");
      TEST_UTIL.createTable(tableName, Bytes.toBytes("cf"));
      //wait for created table to be assigned
      TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate<Exception>() {
        @Override
        public boolean evaluate() throws Exception {
          return getTableRegionMap().get(tableName) != null;
        }
     });
     TEST_UTIL.deleteTable(tableName);
   }
 
   @Test
   public void testCreateMultiRegion() throws IOException {
     LOG.info("testCreateMultiRegion");
     TableName tableName = TableName.valueOf(tablePrefix + "_testCreateMultiRegion");
     byte[] end = {1,3,5,7,9};
     byte[] start = {0,2,4,6,8};
     byte[][] f = {Bytes.toBytes("f")};
     TEST_UTIL.createTable(tableName, f,1,start,end,10);
   }
 
   @Test
   public void testNamespaceCreateAndAssign() throws Exception {
     LOG.info("testNamespaceCreateAndAssign");
     String nsName = tablePrefix+"_foo";
     final TableName tableName = TableName.valueOf(nsName, tablePrefix + "_testCreateAndAssign");
     RSGroupInfo appInfo = addGroup(rsGroupAdmin, "appInfo", 1);
     admin.createNamespace(NamespaceDescriptor.create(nsName)
         .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "appInfo").build());
     final HTableDescriptor desc = new HTableDescriptor(tableName);
     desc.addFamily(new HColumnDescriptor("f"));
     admin.createTable(desc);
     //wait for created table to be assigned
     TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate<Exception>() {
       @Override
       public boolean evaluate() throws Exception {
         return getTableRegionMap().get(desc.getTableName()) != null;
       }
     });
     ServerName targetServer =
         ServerName.parseServerName(appInfo.getServers().iterator().next().toString());
     AdminProtos.AdminService.BlockingInterface rs = admin.getConnection().getAdmin(targetServer);
     //verify it was assigned to the right group
     Assert.assertEquals(1, ProtobufUtil.getOnlineRegions(rs).size());
   }
 
   @Test
   public void testDefaultNamespaceCreateAndAssign() throws Exception {
     LOG.info("testDefaultNamespaceCreateAndAssign");
     final byte[] tableName = Bytes.toBytes(tablePrefix + "_testCreateAndAssign");
     admin.modifyNamespace(NamespaceDescriptor.create("default")
         .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "default").build());
     final HTableDescriptor desc = new HTableDescriptor(tableName);
     desc.addFamily(new HColumnDescriptor("f"));
     admin.createTable(desc);
     //wait for created table to be assigned
     TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate<Exception>() {
       @Override
       public boolean evaluate() throws Exception {
         return getTableRegionMap().get(desc.getTableName()) != null;
       }
     });
   }
 
   @Test
   public void testCloneSnapshot() throws Exception {
     final TableName tableName = TableName.valueOf(tablePrefix+"_testCloneSnapshot");
     LOG.info("testCloneSnapshot");
 
     byte[] FAMILY = Bytes.toBytes("test");
     String snapshotName = tableName.getNameAsString() + "_snap";
     TableName clonedTableName = TableName.valueOf(tableName.getNameAsString() + "_clone");
 
     // create base table
     TEST_UTIL.createTable(tableName, FAMILY);
 
     // create snapshot
     admin.snapshot(snapshotName, tableName);
 
     // clone
     admin.cloneSnapshot(snapshotName, clonedTableName);
   }
 
   @Test
   public void testClearDeadServers() throws Exception {
     // move region servers from default group to new group
     final int serverCountToMoveToNewGroup = 3;
     final RSGroupInfo newGroup =
         addGroup(rsGroupAdmin, "testClearDeadServers", serverCountToMoveToNewGroup);
 
     // stop 1 region server in new group
     ServerName serverToStop = ServerName.parseServerName(
         newGroup.getServers().iterator().next().toString());
     AdminProtos.AdminService.BlockingInterface regionServerToStop =
         ((ClusterConnection) admin.getConnection()).getAdmin(serverToStop);
     try {
       serverToStop = ProtobufUtil.toServerName(regionServerToStop.getServerInfo(null,
           GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName());
       //stopping may cause an exception
       //due to the connection loss
       regionServerToStop.stopServer(null,
           AdminProtos.StopServerRequest.newBuilder().setReason("Die").build());
     } catch(Exception e) {
     }
 
     // wait for the stopped region server to show up in dead server list
     final HMaster master = TEST_UTIL.getHBaseCluster().getMaster();
     TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate<Exception>() {
       @Override
       public boolean evaluate() throws Exception {
         return !master.getServerManager().areDeadServersInProgress()
             && cluster.getClusterStatus().getDeadServerNames().size() > 0;
       }
     });
 
     // verify
     assertFalse(cluster.getClusterStatus().getServers().contains(serverToStop));
     assertTrue(cluster.getClusterStatus().getDeadServerNames().contains(serverToStop));
     assertTrue(newGroup.getServers().contains(serverToStop.getAddress()));
 
     // clear dead servers list
     // We need to retry here because the clearDeadServers() RPC may race with currently processing
     // dead servers in the ServerManager and might not succeed.
     final ServerName finalServerToStop = serverToStop;
     TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate<Exception>() {
       @Override
       public boolean evaluate() throws Exception {
         return admin.clearDeadServers(Lists.newArrayList(finalServerToStop)).isEmpty();
       }
     });
     // verify if the stopped region server gets cleared and removed from the group
     Set<Address> newGroupServers = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers();
     assertFalse(newGroupServers.contains(serverToStop.getAddress()));
     assertEquals(serverCountToMoveToNewGroup - 1 /* 1 stopped */, newGroupServers.size());
   }
 }