Enum rdkafka_sys::types::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,
    Retry,
    PurgeQueue,
    PurgeInflight,
    Fatal,
    Inconsistent,
    GaplessGuarantee,
    PollExceeded,
    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,
    KafkaStorageError,
    LogDirNotFound,
    SaslAuthenticationFailed,
    UnknownProducerId,
    ReassignmentInProgress,
    DelegationTokenAuthDisabled,
    DelegationTokenNotFound,
    DelegationTokenOwnerMismatch,
    DelegationTokenRequestNotAllowed,
    DelegationTokenAuthorizationFailed,
    DelegationTokenExpired,
    InvalidPrincipalType,
    NonEmptyGroup,
    GroupIdNotFound,
    FetchSessionIdNotFound,
    InvalidFetchSessionEpoch,
    ListenerNotFound,
    TopicDeletionDisabled,
    UnsupportedCompressionType,
    // 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

Retry

Retry operation

PurgeQueue

Purged in queue

PurgeInflight

Purged in flight

Fatal

Fatal error: see rd_kafka_fatal_error()

Inconsistent

Inconsistent state

GaplessGuarantee

Gap-less ordering would not be guaranteed if proceeding

PollExceeded

Maximum poll interval exceeded

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

KafkaStorageError

Disk error when trying to access log file on the disk

LogDirNotFound

The user-specified log directory is not found in the broker config

SaslAuthenticationFailed

SASL Authentication failed

UnknownProducerId

Unknown Producer Id

ReassignmentInProgress

Partition reassignment is in progress

DelegationTokenAuthDisabled

Delegation Token feature is not enabled

DelegationTokenNotFound

Delegation Token is not found on server

DelegationTokenOwnerMismatch

Specified Principal is not valid Owner/Renewer

DelegationTokenRequestNotAllowed

Delegation Token requests are not allowed on this connection

DelegationTokenAuthorizationFailed

Delegation Token authorization failed

DelegationTokenExpired

Delegation Token is expired

InvalidPrincipalType

Supplied principalType is not supported

NonEmptyGroup

The group is not empty

GroupIdNotFound

The group id does not exist

FetchSessionIdNotFound

The fetch session ID was not found

InvalidFetchSessionEpoch

The fetch session epoch is invalid

ListenerNotFound

No matching listener

TopicDeletionDisabled

Topic deletion is disabled

UnsupportedCompressionType

Unsupported compression type

Trait Implementations

impl Eq for RDKafkaError

impl Copy for RDKafkaError

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 From<rd_kafka_resp_err_t> for RDKafkaError

fn from(err: RDKafkaRespErr) -> RDKafkaError

Performs the conversion.

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.

impl Display for RDKafkaError

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

Formats the value using the given formatter.

impl Debug for RDKafkaError

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

Formats the value using the given formatter.

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.

fn type_id(&self) -> TypeId where
    Self: 'static, 

Gets the TypeId of self