Enum Error

pub enum Error {
    Transport(TransportError),
    Protocol(ProtocolError),
    Application(ApplicationError),
    User(Box<dyn 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:

1. kind: an enum indicating what kind of error was encountered
2. 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<dyn Error + Sync + Send>)

Carries exception structs defined within the Thrift IDL.

Implementations

impl Error

pub fn read_application_error_from_in_protocol( i: &mut dyn 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.

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

Write an ApplicationError into its cross-platform wire representation.

Application code should never call this method directly.

Trait Implementations

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 Error for Error

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

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

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

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

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

Converts to this type from the input type.

impl From<ApplicationError> for Error

fn from(e: ApplicationError) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for Error

fn from(err: FromUtf8Error) -> Self

Converts to this type from the input type.

impl From<ProtocolError> for Error

fn from(e: ProtocolError) -> Self

Converts to this type from the input type.

impl From<String> for Error

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<TransportError> for Error

fn from(e: TransportError) -> Self

Converts to this type from the input type.