Ejemplo n.º 1
0
 @VisibleForTesting
 public void doTransitionToWritableMode() {
   if (shuttingdown) {
     return;
   }
   if (!readOnly.compareAndSet(true, false)) {
     return;
   }
   LOG.info("Transitioning Bookie to Writable mode and will serve read/write requests.");
   // change zookeeper state only when using zookeeper
   if (null == zk) {
     return;
   }
   try {
     doRegisterBookie(zkBookieRegPath);
     try {
       // Clear the current readonly node
       zk.delete(zkBookieReadOnlyPath, -1);
     } catch (KeeperException.NoNodeException nne) {
       LOG.warn(
           "No readonly bookie registered node {} when transitioning to writable",
           zkBookieReadOnlyPath,
           nne);
     }
   } catch (IOException e) {
     LOG.error("Error in transition to ReadOnly Mode." + " Shutting down", e);
     triggerBookieShutdown(ExitCode.BOOKIE_EXCEPTION);
   } catch (KeeperException e) {
     LOG.error("Error in transition to ReadOnly Mode." + " Shutting down", e);
     triggerBookieShutdown(ExitCode.BOOKIE_EXCEPTION);
   } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
     LOG.warn("Interrupted Exception while transitioning to ReadOnly Mode.");
   }
 }
Ejemplo n.º 2
0
 @VisibleForTesting
 public void doTransitionToReadOnlyMode() {
   if (shuttingdown) {
     return;
   }
   if (!readOnly.compareAndSet(false, true)) {
     return;
   }
   if (!conf.isReadOnlyModeEnabled()) {
     LOG.warn(
         "ReadOnly mode is not enabled. "
             + "Can be enabled by configuring "
             + "'readOnlyModeEnabled=true' in configuration."
             + "Shutting down bookie");
     triggerBookieShutdown(ExitCode.BOOKIE_EXCEPTION);
     return;
   }
   LOG.info(
       "Transitioning Bookie to ReadOnly mode,"
           + " and will serve only read requests from clients!");
   // change zookeeper state only when using zookeeper
   if (null == zk) {
     return;
   }
   try {
     if (null == zk.exists(this.bookieReadonlyRegistrationPath, false)) {
       try {
         zk.create(
             this.bookieReadonlyRegistrationPath,
             new byte[0],
             Ids.OPEN_ACL_UNSAFE,
             CreateMode.PERSISTENT);
       } catch (NodeExistsException e) {
         // this node is just now created by someone.
       }
     }
     doRegisterBookie(zkBookieReadOnlyPath);
     try {
       // Clear the current registered node
       zk.delete(zkBookieRegPath, -1);
     } catch (KeeperException.NoNodeException nne) {
       LOG.warn(
           "No writable bookie registered node {} when transitioning to readonly",
           zkBookieRegPath,
           nne);
     }
   } catch (IOException e) {
     LOG.error("Error in transition to ReadOnly Mode." + " Shutting down", e);
     triggerBookieShutdown(ExitCode.BOOKIE_EXCEPTION);
     return;
   } catch (KeeperException e) {
     LOG.error("Error in transition to ReadOnly Mode." + " Shutting down", e);
     triggerBookieShutdown(ExitCode.BOOKIE_EXCEPTION);
   } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
     LOG.warn("Interrupted Exception while transitioning to ReadOnly Mode.");
   }
 }
Ejemplo n.º 3
0
 // Triggering the Bookie shutdown in its own thread,
 // because shutdown can be called from sync thread which would be
 // interrupted by shutdown call.
 void triggerBookieShutdown(final int exitCode) {
   LOG.info("Triggering shutdown of Bookie-{} with exitCode {}", conf.getBookiePort(), exitCode);
   BookieThread shutdownThread =
       new BookieThread("BookieShutdownTrigger") {
         @Override
         public void run() {
           Bookie.this.shutdown(exitCode);
         }
       };
   shutdownThread.start();
   try {
     shutdownThread.join();
   } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
     LOG.debug("InterruptedException while waiting for shutdown. Not a problem!!");
   }
 }
Ejemplo n.º 4
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);
    }
  }