github.com/muhammedhassanm/blockchain@v0.0.0-20200120143007-697261defd4d/sawtooth-core-master/validator/src/state/error.rs (about)

     1  /*
     2   * Copyright 2018 Intel Corporation
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   * ------------------------------------------------------------------------------
    16   */
    17  use std::error::Error;
    18  use std::fmt;
    19  
    20  use cbor::decoder::DecodeError;
    21  use cbor::encoder::EncodeError;
    22  use protobuf::ProtobufError;
    23  
    24  use database::database::DatabaseError;
    25  
    26  #[derive(Debug)]
    27  pub enum StateDatabaseError {
    28      NotFound(String),
    29      DeserializationError(DecodeError),
    30      SerializationError(EncodeError),
    31      ChangeLogEncodingError(String),
    32      InvalidRecord,
    33      InvalidHash(String),
    34      InvalidChangeLogIndex(String),
    35      DatabaseError(DatabaseError),
    36      UnknownError,
    37  }
    38  
    39  impl fmt::Display for StateDatabaseError {
    40      fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    41          match self {
    42              &StateDatabaseError::NotFound(ref msg) => write!(f, "Value not found: {}", msg),
    43              &StateDatabaseError::DeserializationError(ref err) => {
    44                  write!(f, "Unable to deserialize entry: {}", err)
    45              }
    46              &StateDatabaseError::SerializationError(ref err) => {
    47                  write!(f, "Unable to serialize entry: {}", err)
    48              }
    49              &StateDatabaseError::ChangeLogEncodingError(ref msg) => {
    50                  write!(f, "Unable to serialize change log entry: {}", msg)
    51              }
    52              &StateDatabaseError::InvalidRecord => write!(f, "A node was malformed"),
    53              &StateDatabaseError::InvalidHash(ref msg) => {
    54                  write!(f, "The given hash is invalid: {}", msg)
    55              }
    56              &StateDatabaseError::InvalidChangeLogIndex(ref msg) => {
    57                  write!(f, "A change log entry was missing or malformed: {}", msg)
    58              }
    59              &StateDatabaseError::DatabaseError(ref err) => {
    60                  write!(f, "A database error occurred: {}", err)
    61              }
    62              &StateDatabaseError::UnknownError => write!(f, "An unknown error occurred"),
    63          }
    64      }
    65  }
    66  
    67  impl Error for StateDatabaseError {
    68      fn description(&self) -> &str {
    69          match self {
    70              &StateDatabaseError::NotFound(ref msg) => &msg,
    71              &StateDatabaseError::DeserializationError(ref err) => err.description(),
    72              &StateDatabaseError::SerializationError(ref err) => err.description(),
    73              &StateDatabaseError::ChangeLogEncodingError(ref msg) => &msg,
    74              &StateDatabaseError::InvalidRecord => "Invalid record",
    75              &StateDatabaseError::InvalidHash(ref msg) => &msg,
    76              &StateDatabaseError::InvalidChangeLogIndex(ref msg) => &msg,
    77              &StateDatabaseError::DatabaseError(ref err) => err.description(),
    78              &StateDatabaseError::UnknownError => "Unknown Error",
    79          }
    80      }
    81  
    82      fn cause(&self) -> Option<&Error> {
    83          match self {
    84              &StateDatabaseError::NotFound(_) => None,
    85              &StateDatabaseError::DeserializationError(ref err) => Some(err),
    86              &StateDatabaseError::SerializationError(ref err) => Some(err),
    87              &StateDatabaseError::ChangeLogEncodingError(_) => None,
    88              &StateDatabaseError::InvalidRecord => None,
    89              &StateDatabaseError::InvalidHash(_) => None,
    90              &StateDatabaseError::InvalidChangeLogIndex(_) => None,
    91              &StateDatabaseError::DatabaseError(ref err) => Some(err),
    92              &StateDatabaseError::UnknownError => None,
    93          }
    94      }
    95  }
    96  
    97  impl From<DatabaseError> for StateDatabaseError {
    98      fn from(err: DatabaseError) -> Self {
    99          StateDatabaseError::DatabaseError(err)
   100      }
   101  }
   102  
   103  impl From<EncodeError> for StateDatabaseError {
   104      fn from(err: EncodeError) -> Self {
   105          StateDatabaseError::SerializationError(err)
   106      }
   107  }
   108  
   109  impl From<DecodeError> for StateDatabaseError {
   110      fn from(err: DecodeError) -> Self {
   111          StateDatabaseError::DeserializationError(err)
   112      }
   113  }
   114  
   115  impl From<ProtobufError> for StateDatabaseError {
   116      fn from(error: ProtobufError) -> Self {
   117          use self::ProtobufError::*;
   118          match error {
   119              IoError(err) => StateDatabaseError::ChangeLogEncodingError(format!("{}", err)),
   120              WireError(err) => StateDatabaseError::ChangeLogEncodingError(format!("{:?}", err)),
   121              Utf8(err) => StateDatabaseError::ChangeLogEncodingError(format!("{}", err)),
   122              MessageNotInitialized { message: err } => {
   123                  StateDatabaseError::ChangeLogEncodingError(format!("{}", err))
   124              }
   125          }
   126      }
   127  }