@Override public void asyncCreateLedger(int ensSize, int qSize, DigestType digestType, byte[] passwd, CreateCallback cb, Object ctx) { asyncCreateLedger(ensSize, qSize, qSize, digestType, passwd, cb, ctx, Collections.emptyMap()); }
@Override public void asyncOpenLedgerNoRecovery(long lId, DigestType digestType, byte[] passwd, OpenCallback cb, Object ctx) { asyncOpenLedger(lId, digestType, passwd, cb, ctx); }
@Override public void deleteLedger(long lId) throws InterruptedException, BKException { checkProgrammedFail(); if (!ledgers.containsKey(lId)) { throw BKException.create(BKException.Code.NoSuchLedgerExistsException); } ledgers.remove(lId); }
@Override public void asyncClose(CloseCallback cb, Object ctx) { bk.getProgrammedFailure().thenComposeAsync((res) -> { fenced = true; return FutureUtils.value(null); }, bk.executor).whenCompleteAsync((res, exception) -> { if (exception != null) { cb.closeComplete(PulsarMockBookKeeper.getExceptionCode(exception), null, ctx); } else { cb.closeComplete(BKException.Code.OK, this, ctx); } }, bk.executor); }
@Test(timeOut = 20000) void errorRecoveringCursor2() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); ledger.openCursor("c1"); ManagedLedgerFactory factory2 = new ManagedLedgerFactoryImpl(bkc, bkc.getZkHandle()); bkc.failAfter(4, BKException.Code.MetadataVersionException); try { ledger = factory2.open("my_test_ledger"); fail("should have failed"); } catch (ManagedLedgerException e) { // ok } factory2.shutdown(); }
@Test public void asyncClosingManagedLedger() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); ledger.openCursor("c1"); bkc.failNow(BKException.Code.NoSuchLedgerExistsException); final CountDownLatch latch = new CountDownLatch(1); ledger.asyncClose(new CloseCallback() { public void closeFailed(ManagedLedgerException exception, Object ctx) { latch.countDown(); } public void closeComplete(Object ctx) { fail("should have failed"); } }, null); latch.await(); }
public void failNow(int rc) { failAfter(0, rc); }
@Test public void simpleTest() throws Exception { LedgerHandle ledger = bkc.createLedger(DigestType.MAC, SECRET.getBytes()); long ledgerId = ledger.getId(); log.info("Writing to ledger: {}", ledgerId); for (int i = 0; i < 10; i++) { String content = "entry-" + i; ledger.addEntry(content.getBytes(Encoding)); } ledger.close(); ledger = bkc.openLedger(ledgerId, DigestType.MAC, SECRET.getBytes()); Enumeration<LedgerEntry> entries = ledger.readEntries(0, 9); while (entries.hasMoreElements()) { LedgerEntry entry = entries.nextElement(); String content = new String(entry.getEntry(), Encoding); log.info("Entry {} lenght={} content='{}'", entry.getEntryId(), entry.getLength(), content); } ledger.close(); }
@Test public void removingCursor() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); ManagedCursor c1 = ledger.openCursor("c1"); assertEquals(zkc.exists("/managed-ledgers/my_test_ledger/c1", false) != null, true); zkc.failNow(Code.BADVERSION); try { c1.close(); fail("should fail"); } catch (ManagedLedgerException e) { // ok } bkc.failNow(BKException.Code.NoSuchLedgerExistsException); // Cursor ledger deletion will fail, but that should not prevent the deleteCursor to fail ledger.deleteCursor("c1"); assertEquals(zkc.exists("/managed-ledgers/my_test_ledger/c1", false) != null, false); assertEquals(bkc.getLedgers().size(), 2); }
bkc.asyncOpenLedger(c1.getCursorLedger(), DigestType.CRC32C, "".getBytes(), (rc, lh, ctx) -> { if (rc == BKException.Code.OK) { long lastEntry = lh.getLastAddConfirmed(); factory = new ManagedLedgerFactoryImpl(bkc, bkc.getZkHandle()); ledger = (ManagedLedgerImpl) factory.open(ledgerName, managedLedgerConfig); c1 = (ManagedCursorImpl) ledger.openCursor("c1");
@Test(timeOut = 20000) public void deleteWithErrors1() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); PositionImpl position = (PositionImpl) ledger.addEntry("dummy-entry-1".getBytes(Encoding)); assertEquals(ledger.getNumberOfEntries(), 1); // Force delete a ledger and test that deleting the ML still happens // without errors bkc.deleteLedger(position.getLedgerId()); ledger.delete(); }
@Override public LedgerHandle createLedger(DigestType digestType, byte passwd[]) throws BKException, InterruptedException { return createLedger(3, 2, digestType, passwd); }
static int getExceptionCode(Throwable t) { if (t instanceof BKException) { return ((BKException) t).getCode(); } else if (t.getCause() != null) { return getExceptionCode(t.getCause()); } else { return BKException.Code.UnexpectedConditionException; } }
/** * Start cluster * * @throws Exception */ protected void startBookKeeper() throws Exception { zkc = MockZooKeeper.newInstance(); for (int i = 0; i < numBookies; i++) { ZkUtils.createFullPathOptimistic(zkc, "/ledgers/available/192.168.1.1:" + (5000 + i), "".getBytes(), null, null); } zkc.create("/ledgers/LAYOUT", "1\nflat:1".getBytes(), null, null); bkc = new PulsarMockBookKeeper(zkc, executor.chooseThread(this)); }
doReturn(conf).when(bkClient).getConf(); class MockLedgerHandle extends PulsarMockLedgerHandle { public MockLedgerHandle(PulsarMockBookKeeper bk, long id, DigestType digest, byte[] passwd)
@Override public void asyncReadEntries(final long firstEntry, final long lastEntry, final ReadCallback cb, final Object ctx) { bk.getProgrammedFailure().thenComposeAsync((res) -> { log.debug("readEntries: first={} last={} total={}", firstEntry, lastEntry, entries.size()); final Queue<LedgerEntry> seq = new ArrayDeque<LedgerEntry>(); }).whenCompleteAsync((res, exception) -> { if (exception != null) { cb.readComplete(PulsarMockBookKeeper.getExceptionCode(exception), PulsarMockLedgerHandle.this, null, ctx); } else { cb.readComplete(BKException.Code.OK, PulsarMockLedgerHandle.this, res, ctx);
@Test(timeOut = 20000) void errorRecoveringCursor() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); Position p1 = ledger.addEntry("entry".getBytes()); ledger.addEntry("entry".getBytes()); ManagedCursor c1 = ledger.openCursor("c1"); Position p3 = ledger.addEntry("entry".getBytes()); assertEquals(c1.getReadPosition(), p3); ManagedLedgerFactory factory2 = new ManagedLedgerFactoryImpl(bkc, bkc.getZkHandle()); bkc.failAfter(3, BKException.Code.LedgerRecoveryException); ledger = factory2.open("my_test_ledger"); c1 = ledger.openCursor("c1"); // Verify the ManagedCursor was rewind back to the snapshotted position assertEquals(c1.getReadPosition(), p3); factory2.shutdown(); }
@Test public void closingManagedLedger() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); ledger.openCursor("c1"); ledger.addEntry("entry".getBytes()); bkc.failNow(BKException.Code.NoSuchLedgerExistsException); try { ledger.close(); fail("should fail"); } catch (ManagedLedgerException e) { // ok } // ML should be closed even if it failed before try { ledger.addEntry("entry".getBytes()); fail("managed ledger was closed"); } catch (ManagedLedgerException e) { // ok } }
@Test(timeOut = 20000) void errorCreatingCursor() throws Exception { ManagedLedger ledger = factory.open("my_test_ledger"); bkc.failAfter(1, BKException.Code.NotEnoughBookiesException); zkc.failNow(Code.SESSIONEXPIRED); try { ledger.openCursor("c1"); fail("should have failed"); } catch (ManagedLedgerException e) { // ok } }
bkc.deleteLedger(l1info.getLedgerId());