Enum rdkafka::error::RDKafkaError

pub enum RDKafkaError {
    BadMessage,
    BadCompression,
    BrokerDestroy,
    Fail,
    BrokerTransportFailure,
    CriticalSystemResource,
    Resolve,
    MessageTimedOut,
    PartitionEOF,
    UnknownPartition,
    FileSystem,
    UnknownTopic,
    AllBrokersDown,
    InvalidArgument,
    OperationTimedOut,
    QueueFull,
    ISRInsufficient,
    NodeUpdate,
    SSL,
    WaitingForCoordinator,
    UnknownGroup,
    InProgress,
    PreviousInProgress,
    ExistingSubscription,
    AssignPartitions,
    RevokePartitions,
    Conflict,
    State,
    UnknownProtocol,
    NotImplemented,
    Authentication,
    NoOffset,
    Outdated,
    TimedOutQueue,
    UnsupportedFeature,
    WaitCache,
    Interrupted,
    KeySerialization,
    ValueSerialization,
    KeyDeserialization,
    ValueDeserialization,
    Partial,
    ReadOnly,
    NoEnt,
    Underflow,
    InvalidType,
    Unknown,
    NoError,
    OffsetOutOfRange,
    InvalidMessage,
    UnknownTopicOrPartition,
    InvalidMessageSize,
    LeaderNotAvailable,
    NotLeaderForPartition,
    RequestTimedOut,
    BrokerNotAvailable,
    ReplicaNotAvailable,
    MessageSizeTooLarge,
    StaleControllerEpoch,
    OffsetMetadataTooLarge,
    NetworkException,
    GroupLoadInProgress,
    GroupCoordinatorNotAvailable,
    NotCoordinatorForGroup,
    InvalidTopic,
    MessageBatchTooLarge,
    NotEnoughReplicas,
    NotEnoughReplicasAfterAppend,
    InvalidRequiredAcks,
    IllegalGeneration,
    InconsistentGroupProtocol,
    InvalidGroupId,
    UnknownMemberId,
    InvalidSessionTimeout,
    RebalanceInProgress,
    InvalidCommitOffsetSize,
    TopicAuthorizationFailed,
    GroupAuthorizationFailed,
    ClusterAuthorizationFailed,
    InvalidTimestamp,
    UnsupportedSASLMechanism,
    IllegalSASLState,
    UnsupportedVersion,
    TopicAlreadyExists,
    InvalidPartitions,
    InvalidReplicationFactor,
    InvalidReplicaAssignment,
    InvalidConfig,
    NotController,
    InvalidRequest,
    UnsupportedForMessageFormat,
    PolicyViolation,
    OutOfOrderSequenceNumber,
    DuplicateSequenceNumber,
    InvalidProducerEpoch,
    InvalidTransactionalState,
    InvalidProducerIdMapping,
    InvalidTransactionTimeout,
    ConcurrentTransactions,
    TransactionCoordinatorFenced,
    TransactionalIdAuthorizationFailed,
    SecurityDisabled,
    OperationNotAttempted,
    // some variants omitted
}

Errors enum Error from the underlying rdkafka library.

Variants

BadMessage

Received message is incorrect

BadCompression

Bad/unknown compression

BrokerDestroy

Broker is going away

Fail

Generic failure

BrokerTransportFailure

Broker transport failure

CriticalSystemResource

Critical system resource

Resolve

Failed to resolve broker

MessageTimedOut

Produced message timed out

PartitionEOF

Reached the end of the topic+partition queue on the broker. Not really an error.

UnknownPartition

Permanent: Partition does not exist in cluster.

FileSystem

File or filesystem error

UnknownTopic

Permanent: Topic does not exist in cluster.

AllBrokersDown

All broker connections are down.

InvalidArgument

Invalid argument, or invalid configuration

OperationTimedOut

Operation timed out

QueueFull

Queue is full

ISRInsufficient

ISR count < required.acks

NodeUpdate

Broker node update

SSL

SSL error

WaitingForCoordinator

Waiting for coordinator to become available.

UnknownGroup

Unknown client group

InProgress

Operation in progress

PreviousInProgress

Previous operation in progress, wait for it to finish.

ExistingSubscription

This operation would interfere with an existing subscription

AssignPartitions

Assigned partitions (rebalance_cb)

RevokePartitions

Revoked partitions (rebalance_cb)

Conflict

Conflicting use

State

Wrong state

UnknownProtocol

Unknown protocol

NotImplemented

Not implemented

Authentication

Authentication failure

NoOffset

No stored offset

Outdated

Outdated

TimedOutQueue

Timed out in queue

UnsupportedFeature

Feature not supported by broker

WaitCache

Awaiting cache update

Interrupted

Operation interrupted (e.g., due to yield))

KeySerialization

Key serialization error

ValueSerialization

Value serialization error

KeyDeserialization

Key deserialization error

ValueDeserialization

Value deserialization error

Partial

Partial response

ReadOnly

Modification attempted on read-only object

NoEnt

No such entry or item not found

Underflow

Read underflow

InvalidType

Invalid type

Unknown

Unknown broker error

NoError

Success

OffsetOutOfRange

Offset out of range

InvalidMessage

Invalid message

UnknownTopicOrPartition

Unknown topic or partition

InvalidMessageSize

Invalid message size

LeaderNotAvailable

Leader not available

NotLeaderForPartition

Not leader for partition

RequestTimedOut

Request timed out

BrokerNotAvailable

Broker not available

ReplicaNotAvailable

Replica not available

MessageSizeTooLarge

Message size too large

StaleControllerEpoch

Stale controller epoch code

OffsetMetadataTooLarge

Offset metadata string too large

NetworkException

Broker disconnected before response received

GroupLoadInProgress

Group coordinator load in progress

GroupCoordinatorNotAvailable

Group coordinator not available

NotCoordinatorForGroup

Not coordinator for group

InvalidTopic

Invalid topic

MessageBatchTooLarge

Message batch larger than configured server segment size

NotEnoughReplicas

Not enough in-sync replicas

NotEnoughReplicasAfterAppend

Message(s) written to insufficient number of in-sync replicas

InvalidRequiredAcks

Invalid required acks value

IllegalGeneration

Specified group generation id is not valid

InconsistentGroupProtocol

Inconsistent group protocol

InvalidGroupId

Invalid group.id

UnknownMemberId

Unknown member

InvalidSessionTimeout

Invalid session timeout

RebalanceInProgress

Group rebalance in progress

InvalidCommitOffsetSize

Commit offset data size is not valid

TopicAuthorizationFailed

Topic authorization failed

GroupAuthorizationFailed

Group authorization failed

ClusterAuthorizationFailed

Cluster authorization failed

InvalidTimestamp

Invalid timestamp

UnsupportedSASLMechanism

Unsupported SASL mechanism

IllegalSASLState

Illegal SASL state

UnsupportedVersion

Unsupported version

TopicAlreadyExists

Topic already exists

InvalidPartitions

Invalid number of partitions

InvalidReplicationFactor

Invalid replication factor

InvalidReplicaAssignment

Invalid replica assignment

InvalidConfig

Invalid config */

NotController

Not controller for cluster

InvalidRequest

Invalid request

UnsupportedForMessageFormat

Message format on broker does not support request

PolicyViolation

Policy violation

OutOfOrderSequenceNumber

Broker received an out of order sequence number

DuplicateSequenceNumber

Broker received a duplicate sequence number

InvalidProducerEpoch

Producer attempted an operation with an old epoch

InvalidTransactionalState

Producer attempted a transactional operation in an invalid state

InvalidProducerIdMapping

Producer attempted to use a producer id which is currently assigned to its transactional id

InvalidTransactionTimeout

Transaction timeout is larger than the maxi value allowed by the broker's max.transaction.timeout.ms

ConcurrentTransactions

Producer attempted to update a transaction while another concurrent operation on the same transaction was ongoing

TransactionCoordinatorFenced

Indicates that the transaction coordinator sending a WriteTxnMarker is no longer the current coordinator for a given producer

TransactionalIdAuthorizationFailed

Transactional Id authorization failed

SecurityDisabled

Security features are disabled

OperationNotAttempted

Operation not attempted

Trait Implementations

impl Copy for RDKafkaError

impl Display for RDKafkaError

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

Formats the value using the given formatter.

impl Eq for RDKafkaError

impl From<rd_kafka_resp_err_t> for RDKafkaError

fn from(err: rd_kafka_resp_err_t) -> RDKafkaError

Performs the conversion.

impl Error for RDKafkaError

fn description(&self) -> &str

This method is soft-deprecated.

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

Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

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

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

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

impl PartialEq<RDKafkaError> for RDKafkaError

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl Debug for RDKafkaError

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

Formats the value using the given formatter.

impl Clone for RDKafkaError

fn clone(&self) -> RDKafkaError

Returns a copy of the value.

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

Performs copy-assignment from source.