Esempio n. 1
0
  public void initialize()
      throws IOException, KeeperException, InterruptedException, BookieException {
    // instantiate zookeeper client to initialize ledger manager
    this.zk = instantiateZookeeperClient(conf);
    checkEnvironment(this.zk);

    activeLedgerManagerFactory = LedgerManagerFactory.newLedgerManagerFactory(conf, this.zk);
    activeLedgerManager = activeLedgerManagerFactory.newActiveLedgerManager();

    // instantiate the journal
    journal = new Journal(conf, ledgerDirsManager, statsLogger);

    // Check the type of storage.
    if (conf.getSortedLedgerStorageEnabled()) {
      ledgerStorage =
          new SortedLedgerStorage(
              conf, activeLedgerManager, ledgerDirsManager, indexDirsManager, journal, statsLogger);
    } else {
      ledgerStorage =
          new InterleavedLedgerStorage(
              conf, activeLedgerManager, ledgerDirsManager, indexDirsManager, journal, statsLogger);
    }
    ledgerStorage.registerListener(this);

    // start sync thread
    syncThread = new SyncThread(conf, getLedgerDirsListener(), ledgerStorage, journal);

    handles = new HandleFactoryImpl(ledgerStorage, statsLogger);

    // Initialise ledgerDirManager. This would look through all the
    // configured directories. When disk errors or all the ledger
    // directories are full, would throws exception and fail bookie startup.
    try {
      checkDiskSpace();
    } catch (NoWritableLedgerDirException nwlde) {
      LOG.info("Ledger storage is already full : ", nwlde);
      // if there is no writable ledger dir, we should try reclaimSpace
      reclaimDiskSpace();
      // check disk again if we still can't have enough room for replaying journal, fail it
      checkDiskSpace();
    }

    // ZK ephemeral node for this Bookie.
    String myID = getMyId();
    zkBookieRegPath = this.bookieRegistrationPath + myID;
    zkBookieReadOnlyPath = this.bookieReadonlyRegistrationPath + "/" + myID;
  }
Esempio n. 2
0
  // internal shutdown method to let shutdown bookie gracefully
  // when encountering exception
  synchronized int shutdown(int exitCode) {
    try {
      if (running) { // avoid shutdown twice
        // the exitCode only set when first shutdown usually due to exception found
        this.exitCode = exitCode;
        // mark bookie as in shutting down progress
        shuttingdown = true;

        // Shutdown Sync thread
        syncThread.shutdown();

        // Shutdown disk checker
        ledgerDirsManager.shutdown();
        if (indexDirsManager != ledgerDirsManager) {
          indexDirsManager.shutdown();
        }

        // Shutdown journal
        journal.shutdown();
        this.join();

        // Shutdown the EntryLogger which has the GarbageCollector Thread running
        ledgerStorage.shutdown();

        // close Ledger Manager
        try {
          activeLedgerManager.close();
          activeLedgerManagerFactory.uninitialize();
        } catch (IOException ie) {
          LOG.error("Failed to close active ledger manager : ", ie);
        }

        // Shutdown the ZK client
        if (zk != null) zk.close();

        // Shutdown State Service
        stateService.shutdown();

        // setting running to false here, so watch thread in bookie server know it only after bookie
        // shut down
        running = false;
      }
    } catch (InterruptedException ie) {
      LOG.error("Interrupted during shutting down bookie : ", ie);
    }
    return this.exitCode;
  }
Esempio n. 3
0
  @Override
  public synchronized void start() {
    setDaemon(true);
    LOG.info("I'm starting a bookie with journal directory {}", journalDirectory.getName());
    // Start DiskChecker thread
    ledgerDirsManager.start();
    if (indexDirsManager != ledgerDirsManager) {
      indexDirsManager.start();
    }

    // start sync thread first, so during replaying journals, we could do checkpoint
    // which reduce the chance that we need to replay journals again if bookie restarted
    // again before finished journal replays.
    syncThread.start();

    // replay journals
    try {
      readJournal();
    } catch (IOException ioe) {
      LOG.error("Exception while replaying journals, shutting down", ioe);
      shutdown(ExitCode.BOOKIE_EXCEPTION);
      return;
    } catch (BookieException be) {
      LOG.error("Exception while replaying journals, shutting down", be);
      shutdown(ExitCode.BOOKIE_EXCEPTION);
      return;
    }

    // Do a fully flush after journal replay
    try {
      syncThread.requestFlush().get();
    } catch (InterruptedException e) {
      LOG.warn("Interrupting the fully flush after replaying journals : ", e);
      Thread.currentThread().interrupt();
    } catch (ExecutionException e) {
      LOG.error("Error on executing a fully flush after replaying journals.");
      shutdown(ExitCode.BOOKIE_EXCEPTION);
    }

    // start bookie thread
    super.start();

    // After successful bookie startup, register listener for disk
    // error/full notifications.
    ledgerDirsManager.addLedgerDirsListener(getLedgerDirsListener());
    if (indexDirsManager != ledgerDirsManager) {
      indexDirsManager.addLedgerDirsListener(getLedgerDirsListener());
    }

    ledgerStorage.start();

    // set running here.
    // since bookie server use running as a flag to tell bookie server whether it is alive
    // if setting it in bookie thread, the watcher might run before bookie thread.
    running = true;
    try {
      registerBookie(true).get();
    } catch (Exception ie) {
      LOG.error("Couldn't register bookie with zookeeper, shutting down : ", ie);
      shutdown(ExitCode.ZK_REG_FAIL);
    }
  }
Esempio n. 4
0
 private void reclaimDiskSpace() throws IOException {
   LOG.info("Reclaiming disk space from ledger storage.");
   ledgerStorage.reclaimDiskSpace();
   LOG.info("Reclaimed disk space from ledger storage.");
 }
Esempio n. 5
0
 protected void addEntryByLedgerId(long ledgerId, ByteBuffer entry)
     throws IOException, BookieException {
   byte[] key = ledgerStorage.readMasterKey(ledgerId);
   LedgerDescriptor handle = handles.getHandle(ledgerId, key);
   handle.addEntry(entry);
 }