content: /*
   *
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   *
   */
  package org.apache.bookkeeper.bookie;
  
  /**
   * Signals that a Bookie exception of some sort has occurred. This class
   * is the general class of exceptions produced by failed or interrupted bookie operations.
   */
  @SuppressWarnings("serial")
  public abstract class BookieException extends Exception {
  
      private final int code;
  
      public BookieException(int code) {
          super();
          this.code = code;
      }
  
      public BookieException(int code, Throwable t) {
          super(t);
          this.code = code;
      }
  
      public BookieException(int code, String reason) {
          super(reason);
          this.code = code;
      }
  
      public BookieException(int code, String reason, Throwable t) {
          super(reason, t);
          this.code = code;
      }
  
      public static BookieException create(int code) {
          switch(code) {
          case Code.UnauthorizedAccessException:
              return new BookieUnauthorizedAccessException();
          case Code.LedgerFencedException:
              return new LedgerFencedException();
          case Code.InvalidCookieException:
              return new InvalidCookieException();
          case Code.UpgradeException:
              return new UpgradeException();
          case Code.DiskPartitionDuplicationException:
              return new DiskPartitionDuplicationException();
          case Code.CookieNotFoundException:
              return new CookieNotFoundException();
          case Code.CookieExistsException:
              return new CookieExistException();
          case Code.MetadataStoreException:
              return new MetadataStoreException();
          case Code.UnknownBookieIdException:
              return new UnknownBookieIdException();
          case Code.LedgerFencedAndDeletedException:
              return new LedgerFencedAndDeletedException();
          case Code.DataUnknownException:
              return new DataUnknownException();
          default:
              return new BookieIllegalOpException();
          }
      }
  
      /**
       * An exception code indicates the failure reason.
       */
      public interface Code {
          int OK = 0;
          int UnauthorizedAccessException = -1;
  
          int IllegalOpException = -100;
          int LedgerFencedException = -101;
          int InvalidCookieException = -102;
          int UpgradeException = -103;
          int DiskPartitionDuplicationException = -104;
          int CookieNotFoundException = -105;
          int MetadataStoreException = -106;
          int UnknownBookieIdException = -107;
          int OperationRejectedException = -108;
          int CookieExistsException = -109;
          int EntryLogMetadataMapException = -110;
          int DataUnknownException = -111;
          int LedgerFencedAndDeletedException = -112;
      }
  
      public int getCode() {
          return this.code;
      }
  
      public String getMessage(int code) {
          String err;
          switch(code) {
          case Code.OK:
              err = "No problem";
              break;
          case Code.UnauthorizedAccessException:
              err = "Error while reading ledger";
              break;
          case Code.LedgerFencedException:
              err = "Ledger has been fenced; No more entries can be added";
              break;
          case Code.InvalidCookieException:
              err = "Invalid environment cookie found";
              break;
          case Code.UpgradeException:
              err = "Error performing an upgrade operation ";
              break;
          case Code.DiskPartitionDuplicationException:
              err = "Disk Partition Duplication is not allowed";
              break;
          case Code.CookieNotFoundException:
              err = "Cookie not found";
              break;
          case Code.CookieExistsException:
              err = "Cookie already exists";
              break;
          case Code.EntryLogMetadataMapException:
              err = "Error in accessing Entry-log metadata map";
              break;
          case Code.MetadataStoreException:
              err = "Error performing metadata operations";
              break;
          case Code.UnknownBookieIdException:
              err = "Unknown bookie id";
              break;
          case Code.OperationRejectedException:
              err = "Operation rejected";
              break;
          case Code.DataUnknownException:
              err = "Unable to respond, ledger is in unknown state";
              break;
          default:
              err = "Invalid operation";
              break;
          }
          String reason = super.getMessage();
          if (reason == null) {
              if (super.getCause() != null) {
                  reason = super.getCause().getMessage();
              }
          }
          if (reason == null) {
              return err;
          } else {
              return String.format("%s [%s]", err, reason);
          }
      }
  
      /**
       * Signals that an unauthorized operation attempts to access the data in a bookie.
       */
      public static class BookieUnauthorizedAccessException extends BookieException {
          public BookieUnauthorizedAccessException() {
              super(Code.UnauthorizedAccessException);
          }
  
          public BookieUnauthorizedAccessException(String reason) {
              super(Code.UnauthorizedAccessException, reason);
          }
      }
  
      /**
       * Signals that an illegal operation attempts to access the data in a bookie.
       */
      public static class BookieIllegalOpException extends BookieException {
          public BookieIllegalOpException() {
              super(Code.IllegalOpException);
          }
  
          public BookieIllegalOpException(String reason) {
              super(Code.IllegalOpException, reason);
          }
  
          public BookieIllegalOpException(Throwable cause) {
              super(Code.IllegalOpException, cause);
          }
      }
  
      /**
       * Signals that a ledger has been fenced in a bookie. No more entries can be appended to that ledger.
       */
      public static class LedgerFencedException extends BookieException {
          public LedgerFencedException() {
              super(Code.LedgerFencedException);
          }
      }
  
      /**
       * Signals that a ledger has been fenced in a bookie. No more entries can be appended to that ledger.
       */
      public static class LedgerFencedAndDeletedException extends BookieException {
          public LedgerFencedAndDeletedException() {
              super(Code.LedgerFencedException);
          }
      }
  
      /**
       * Signals that a ledger's operation has been rejected by an internal component because of the resource saturation.
       */
      public static class OperationRejectedException extends BookieException {
          public OperationRejectedException() {
              super(Code.OperationRejectedException);
          }
  
          @Override
          public Throwable fillInStackTrace() {
              // Since this exception is a way to signal a specific condition and it's triggered and very specific points,
              // we can disable stack traces.
              return null;
          }
      }
  
      /**
       * Signal that an invalid cookie is found when starting a bookie.
       *
       * <p>This exception is mainly used for detecting if there is any malformed configuration in a bookie.
       */
      public static class InvalidCookieException extends BookieException {
          public InvalidCookieException() {
              this("");
          }
  
          public InvalidCookieException(String reason) {
              super(Code.InvalidCookieException, reason);
          }
  
          public InvalidCookieException(Throwable cause) {
              super(Code.InvalidCookieException, cause);
          }
      }
  
      /**
       * Signal that no cookie is found when starting a bookie.
       */
      public static class CookieNotFoundException extends BookieException {
          public CookieNotFoundException() {
              this("");
          }
  
          public CookieNotFoundException(String reason) {
              super(Code.CookieNotFoundException, reason);
          }
  
          public CookieNotFoundException(Throwable cause) {
              super(Code.CookieNotFoundException, cause);
          }
      }
  
      /**
       * Signal that cookie already exists when creating a new cookie.
       */
      public static class CookieExistException extends BookieException {
          public CookieExistException() {
              this("");
          }
  
          public CookieExistException(String reason) {
              super(Code.CookieExistsException, reason);
          }
  
          public CookieExistException(Throwable cause) {
              super(Code.CookieExistsException, cause);
          }
      }
  
      /**
       * Signal that error while accessing entry-log metadata map.
       */
      public static class EntryLogMetadataMapException extends BookieException {
          public EntryLogMetadataMapException(Throwable cause) {
              super(Code.EntryLogMetadataMapException, cause);
          }
      }
  
      /**
       * Signals that an exception occurs on upgrading a bookie.
       */
      public static class UpgradeException extends BookieException {
          public UpgradeException() {
              super(Code.UpgradeException);
          }
  
          public UpgradeException(Throwable cause) {
              super(Code.UpgradeException, cause);
          }
  
          public UpgradeException(String reason) {
              super(Code.UpgradeException, reason);
          }
      }
  
      /**
       * Signals when multiple ledger/journal directories are mounted in same disk partition.
       */
      public static class DiskPartitionDuplicationException extends BookieException {
          public DiskPartitionDuplicationException() {
              super(Code.DiskPartitionDuplicationException);
          }
  
          public DiskPartitionDuplicationException(Throwable cause) {
              super(Code.DiskPartitionDuplicationException, cause);
          }
  
          public DiskPartitionDuplicationException(String reason) {
              super(Code.DiskPartitionDuplicationException, reason);
          }
      }
  
      /**
       * Signal when bookie has problems on accessing metadata store.
       */
      public static class MetadataStoreException extends BookieException {
  
          public MetadataStoreException() {
              this("");
          }
  
          public MetadataStoreException(String reason) {
              super(Code.MetadataStoreException, reason);
          }
  
          public MetadataStoreException(Throwable cause) {
              super(Code.MetadataStoreException, cause);
          }
  
          public MetadataStoreException(String reason, Throwable cause) {
              super(Code.MetadataStoreException, reason, cause);
          }
      }
  
      /**
       * Signal when bookie has problems on accessing metadata store.
       */
      public static class UnknownBookieIdException extends BookieException {
  
          public UnknownBookieIdException() {
              super(Code.UnknownBookieIdException);
          }
  
          public UnknownBookieIdException(Throwable cause) {
              super(Code.UnknownBookieIdException, cause);
          }
      }
  
      /**
       * Signal when a ledger is in a limbo state and certain operations
       * cannot be performed on it.
       */
      public static class DataUnknownException extends BookieException {
          public DataUnknownException() {
              super(Code.DataUnknownException);
          }
  
          public DataUnknownException(Throwable t) {
              super(Code.DataUnknownException, t);
          }
  
          public DataUnknownException(String reason) {
              super(Code.DataUnknownException, reason);
          }
  
          public DataUnknownException(String reason, Throwable t) {
              super(Code.DataUnknownException, reason, t);
          }
      }
  }
  