You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
281 lines
15 KiB
281 lines
15 KiB
package sarama |
|
|
|
import ( |
|
"errors" |
|
"fmt" |
|
) |
|
|
|
// ErrOutOfBrokers is the error returned when the client has run out of brokers to talk to because all of them errored |
|
// or otherwise failed to respond. |
|
var ErrOutOfBrokers = errors.New("kafka: client has run out of available brokers to talk to (Is your cluster reachable?)") |
|
|
|
// ErrClosedClient is the error returned when a method is called on a client that has been closed. |
|
var ErrClosedClient = errors.New("kafka: tried to use a client that was closed") |
|
|
|
// ErrIncompleteResponse is the error returned when the server returns a syntactically valid response, but it does |
|
// not contain the expected information. |
|
var ErrIncompleteResponse = errors.New("kafka: response did not contain all the expected topic/partition blocks") |
|
|
|
// ErrInvalidPartition is the error returned when a partitioner returns an invalid partition index |
|
// (meaning one outside of the range [0...numPartitions-1]). |
|
var ErrInvalidPartition = errors.New("kafka: partitioner returned an invalid partition index") |
|
|
|
// ErrAlreadyConnected is the error returned when calling Open() on a Broker that is already connected or connecting. |
|
var ErrAlreadyConnected = errors.New("kafka: broker connection already initiated") |
|
|
|
// ErrNotConnected is the error returned when trying to send or call Close() on a Broker that is not connected. |
|
var ErrNotConnected = errors.New("kafka: broker not connected") |
|
|
|
// ErrInsufficientData is returned when decoding and the packet is truncated. This can be expected |
|
// when requesting messages, since as an optimization the server is allowed to return a partial message at the end |
|
// of the message set. |
|
var ErrInsufficientData = errors.New("kafka: insufficient data to decode packet, more bytes expected") |
|
|
|
// ErrShuttingDown is returned when a producer receives a message during shutdown. |
|
var ErrShuttingDown = errors.New("kafka: message received by producer in process of shutting down") |
|
|
|
// ErrMessageTooLarge is returned when the next message to consume is larger than the configured Consumer.Fetch.Max |
|
var ErrMessageTooLarge = errors.New("kafka: message is larger than Consumer.Fetch.Max") |
|
|
|
// ErrConsumerOffsetNotAdvanced is returned when a partition consumer didn't advance its offset after parsing |
|
// a RecordBatch. |
|
var ErrConsumerOffsetNotAdvanced = errors.New("kafka: consumer offset was not advanced after a RecordBatch") |
|
|
|
// ErrControllerNotAvailable is returned when server didn't give correct controller id. May be kafka server's version |
|
// is lower than 0.10.0.0. |
|
var ErrControllerNotAvailable = errors.New("kafka: controller is not available") |
|
|
|
// ErrNoTopicsToUpdateMetadata is returned when Meta.Full is set to false but no specific topics were found to update |
|
// the metadata. |
|
var ErrNoTopicsToUpdateMetadata = errors.New("kafka: no specific topics to update metadata") |
|
|
|
// PacketEncodingError is returned from a failure while encoding a Kafka packet. This can happen, for example, |
|
// if you try to encode a string over 2^15 characters in length, since Kafka's encoding rules do not permit that. |
|
type PacketEncodingError struct { |
|
Info string |
|
} |
|
|
|
func (err PacketEncodingError) Error() string { |
|
return fmt.Sprintf("kafka: error encoding packet: %s", err.Info) |
|
} |
|
|
|
// PacketDecodingError is returned when there was an error (other than truncated data) decoding the Kafka broker's response. |
|
// This can be a bad CRC or length field, or any other invalid value. |
|
type PacketDecodingError struct { |
|
Info string |
|
} |
|
|
|
func (err PacketDecodingError) Error() string { |
|
return fmt.Sprintf("kafka: error decoding packet: %s", err.Info) |
|
} |
|
|
|
// ConfigurationError is the type of error returned from a constructor (e.g. NewClient, or NewConsumer) |
|
// when the specified configuration is invalid. |
|
type ConfigurationError string |
|
|
|
func (err ConfigurationError) Error() string { |
|
return "kafka: invalid configuration (" + string(err) + ")" |
|
} |
|
|
|
// KError is the type of error that can be returned directly by the Kafka broker. |
|
// See https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol#AGuideToTheKafkaProtocol-ErrorCodes |
|
type KError int16 |
|
|
|
// Numeric error codes returned by the Kafka server. |
|
const ( |
|
ErrNoError KError = 0 |
|
ErrUnknown KError = -1 |
|
ErrOffsetOutOfRange KError = 1 |
|
ErrInvalidMessage KError = 2 |
|
ErrUnknownTopicOrPartition KError = 3 |
|
ErrInvalidMessageSize KError = 4 |
|
ErrLeaderNotAvailable KError = 5 |
|
ErrNotLeaderForPartition KError = 6 |
|
ErrRequestTimedOut KError = 7 |
|
ErrBrokerNotAvailable KError = 8 |
|
ErrReplicaNotAvailable KError = 9 |
|
ErrMessageSizeTooLarge KError = 10 |
|
ErrStaleControllerEpochCode KError = 11 |
|
ErrOffsetMetadataTooLarge KError = 12 |
|
ErrNetworkException KError = 13 |
|
ErrOffsetsLoadInProgress KError = 14 |
|
ErrConsumerCoordinatorNotAvailable KError = 15 |
|
ErrNotCoordinatorForConsumer KError = 16 |
|
ErrInvalidTopic KError = 17 |
|
ErrMessageSetSizeTooLarge KError = 18 |
|
ErrNotEnoughReplicas KError = 19 |
|
ErrNotEnoughReplicasAfterAppend KError = 20 |
|
ErrInvalidRequiredAcks KError = 21 |
|
ErrIllegalGeneration KError = 22 |
|
ErrInconsistentGroupProtocol KError = 23 |
|
ErrInvalidGroupId KError = 24 |
|
ErrUnknownMemberId KError = 25 |
|
ErrInvalidSessionTimeout KError = 26 |
|
ErrRebalanceInProgress KError = 27 |
|
ErrInvalidCommitOffsetSize KError = 28 |
|
ErrTopicAuthorizationFailed KError = 29 |
|
ErrGroupAuthorizationFailed KError = 30 |
|
ErrClusterAuthorizationFailed KError = 31 |
|
ErrInvalidTimestamp KError = 32 |
|
ErrUnsupportedSASLMechanism KError = 33 |
|
ErrIllegalSASLState KError = 34 |
|
ErrUnsupportedVersion KError = 35 |
|
ErrTopicAlreadyExists KError = 36 |
|
ErrInvalidPartitions KError = 37 |
|
ErrInvalidReplicationFactor KError = 38 |
|
ErrInvalidReplicaAssignment KError = 39 |
|
ErrInvalidConfig KError = 40 |
|
ErrNotController KError = 41 |
|
ErrInvalidRequest KError = 42 |
|
ErrUnsupportedForMessageFormat KError = 43 |
|
ErrPolicyViolation KError = 44 |
|
ErrOutOfOrderSequenceNumber KError = 45 |
|
ErrDuplicateSequenceNumber KError = 46 |
|
ErrInvalidProducerEpoch KError = 47 |
|
ErrInvalidTxnState KError = 48 |
|
ErrInvalidProducerIDMapping KError = 49 |
|
ErrInvalidTransactionTimeout KError = 50 |
|
ErrConcurrentTransactions KError = 51 |
|
ErrTransactionCoordinatorFenced KError = 52 |
|
ErrTransactionalIDAuthorizationFailed KError = 53 |
|
ErrSecurityDisabled KError = 54 |
|
ErrOperationNotAttempted KError = 55 |
|
ErrKafkaStorageError KError = 56 |
|
ErrLogDirNotFound KError = 57 |
|
ErrSASLAuthenticationFailed KError = 58 |
|
ErrUnknownProducerID KError = 59 |
|
ErrReassignmentInProgress KError = 60 |
|
) |
|
|
|
func (err KError) Error() string { |
|
// Error messages stolen/adapted from |
|
// https://kafka.apache.org/protocol#protocol_error_codes |
|
switch err { |
|
case ErrNoError: |
|
return "kafka server: Not an error, why are you printing me?" |
|
case ErrUnknown: |
|
return "kafka server: Unexpected (unknown?) server error." |
|
case ErrOffsetOutOfRange: |
|
return "kafka server: The requested offset is outside the range of offsets maintained by the server for the given topic/partition." |
|
case ErrInvalidMessage: |
|
return "kafka server: Message contents does not match its CRC." |
|
case ErrUnknownTopicOrPartition: |
|
return "kafka server: Request was for a topic or partition that does not exist on this broker." |
|
case ErrInvalidMessageSize: |
|
return "kafka server: The message has a negative size." |
|
case ErrLeaderNotAvailable: |
|
return "kafka server: In the middle of a leadership election, there is currently no leader for this partition and hence it is unavailable for writes." |
|
case ErrNotLeaderForPartition: |
|
return "kafka server: Tried to send a message to a replica that is not the leader for some partition. Your metadata is out of date." |
|
case ErrRequestTimedOut: |
|
return "kafka server: Request exceeded the user-specified time limit in the request." |
|
case ErrBrokerNotAvailable: |
|
return "kafka server: Broker not available. Not a client facing error, we should never receive this!!!" |
|
case ErrReplicaNotAvailable: |
|
return "kafka server: Replica information not available, one or more brokers are down." |
|
case ErrMessageSizeTooLarge: |
|
return "kafka server: Message was too large, server rejected it to avoid allocation error." |
|
case ErrStaleControllerEpochCode: |
|
return "kafka server: StaleControllerEpochCode (internal error code for broker-to-broker communication)." |
|
case ErrOffsetMetadataTooLarge: |
|
return "kafka server: Specified a string larger than the configured maximum for offset metadata." |
|
case ErrNetworkException: |
|
return "kafka server: The server disconnected before a response was received." |
|
case ErrOffsetsLoadInProgress: |
|
return "kafka server: The broker is still loading offsets after a leader change for that offset's topic partition." |
|
case ErrConsumerCoordinatorNotAvailable: |
|
return "kafka server: Offset's topic has not yet been created." |
|
case ErrNotCoordinatorForConsumer: |
|
return "kafka server: Request was for a consumer group that is not coordinated by this broker." |
|
case ErrInvalidTopic: |
|
return "kafka server: The request attempted to perform an operation on an invalid topic." |
|
case ErrMessageSetSizeTooLarge: |
|
return "kafka server: The request included message batch larger than the configured segment size on the server." |
|
case ErrNotEnoughReplicas: |
|
return "kafka server: Messages are rejected since there are fewer in-sync replicas than required." |
|
case ErrNotEnoughReplicasAfterAppend: |
|
return "kafka server: Messages are written to the log, but to fewer in-sync replicas than required." |
|
case ErrInvalidRequiredAcks: |
|
return "kafka server: The number of required acks is invalid (should be either -1, 0, or 1)." |
|
case ErrIllegalGeneration: |
|
return "kafka server: The provided generation id is not the current generation." |
|
case ErrInconsistentGroupProtocol: |
|
return "kafka server: The provider group protocol type is incompatible with the other members." |
|
case ErrInvalidGroupId: |
|
return "kafka server: The provided group id was empty." |
|
case ErrUnknownMemberId: |
|
return "kafka server: The provided member is not known in the current generation." |
|
case ErrInvalidSessionTimeout: |
|
return "kafka server: The provided session timeout is outside the allowed range." |
|
case ErrRebalanceInProgress: |
|
return "kafka server: A rebalance for the group is in progress. Please re-join the group." |
|
case ErrInvalidCommitOffsetSize: |
|
return "kafka server: The provided commit metadata was too large." |
|
case ErrTopicAuthorizationFailed: |
|
return "kafka server: The client is not authorized to access this topic." |
|
case ErrGroupAuthorizationFailed: |
|
return "kafka server: The client is not authorized to access this group." |
|
case ErrClusterAuthorizationFailed: |
|
return "kafka server: The client is not authorized to send this request type." |
|
case ErrInvalidTimestamp: |
|
return "kafka server: The timestamp of the message is out of acceptable range." |
|
case ErrUnsupportedSASLMechanism: |
|
return "kafka server: The broker does not support the requested SASL mechanism." |
|
case ErrIllegalSASLState: |
|
return "kafka server: Request is not valid given the current SASL state." |
|
case ErrUnsupportedVersion: |
|
return "kafka server: The version of API is not supported." |
|
case ErrTopicAlreadyExists: |
|
return "kafka server: Topic with this name already exists." |
|
case ErrInvalidPartitions: |
|
return "kafka server: Number of partitions is invalid." |
|
case ErrInvalidReplicationFactor: |
|
return "kafka server: Replication-factor is invalid." |
|
case ErrInvalidReplicaAssignment: |
|
return "kafka server: Replica assignment is invalid." |
|
case ErrInvalidConfig: |
|
return "kafka server: Configuration is invalid." |
|
case ErrNotController: |
|
return "kafka server: This is not the correct controller for this cluster." |
|
case ErrInvalidRequest: |
|
return "kafka server: This most likely occurs because of a request being malformed by the client library or the message was sent to an incompatible broker. See the broker logs for more details." |
|
case ErrUnsupportedForMessageFormat: |
|
return "kafka server: The requested operation is not supported by the message format version." |
|
case ErrPolicyViolation: |
|
return "kafka server: Request parameters do not satisfy the configured policy." |
|
case ErrOutOfOrderSequenceNumber: |
|
return "kafka server: The broker received an out of order sequence number." |
|
case ErrDuplicateSequenceNumber: |
|
return "kafka server: The broker received a duplicate sequence number." |
|
case ErrInvalidProducerEpoch: |
|
return "kafka server: Producer attempted an operation with an old epoch." |
|
case ErrInvalidTxnState: |
|
return "kafka server: The producer attempted a transactional operation in an invalid state." |
|
case ErrInvalidProducerIDMapping: |
|
return "kafka server: The producer attempted to use a producer id which is not currently assigned to its transactional id." |
|
case ErrInvalidTransactionTimeout: |
|
return "kafka server: The transaction timeout is larger than the maximum value allowed by the broker (as configured by max.transaction.timeout.ms)." |
|
case ErrConcurrentTransactions: |
|
return "kafka server: The producer attempted to update a transaction while another concurrent operation on the same transaction was ongoing." |
|
case ErrTransactionCoordinatorFenced: |
|
return "kafka server: The transaction coordinator sending a WriteTxnMarker is no longer the current coordinator for a given producer." |
|
case ErrTransactionalIDAuthorizationFailed: |
|
return "kafka server: Transactional ID authorization failed." |
|
case ErrSecurityDisabled: |
|
return "kafka server: Security features are disabled." |
|
case ErrOperationNotAttempted: |
|
return "kafka server: The broker did not attempt to execute this operation." |
|
case ErrKafkaStorageError: |
|
return "kafka server: Disk error when trying to access log file on the disk." |
|
case ErrLogDirNotFound: |
|
return "kafka server: The specified log directory is not found in the broker config." |
|
case ErrSASLAuthenticationFailed: |
|
return "kafka server: SASL Authentication failed." |
|
case ErrUnknownProducerID: |
|
return "kafka server: The broker could not locate the producer metadata associated with the Producer ID." |
|
case ErrReassignmentInProgress: |
|
return "kafka server: A partition reassignment is in progress." |
|
} |
|
|
|
return fmt.Sprintf("Unknown error, how did this happen? Error code = %d", err) |
|
}
|
|
|