001/** 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018package org.apache.hadoop.hbase.procedure2.store; 019 020import static org.junit.Assert.assertEquals; 021import static org.junit.Assert.assertFalse; 022import static org.junit.Assert.assertTrue; 023 024import java.util.Random; 025import org.apache.hadoop.hbase.HBaseClassTestRule; 026import org.apache.hadoop.hbase.procedure2.Procedure; 027import org.apache.hadoop.hbase.testclassification.MasterTests; 028import org.apache.hadoop.hbase.testclassification.MediumTests; 029import org.junit.ClassRule; 030import org.junit.Test; 031import org.junit.experimental.categories.Category; 032import org.slf4j.Logger; 033import org.slf4j.LoggerFactory; 034 035@Category({MasterTests.class, MediumTests.class}) 036public class TestProcedureStoreTracker { 037 038 @ClassRule 039 public static final HBaseClassTestRule CLASS_RULE = 040 HBaseClassTestRule.forClass(TestProcedureStoreTracker.class); 041 042 private static final Logger LOG = LoggerFactory.getLogger(TestProcedureStoreTracker.class); 043 044 @Test 045 public void testSeqInsertAndDelete() { 046 ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 047 assertTrue(tracker.isEmpty()); 048 049 final int MIN_PROC = 1; 050 final int MAX_PROC = 1 << 10; 051 052 // sequential insert 053 for (int i = MIN_PROC; i < MAX_PROC; ++i) { 054 tracker.insert(i); 055 056 // All the proc that we inserted should not be deleted 057 for (int j = MIN_PROC; j <= i; ++j) { 058 assertEquals(ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(j)); 059 } 060 // All the proc that are not yet inserted should be result as deleted 061 for (int j = i + 1; j < MAX_PROC; ++j) { 062 assertTrue(tracker.isDeleted(j) != ProcedureStoreTracker.DeleteState.NO); 063 } 064 } 065 066 // sequential delete 067 for (int i = MIN_PROC; i < MAX_PROC; ++i) { 068 tracker.delete(i); 069 070 // All the proc that we deleted should be deleted 071 for (int j = MIN_PROC; j <= i; ++j) { 072 assertEquals(ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(j)); 073 } 074 // All the proc that are not yet deleted should be result as not deleted 075 for (int j = i + 1; j < MAX_PROC; ++j) { 076 assertEquals(ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(j)); 077 } 078 } 079 assertTrue(tracker.isEmpty()); 080 } 081 082 @Test 083 public void testPartialTracker() { 084 ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 085 tracker.setPartialFlag(true); 086 087 // nothing in the tracker, the state is unknown 088 assertTrue(tracker.isEmpty()); 089 assertEquals(ProcedureStoreTracker.DeleteState.MAYBE, tracker.isDeleted(1)); 090 assertEquals(ProcedureStoreTracker.DeleteState.MAYBE, tracker.isDeleted(579)); 091 092 // Mark 1 as deleted, now that is a known state 093 tracker.setDeleted(1, true); 094 tracker.dump(); 095 assertEquals(ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(1)); 096 assertEquals(ProcedureStoreTracker.DeleteState.MAYBE, tracker.isDeleted(2)); 097 assertEquals(ProcedureStoreTracker.DeleteState.MAYBE, tracker.isDeleted(579)); 098 099 // Mark 579 as non-deleted, now that is a known state 100 tracker.setDeleted(579, false); 101 assertEquals(ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(1)); 102 assertEquals(ProcedureStoreTracker.DeleteState.MAYBE, tracker.isDeleted(2)); 103 assertEquals(ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(579)); 104 assertEquals(ProcedureStoreTracker.DeleteState.MAYBE, tracker.isDeleted(577)); 105 assertEquals(ProcedureStoreTracker.DeleteState.MAYBE, tracker.isDeleted(580)); 106 107 tracker.setDeleted(579, true); 108 tracker.setPartialFlag(false); 109 assertTrue(tracker.isEmpty()); 110 } 111 112 @Test 113 public void testBasicCRUD() { 114 ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 115 assertTrue(tracker.isEmpty()); 116 117 long[] procs = new long[] { 1, 2, 3, 4, 5, 6 }; 118 119 tracker.insert(procs[0]); 120 tracker.insert(procs[1], new long[] { procs[2], procs[3], procs[4] }); 121 assertFalse(tracker.isEmpty()); 122 assertTrue(tracker.isAllModified()); 123 124 tracker.resetModified(); 125 assertFalse(tracker.isAllModified()); 126 127 for (int i = 0; i < 4; ++i) { 128 tracker.update(procs[i]); 129 assertFalse(tracker.isEmpty()); 130 assertFalse(tracker.isAllModified()); 131 } 132 133 tracker.update(procs[4]); 134 assertFalse(tracker.isEmpty()); 135 assertTrue(tracker.isAllModified()); 136 137 tracker.update(procs[5]); 138 assertFalse(tracker.isEmpty()); 139 assertTrue(tracker.isAllModified()); 140 141 for (int i = 0; i < 5; ++i) { 142 tracker.delete(procs[i]); 143 assertFalse(tracker.isEmpty()); 144 assertTrue(tracker.isAllModified()); 145 } 146 tracker.delete(procs[5]); 147 assertTrue(tracker.isEmpty()); 148 } 149 150 @Test 151 public void testRandLoad() { 152 final int NPROCEDURES = 2500; 153 final int NRUNS = 5000; 154 155 final ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 156 157 Random rand = new Random(1); 158 for (int i = 0; i < NRUNS; ++i) { 159 assertTrue(tracker.isEmpty()); 160 161 int count = 0; 162 while (count < NPROCEDURES) { 163 long procId = rand.nextLong(); 164 if (procId < 1) continue; 165 166 tracker.setDeleted(procId, i % 2 == 0); 167 count++; 168 } 169 170 tracker.reset(); 171 } 172 } 173 174 @Test 175 public void testLoad() { 176 final int MAX_PROCS = 1000; 177 final ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 178 for (int numProcs = 1; numProcs < MAX_PROCS; ++numProcs) { 179 for (int start = 1; start <= numProcs; ++start) { 180 assertTrue(tracker.isEmpty()); 181 182 LOG.debug("loading " + numProcs + " procs from start=" + start); 183 for (int i = start; i <= numProcs; ++i) { 184 tracker.setDeleted(i, false); 185 } 186 for (int i = 1; i < start; ++i) { 187 tracker.setDeleted(i, false); 188 } 189 190 tracker.reset(); 191 } 192 } 193 } 194 195 @Test 196 public void testDelete() { 197 final ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 198 199 long[] procIds = new long[] { 65, 1, 193 }; 200 for (int i = 0; i < procIds.length; ++i) { 201 tracker.insert(procIds[i]); 202 tracker.dump(); 203 } 204 205 for (int i = 0; i < (64 * 4); ++i) { 206 boolean hasProc = false; 207 for (int j = 0; j < procIds.length; ++j) { 208 if (procIds[j] == i) { 209 hasProc = true; 210 break; 211 } 212 } 213 if (hasProc) { 214 assertEquals(ProcedureStoreTracker.DeleteState.NO, tracker.isDeleted(i)); 215 } else { 216 assertEquals("procId=" + i, ProcedureStoreTracker.DeleteState.YES, tracker.isDeleted(i)); 217 } 218 } 219 } 220 221 @Test 222 public void testSetDeletedIfModified() { 223 final ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 224 final long[] procIds = new long[] { 1, 3, 7, 152, 512, 1024, 1025 }; 225 226 // test single proc 227 for (int i = 0; i < procIds.length; ++i) { 228 tracker.insert(procIds[i]); 229 } 230 assertEquals(false, tracker.isEmpty()); 231 232 for (int i = 0; i < procIds.length; ++i) { 233 tracker.setDeletedIfModified(procIds[i] - 1); 234 tracker.setDeletedIfModified(procIds[i]); 235 tracker.setDeletedIfModified(procIds[i] + 1); 236 } 237 assertEquals(true, tracker.isEmpty()); 238 239 // test batch 240 tracker.reset(); 241 for (int i = 0; i < procIds.length; ++i) { 242 tracker.insert(procIds[i]); 243 } 244 assertEquals(false, tracker.isEmpty()); 245 246 tracker.setDeletedIfModified(procIds); 247 assertEquals(true, tracker.isEmpty()); 248 } 249 250 @Test 251 public void testGetActiveProcIds() { 252 ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 253 for (int i = 0; i < 10000; i++) { 254 tracker.insert(i * 10); 255 } 256 for (int i = 0; i < 10000; i += 2) { 257 tracker.delete(i * 10); 258 } 259 long[] activeProcIds = tracker.getAllActiveProcIds(); 260 assertEquals(5000, activeProcIds.length); 261 for (int i = 0; i < 5000; i++) { 262 assertEquals((2 * i + 1) * 10, activeProcIds[i]); 263 } 264 } 265 266 @Test 267 public void testGetActiveMinProcId() { 268 ProcedureStoreTracker tracker = new ProcedureStoreTracker(); 269 assertEquals(Procedure.NO_PROC_ID, tracker.getActiveMinProcId()); 270 for (int i = 100; i < 1000; i = 2 * i + 1) { 271 tracker.insert(i); 272 } 273 for (int i = 100; i < 1000; i = 2 * i + 1) { 274 assertEquals(i, tracker.getActiveMinProcId()); 275 tracker.delete(i); 276 } 277 assertEquals(Procedure.NO_PROC_ID, tracker.getActiveMinProcId()); 278 } 279}