final Stopwatch stopwatch = Stopwatch.createStarted(); final LedgerHandleCache handleCache = LedgerHandleCache.newBuilder().bkc(bookKeeperClient).conf(conf).build(); return ReadUtils.asyncReadLastRecord( getFullyQualifiedName(),
private Future<DLSN> getDLSNNotLessThanTxId(long fromTxnId, final List<LogSegmentMetadata> segments) { if (segments.isEmpty()) { return getLastDLSNAsync(); } final int segmentIdx = DLUtils.findLogSegmentNotLessThanTxnId(segments, fromTxnId); if (segmentIdx < 0) { return Future.value(new DLSN(segments.get(0).getLogSegmentSequenceNumber(), 0L, 0L)); } final LedgerHandleCache handleCache = LedgerHandleCache.newBuilder().bkc(readerBKC).conf(conf).build(); return getDLSNNotLessThanTxIdInSegment( fromTxnId, segmentIdx, segments, handleCache ).ensure(new AbstractFunction0<BoxedUnit>() { @Override public BoxedUnit apply() { handleCache.clear(); return BoxedUnit.UNIT; } }); }
private Future<LogRecordWithDLSN> getFirstGreaterThanRecord(BKDistributedLogManager bkdlm, int ledgerNo, DLSN dlsn) throws Exception { List<LogSegmentMetadata> ledgerList = bkdlm.getLogSegments(); final LedgerHandleCache handleCache = LedgerHandleCache.newBuilder() .bkc(bkdlm.getWriterBKC()) .conf(conf) .build(); return ReadUtils.asyncReadFirstUserRecord( bkdlm.getStreamName(), ledgerList.get(ledgerNo), 2, 16, new AtomicInteger(0), Executors.newFixedThreadPool(1), handleCache, dlsn ).ensure(new AbstractFunction0<BoxedUnit>() { @Override public BoxedUnit apply() { handleCache.clear(); return BoxedUnit.UNIT; } }); }
.conf(conf) .statsLogger(statsLogger) .build(); readAheadCache = new ReadAheadCache( getFullyQualifiedName(),
.bkc(bkc) .conf(new DistributedLogConfiguration().setBKDigestPW(digestpw)) .build(); return ReadUtils.asyncReadLastRecord( streamName,
@Test(timeout = 60000) public void testOpenAndCloseLedger() throws Exception { LedgerHandle lh = bkc.get().createLedger(1, 1, 1, BookKeeper.DigestType.CRC32, conf.getBKDigestPW().getBytes(UTF_8)); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(bkc).conf(conf).build(); LogSegmentMetadata segment = new LogSegmentMetadata.LogSegmentMetadataBuilder( "/data", LogSegmentMetadata.LogSegmentMetadataVersion.VERSION_V5_SEQUENCE_ID, lh.getId(), 0L) .build(); LedgerDescriptor desc1 = cache.openLedger(segment, false); assertTrue(cache.handlesMap.containsKey(desc1)); LedgerHandleCache.RefCountedLedgerHandle refLh = cache.handlesMap.get(desc1); assertEquals(1, refLh.getRefCount()); cache.openLedger(segment, false); assertTrue(cache.handlesMap.containsKey(desc1)); assertEquals(2, refLh.getRefCount()); // close the ledger cache.closeLedger(desc1); assertTrue(cache.handlesMap.containsKey(desc1)); assertEquals(1, refLh.getRefCount()); cache.closeLedger(desc1); assertFalse(cache.handlesMap.containsKey(desc1)); assertEquals(0, refLh.getRefCount()); } }
@Test(timeout = 60000, expected = BKException.ZKException.class) public void testOpenLedgerWhenZkClosed() throws Exception { ZooKeeperClient newZkc = TestZooKeeperClientBuilder.newBuilder() .name("zkc-openledger-when-zk-closed") .zkServers(zkServers) .build(); BookKeeperClient newBkc = BookKeeperClientBuilder.newBuilder() .name("bkc-openledger-when-zk-closed") .zkc(newZkc) .ledgersPath(ledgersPath) .dlConfig(conf) .build(); try { LedgerHandle lh = newBkc.get().createLedger(BookKeeper.DigestType.CRC32, "zkcClosed".getBytes(UTF_8)); lh.close(); newZkc.close(); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(newBkc).conf(conf).build(); // open ledger after zkc closed cache.openLedger(new LogSegmentMetadata.LogSegmentMetadataBuilder("", 2, lh.getId(), 1).setLogSegmentSequenceNo(lh.getId()).build(), false); } finally { newBkc.close(); } }
private Future<Optional<LogRecordWithDLSN>> getLogRecordNotLessThanTxId( BKDistributedLogManager bkdlm, int logsegmentIdx, long transactionId) throws Exception { List<LogSegmentMetadata> logSegments = bkdlm.getLogSegments(); final LedgerHandleCache handleCache = LedgerHandleCache.newBuilder() .bkc(bkdlm.getWriterBKC()) .conf(conf) .build(); return ReadUtils.getLogRecordNotLessThanTxId( bkdlm.getStreamName(), logSegments.get(logsegmentIdx), transactionId, Executors.newSingleThreadExecutor(), handleCache, 10 ).ensure(new AbstractFunction0<BoxedUnit>() { @Override public BoxedUnit apply() { handleCache.clear(); return BoxedUnit.UNIT; } }); }
private Future<LogRecordWithDLSN> asyncReadFirstUserRecord(LogSegmentMetadata ledger, DLSN beginDLSN) { final LedgerHandleCache handleCache = LedgerHandleCache.newBuilder().bkc(bookKeeperClient).conf(conf).build(); return ReadUtils.asyncReadFirstUserRecord( getFullyQualifiedName(), ledger, firstNumEntriesPerReadLastRecordScan, maxNumEntriesPerReadLastRecordScan, new AtomicInteger(0), scheduler, handleCache, beginDLSN ).ensure(new AbstractFunction0<BoxedUnit>() { @Override public BoxedUnit apply() { handleCache.clear(); return BoxedUnit.UNIT; } }); }
private Future<LogRecordWithDLSN> getLastUserRecord(BKDistributedLogManager bkdlm, int ledgerNo) throws Exception { BKLogReadHandler readHandler = bkdlm.createReadHandler(); List<LogSegmentMetadata> ledgerList = readHandler.getLedgerList(false, false, LogSegmentMetadata.COMPARATOR, false); final LedgerHandleCache handleCache = LedgerHandleCache.newBuilder() .bkc(bkdlm.getWriterBKC()) .conf(conf) .build(); return ReadUtils.asyncReadLastRecord( bkdlm.getStreamName(), ledgerList.get(ledgerNo), false, false, false, 2, 16, new AtomicInteger(0), Executors.newFixedThreadPool(1), handleCache ).ensure(new AbstractFunction0<BoxedUnit>() { @Override public BoxedUnit apply() { handleCache.clear(); return BoxedUnit.UNIT; } }); }
@Test(timeout = 60000, expected = NullPointerException.class) public void testBuilderWithoutStatsLogger() throws Exception { LedgerHandleCache.newBuilder().bkc(bkc).conf(conf).statsLogger(null).build(); }
@Test(timeout = 60000, expected = NullPointerException.class) public void testBuilderWithoutBKC() throws Exception { LedgerHandleCache.newBuilder().build(); }
@Test(timeout = 60000, expected = BKException.BKUnexpectedConditionException.class) public void testGetLengthWithoutOpeningLedger() throws Exception { LedgerDescriptor desc = new LedgerDescriptor(9999, 9999, false); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(bkc).conf(conf).build(); // read entries cache.getLength(desc); }
@Test(timeout = 60000, expected = BKException.BKUnexpectedConditionException.class) public void testReadEntriesWithoutOpeningLedger() throws Exception { LedgerDescriptor desc = new LedgerDescriptor(9999, 9999, false); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(bkc).conf(conf).build(); // read entries cache.readEntries(desc, 0, 10); }
@Test(timeout = 60000, expected = BKException.BKUnexpectedConditionException.class) public void testReadLastConfirmedAndEntryWithoutOpeningLedger() throws Exception { LedgerDescriptor desc = new LedgerDescriptor(9999, 9999, false); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(bkc).conf(conf).build(); // read entries FutureUtils.bkResult(cache.asyncReadLastConfirmedAndEntry(desc, 1L, 200L, false)); }
@Test(timeout = 60000, expected = BKException.BKUnexpectedConditionException.class) public void testGetLastConfirmedWithoutOpeningLedger() throws Exception { LedgerDescriptor desc = new LedgerDescriptor(9999, 9999, false); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(bkc).conf(conf).build(); // read entries cache.getLastAddConfirmed(desc); }
@Test(timeout = 60000, expected = BKException.BKUnexpectedConditionException.class) public void testReadLastConfirmedWithoutOpeningLedger() throws Exception { LedgerDescriptor desc = new LedgerDescriptor(9999, 9999, false); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(bkc).conf(conf).build(); // read last confirmed cache.tryReadLastConfirmed(desc); }
@Test(timeout = 60000, expected = BKException.BKBookieHandleNotAvailableException.class) public void testOpenLedgerWhenBkcClosed() throws Exception { BookKeeperClient newBkc = BookKeeperClientBuilder.newBuilder().name("newBkc") .zkc(zkc).ledgersPath(ledgersPath).dlConfig(conf).build(); LedgerHandleCache cache = LedgerHandleCache.newBuilder().bkc(newBkc).conf(conf).build(); // closed the bkc newBkc.close(); // open ledger after bkc closed. cache.openLedger(new LogSegmentMetadata.LogSegmentMetadataBuilder("", 2, 1, 1).setRegionId(1).build(), false); }