Examples with ManagedLedgerException org.apache.bookkeeper.mledger.ManagedLedgerException used on opensource projects

Example 66 with ManagedLedgerException

use of org.apache.bookkeeper.mledger.ManagedLedgerException in project pulsar by yahoo.

the class ManagedLedgerErrorsTest method closingManagedLedger.

@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
    }
}

Example 67 with ManagedLedgerException

use of org.apache.bookkeeper.mledger.ManagedLedgerException in project pulsar by yahoo.

the class ManagedCursorImpl method asyncCloseCursorLedger.

void asyncCloseCursorLedger(final AsyncCallbacks.CloseCallback callback, final Object ctx) {
    LedgerHandle lh = cursorLedger;
    ledger.mbean.startCursorLedgerCloseOp();
    log.info("[{}] [{}] Closing metadata ledger {}", ledger.getName(), name, lh.getId());
    lh.asyncClose(new CloseCallback() {

        @Override
        public void closeComplete(int rc, LedgerHandle lh, Object ctx) {
            ledger.mbean.endCursorLedgerCloseOp();
            if (rc == BKException.Code.OK) {
                callback.closeComplete(ctx);
            } else {
                callback.closeFailed(new ManagedLedgerException(BKException.getMessage(rc)), ctx);
            }
        }
    }, ctx);
}

Example 68 with ManagedLedgerException

use of org.apache.bookkeeper.mledger.ManagedLedgerException in project pulsar by yahoo.

the class ManagedLedgerFactoryImpl method shutdown.

@Override
public void shutdown() throws InterruptedException, ManagedLedgerException {
    statsTask.cancel(true);
    int numLedgers = ledgers.size();
    final CountDownLatch latch = new CountDownLatch(numLedgers);
    log.info("Closing {} ledgers", numLedgers);
    for (CompletableFuture<ManagedLedgerImpl> ledgerFuture : ledgers.values()) {
        ManagedLedgerImpl ledger = ledgerFuture.getNow(null);
        if (ledger == null) {
            continue;
        }
        ledger.asyncClose(new AsyncCallbacks.CloseCallback() {

            @Override
            public void closeComplete(Object ctx) {
                latch.countDown();
            }

            @Override
            public void closeFailed(ManagedLedgerException exception, Object ctx) {
                log.warn("[{}] Got exception when closing managed ledger: {}", ledger.getName(), exception);
                latch.countDown();
            }
        }, null);
    }
    latch.await();
    log.info("{} ledgers closed", numLedgers);
    if (zookeeper != null) {
        zookeeper.close();
    }
    if (isBookkeeperManaged) {
        try {
            bookKeeper.close();
        } catch (BKException e) {
            throw new ManagedLedgerException(e);
        }
    }
    executor.shutdown();
    orderedExecutor.shutdown();
    entryCacheManager.clear();
}

Example 69 with ManagedLedgerException

use of org.apache.bookkeeper.mledger.ManagedLedgerException in project pulsar by yahoo.

the class ManagedLedgerImpl method asyncOpenCursor.

@Override
public synchronized void asyncOpenCursor(final String cursorName, final OpenCursorCallback callback, final Object ctx) {
    try {
        checkManagedLedgerIsOpen();
        checkFenced();
    } catch (ManagedLedgerException e) {
        callback.openCursorFailed(e, ctx);
        return;
    }
    if (uninitializedCursors.containsKey(cursorName)) {
        uninitializedCursors.get(cursorName).thenAccept(cursor -> {
            callback.openCursorComplete(cursor, ctx);
        }).exceptionally(ex -> {
            callback.openCursorFailed((ManagedLedgerException) ex, ctx);
            return null;
        });
        return;
    }
    ManagedCursor cachedCursor = cursors.get(cursorName);
    if (cachedCursor != null) {
        if (log.isDebugEnabled()) {
            log.debug("[{}] Cursor was already created {}", name, cachedCursor);
        }
        callback.openCursorComplete(cachedCursor, ctx);
        return;
    }
    // Create a new one and persist it
    if (log.isDebugEnabled()) {
        log.debug("[{}] Creating new cursor: {}", name, cursorName);
    }
    final ManagedCursorImpl cursor = new ManagedCursorImpl(bookKeeper, config, this, cursorName);
    CompletableFuture<ManagedCursor> cursorFuture = new CompletableFuture<>();
    uninitializedCursors.put(cursorName, cursorFuture);
    cursor.initialize(getLastPosition(), new VoidCallback() {

        @Override
        public void operationComplete() {
            log.info("[{}] Opened new cursor: {}", name, cursor);
            cursor.setActive();
            // Update the ack position (ignoring entries that were written while the cursor was being created)
            cursor.initializeCursorPosition(getLastPositionAndCounter());
            synchronized (this) {
                cursors.add(cursor);
                uninitializedCursors.remove(cursorName).complete(cursor);
            }
            callback.openCursorComplete(cursor, ctx);
        }

        @Override
        public void operationFailed(ManagedLedgerException exception) {
            log.warn("[{}] Failed to open cursor: {}", name, cursor);
            synchronized (this) {
                uninitializedCursors.remove(cursorName).completeExceptionally(exception);
            }
            callback.openCursorFailed(exception, ctx);
        }
    });
}

Example 70 with ManagedLedgerException

use of org.apache.bookkeeper.mledger.ManagedLedgerException in project pulsar by yahoo.

the class ManagedLedgerImpl method delete.

/**
     * Delete this ManagedLedger completely from the system.
     *
     * @throws Exception
     */
@Override
public void delete() throws InterruptedException, ManagedLedgerException {
    final CountDownLatch counter = new CountDownLatch(1);
    final AtomicReference<ManagedLedgerException> exception = new AtomicReference<>();
    asyncDelete(new DeleteLedgerCallback() {

        @Override
        public void deleteLedgerComplete(Object ctx) {
            counter.countDown();
        }

        @Override
        public void deleteLedgerFailed(ManagedLedgerException e, Object ctx) {
            exception.set(e);
            counter.countDown();
        }
    }, null);
    if (!counter.await(AsyncOperationTimeoutSeconds, TimeUnit.SECONDS)) {
        throw new ManagedLedgerException("Timeout during managed ledger delete operation");
    }
    if (exception.get() != null) {
        log.error("[{}] Error deleting managed ledger", name, exception.get());
        throw exception.get();
    }
}