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.util.List;
  24 import java.util.Set;
  25 import org.apache.hadoop.hbase.HBaseClassTestRule;
  26 import org.apache.hadoop.hbase.HBaseTestingUtility;
  27 import org.apache.hadoop.hbase.ServerName;
  28 import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
  29 import org.apache.hadoop.hbase.master.procedure.ServerCrashProcedure;
  30 import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
  31 import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility;
  32 import org.apache.hadoop.hbase.testclassification.MasterTests;
  33 import org.apache.hadoop.hbase.testclassification.MediumTests;
  34 import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
  35 import org.apache.hadoop.hbase.util.ManualEnvironmentEdge;
  36 import org.apache.hadoop.hbase.util.Pair;
  37 import org.junit.AfterClass;
  38 import org.junit.Assert;
  39 import org.junit.BeforeClass;
  40 import org.junit.ClassRule;
  41 import org.junit.Test;
  42 import org.junit.experimental.categories.Category;
  43
  44 @Category({MasterTests.class, MediumTests.class})
  45 public class TestDeadServer {
  46
  47   @ClassRule
  48   public static final HBaseClassTestRule CLASS_RULE =
  49       HBaseClassTestRule.forClass(TestDeadServer.class);
  50
  51   private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility();
  52
  53   final ServerName hostname123 = ServerName.valueOf("127.0.0.1", 123, 3L);
  54   final ServerName hostname123_2 = ServerName.valueOf("127.0.0.1", 123, 4L);
  55   final ServerName hostname1234 = ServerName.valueOf("127.0.0.2", 1234, 4L);
  56   final ServerName hostname12345 = ServerName.valueOf("127.0.0.2", 12345, 4L);
  57
  58   @BeforeClass
  59   public static void setupBeforeClass() throws Exception {
  60     TEST_UTIL.startMiniCluster();
  61   }
  62
  63   @AfterClass
  64   public static void tearDownAfterClass() throws Exception {
  65     TEST_UTIL.shutdownMiniCluster();
  66   }
  67
  68   @Test public void testIsDead() {
  69     DeadServer ds = new DeadServer();
  70     ds.putIfAbsent(hostname123);
  71     ds.processing(hostname123);
  72     assertTrue(ds.areDeadServersInProgress());
  73     ds.finish(hostname123);
  74     assertFalse(ds.areDeadServersInProgress());
  75
  76     ds.putIfAbsent(hostname1234);
  77     ds.processing(hostname1234);
  78     assertTrue(ds.areDeadServersInProgress());
  79     ds.finish(hostname1234);
  80     assertFalse(ds.areDeadServersInProgress());
  81
  82     ds.putIfAbsent(hostname12345);
  83     ds.processing(hostname12345);
  84     assertTrue(ds.areDeadServersInProgress());
  85     ds.finish(hostname12345);
  86     assertFalse(ds.areDeadServersInProgress());
  87
  88     // Already dead =       127.0.0.1,9090,112321
  89     // Coming back alive =  127.0.0.1,9090,223341
  90
  91     final ServerName deadServer = ServerName.valueOf("127.0.0.1", 9090, 112321L);
  92     assertFalse(ds.cleanPreviousInstance(deadServer));
  93     ds.putIfAbsent(deadServer);
  94     assertTrue(ds.isDeadServer(deadServer));
  95     Set<ServerName> deadServerNames = ds.copyServerNames();
  96     for (ServerName eachDeadServer : deadServerNames) {
  97       Assert.assertNotNull(ds.getTimeOfDeath(eachDeadServer));
  98     }
  99     final ServerName deadServerHostComingAlive =
 100         ServerName.valueOf("127.0.0.1", 9090, 223341L);
 101     assertTrue(ds.cleanPreviousInstance(deadServerHostComingAlive));
 102     assertFalse(ds.isDeadServer(deadServer));
 103     assertFalse(ds.cleanPreviousInstance(deadServerHostComingAlive));
 104   }
 105
 106   @Test
 107   public void testCrashProcedureReplay() {
 108     HMaster master = TEST_UTIL.getHBaseCluster().getMaster();
 109     final ProcedureExecutor<MasterProcedureEnv> pExecutor = master.getMasterProcedureExecutor();
 110     ServerCrashProcedure proc = new ServerCrashProcedure(
 111       pExecutor.getEnvironment(), hostname123, false, false);
 112
 113     ProcedureTestingUtility.submitAndWait(pExecutor, proc);
 114
 115     assertFalse(master.getServerManager().getDeadServers().areDeadServersInProgress());
 116   }
 117
 118   @Test
 119   public void testSortExtract(){
 120     ManualEnvironmentEdge mee = new ManualEnvironmentEdge();
 121     EnvironmentEdgeManager.injectEdge(mee);
 122     mee.setValue(1);
 123
 124     DeadServer d = new DeadServer();
 125
 126     d.putIfAbsent(hostname123);
 127     mee.incValue(1);
 128     d.putIfAbsent(hostname1234);
 129     mee.incValue(1);
 130     d.putIfAbsent(hostname12345);
 131
 132     List<Pair<ServerName, Long>> copy = d.copyDeadServersSince(2L);
 133     Assert.assertEquals(2, copy.size());
 134
 135     Assert.assertEquals(hostname1234, copy.get(0).getFirst());
 136     Assert.assertEquals(new Long(2L), copy.get(0).getSecond());
 137
 138     Assert.assertEquals(hostname12345, copy.get(1).getFirst());
 139     Assert.assertEquals(new Long(3L), copy.get(1).getSecond());
 140
 141     EnvironmentEdgeManager.reset();
 142   }
 143
 144   @Test
 145   public void testClean(){
 146     DeadServer d = new DeadServer();
 147     d.putIfAbsent(hostname123);
 148
 149     d.cleanPreviousInstance(hostname12345);
 150     Assert.assertFalse(d.isEmpty());
 151
 152     d.cleanPreviousInstance(hostname1234);
 153     Assert.assertFalse(d.isEmpty());
 154
 155     d.cleanPreviousInstance(hostname123_2);
 156     Assert.assertTrue(d.isEmpty());
 157   }
 158
 159   @Test
 160   public void testClearDeadServer(){
 161     DeadServer d = new DeadServer();
 162     d.putIfAbsent(hostname123);
 163     d.putIfAbsent(hostname1234);
 164     Assert.assertEquals(2, d.size());
 165
 166     d.finish(hostname123);
 167     d.removeDeadServer(hostname123);
 168     Assert.assertEquals(1, d.size());
 169     d.finish(hostname1234);
 170     d.removeDeadServer(hostname1234);
 171     Assert.assertTrue(d.isEmpty());
 172
 173     d.putIfAbsent(hostname1234);
 174     Assert.assertFalse(d.removeDeadServer(hostname123_2));
 175     Assert.assertEquals(1, d.size());
 176     d.finish(hostname1234);
 177     Assert.assertTrue(d.removeDeadServer(hostname1234));
 178     Assert.assertTrue(d.isEmpty());
 179   }
 180 }
 181