@Test public void errorInRecovering4() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); ledger.addEntry("entry".getBytes()); ledger.close(); factory = new ManagedLedgerFactoryImpl(bkc, zkc); zkc.failAfter(1, Code.CONNECTIONLOSS); try { ledger = factory.open("my_test_ledger"); fail("should fail"); } catch (ManagedLedgerException e) { // ok } // It should be fine now ledger = factory.open("my_test_ledger"); }
private void readLedgerMeta(final ManagedLedgerFactoryImpl factory, final TopicName topicName, final NavigableMap<Long, MLDataFormats.ManagedLedgerInfo.LedgerInfo> ledgers) throws Exception { String managedLedgerName = topicName.getPersistenceNamingEncoding(); MetaStore store = factory.getMetaStore(); BookKeeper bk = factory.getBookKeeper(); final CountDownLatch mlMetaCounter = new CountDownLatch(1);
@Override public ManagedLedger open(String name, ManagedLedgerConfig config) throws InterruptedException, ManagedLedgerException { class Result { ManagedLedger l = null; ManagedLedgerException e = null; } final Result r = new Result(); final CountDownLatch latch = new CountDownLatch(1); asyncOpen(name, config, new OpenLedgerCallback() { @Override public void openLedgerComplete(ManagedLedger ledger, Object ctx) { r.l = ledger; latch.countDown(); } @Override public void openLedgerFailed(ManagedLedgerException exception, Object ctx) { r.e = exception; latch.countDown(); } }, null); latch.await(); if (r.e != null) { throw r.e; } return r.l; }
@Test public void testManagedLedgerWithoutAutoCreate() throws Exception { ManagedLedgerConfig config = new ManagedLedgerConfig().setCreateIfMissing(false); try { factory.open("testManagedLedgerWithoutAutoCreate", config); fail("should have thrown ManagedLedgerNotFoundException"); } catch (ManagedLedgerNotFoundException e) { // Expected } assertFalse(factory.getManagedLedgers().containsKey("testManagedLedgerWithoutAutoCreate")); }
@Test void verifyNoCacheIfNoConsumer() throws Exception { ManagedLedgerFactoryConfig config = new ManagedLedgerFactoryConfig(); config.setMaxCacheSize(7 * 10); config.setCacheEvictionWatermark(0.8); factory = new ManagedLedgerFactoryImpl(bkc, bkc.getZkHandle(), config); EntryCacheManager cacheManager = factory.getEntryCacheManager(); ManagedLedgerImpl ledger = (ManagedLedgerImpl) factory.open("ledger"); EntryCache cache1 = ledger.entryCache; for (int i = 0; i < 10; i++) { ledger.addEntry(("entry-" + i).getBytes()); } assertEquals(cache1.getSize(), 0); assertEquals(cacheManager.getSize(), 0); cacheManager.mlFactoryMBean.refreshStats(1, TimeUnit.SECONDS); assertEquals(cacheManager.mlFactoryMBean.getCacheMaxSize(), 7 * 10); assertEquals(cacheManager.mlFactoryMBean.getCacheUsedSize(), 0); assertEquals(cacheManager.mlFactoryMBean.getCacheHitsRate(), 0.0); assertEquals(cacheManager.mlFactoryMBean.getCacheMissesRate(), 0.0); assertEquals(cacheManager.mlFactoryMBean.getCacheHitsThroughput(), 0.0); assertEquals(cacheManager.mlFactoryMBean.getNumberOfCacheEvictions(), 0); }
@Test(timeOut = 20000) public void testReopenAndCleanup() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); ledger.openCursor("c1"); ledger.addEntry("data".getBytes(Encoding)); ledger.close(); Thread.sleep(100); assertEquals(bkc.getLedgers().size(), 1); factory.shutdown(); factory = new ManagedLedgerFactoryImpl(bkc, bkc.getZkHandle()); ledger = factory.open("my_test_ledger"); ledger.openCursor("c1"); Thread.sleep(100); assertEquals(bkc.getLedgers().size(), 2); ledger.close(); factory.open("my_test_ledger", new ManagedLedgerConfig()).delete(); Thread.sleep(100); assertEquals(bkc.getLedgers().size(), 0); factory.shutdown(); }
ManagedLedgerFactoryImpl factory = new ManagedLedgerFactoryImpl(bkc, bkc.getZkHandle(), config); EntryCacheManager cacheManager = factory.getEntryCacheManager(); ManagedLedgerConfig conf = new ManagedLedgerConfig(); conf.setEnsembleSize(2).setAckQuorumSize(2).setMetadataEnsembleSize(2); final ManagedLedgerImpl ledger = (ManagedLedgerImpl) factory.open("my-ledger", conf); assertEquals(cacheManager.mlFactoryMBean.getNumberOfCacheEvictions(), 0); factory.shutdown();
@Test void doubleInsert() throws Exception { ManagedLedgerFactoryConfig config = new ManagedLedgerFactoryConfig(); config.setMaxCacheSize(10); config.setCacheEvictionWatermark(0.8); factory = new ManagedLedgerFactoryImpl(bkc, bkc.getZkHandle(), config); EntryCacheManager cacheManager = factory.getEntryCacheManager(); EntryCache cache1 = cacheManager.getEntryCache(ml1); assertEquals(cache1.insert(EntryImpl.create(1, 1, new byte[4])), true); assertEquals(cache1.insert(EntryImpl.create(1, 0, new byte[3])), true); assertEquals(cache1.getSize(), 7); assertEquals(cacheManager.getSize(), 7); assertEquals(cache1.insert(EntryImpl.create(1, 0, new byte[5])), false); assertEquals(cache1.getSize(), 7); assertEquals(cacheManager.getSize(), 7); }
@Override public long getCacheMaxSize() { return factory.getEntryCacheManager().getMaxSize(); }
@Test public void ledgersList() throws Exception { MetaStore store = factory.getMetaStore(); assertEquals(Sets.newHashSet(store.getManagedLedgers()), Sets.newHashSet()); ManagedLedger ledger1 = factory.open("ledger1"); assertEquals(Sets.newHashSet(store.getManagedLedgers()), Sets.newHashSet("ledger1")); ManagedLedger ledger2 = factory.open("ledger2"); assertEquals(Sets.newHashSet(store.getManagedLedgers()), Sets.newHashSet("ledger1", "ledger2")); ledger1.delete(); assertEquals(Sets.newHashSet(store.getManagedLedgers()), Sets.newHashSet("ledger2")); ledger2.delete(); assertEquals(Sets.newHashSet(store.getManagedLedgers()), Sets.newHashSet()); }
@BeforeMethod public void setUp(Method method) throws Exception { LOG.info(">>>>>> starting {}", method); try { // start bookkeeper service startBookKeeper(); } catch (Exception e) { LOG.error("Error setting up", e); throw e; } ManagedLedgerFactoryConfig conf = new ManagedLedgerFactoryConfig(); factory = new ManagedLedgerFactoryImpl(bkc, zkc, conf); zkc.create("/managed-ledgers", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); }
@Test(timeOut = 20000) void markDeleteAcrossLedgers() throws Exception { ManagedLedger ml1 = factory.open("my_test_ledger"); ManagedCursor mc1 = ml1.openCursor("c1"); // open ledger id 3 for ml1 // markDeletePosition for mc1 is 3:-1 // readPosition is 3:0 ml1.close(); mc1.close(); // force removal of this ledger from the cache factory.close(ml1); ManagedLedger ml2 = factory.open("my_test_ledger"); ManagedCursor mc2 = ml2.openCursor("c1"); // open ledger id 5 for ml2 // this entry is written at 5:0 Position pos = ml2.addEntry("dummy-entry-1".getBytes(Encoding)); List<Entry> entries = mc2.readEntries(1); assertEquals(entries.size(), 1); assertEquals(new String(entries.get(0).getData(), Encoding), "dummy-entry-1"); entries.forEach(e -> e.release()); mc2.delete(pos); // verify if the markDeletePosition moves from 3:-1 to 5:0 assertEquals(mc2.getMarkDeletedPosition(), pos); assertEquals(mc2.getMarkDeletedPosition().getNext(), mc2.getReadPosition()); }
@Test public void invalidateConsumedEntriesFromCache() throws Exception { ManagedLedgerImpl ledger = (ManagedLedgerImpl) factory.open("my_test_ledger"); EntryCacheManager cacheManager = factory.getEntryCacheManager(); EntryCache entryCache = ledger.entryCache;
@Override public void asyncOpen(String name, OpenLedgerCallback callback, Object ctx) { asyncOpen(name, new ManagedLedgerConfig(), callback, ctx); }
/** * Returns managed ledgers map from ML factory * * @return */ protected Map<String, ManagedLedgerImpl> getManagedLedgers() { return ((ManagedLedgerFactoryImpl) pulsar.getManagedLedgerFactory()).getManagedLedgers(); }
((ManagedLedgerFactoryImpl) pulsar().getManagedLedgerFactory()).getMetaStore().getCursors(ledgerName, new MetaStoreCallback<List<String>>() {
@Override public ManagedLedgerInfo getManagedLedgerInfo(String name) throws InterruptedException, ManagedLedgerException { class Result { ManagedLedgerInfo info = null; ManagedLedgerException e = null; } final Result r = new Result(); final CountDownLatch latch = new CountDownLatch(1); asyncGetManagedLedgerInfo(name, new ManagedLedgerInfoCallback() { @Override public void getInfoComplete(ManagedLedgerInfo info, Object ctx) { r.info = info; latch.countDown(); } @Override public void getInfoFailed(ManagedLedgerException exception, Object ctx) { r.e = exception; latch.countDown(); } }, null); latch.await(); if (r.e != null) { throw r.e; } return r.info; }
/** * Returns the managed ledger cache statistics from ML factory * * @return */ protected ManagedLedgerFactoryMXBean getManagedLedgerCacheStats() { return ((ManagedLedgerFactoryImpl) pulsar.getManagedLedgerFactory()).getCacheStats(); }