コード例 #1
0
  private void initializeBookKeeper(final ManagedLedgerCallback<Void> callback) {
    log.debug("[{}] initializing bookkeeper; ledgers {}", name, ledgers);

    final MetaStoreCallback<Void> storeLedgersCb =
        new MetaStoreCallback<Void>() {
          public void operationComplete(Void v, Version version) {
            ledgersVersion = version;
            initializeCursors(callback);
          }

          public void operationFailed(MetaStoreException e) {
            callback.operationFailed(new ManagedLedgerException(e));
          }
        };
    // Create a new ledger to start writing
    bookKeeper.asyncCreateLedger(
        config.getEnsembleSize(),
        config.getQuorumSize(),
        config.getDigestType(),
        config.getPassword(),
        new CreateCallback() {
          public void createComplete(int rc, LedgerHandle lh, Object ctx) {
            if (rc == BKException.Code.OK) {
              state = State.LedgerOpened;
              currentLedger = lh;
              ledgers.put(currentLedger.getId(), new LedgerStat(currentLedger.getId(), 0, 0));
              // Save it back to ensure all nodes exist
              store.asyncUpdateLedgerIds(name, ledgers.values(), ledgersVersion, storeLedgersCb);
            } else {
              callback.operationFailed(new ManagedLedgerException(BKException.create(rc)));
            }
          }
        },
        null);
  }
コード例 #2
0
  @Override
  public synchronized void asyncAddEntry(
      final byte[] data, final AddEntryCallback callback, final Object ctx) {
    checkArgument(state != State.None);
    log.debug("[{}] asyncAddEntry size={} state={}", va(name, data.length, state));
    if (state == State.Fenced) {
      callback.addComplete(new ManagedLedgerFencedException(), null, ctx);
      return;
    }

    OpAddEntry addOperation = new OpAddEntry(this, data, callback, ctx);

    if (state == State.ClosingLedger || state == State.CreatingLedger) {
      // We don't have a ready ledger to write into
      // We are waiting for a new ledger to be created
      log.debug("[{}] Queue addEntry request", name);
      pendingAddEntries.add(addOperation);
    } else if (state == State.ClosedLedger) {
      // No ledger and no pending operations. Create a new one
      pendingAddEntries.add(addOperation);
      log.debug("[{}] Creating a new ledger", name);
      state = State.CreatingLedger;
      bookKeeper.asyncCreateLedger(
          config.getEnsembleSize(),
          config.getQuorumSize(),
          config.getDigestType(),
          config.getPassword(),
          this,
          ctx);
    } else {
      checkArgument(state == State.LedgerOpened);
      checkArgument(!currentLedgerIsFull());

      // Write into lastLedger
      log.debug("[{}] Write into current ledger lh={}", name, currentLedger.getId());
      addOperation.setLedger(currentLedger);

      ++currentLedgerEntries;
      currentLedgerSize += data.length;
      if (currentLedgerIsFull()) {
        // This entry will be the last added to current ledger
        addOperation.setCloseWhenDone(true);
        state = State.ClosingLedger;
      }

      addOperation.initiate();
    }
  }
コード例 #3
0
  protected synchronized void ledgerClosed(LedgerHandle lh) {
    checkArgument(lh.getId() == currentLedger.getId());
    state = State.ClosedLedger;

    log.debug(
        "[{}] Ledger has been closed id={} entries={}",
        va(name, lh.getId(), lh.getLastAddConfirmed() + 1));
    ledgers.put(lh.getId(), new LedgerStat(lh));

    trimConsumedLedgersInBackground();

    if (!pendingAddEntries.isEmpty()) {
      // Need to create a new ledger to write pending entries
      log.debug("[{}] Creating a new ledger", name);
      state = State.CreatingLedger;
      bookKeeper.asyncCreateLedger(
          config.getEnsembleSize(),
          config.getQuorumSize(),
          config.getDigestType(),
          config.getPassword(),
          this,
          null);
    }
  }