Enum DMSCError 

pub enum DMSCError {
    Io(String),
    Serde(String),
    Config(String),
    Hook(String),
    Prometheus(String),
    ServiceMesh(String),
    InvalidState(String),
    InvalidInput(String),
    SecurityViolation(String),
    DeviceNotFound {
        device_id: String,
    },
    DeviceAllocationFailed {
        device_id: String,
        reason: String,
    },
    AllocationNotFound {
        allocation_id: String,
    },
    ModuleNotFound {
        module_name: String,
    },
    ModuleInitFailed {
        module_name: String,
        reason: String,
    },
    ModuleStartFailed {
        module_name: String,
        reason: String,
    },
    ModuleShutdownFailed {
        module_name: String,
        reason: String,
    },
    CircularDependency {
        modules: Vec<String>,
    },
    MissingDependency {
        module_name: String,
        dependency: String,
    },
    Other(String),
    ExternalError(String),
    PoolError(String),
    DeviceError(String),
    RedisError(String),
    HttpClientError(String),
    TomlError(String),
    YamlError(String),
    Queue(String),
    FrameError(String),
    Database(String),
}

Core error type for DMSC. Represents all possible errors that can occur in the library.

This enum provides a comprehensive set of error variants, each tailored to a specific error scenario encountered in DMSC. It includes variants for I/O errors, serialization errors, configuration errors, module errors, and more.

Variants

Io(String)

I/O operation failed. Contains a descriptive error message.

Serde(String)

Serialization or deserialization failed. Contains a descriptive error message.

Config(String)

Configuration error. Contains a descriptive error message.

Hook(String)

Hook execution error. Contains a descriptive error message.

Prometheus(String)

Prometheus metrics error. Contains a descriptive error message.

ServiceMesh(String)

Service mesh error. Contains a descriptive error message.

InvalidState(String)

Invalid state error. Indicates an operation was attempted in an invalid state.

InvalidInput(String)

Invalid input error. Indicates that provided input data is not valid.

SecurityViolation(String)

Security violation error. Indicates a security policy or rule was violated.

DeviceNotFound

Device not found. Contains the device ID that was not found.

Fields

device_id: String

DeviceAllocationFailed

Device allocation failed. Contains the device ID and reason for failure.

Fields

device_id: String

reason: String

AllocationNotFound

Allocation not found. Contains the allocation ID that was not found.

Fields

allocation_id: String

ModuleNotFound

Module not found. Contains the module name that was not found.

Fields

module_name: String

ModuleInitFailed

Module initialization failed. Contains the module name and reason for failure.

Fields

module_name: String

reason: String

ModuleStartFailed

Module start failed. Contains the module name and reason for failure.

Fields

module_name: String

reason: String

ModuleShutdownFailed

Module shutdown failed. Contains the module name and reason for failure.

Fields

module_name: String

reason: String

CircularDependency

Circular dependency detected. Contains the list of modules involved in the cycle.

Fields

modules: Vec<String>

MissingDependency

Missing dependency. Contains the module name and the missing dependency.

Fields

module_name: String

dependency: String

Other(String)

Other error. Contains a descriptive error message for unclassified errors.

ExternalError(String)

External error. Contains a descriptive error message for external service errors.

PoolError(String)

Pool error. Contains a descriptive error message for connection pool errors.

DeviceError(String)

Device error. Contains a descriptive error message for device-related errors.

RedisError(String)

Redis error. Contains a descriptive error message for Redis operations.

HttpClientError(String)

HTTP client error. Contains a descriptive error message for HTTP requests.

TomlError(String)

TOML parsing error. Contains a descriptive error message for TOML parsing.

YamlError(String)

YAML parsing error. Contains a descriptive error message for YAML parsing.

Queue(String)

Queue error. Contains a descriptive error message for queue operations.

FrameError(String)

Frame error. Contains a descriptive error message for frame parsing/building errors.

Database(String)

Database error. Contains a descriptive error message for database operations.

Implementations

impl DMSCError

Python bindings for DMSCError.

This implementation provides a Python interface for the DMSCError type, enabling Python applications to create, inspect, and handle DMSC errors. The bindings expose factory methods for creating specific error types and predicate methods for checking error variants at runtime.

Python Usage Example

 

try:
    # Some operation that might fail
    pass
except Exception as e:
    if isinstance(e, dms.DMSCError):
        print(f"Error type: {type(e)}")
        if e.is_io():
            print("I/O error occurred")

Available Methods

• Factory methods: Create specific error types from Python
• Inspection methods: Check the error variant at runtime
• String representation: str and repr for display

pub fn __str__(&self) -> String

Returns the string representation of the error.

This method implements the Python str protocol, returning a human-readable error message that describes the error. The format matches the Display trait implementation in Rust, providing consistent output across language boundaries.

Returns: A String containing the formatted error message

pub fn __repr__(&self) -> String

Returns the debug representation of the error.

This method implements the Python repr protocol, returning a detailed representation suitable for debugging. Unlike str, this format includes the specific error variant and all associated data.

Returns: A String containing the debug-formatted error representation

pub fn from_str(message: &str) -> Self

Creates a new DMSCError from a string message.

This factory method creates an Other variant error containing the provided message. It serves as a generic error constructor for custom error scenarios that don’t fit other specific error types.

Arguments: message: The error message describing the failure

Returns: A new DMSCError instance with Other variant

pub fn io(message: &str) -> Self

Creates a new IO error.

This factory method creates an Io variant error for I/O operation failures. Use this when file operations, network I/O, or other standard I/O operations fail.

Arguments: message: A description of the I/O failure

Returns: A new DMSCError instance with Io variant

pub fn serde(message: &str) -> Self

Creates a new serialization error.

This factory method creates a Serde variant error for serialization or deserialization failures. Use this for JSON, binary, or other data format conversion errors.

Arguments: message: A description of the serialization failure

Returns: A new DMSCError instance with Serde variant

pub fn config(message: &str) -> Self

Creates a new configuration error.

This factory method creates a Config variant error for configuration-related failures. Use this when configuration files are invalid, missing, or contain unsupported values.

Arguments: message: A description of the configuration error

Returns: A new DMSCError instance with Config variant

pub fn hook(message: &str) -> Self

Creates a new hook execution error.

This factory method creates a Hook variant error for hook callback failures. Use this when a registered hook function fails to execute properly.

Arguments: message: A description of the hook execution failure

Returns: A new DMSCError instance with Hook variant

pub fn is_io(&self) -> bool

Checks if this error is an IO error.

This predicate method returns true if the error is an Io variant. Use this for conditional error handling based on error type.

Returns: true if the error is an Io variant, false otherwise

pub fn is_serde(&self) -> bool

Checks if this error is a serialization error.

This predicate method returns true if the error is a Serde variant. Use this for conditional error handling based on error type.

Returns: true if the error is a Serde variant, false otherwise

pub fn is_config(&self) -> bool

Checks if this error is a configuration error.

This predicate method returns true if the error is a Config variant. Use this for conditional error handling based on error type.

Returns: true if the error is a Config variant, false otherwise

pub fn is_hook(&self) -> bool

Checks if this error is a hook error.

This predicate method returns true if the error is a Hook variant. Use this for conditional error handling based on error type.

Returns: true if the error is a Hook variant, false otherwise

pub fn is_prometheus(&self) -> bool

Checks if this error is a Prometheus metrics error.

This predicate method returns true if the error is a Prometheus variant. This method is only available when the “observability” feature is enabled.

Returns: true if the error is a Prometheus variant, false otherwise

pub fn is_service_mesh(&self) -> bool

Checks if this error is a service mesh error.

This predicate method returns true if the error is a ServiceMesh variant. Use this for conditional error handling related to service mesh operations.

Returns: true if the error is a ServiceMesh variant, false otherwise

pub fn is_invalid_state(&self) -> bool

Checks if this error is an invalid state error.

This predicate method returns true if the error is an InvalidState variant. Use this when an operation was attempted in an invalid program state.

Returns: true if the error is an InvalidState variant, false otherwise

pub fn is_invalid_input(&self) -> bool

Checks if this error is an invalid input error.

This predicate method returns true if the error is an InvalidInput variant. Use this when provided input data fails validation checks.

Returns: true if the error is an InvalidInput variant, false otherwise

pub fn is_security_violation(&self) -> bool

Checks if this error is a security violation error.

This predicate method returns true if the error is a SecurityViolation variant. Use this when a security policy or rule has been violated.

Returns: true if the error is a SecurityViolation variant, false otherwise

pub fn is_device_not_found(&self) -> bool

Checks if this error is a device not found error.

This predicate method returns true if the error is a DeviceNotFound variant. Use this when a requested device identifier does not exist.

Returns: true if the error is a DeviceNotFound variant, false otherwise

pub fn is_device_allocation_failed(&self) -> bool

Checks if this error is a device allocation failed error.

This predicate method returns true if the error is a DeviceAllocationFailed variant. Use this when a device cannot be allocated for use.

Returns: true if the error is a DeviceAllocationFailed variant, false otherwise

pub fn is_allocation_not_found(&self) -> bool

Checks if this error is an allocation not found error.

This predicate method returns true if the error is an AllocationNotFound variant. Use this when a requested allocation identifier does not exist.

Returns: true if the error is an AllocationNotFound variant, false otherwise

pub fn is_module_not_found(&self) -> bool

Checks if this error is a module not found error.

This predicate method returns true if the error is a ModuleNotFound variant. Use this when a requested module does not exist in the system.

Returns: true if the error is a ModuleNotFound variant, false otherwise

pub fn is_module_init_failed(&self) -> bool

Checks if this error is a module initialization failed error.

This predicate method returns true if the error is a ModuleInitFailed variant. Use this when a module fails to initialize properly.

Returns: true if the error is a ModuleInitFailed variant, false otherwise

pub fn is_module_start_failed(&self) -> bool

Checks if this error is a module start failed error.

This predicate method returns true if the error is a ModuleStartFailed variant. Use this when a module fails to start after successful initialization.

Returns: true if the error is a ModuleStartFailed variant, false otherwise

pub fn is_module_shutdown_failed(&self) -> bool

Checks if this error is a module shutdown failed error.

This predicate method returns true if the error is a ModuleShutdownFailed variant. Use this when a module fails to shut down gracefully.

Returns: true if the error is a ModuleShutdownFailed variant, false otherwise

pub fn is_circular_dependency(&self) -> bool

Checks if this error is a circular dependency error.

This predicate method returns true if the error is a CircularDependency variant. Use this when modules have circular import or initialization dependencies.

Returns: true if the error is a CircularDependency variant, false otherwise

pub fn is_missing_dependency(&self) -> bool

Checks if this error is a missing dependency error.

This predicate method returns true if the error is a MissingDependency variant. Use this when a module depends on another module that is not available.

Returns: true if the error is a MissingDependency variant, false otherwise

pub fn is_other(&self) -> bool

Checks if this error is a generic other error.

This predicate method returns true if the error is an Other variant. Use this as a catch-all check for unclassified errors.

Returns: true if the error is an Other variant, false otherwise

pub fn is_external_error(&self) -> bool

Checks if this error is an external error.

This predicate method returns true if the error is an ExternalError variant. Use this for errors originating from external services or dependencies.

Returns: true if the error is an ExternalError variant, false otherwise

pub fn is_pool_error(&self) -> bool

Checks if this error is a connection pool error.

This predicate method returns true if the error is a PoolError variant. Use this for errors related to connection pool management.

Returns: true if the error is a PoolError variant, false otherwise

pub fn is_device_error(&self) -> bool

Checks if this error is a device error.

This predicate method returns true if the error is a DeviceError variant. Use this for general device-related errors not covered by specific variants.

Returns: true if the error is a DeviceError variant, false otherwise

pub fn is_redis_error(&self) -> bool

Checks if this error is a Redis error.

This predicate method returns true if the error is a RedisError variant. This method is only available when the “redis” feature is enabled.

Returns: true if the error is a RedisError variant, false otherwise

pub fn is_http_client_error(&self) -> bool

Checks if this error is an HTTP client error.

This predicate method returns true if the error is an HttpClientError variant. This method is only available when the “http_client” feature is enabled.

Returns: true if the error is an HttpClientError variant, false otherwise

pub fn is_toml_error(&self) -> bool

Checks if this error is a TOML parsing error.

This predicate method returns true if the error is a TomlError variant. Use this for errors related to TOML configuration file parsing.

Returns: true if the error is a TomlError variant, false otherwise

pub fn is_yaml_error(&self) -> bool

Checks if this error is a YAML parsing error.

This predicate method returns true if the error is a YamlError variant. Use this for errors related to YAML configuration file parsing.

Returns: true if the error is a YamlError variant, false otherwise

pub fn is_queue(&self) -> bool

Checks if this error is a queue error.

This predicate method returns true if the error is a Queue variant. Use this for errors related to message queue operations (RabbitMQ, Kafka).

Returns: true if the error is a Queue variant, false otherwise

Trait Implementations

impl Clone for DMSCError

fn clone(&self) -> DMSCError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DMSCError

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

Formats the value using the given formatter.

impl Display for DMSCError

Implements Display trait for human-readable error messages.

Each error variant is formatted with a clear, descriptive prefix indicating the error category, followed by the specific error details. This enables developers to quickly identify the source and nature of errors during development and debugging.

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

Formats the value using the given formatter.

impl Error for DMSCError

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

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

fn description(&self) -> &str

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

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 From<DMSCDatabaseTransactionError> for DMSCError

fn from(e: DMSCDatabaseTransactionError) -> Self

Converts to this type from the input type.

impl From<DMSCError> for PyErr

Available on crate feature pyo3 only.

fn from(error: DMSCError) -> Self

Converts to this type from the input type.

impl From<DMSCLockError> for DMSCError

fn from(error: DMSCLockError) -> Self

Converts to this type from the input type.

impl From<DMSCQueueError> for DMSCError

fn from(error: DMSCQueueError) -> Self

Converts to this type from the input type.

impl From<Elapsed> for DMSCError

fn from(error: Elapsed) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Enables automatic conversion from standard I/O errors to DMSC errors. This implementation wraps std::io::Error instances into DMSCError::Io variants, allowing seamless error propagation when working with file operations, network I/O, and other standard I/O operations.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Enables automatic conversion from JSON serialization/deserialization errors. This implementation wraps serde_json::Error instances into DMSCError::Serde variants, providing consistent error handling for JSON parsing and generation operations.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Available on crate feature observability only.

Enables automatic conversion from Prometheus metrics errors to DMSC errors. This implementation is conditionally compiled with the “observability” feature. Prometheus errors are wrapped into DMSCError::Prometheus variants.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Available on crate feature http_client only.

Enables automatic conversion from HTTP client errors to DMSC errors. This implementation is conditionally compiled with the “http_client” feature. HTTP request failures, timeouts, and network errors are wrapped into DMSCError::HttpClientError variants for consistent error handling.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Enables automatic conversion from TOML parsing errors to DMSC errors. This implementation wraps toml::de::Error instances into DMSCError::TomlError variants, providing consistent error handling for TOML configuration file parsing.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Enables automatic conversion from TOML serialization errors to DMSC errors. This implementation wraps toml::ser::Error instances into DMSCError::TomlError variants, providing consistent error handling for TOML configuration generation.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Enables automatic conversion from YAML parsing errors to DMSC errors. This implementation wraps serde_yaml::Error instances into DMSCError::YamlError variants, providing consistent error handling for YAML configuration file parsing.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DMSCError

Available on crate feature rabbitmq only.

Enables automatic conversion from RabbitMQ client errors to DMSC errors. This implementation is conditionally compiled with the “rabbitmq” feature. RabbitMQ connection and channel errors are wrapped into DMSCError::Other variants with a “RabbitMQ error:” prefix for consistent error categorization.

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<GrpcError> for DMSCError

fn from(error: GrpcError) -> Self

Converts to this type from the input type.

impl From<KafkaError> for DMSCError

Available on crate feature kafka and non-Windows only.

Enables automatic conversion from Kafka client errors to DMSC errors. This implementation is conditionally compiled with the “kafka” feature on non-Windows platforms. Kafka producer, consumer, and administration errors are wrapped into DMSCError::Queue variants for consistent error handling in message queue operations.

fn from(error: KafkaError) -> Self

Converts to this type from the input type.

impl From<ProtocolError> for DMSCError

fn from(error: ProtocolError) -> Self

Converts to this type from the input type.

impl From<PyErr> for DMSCError

Available on crate feature pyo3 only.

fn from(error: PyErr) -> Self

Converts to this type from the input type.

impl From<RedisError> for DMSCError

Available on crate feature redis only.

Enables automatic conversion from Redis client errors to DMSC errors. This implementation is conditionally compiled with the “redis” feature. Redis errors are wrapped into DMSCError::RedisError variants, providing consistent error handling for Redis connection and operation failures.

fn from(error: RedisError) -> Self

Converts to this type from the input type.

impl From<TryLockError> for DMSCError

fn from(error: TryLockError) -> Self

Converts to this type from the input type.

impl From<Utf8Error> for DMSCError

fn from(error: Utf8Error) -> Self

Converts to this type from the input type.

impl From<WSError> for DMSCError

fn from(error: WSError) -> Self

Converts to this type from the input type.

impl Hash for DMSCError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'py> IntoPyObject<'py> for DMSCError

type Target = DMSCError

The Python output type

type Output = Bound<'py, <DMSCError as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PartialEq for DMSCError

fn eq(&self, other: &DMSCError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyClass for DMSCError

type Frozen = True

Whether the pyclass is frozen.

impl PyClassBaseType for DMSCError

type LayoutAsBase = PyClassObject<DMSCError>

type BaseNativeType = <DMSCError as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<DMSCError>

type PyClassMutability = <DMSCError as PyClassImpl>::PyClassMutability

impl PyClassImpl for DMSCError

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// configuration errors, module errors, and more.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<DMSCError>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::ImmutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyMethods<DMSCError> for PyClassImplCollector<DMSCError>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for DMSCError

const NAME: &'static str = "DMSCError"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl Eq for DMSCError

impl ExtractPyClassWithClone for DMSCError

impl StructuralPartialEq for DMSCError