hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestDeadServer.java

   1 /**
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements.  See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership.  The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License.  You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 package org.apache.hadoop.hbase.master;
  19
  20 import static org.junit.Assert.assertFalse;
  21 import static org.junit.Assert.assertTrue;
  22
  23 import java.io.IOException;
  24 import java.util.List;
  25 import java.util.Set;
  26 import org.apache.hadoop.hbase.HBaseClassTestRule;
  27 import org.apache.hadoop.hbase.HBaseTestingUtil;
  28 import org.apache.hadoop.hbase.HConstants;
  29 import org.apache.hadoop.hbase.ServerName;
  30 import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
  31 import org.apache.hadoop.hbase.master.procedure.ServerCrashProcedure;
  32 import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
  33 import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility;
  34 import org.apache.hadoop.hbase.testclassification.MasterTests;
  35 import org.apache.hadoop.hbase.testclassification.MediumTests;
  36 import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
  37 import org.apache.hadoop.hbase.util.ManualEnvironmentEdge;
  38 import org.apache.hadoop.hbase.util.Pair;
  39 import org.junit.AfterClass;
  40 import org.junit.Assert;
  41 import org.junit.BeforeClass;
  42 import org.junit.ClassRule;
  43 import org.junit.Test;
  44 import org.junit.experimental.categories.Category;
  45
  46 @Category({MasterTests.class, MediumTests.class})
  47 public class TestDeadServer {
  48
  49   @ClassRule
  50   public static final HBaseClassTestRule CLASS_RULE =
  51       HBaseClassTestRule.forClass(TestDeadServer.class);
  52
  53   private static final HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil();
  54
  55   final ServerName hostname123 = ServerName.valueOf("127.0.0.1", 123, 3L);
  56   final ServerName hostname123_2 = ServerName.valueOf("127.0.0.1", 123, 4L);
  57   final ServerName hostname1234 = ServerName.valueOf("127.0.0.2", 1234, 4L);
  58   final ServerName hostname12345 = ServerName.valueOf("127.0.0.2", 12345, 4L);
  59
  60   @BeforeClass
  61   public static void setupBeforeClass() throws Exception {
  62     TEST_UTIL.startMiniCluster();
  63   }
  64
  65   @AfterClass
  66   public static void tearDownAfterClass() throws Exception {
  67     TEST_UTIL.shutdownMiniCluster();
  68   }
  69
  70   @Test public void testIsDead() {
  71     DeadServer ds = new DeadServer();
  72     ds.putIfAbsent(hostname123);
  73
  74     ds.putIfAbsent(hostname1234);
  75
  76     ds.putIfAbsent(hostname12345);
  77
  78     // Already dead =       127.0.0.1,9090,112321
  79     // Coming back alive =  127.0.0.1,9090,223341
  80
  81     final ServerName deadServer = ServerName.valueOf("127.0.0.1", 9090, 112321L);
  82     assertFalse(ds.cleanPreviousInstance(deadServer));
  83     ds.putIfAbsent(deadServer);
  84     assertTrue(ds.isDeadServer(deadServer));
  85     Set<ServerName> deadServerNames = ds.copyServerNames();
  86     for (ServerName eachDeadServer : deadServerNames) {
  87       Assert.assertNotNull(ds.getTimeOfDeath(eachDeadServer));
  88     }
  89     final ServerName deadServerHostComingAlive =
  90         ServerName.valueOf("127.0.0.1", 9090, 223341L);
  91     assertTrue(ds.cleanPreviousInstance(deadServerHostComingAlive));
  92     assertFalse(ds.isDeadServer(deadServer));
  93     assertFalse(ds.cleanPreviousInstance(deadServerHostComingAlive));
  94   }
  95
  96   @Test
  97   public void testCrashProcedureReplay() throws Exception {
  98     HMaster master = TEST_UTIL.getHBaseCluster().getMaster();
  99     final ProcedureExecutor<MasterProcedureEnv> pExecutor = master.getMasterProcedureExecutor();
 100     ServerCrashProcedure proc = new ServerCrashProcedure(
 101       pExecutor.getEnvironment(), hostname123, false, false);
 102
 103     pExecutor.stop();
 104     ProcedureTestingUtility.submitAndWait(pExecutor, proc);
 105     assertTrue(master.getServerManager().areDeadServersInProgress());
 106
 107     ProcedureTestingUtility.restart(pExecutor);
 108     ProcedureTestingUtility.waitProcedure(pExecutor, proc);
 109     assertFalse(master.getServerManager().areDeadServersInProgress());
 110   }
 111
 112   @Test
 113   public void testSortExtract(){
 114     ManualEnvironmentEdge mee = new ManualEnvironmentEdge();
 115     EnvironmentEdgeManager.injectEdge(mee);
 116     mee.setValue(1);
 117
 118     DeadServer d = new DeadServer();
 119
 120     d.putIfAbsent(hostname123);
 121     mee.incValue(1);
 122     d.putIfAbsent(hostname1234);
 123     mee.incValue(1);
 124     d.putIfAbsent(hostname12345);
 125
 126     List<Pair<ServerName, Long>> copy = d.copyDeadServersSince(2L);
 127     Assert.assertEquals(2, copy.size());
 128
 129     Assert.assertEquals(hostname1234, copy.get(0).getFirst());
 130     Assert.assertEquals(new Long(2L), copy.get(0).getSecond());
 131
 132     Assert.assertEquals(hostname12345, copy.get(1).getFirst());
 133     Assert.assertEquals(new Long(3L), copy.get(1).getSecond());
 134
 135     EnvironmentEdgeManager.reset();
 136   }
 137
 138   @Test
 139   public void testClean(){
 140     DeadServer d = new DeadServer();
 141     d.putIfAbsent(hostname123);
 142
 143     d.cleanPreviousInstance(hostname12345);
 144     Assert.assertFalse(d.isEmpty());
 145
 146     d.cleanPreviousInstance(hostname1234);
 147     Assert.assertFalse(d.isEmpty());
 148
 149     d.cleanPreviousInstance(hostname123_2);
 150     Assert.assertTrue(d.isEmpty());
 151   }
 152
 153   @Test
 154   public void testClearDeadServer(){
 155     DeadServer d = new DeadServer();
 156     d.putIfAbsent(hostname123);
 157     d.putIfAbsent(hostname1234);
 158     Assert.assertEquals(2, d.size());
 159
 160     d.removeDeadServer(hostname123);
 161     Assert.assertEquals(1, d.size());
 162     d.removeDeadServer(hostname1234);
 163     Assert.assertTrue(d.isEmpty());
 164
 165     d.putIfAbsent(hostname1234);
 166     Assert.assertFalse(d.removeDeadServer(hostname123_2));
 167     Assert.assertEquals(1, d.size());
 168     Assert.assertTrue(d.removeDeadServer(hostname1234));
 169     Assert.assertTrue(d.isEmpty());
 170   }
 171 }
 172