Enum rift::Error

pub enum Error {
    Transport(TransportError),
    Protocol(ProtocolError),
    Application(ApplicationError),
    User(Box<Error + Sync + Send>),
}

Rift error type.

The error type defined here is used throughout this crate as well as in all Thrift-compiler-generated Rust code. It falls into one of four standard (i.e. defined by convention in Thrift implementations) categories. These are:

1. Transport errors: errors encountered while writing byes to the I/O channel. These include "connection closed", "bind errors", etc.
2. Protocol errors: errors encountered when processing a Thrift message within the rift library. These include "exceeding size limits", "unsupported protocol versions", etc.
3. Application errors: errors encountered when Thrift-compiler-generated 'application' code encounters conditions that violate the spec. These include "out-of-order messages", "missing required-field values", etc. This category also functions as a catch-all: any error returned by handler functions is automatically encoded as an ApplicationError and returned to the caller.

4. User errors: exception structs defined within the Thrift IDL.

   With the exception of Error::User, each error variant encapsulates a corresponding struct which encodes two required fields:

5. kind: an enum indicating what kind of error was encountered

6. message: string with human-readable error information

   These two fields are encoded and sent over the wire to the remote. kind is defined by convention while message is freeform. If none of the enumerated error kinds seem suitable use the catch-all Unknown.

   Examples

   Creating a TransportError explicitly.

   Conversions are defined from rift::TransportError, rift::ProtocolError and rift::ApplicationError to the corresponding rift::Error variant (see err2 below).

   use rift;
   use rift::{TransportError, TransportErrorKind};
   
   let err0: rift::Result<()> = Err(
   rift::Error::Transport(
    TransportError {
      kind: TransportErrorKind::TimedOut,
      message: format!("connection to server timed out")
    }
   )
   );
   
   let err1: rift::Result<()> = Err(
   rift::Error::Transport(
    TransportError::new(
      TransportErrorKind::TimedOut,
      format!("connection to server timed out")
    )
   )
   );
   
   let err2: rift::Result<()> = Err(
   rift::Error::from(
    TransportError::new(
      TransportErrorKind::TimedOut,
      format!("connection to server timed out")
    )
   )
   );
   

   Creating an arbitrary error from a string

   use rift;
   use rift::{ApplicationError, ApplicationErrorKind};
   
   let err0: rift::Result<()> = Err(
   rift::Error::from("This is an error")
   );
   
   // err0 is equivalent to...
   
   let err1: rift::Result<()> = Err(
   rift::Error::Application(
    ApplicationError::new(
      ApplicationErrorKind::Unknown,
      format!("This is an error")
    )
   )
   );

   Returning a user-defined (using the Thrift IDL) exception struct.

   // Thrift IDL exception definition.
   exception Xception {
   1: i32 errorCode,
   2: string message
   }
   

   use std::convert::From;
   use std::error::Error;
   use std::fmt;
   use std::fmt::{Display, Formatter};
   
   // auto-generated by the Thrift compiler
   #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
   pub struct Xception {
   pub error_code: Option<i32>,
   pub message: Option<String>,
   }
   
   // auto-generated by the Thrift compiler
   impl Error for Xception {
   fn description(&self) -> &str {
    "remote service threw Xception"
   }
   }
   
   // auto-generated by the Thrift compiler
   impl From<Xception> for rift::Error {
   fn from(e: Xception) -> Self {
    rift::Error::User(Box::new(e))
   }
   }
   
   // auto-generated by the Thrift compiler
   impl Display for Xception {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
    self.description().fmt(f)
   }
   }
   
   // in user code...
   let err: rift::Result<()> = Err(
   rift::Error::from(Xception { error_code: Some(1), message: None })
   );

Variants

Transport(TransportError)

Errors encountered while writing byes to the I/O channel.

These include "connection closed", "bind errors", etc.

Protocol(ProtocolError)

Errors encountered when processing a Thrift message within the rift library.

These include "exceeding size limits", "unsupported protocol versions", etc.

Application(ApplicationError)

Errors encountered when Thrift-compiler-generated 'application' code encounters conditions that violate the spec.

These include "out-of-order messages", "missing required-field values", etc. This variant also functions as a catch-all: any error returned by handler functions is automatically encoded as an ApplicationError and returned to the caller.

User(Box<Error + Sync + Send>)

Carries exception structs defined within the Thrift IDL.

Methods

impl Error

fn read_application_error_from_in_protocol(
    i: &mut TInputProtocol
) -> Result<ApplicationError>

Read the wire representation of an application exception thrown by the remote Thrift endpoint into its corresponding rift ApplicationError representation.

Application code should never call this method directly.

fn write_application_error_to_out_protocol(
    e: &ApplicationError,
    o: &mut TOutputProtocol
) -> Result<()>

Write an ApplicationError into its cross-platform wire representation.

Application code should never call this method directly.

Trait Implementations

impl Error for Error

fn description(&self) -> &str

A short description of the error.

fn cause(&self) -> Option<&Error>

The lower-level cause of this error, if any.

impl Debug for Error

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for Error

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl From<String> for Error

fn from(s: String) -> Self

Performs the conversion.

impl<'a> From<&'a str> for Error

fn from(s: &'a str) -> Self

Performs the conversion.

impl From<TransportError> for Error

fn from(e: TransportError) -> Self

Performs the conversion.

impl From<ProtocolError> for Error

fn from(e: ProtocolError) -> Self

Performs the conversion.

impl From<ApplicationError> for Error

fn from(e: ApplicationError) -> Self

Performs the conversion.

impl From<Error> for Error

fn from(err: Error) -> Self

Performs the conversion.

impl From<FromUtf8Error> for Error

fn from(err: FromUtf8Error) -> Self

Performs the conversion.