/** * Resets the managed instance to the default instance: {@link * DefaultEnvironmentEdge}. */ public static void reset() { injectEdge(new DefaultEnvironmentEdge()); }
public static void injectEdge(EnvironmentEdge edge) { EnvironmentEdgeManager.injectEdge(edge); } }
protected static final void initialize(Class<?>... cps) throws Exception { // Uncomment the following lines if more verbosity is needed for // debugging (see HBASE-12285 for details). // ((Log4JLogger)RpcServer.LOG).getLogger().setLevel(Level.ALL); // ((Log4JLogger)RpcClient.LOG).getLogger().setLevel(Level.ALL); // ((Log4JLogger)ScannerCallable.LOG).getLogger().setLevel(Level.ALL); // make sure that we do not get the same ts twice, see HBASE-19731 for more details. EnvironmentEdgeManager.injectEdge(new NonRepeatedEnvironmentEdge()); Configuration conf = TEST_UTIL.getConfiguration(); conf.setStrings(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, Arrays.stream(cps).map(Class::getName).toArray(String[]::new)); conf.setBoolean("hbase.table.sanity.checks", true); // enable for below tests // We need more than one region server in this test TEST_UTIL.startMiniCluster(SLAVES); }
@Before public void before() { mee.setValue(0); EnvironmentEdgeManager.injectEdge(mee); }
@BeforeClass public static void setupBeforeClass() throws Exception { util.getConfiguration().set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, MyObserver.class.getName()); // Make general delay zero rather than default. Timing is off in this // test that depends on an evironment edge that is manually moved forward. util.getConfiguration().setInt(RemoteProcedureDispatcher.DISPATCH_DELAY_CONF_KEY, 0); util.startMiniCluster(); EnvironmentEdgeManager.injectEdge(mee); }
@BeforeClass public static void setupBeforeClass() throws Exception { util.getConfiguration().set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, MyObserver.class.getName()); // Make general delay zero rather than default. Timing is off in this // test that depends on an evironment edge that is manually moved forward. util.getConfiguration().setInt(RemoteProcedureDispatcher.DISPATCH_DELAY_CONF_KEY, 0); util.startMiniCluster(); EnvironmentEdgeManager.injectEdge(mee); }
@Test public void testCurrentTimeInMillis() { EnvironmentEdge mock = mock(EnvironmentEdge.class); EnvironmentEdgeManager.injectEdge(mock); long expectation = 3456; when(mock.currentTime()).thenReturn(expectation); long result = EnvironmentEdgeManager.currentTime(); verify(mock).currentTime(); assertEquals(expectation, result); } }
@BeforeClass public static void setEnvironmentEdge() throws Exception { EnvironmentEdge ee = new TimeOffsetEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(ee); Configuration conf = TEST_UTIL.getConfiguration(); conf.setInt(HStore.BLOCKING_STOREFILES_KEY, 10000); TEST_UTIL.startMiniCluster(1); }
@BeforeClass public static void setUp() throws Exception { ManualEnvironmentEdge edge = new ManualEnvironmentEdge(); edge.setValue(12345); EnvironmentEdgeManager.injectEdge(edge); }
protected ArrayList<HStoreFile> sfCreate(long[] minTimestamps, long[] maxTimestamps, long[] sizes) throws IOException { ManualEnvironmentEdge timeMachine = new ManualEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(timeMachine); // Has to be > 0 and < now. timeMachine.setValue(1); ArrayList<Long> ageInDisk = new ArrayList<>(); for (int i = 0; i < sizes.length; i++) { ageInDisk.add(0L); } ArrayList<HStoreFile> ret = Lists.newArrayList(); for (int i = 0; i < sizes.length; i++) { MockHStoreFile msf = new MockHStoreFile(TEST_UTIL, TEST_FILE, sizes[i], ageInDisk.get(i), false, i); msf.setTimeRangeTracker(TimeRangeTracker.create(TimeRangeTracker.Type.SYNC, minTimestamps[i], maxTimestamps[i])); ret.add(msf); } return ret; }
@Test public void testSortExtract(){ ManualEnvironmentEdge mee = new ManualEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(mee); mee.setValue(1); DeadServer d = new DeadServer(); d.add(hostname123); mee.incValue(1); d.add(hostname1234); mee.incValue(1); d.add(hostname12345); List<Pair<ServerName, Long>> copy = d.copyDeadServersSince(2L); Assert.assertEquals(2, copy.size()); Assert.assertEquals(hostname1234, copy.get(0).getFirst()); Assert.assertEquals(new Long(2L), copy.get(0).getSecond()); Assert.assertEquals(hostname12345, copy.get(1).getFirst()); Assert.assertEquals(new Long(3L), copy.get(1).getSecond()); EnvironmentEdgeManager.reset(); }
protected void checkShouldFlush(Configuration conf, boolean expected) throws Exception { try { EnvironmentEdgeForMemstoreTest edge = new EnvironmentEdgeForMemstoreTest(); EnvironmentEdgeManager.injectEdge(edge); HBaseTestingUtility hbaseUtility = HBaseTestingUtility.createLocalHTU(conf); String cf = "foo"; HRegion region = hbaseUtility.createTestRegion("foobar", ColumnFamilyDescriptorBuilder.of(cf)); edge.setCurrentTimeMillis(1234); Put p = new Put(Bytes.toBytes("r")); p.add(KeyValueTestUtil.create("r", cf, "q", 100, "v")); region.put(p); edge.setCurrentTimeMillis(1234 + 100); StringBuilder sb = new StringBuilder(); assertTrue(!region.shouldFlush(sb)); edge.setCurrentTimeMillis(1234 + 10000); assertTrue(region.shouldFlush(sb) == expected); } finally { EnvironmentEdgeManager.reset(); } }
protected void compactEquals(long now, ArrayList<HStoreFile> candidates, long[] expectedFileSizes, long[] expectedBoundaries, boolean isMajor, boolean toCompact) throws IOException { ManualEnvironmentEdge timeMachine = new ManualEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(timeMachine); timeMachine.setValue(now); DateTieredCompactionRequest request; DateTieredCompactionPolicy policy = (DateTieredCompactionPolicy) store.storeEngine.getCompactionPolicy(); if (isMajor) { for (HStoreFile file : candidates) { ((MockHStoreFile) file).setIsMajor(true); } assertEquals(toCompact, policy.shouldPerformMajorCompaction(candidates)); request = (DateTieredCompactionRequest) policy.selectMajorCompaction(candidates); } else { assertEquals(toCompact, policy.needsCompaction(candidates, ImmutableList.of())); request = (DateTieredCompactionRequest) policy.selectMinorCompaction(candidates, false, false); } List<HStoreFile> actual = Lists.newArrayList(request.getFiles()); assertEquals(Arrays.toString(expectedFileSizes), Arrays.toString(getSizes(actual))); assertEquals(Arrays.toString(expectedBoundaries), Arrays.toString(request.getBoundaries().toArray())); } }
@Test public void testManageSingleton() { EnvironmentEdgeManager.reset(); EnvironmentEdge edge = EnvironmentEdgeManager.getDelegate(); assertNotNull(edge); assertTrue(edge instanceof DefaultEnvironmentEdge); EnvironmentEdgeManager.reset(); EnvironmentEdge edge2 = EnvironmentEdgeManager.getDelegate(); assertFalse(edge == edge2); IncrementingEnvironmentEdge newEdge = new IncrementingEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(newEdge); assertEquals(newEdge, EnvironmentEdgeManager.getDelegate()); //injecting null will result in default being assigned. EnvironmentEdgeManager.injectEdge(null); EnvironmentEdge nullResult = EnvironmentEdgeManager.getDelegate(); assertTrue(nullResult instanceof DefaultEnvironmentEdge); }
@SuppressWarnings("unchecked") @Test public void testMergeExpiredStripes() throws Exception { // HBASE-11397 ManualEnvironmentEdge edge = new ManualEnvironmentEdge(); long now = defaultTtl + 2; edge.setValue(now); EnvironmentEdgeManager.injectEdge(edge); try { HStoreFile expiredFile = createFile(), notExpiredFile = createFile(); when(expiredFile.getReader().getMaxTimestamp()).thenReturn(now - defaultTtl - 1); when(notExpiredFile.getReader().getMaxTimestamp()).thenReturn(now - defaultTtl + 1); List<HStoreFile> expired = Lists.newArrayList(expiredFile, expiredFile); List<HStoreFile> notExpired = Lists.newArrayList(notExpiredFile, notExpiredFile); StripeCompactionPolicy policy = createPolicy(HBaseConfiguration.create(), defaultSplitSize, defaultSplitCount, defaultInitialCount, true); // Merge all three expired stripes into one. StripeCompactionPolicy.StripeInformationProvider si = createStripesWithFiles(expired, expired, expired); verifyMergeCompatcion(policy, si, 0, 2); // Merge two adjacent expired stripes into one. si = createStripesWithFiles(notExpired, expired, notExpired, expired, expired, notExpired); verifyMergeCompatcion(policy, si, 3, 4); } finally { EnvironmentEdgeManager.reset(); } }
@Test public void testAppendTimestampsAreMonotonic() throws IOException { region = initHRegion(tableName, method, CONF, fam1); ManualEnvironmentEdge edge = new ManualEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(edge); edge.setValue(10); Append a = new Append(row); a.setDurability(Durability.SKIP_WAL); a.addColumn(fam1, qual1, qual1); region.append(a); Result result = region.get(new Get(row)); Cell c = result.getColumnLatestCell(fam1, qual1); assertNotNull(c); assertEquals(10L, c.getTimestamp()); edge.setValue(1); // clock goes back region.append(a); result = region.get(new Get(row)); c = result.getColumnLatestCell(fam1, qual1); assertEquals(11L, c.getTimestamp()); byte[] expected = new byte[qual1.length*2]; System.arraycopy(qual1, 0, expected, 0, qual1.length); System.arraycopy(qual1, 0, expected, qual1.length, qual1.length); assertTrue(Bytes.equals(c.getValueArray(), c.getValueOffset(), c.getValueLength(), expected, 0, expected.length)); }
@Test public void testCheckAndMutateTimestampsAreMonotonic() throws IOException { region = initHRegion(tableName, method, CONF, fam1); ManualEnvironmentEdge edge = new ManualEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(edge); edge.setValue(10); Put p = new Put(row); p.setDurability(Durability.SKIP_WAL); p.addColumn(fam1, qual1, qual1); region.put(p); Result result = region.get(new Get(row)); Cell c = result.getColumnLatestCell(fam1, qual1); assertNotNull(c); assertEquals(10L, c.getTimestamp()); edge.setValue(1); // clock goes back p = new Put(row); p.setDurability(Durability.SKIP_WAL); p.addColumn(fam1, qual1, qual2); region.checkAndMutate(row, fam1, qual1, CompareOperator.EQUAL, new BinaryComparator(qual1), p); result = region.get(new Get(row)); c = result.getColumnLatestCell(fam1, qual1); assertEquals(10L, c.getTimestamp()); assertTrue(Bytes.equals(c.getValueArray(), c.getValueOffset(), c.getValueLength(), qual2, 0, qual2.length)); }
@Test public void testIncrementTimestampsAreMonotonic() throws IOException { region = initHRegion(tableName, method, CONF, fam1); ManualEnvironmentEdge edge = new ManualEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(edge); edge.setValue(10); Increment inc = new Increment(row); inc.setDurability(Durability.SKIP_WAL); inc.addColumn(fam1, qual1, 1L); region.increment(inc); Result result = region.get(new Get(row)); Cell c = result.getColumnLatestCell(fam1, qual1); assertNotNull(c); assertEquals(10L, c.getTimestamp()); edge.setValue(1); // clock goes back region.increment(inc); result = region.get(new Get(row)); c = result.getColumnLatestCell(fam1, qual1); assertEquals(11L, c.getTimestamp()); assertEquals(2L, Bytes.toLong(c.getValueArray(), c.getValueOffset(), c.getValueLength())); }
@Test public void testOverconsumptionFixedIntervalRefillStrategy() throws InterruptedException { RateLimiter limiter = new FixedIntervalRateLimiter(); limiter.set(10, TimeUnit.SECONDS); // fix the current time in order to get the precise value of interval EnvironmentEdge edge = new EnvironmentEdge() { private final long ts = System.currentTimeMillis(); @Override public long currentTime() { return ts; } }; EnvironmentEdgeManager.injectEdge(edge); // 10 resources are available, but we need to consume 20 resources // Verify that we have to wait at least 1.1sec to have 1 resource available assertTrue(limiter.canExecute()); limiter.consume(20); // To consume 1 resource also wait for 1000ms assertEquals(1000, limiter.waitInterval(1)); // To consume 10 resource wait for 100ms assertEquals(1000, limiter.waitInterval(10)); EnvironmentEdgeManager.reset(); limiter.setNextRefillTime(limiter.getNextRefillTime() - 900); // Verify that after 1sec also no resource should be available assertFalse(limiter.canExecute(1)); limiter.setNextRefillTime(limiter.getNextRefillTime() - 100); // Verify that after 1sec the 10 resource is available assertTrue(limiter.canExecute()); assertEquals(0, limiter.waitInterval()); }
@Test public void testUnconfiguredLimiters() throws InterruptedException { ManualEnvironmentEdge testEdge = new ManualEnvironmentEdge(); EnvironmentEdgeManager.injectEdge(testEdge); long limit = Long.MAX_VALUE; // For unconfigured limiters, it is supposed to use as much as possible RateLimiter avgLimiter = new AverageIntervalRateLimiter(); RateLimiter fixLimiter = new FixedIntervalRateLimiter(); assertEquals(limit, avgLimiter.getAvailable()); assertEquals(limit, fixLimiter.getAvailable()); assertTrue(avgLimiter.canExecute(limit)); avgLimiter.consume(limit); assertTrue(fixLimiter.canExecute(limit)); fixLimiter.consume(limit); // Make sure that available is Long.MAX_VALUE assertTrue(limit == avgLimiter.getAvailable()); assertTrue(limit == fixLimiter.getAvailable()); // after 100 millseconds, it should be able to execute limit as well testEdge.incValue(100); assertTrue(avgLimiter.canExecute(limit)); avgLimiter.consume(limit); assertTrue(fixLimiter.canExecute(limit)); fixLimiter.consume(limit); // Make sure that available is Long.MAX_VALUE assertTrue(limit == avgLimiter.getAvailable()); assertTrue(limit == fixLimiter.getAvailable()); EnvironmentEdgeManager.reset(); }