Browse Source
Phase 7: Comprehensive error handling and edge cases
Phase 7: Comprehensive error handling and edge cases
- Added centralized errors.go with complete Kafka error code definitions - Implemented timeout detection and network error classification - Enhanced connection handling with configurable timeouts and better error reporting - Added comprehensive error handling test suite with 21 test cases - Unified error code usage across all protocol handlers - Improved request/response timeout handling with graceful fallbacks - All protocol and E2E tests passing with robust error handlingpull/7231/head
chrislu
2 months ago
11 changed files with 1057 additions and 271 deletions
-
23weed/mq/kafka/IMPLEMENTATION_PHASES.md
-
6weed/mq/kafka/protocol/consumer_coordination.go
-
414weed/mq/kafka/protocol/error_handling_test.go
-
361weed/mq/kafka/protocol/errors.go
-
8weed/mq/kafka/protocol/flexible_versions_integration_test.go
-
123weed/mq/kafka/protocol/handler.go
-
16weed/mq/kafka/protocol/joingroup.go
-
9weed/mq/kafka/protocol/offset_management.go
@ -0,0 +1,414 @@ |
|||
package protocol |
|||
|
|||
import ( |
|||
"context" |
|||
"encoding/binary" |
|||
"errors" |
|||
"testing" |
|||
"time" |
|||
) |
|||
|
|||
func TestKafkaErrorCodes(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
errorCode int16 |
|||
expectedInfo ErrorInfo |
|||
}{ |
|||
{ |
|||
name: "No error", |
|||
errorCode: ErrorCodeNone, |
|||
expectedInfo: ErrorInfo{ |
|||
Code: 0, Name: "NONE", Description: "No error", Retriable: false, |
|||
}, |
|||
}, |
|||
{ |
|||
name: "Unknown server error", |
|||
errorCode: ErrorCodeUnknownServerError, |
|||
expectedInfo: ErrorInfo{ |
|||
Code: 1, Name: "UNKNOWN_SERVER_ERROR", Description: "Unknown server error", Retriable: true, |
|||
}, |
|||
}, |
|||
{ |
|||
name: "Topic already exists", |
|||
errorCode: ErrorCodeTopicAlreadyExists, |
|||
expectedInfo: ErrorInfo{ |
|||
Code: 36, Name: "TOPIC_ALREADY_EXISTS", Description: "Topic already exists", Retriable: false, |
|||
}, |
|||
}, |
|||
{ |
|||
name: "Invalid partitions", |
|||
errorCode: ErrorCodeInvalidPartitions, |
|||
expectedInfo: ErrorInfo{ |
|||
Code: 37, Name: "INVALID_PARTITIONS", Description: "Invalid number of partitions", Retriable: false, |
|||
}, |
|||
}, |
|||
{ |
|||
name: "Request timed out", |
|||
errorCode: ErrorCodeRequestTimedOut, |
|||
expectedInfo: ErrorInfo{ |
|||
Code: 7, Name: "REQUEST_TIMED_OUT", Description: "Request timed out", Retriable: true, |
|||
}, |
|||
}, |
|||
{ |
|||
name: "Connection timeout", |
|||
errorCode: ErrorCodeConnectionTimeout, |
|||
expectedInfo: ErrorInfo{ |
|||
Code: 61, Name: "CONNECTION_TIMEOUT", Description: "Connection timeout", Retriable: true, |
|||
}, |
|||
}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
info := GetErrorInfo(tt.errorCode) |
|||
if info.Code != tt.expectedInfo.Code { |
|||
t.Errorf("GetErrorInfo().Code = %d, want %d", info.Code, tt.expectedInfo.Code) |
|||
} |
|||
if info.Name != tt.expectedInfo.Name { |
|||
t.Errorf("GetErrorInfo().Name = %s, want %s", info.Name, tt.expectedInfo.Name) |
|||
} |
|||
if info.Description != tt.expectedInfo.Description { |
|||
t.Errorf("GetErrorInfo().Description = %s, want %s", info.Description, tt.expectedInfo.Description) |
|||
} |
|||
if info.Retriable != tt.expectedInfo.Retriable { |
|||
t.Errorf("GetErrorInfo().Retriable = %v, want %v", info.Retriable, tt.expectedInfo.Retriable) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestIsRetriableError(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
errorCode int16 |
|||
retriable bool |
|||
}{ |
|||
{"None", ErrorCodeNone, false}, |
|||
{"Unknown server error", ErrorCodeUnknownServerError, true}, |
|||
{"Topic already exists", ErrorCodeTopicAlreadyExists, false}, |
|||
{"Request timed out", ErrorCodeRequestTimedOut, true}, |
|||
{"Rebalance in progress", ErrorCodeRebalanceInProgress, true}, |
|||
{"Invalid group ID", ErrorCodeInvalidGroupID, false}, |
|||
{"Network exception", ErrorCodeNetworkException, true}, |
|||
{"Connection timeout", ErrorCodeConnectionTimeout, true}, |
|||
{"Read timeout", ErrorCodeReadTimeout, true}, |
|||
{"Write timeout", ErrorCodeWriteTimeout, true}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
if got := IsRetriableError(tt.errorCode); got != tt.retriable { |
|||
t.Errorf("IsRetriableError() = %v, want %v", got, tt.retriable) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestBuildErrorResponse(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
correlationID uint32 |
|||
errorCode int16 |
|||
expectedLen int |
|||
}{ |
|||
{"Basic error response", 12345, ErrorCodeUnknownServerError, 6}, |
|||
{"Topic already exists", 67890, ErrorCodeTopicAlreadyExists, 6}, |
|||
{"No error", 11111, ErrorCodeNone, 6}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
response := BuildErrorResponse(tt.correlationID, tt.errorCode) |
|||
|
|||
if len(response) != tt.expectedLen { |
|||
t.Errorf("BuildErrorResponse() length = %d, want %d", len(response), tt.expectedLen) |
|||
} |
|||
|
|||
// Verify correlation ID
|
|||
if len(response) >= 4 { |
|||
correlationID := binary.BigEndian.Uint32(response[0:4]) |
|||
if correlationID != tt.correlationID { |
|||
t.Errorf("Correlation ID = %d, want %d", correlationID, tt.correlationID) |
|||
} |
|||
} |
|||
|
|||
// Verify error code
|
|||
if len(response) >= 6 { |
|||
errorCode := binary.BigEndian.Uint16(response[4:6]) |
|||
if errorCode != uint16(tt.errorCode) { |
|||
t.Errorf("Error code = %d, want %d", errorCode, uint16(tt.errorCode)) |
|||
} |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestBuildErrorResponseWithMessage(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
correlationID uint32 |
|||
errorCode int16 |
|||
message string |
|||
expectNullMsg bool |
|||
}{ |
|||
{"Error with message", 12345, ErrorCodeUnknownServerError, "Test error message", false}, |
|||
{"Error with empty message", 67890, ErrorCodeTopicAlreadyExists, "", true}, |
|||
{"Error with long message", 11111, ErrorCodeInvalidPartitions, "This is a longer error message for testing", false}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
response := BuildErrorResponseWithMessage(tt.correlationID, tt.errorCode, tt.message) |
|||
|
|||
// Should have at least correlation ID (4) + error code (2) + message length (2)
|
|||
minLen := 8 |
|||
if len(response) < minLen { |
|||
t.Errorf("BuildErrorResponseWithMessage() length = %d, want at least %d", len(response), minLen) |
|||
} |
|||
|
|||
// Verify correlation ID
|
|||
correlationID := binary.BigEndian.Uint32(response[0:4]) |
|||
if correlationID != tt.correlationID { |
|||
t.Errorf("Correlation ID = %d, want %d", correlationID, tt.correlationID) |
|||
} |
|||
|
|||
// Verify error code
|
|||
errorCode := binary.BigEndian.Uint16(response[4:6]) |
|||
if errorCode != uint16(tt.errorCode) { |
|||
t.Errorf("Error code = %d, want %d", errorCode, uint16(tt.errorCode)) |
|||
} |
|||
|
|||
// Verify message
|
|||
if tt.expectNullMsg { |
|||
// Should have null string marker (0xFF, 0xFF)
|
|||
if len(response) >= 8 && (response[6] != 0xFF || response[7] != 0xFF) { |
|||
t.Errorf("Expected null string marker, got %x %x", response[6], response[7]) |
|||
} |
|||
} else { |
|||
// Should have message length and message
|
|||
if len(response) >= 8 { |
|||
messageLen := binary.BigEndian.Uint16(response[6:8]) |
|||
if messageLen != uint16(len(tt.message)) { |
|||
t.Errorf("Message length = %d, want %d", messageLen, len(tt.message)) |
|||
} |
|||
|
|||
if len(response) >= 8+len(tt.message) { |
|||
actualMessage := string(response[8 : 8+len(tt.message)]) |
|||
if actualMessage != tt.message { |
|||
t.Errorf("Message = %q, want %q", actualMessage, tt.message) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestClassifyNetworkError(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
err error |
|||
expected int16 |
|||
}{ |
|||
{"No error", nil, ErrorCodeNone}, |
|||
{"Generic error", errors.New("generic error"), ErrorCodeUnknownServerError}, |
|||
{"Connection refused", errors.New("connection refused"), ErrorCodeConnectionRefused}, |
|||
{"Connection timeout", errors.New("connection timeout"), ErrorCodeConnectionTimeout}, |
|||
{"Network timeout", &timeoutError{}, ErrorCodeRequestTimedOut}, |
|||
{"Network error", &networkError{}, ErrorCodeNetworkException}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
if got := ClassifyNetworkError(tt.err); got != tt.expected { |
|||
t.Errorf("ClassifyNetworkError() = %v, want %v", got, tt.expected) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestHandleTimeoutError(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
err error |
|||
operation string |
|||
expected int16 |
|||
}{ |
|||
{"No error", nil, "read", ErrorCodeNone}, |
|||
{"Read timeout", &timeoutError{}, "read", ErrorCodeReadTimeout}, |
|||
{"Write timeout", &timeoutError{}, "write", ErrorCodeWriteTimeout}, |
|||
{"Connect timeout", &timeoutError{}, "connect", ErrorCodeConnectionTimeout}, |
|||
{"Generic timeout", &timeoutError{}, "unknown", ErrorCodeRequestTimedOut}, |
|||
{"Non-timeout error", errors.New("other error"), "read", ErrorCodeUnknownServerError}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
if got := HandleTimeoutError(tt.err, tt.operation); got != tt.expected { |
|||
t.Errorf("HandleTimeoutError() = %v, want %v", got, tt.expected) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestDefaultTimeoutConfig(t *testing.T) { |
|||
config := DefaultTimeoutConfig() |
|||
|
|||
if config.ConnectionTimeout != 30*time.Second { |
|||
t.Errorf("ConnectionTimeout = %v, want %v", config.ConnectionTimeout, 30*time.Second) |
|||
} |
|||
if config.ReadTimeout != 10*time.Second { |
|||
t.Errorf("ReadTimeout = %v, want %v", config.ReadTimeout, 10*time.Second) |
|||
} |
|||
if config.WriteTimeout != 10*time.Second { |
|||
t.Errorf("WriteTimeout = %v, want %v", config.WriteTimeout, 10*time.Second) |
|||
} |
|||
if config.RequestTimeout != 30*time.Second { |
|||
t.Errorf("RequestTimeout = %v, want %v", config.RequestTimeout, 30*time.Second) |
|||
} |
|||
} |
|||
|
|||
func TestSafeFormatError(t *testing.T) { |
|||
tests := []struct { |
|||
name string |
|||
err error |
|||
expected string |
|||
}{ |
|||
{"No error", nil, ""}, |
|||
{"Generic error", errors.New("test error"), "Error: test error"}, |
|||
{"Network error", &networkError{}, "Error: network error"}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
if got := SafeFormatError(tt.err); got != tt.expected { |
|||
t.Errorf("SafeFormatError() = %q, want %q", got, tt.expected) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
func TestGetErrorInfo_UnknownErrorCode(t *testing.T) { |
|||
unknownCode := int16(9999) |
|||
info := GetErrorInfo(unknownCode) |
|||
|
|||
if info.Code != unknownCode { |
|||
t.Errorf("Code = %d, want %d", info.Code, unknownCode) |
|||
} |
|||
if info.Name != "UNKNOWN" { |
|||
t.Errorf("Name = %s, want UNKNOWN", info.Name) |
|||
} |
|||
if info.Description != "Unknown error code" { |
|||
t.Errorf("Description = %s, want 'Unknown error code'", info.Description) |
|||
} |
|||
if info.Retriable != false { |
|||
t.Errorf("Retriable = %v, want false", info.Retriable) |
|||
} |
|||
} |
|||
|
|||
// Integration test for error handling in protocol context
|
|||
func TestErrorHandling_Integration(t *testing.T) { |
|||
// Test building various protocol error responses
|
|||
tests := []struct { |
|||
name string |
|||
apiKey uint16 |
|||
errorCode int16 |
|||
message string |
|||
}{ |
|||
{"ApiVersions error", 18, ErrorCodeUnsupportedVersion, "Version not supported"}, |
|||
{"Metadata error", 3, ErrorCodeUnknownTopicOrPartition, "Topic not found"}, |
|||
{"Produce error", 0, ErrorCodeMessageTooLarge, "Message exceeds size limit"}, |
|||
{"Fetch error", 1, ErrorCodeOffsetOutOfRange, "Offset out of range"}, |
|||
{"CreateTopics error", 19, ErrorCodeTopicAlreadyExists, "Topic already exists"}, |
|||
} |
|||
|
|||
for _, tt := range tests { |
|||
t.Run(tt.name, func(t *testing.T) { |
|||
correlationID := uint32(12345) |
|||
|
|||
// Test basic error response
|
|||
basicResponse := BuildErrorResponse(correlationID, tt.errorCode) |
|||
if len(basicResponse) != 6 { |
|||
t.Errorf("Basic response length = %d, want 6", len(basicResponse)) |
|||
} |
|||
|
|||
// Test error response with message
|
|||
messageResponse := BuildErrorResponseWithMessage(correlationID, tt.errorCode, tt.message) |
|||
expectedMinLen := 8 + len(tt.message) // 4 (correlationID) + 2 (errorCode) + 2 (messageLen) + len(message)
|
|||
if len(messageResponse) < expectedMinLen { |
|||
t.Errorf("Message response length = %d, want at least %d", len(messageResponse), expectedMinLen) |
|||
} |
|||
|
|||
// Verify error is correctly classified
|
|||
info := GetErrorInfo(tt.errorCode) |
|||
if info.Code != tt.errorCode { |
|||
t.Errorf("Error info code = %d, want %d", info.Code, tt.errorCode) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
// Mock error types for testing
|
|||
type timeoutError struct{} |
|||
|
|||
func (e *timeoutError) Error() string { return "timeout error" } |
|||
func (e *timeoutError) Timeout() bool { return true } |
|||
func (e *timeoutError) Temporary() bool { return true } |
|||
|
|||
type networkError struct{} |
|||
|
|||
func (e *networkError) Error() string { return "network error" } |
|||
func (e *networkError) Timeout() bool { return false } |
|||
func (e *networkError) Temporary() bool { return true } |
|||
|
|||
// Test timeout detection
|
|||
func TestTimeoutDetection(t *testing.T) { |
|||
// Test with context timeout
|
|||
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Millisecond) |
|||
defer cancel() |
|||
|
|||
// Wait for context to timeout
|
|||
time.Sleep(2 * time.Millisecond) |
|||
|
|||
select { |
|||
case <-ctx.Done(): |
|||
err := ctx.Err() |
|||
errorCode := HandleTimeoutError(err, "context") |
|||
if errorCode != ErrorCodeRequestTimedOut { |
|||
t.Errorf("Context timeout error code = %v, want %v", errorCode, ErrorCodeRequestTimedOut) |
|||
} |
|||
default: |
|||
t.Error("Context should have timed out") |
|||
} |
|||
} |
|||
|
|||
// Benchmark error response building
|
|||
func BenchmarkBuildErrorResponse(b *testing.B) { |
|||
correlationID := uint32(12345) |
|||
errorCode := ErrorCodeUnknownServerError |
|||
|
|||
b.ResetTimer() |
|||
for i := 0; i < b.N; i++ { |
|||
BuildErrorResponse(correlationID, errorCode) |
|||
} |
|||
} |
|||
|
|||
func BenchmarkBuildErrorResponseWithMessage(b *testing.B) { |
|||
correlationID := uint32(12345) |
|||
errorCode := ErrorCodeUnknownServerError |
|||
message := "This is a test error message" |
|||
|
|||
b.ResetTimer() |
|||
for i := 0; i < b.N; i++ { |
|||
BuildErrorResponseWithMessage(correlationID, errorCode, message) |
|||
} |
|||
} |
|||
|
|||
func BenchmarkClassifyNetworkError(b *testing.B) { |
|||
err := &timeoutError{} |
|||
|
|||
b.ResetTimer() |
|||
for i := 0; i < b.N; i++ { |
|||
ClassifyNetworkError(err) |
|||
} |
|||
} |
|||
@ -0,0 +1,361 @@ |
|||
package protocol |
|||
|
|||
import ( |
|||
"encoding/binary" |
|||
"fmt" |
|||
"net" |
|||
"time" |
|||
) |
|||
|
|||
// Kafka Protocol Error Codes
|
|||
// Based on Apache Kafka protocol specification
|
|||
const ( |
|||
// Success
|
|||
ErrorCodeNone int16 = 0 |
|||
|
|||
// General server errors
|
|||
ErrorCodeUnknownServerError int16 = 1 |
|||
ErrorCodeOffsetOutOfRange int16 = 2 |
|||
ErrorCodeCorruptMessage int16 = 3 // Also UNKNOWN_TOPIC_OR_PARTITION
|
|||
ErrorCodeUnknownTopicOrPartition int16 = 3 |
|||
ErrorCodeInvalidFetchSize int16 = 4 |
|||
ErrorCodeLeaderNotAvailable int16 = 5 |
|||
ErrorCodeNotLeaderOrFollower int16 = 6 // Formerly NOT_LEADER_FOR_PARTITION
|
|||
ErrorCodeRequestTimedOut int16 = 7 |
|||
ErrorCodeBrokerNotAvailable int16 = 8 |
|||
ErrorCodeReplicaNotAvailable int16 = 9 |
|||
ErrorCodeMessageTooLarge int16 = 10 |
|||
ErrorCodeStaleControllerEpoch int16 = 11 |
|||
ErrorCodeOffsetMetadataTooLarge int16 = 12 |
|||
ErrorCodeNetworkException int16 = 13 |
|||
ErrorCodeOffsetLoadInProgress int16 = 14 |
|||
ErrorCodeGroupLoadInProgress int16 = 15 |
|||
ErrorCodeNotCoordinatorForGroup int16 = 16 |
|||
ErrorCodeNotCoordinatorForTransaction int16 = 17 |
|||
|
|||
// Consumer group coordination errors
|
|||
ErrorCodeIllegalGeneration int16 = 22 |
|||
ErrorCodeInconsistentGroupProtocol int16 = 23 |
|||
ErrorCodeInvalidGroupID int16 = 24 |
|||
ErrorCodeUnknownMemberID int16 = 25 |
|||
ErrorCodeInvalidSessionTimeout int16 = 26 |
|||
ErrorCodeRebalanceInProgress int16 = 27 |
|||
ErrorCodeInvalidCommitOffsetSize int16 = 28 |
|||
ErrorCodeTopicAuthorizationFailed int16 = 29 |
|||
ErrorCodeGroupAuthorizationFailed int16 = 30 |
|||
ErrorCodeClusterAuthorizationFailed int16 = 31 |
|||
ErrorCodeInvalidTimestamp int16 = 32 |
|||
ErrorCodeUnsupportedSASLMechanism int16 = 33 |
|||
ErrorCodeIllegalSASLState int16 = 34 |
|||
ErrorCodeUnsupportedVersion int16 = 35 |
|||
|
|||
// Topic management errors
|
|||
ErrorCodeTopicAlreadyExists int16 = 36 |
|||
ErrorCodeInvalidPartitions int16 = 37 |
|||
ErrorCodeInvalidReplicationFactor int16 = 38 |
|||
ErrorCodeInvalidReplicaAssignment int16 = 39 |
|||
ErrorCodeInvalidConfig int16 = 40 |
|||
ErrorCodeNotController int16 = 41 |
|||
ErrorCodeInvalidRecord int16 = 42 |
|||
ErrorCodePolicyViolation int16 = 43 |
|||
ErrorCodeOutOfOrderSequenceNumber int16 = 44 |
|||
ErrorCodeDuplicateSequenceNumber int16 = 45 |
|||
ErrorCodeInvalidProducerEpoch int16 = 46 |
|||
ErrorCodeInvalidTxnState int16 = 47 |
|||
ErrorCodeInvalidProducerIDMapping int16 = 48 |
|||
ErrorCodeInvalidTransactionTimeout int16 = 49 |
|||
ErrorCodeConcurrentTransactions int16 = 50 |
|||
|
|||
// Connection and timeout errors
|
|||
ErrorCodeConnectionRefused int16 = 60 // Custom for connection issues
|
|||
ErrorCodeConnectionTimeout int16 = 61 // Custom for connection timeouts
|
|||
ErrorCodeReadTimeout int16 = 62 // Custom for read timeouts
|
|||
ErrorCodeWriteTimeout int16 = 63 // Custom for write timeouts
|
|||
|
|||
// Consumer group specific errors
|
|||
ErrorCodeMemberIDRequired int16 = 79 |
|||
ErrorCodeFencedInstanceID int16 = 82 |
|||
ErrorCodeGroupMaxSizeReached int16 = 84 |
|||
ErrorCodeUnstableOffsetCommit int16 = 95 |
|||
) |
|||
|
|||
// ErrorInfo contains metadata about a Kafka error
|
|||
type ErrorInfo struct { |
|||
Code int16 |
|||
Name string |
|||
Description string |
|||
Retriable bool |
|||
} |
|||
|
|||
// KafkaErrors maps error codes to their metadata
|
|||
var KafkaErrors = map[int16]ErrorInfo{ |
|||
ErrorCodeNone: { |
|||
Code: ErrorCodeNone, Name: "NONE", Description: "No error", Retriable: false, |
|||
}, |
|||
ErrorCodeUnknownServerError: { |
|||
Code: ErrorCodeUnknownServerError, Name: "UNKNOWN_SERVER_ERROR", |
|||
Description: "Unknown server error", Retriable: true, |
|||
}, |
|||
ErrorCodeOffsetOutOfRange: { |
|||
Code: ErrorCodeOffsetOutOfRange, Name: "OFFSET_OUT_OF_RANGE", |
|||
Description: "Offset out of range", Retriable: false, |
|||
}, |
|||
ErrorCodeUnknownTopicOrPartition: { |
|||
Code: ErrorCodeUnknownTopicOrPartition, Name: "UNKNOWN_TOPIC_OR_PARTITION", |
|||
Description: "Topic or partition does not exist", Retriable: false, |
|||
}, |
|||
ErrorCodeInvalidFetchSize: { |
|||
Code: ErrorCodeInvalidFetchSize, Name: "INVALID_FETCH_SIZE", |
|||
Description: "Invalid fetch size", Retriable: false, |
|||
}, |
|||
ErrorCodeLeaderNotAvailable: { |
|||
Code: ErrorCodeLeaderNotAvailable, Name: "LEADER_NOT_AVAILABLE", |
|||
Description: "Leader not available", Retriable: true, |
|||
}, |
|||
ErrorCodeNotLeaderOrFollower: { |
|||
Code: ErrorCodeNotLeaderOrFollower, Name: "NOT_LEADER_OR_FOLLOWER", |
|||
Description: "Not leader or follower", Retriable: true, |
|||
}, |
|||
ErrorCodeRequestTimedOut: { |
|||
Code: ErrorCodeRequestTimedOut, Name: "REQUEST_TIMED_OUT", |
|||
Description: "Request timed out", Retriable: true, |
|||
}, |
|||
ErrorCodeBrokerNotAvailable: { |
|||
Code: ErrorCodeBrokerNotAvailable, Name: "BROKER_NOT_AVAILABLE", |
|||
Description: "Broker not available", Retriable: true, |
|||
}, |
|||
ErrorCodeMessageTooLarge: { |
|||
Code: ErrorCodeMessageTooLarge, Name: "MESSAGE_TOO_LARGE", |
|||
Description: "Message size exceeds limit", Retriable: false, |
|||
}, |
|||
ErrorCodeOffsetMetadataTooLarge: { |
|||
Code: ErrorCodeOffsetMetadataTooLarge, Name: "OFFSET_METADATA_TOO_LARGE", |
|||
Description: "Offset metadata too large", Retriable: false, |
|||
}, |
|||
ErrorCodeNetworkException: { |
|||
Code: ErrorCodeNetworkException, Name: "NETWORK_EXCEPTION", |
|||
Description: "Network error", Retriable: true, |
|||
}, |
|||
ErrorCodeOffsetLoadInProgress: { |
|||
Code: ErrorCodeOffsetLoadInProgress, Name: "OFFSET_LOAD_IN_PROGRESS", |
|||
Description: "Offset load in progress", Retriable: true, |
|||
}, |
|||
ErrorCodeNotCoordinatorForGroup: { |
|||
Code: ErrorCodeNotCoordinatorForGroup, Name: "NOT_COORDINATOR_FOR_GROUP", |
|||
Description: "Not coordinator for group", Retriable: true, |
|||
}, |
|||
ErrorCodeInvalidGroupID: { |
|||
Code: ErrorCodeInvalidGroupID, Name: "INVALID_GROUP_ID", |
|||
Description: "Invalid group ID", Retriable: false, |
|||
}, |
|||
ErrorCodeUnknownMemberID: { |
|||
Code: ErrorCodeUnknownMemberID, Name: "UNKNOWN_MEMBER_ID", |
|||
Description: "Unknown member ID", Retriable: false, |
|||
}, |
|||
ErrorCodeInvalidSessionTimeout: { |
|||
Code: ErrorCodeInvalidSessionTimeout, Name: "INVALID_SESSION_TIMEOUT", |
|||
Description: "Invalid session timeout", Retriable: false, |
|||
}, |
|||
ErrorCodeRebalanceInProgress: { |
|||
Code: ErrorCodeRebalanceInProgress, Name: "REBALANCE_IN_PROGRESS", |
|||
Description: "Group rebalance in progress", Retriable: true, |
|||
}, |
|||
ErrorCodeInvalidCommitOffsetSize: { |
|||
Code: ErrorCodeInvalidCommitOffsetSize, Name: "INVALID_COMMIT_OFFSET_SIZE", |
|||
Description: "Invalid commit offset size", Retriable: false, |
|||
}, |
|||
ErrorCodeTopicAuthorizationFailed: { |
|||
Code: ErrorCodeTopicAuthorizationFailed, Name: "TOPIC_AUTHORIZATION_FAILED", |
|||
Description: "Topic authorization failed", Retriable: false, |
|||
}, |
|||
ErrorCodeGroupAuthorizationFailed: { |
|||
Code: ErrorCodeGroupAuthorizationFailed, Name: "GROUP_AUTHORIZATION_FAILED", |
|||
Description: "Group authorization failed", Retriable: false, |
|||
}, |
|||
ErrorCodeUnsupportedVersion: { |
|||
Code: ErrorCodeUnsupportedVersion, Name: "UNSUPPORTED_VERSION", |
|||
Description: "Unsupported version", Retriable: false, |
|||
}, |
|||
ErrorCodeTopicAlreadyExists: { |
|||
Code: ErrorCodeTopicAlreadyExists, Name: "TOPIC_ALREADY_EXISTS", |
|||
Description: "Topic already exists", Retriable: false, |
|||
}, |
|||
ErrorCodeInvalidPartitions: { |
|||
Code: ErrorCodeInvalidPartitions, Name: "INVALID_PARTITIONS", |
|||
Description: "Invalid number of partitions", Retriable: false, |
|||
}, |
|||
ErrorCodeInvalidReplicationFactor: { |
|||
Code: ErrorCodeInvalidReplicationFactor, Name: "INVALID_REPLICATION_FACTOR", |
|||
Description: "Invalid replication factor", Retriable: false, |
|||
}, |
|||
ErrorCodeInvalidRecord: { |
|||
Code: ErrorCodeInvalidRecord, Name: "INVALID_RECORD", |
|||
Description: "Invalid record", Retriable: false, |
|||
}, |
|||
ErrorCodeConnectionRefused: { |
|||
Code: ErrorCodeConnectionRefused, Name: "CONNECTION_REFUSED", |
|||
Description: "Connection refused", Retriable: true, |
|||
}, |
|||
ErrorCodeConnectionTimeout: { |
|||
Code: ErrorCodeConnectionTimeout, Name: "CONNECTION_TIMEOUT", |
|||
Description: "Connection timeout", Retriable: true, |
|||
}, |
|||
ErrorCodeReadTimeout: { |
|||
Code: ErrorCodeReadTimeout, Name: "READ_TIMEOUT", |
|||
Description: "Read operation timeout", Retriable: true, |
|||
}, |
|||
ErrorCodeWriteTimeout: { |
|||
Code: ErrorCodeWriteTimeout, Name: "WRITE_TIMEOUT", |
|||
Description: "Write operation timeout", Retriable: true, |
|||
}, |
|||
ErrorCodeIllegalGeneration: { |
|||
Code: ErrorCodeIllegalGeneration, Name: "ILLEGAL_GENERATION", |
|||
Description: "Illegal generation", Retriable: false, |
|||
}, |
|||
ErrorCodeInconsistentGroupProtocol: { |
|||
Code: ErrorCodeInconsistentGroupProtocol, Name: "INCONSISTENT_GROUP_PROTOCOL", |
|||
Description: "Inconsistent group protocol", Retriable: false, |
|||
}, |
|||
ErrorCodeMemberIDRequired: { |
|||
Code: ErrorCodeMemberIDRequired, Name: "MEMBER_ID_REQUIRED", |
|||
Description: "Member ID required", Retriable: false, |
|||
}, |
|||
ErrorCodeFencedInstanceID: { |
|||
Code: ErrorCodeFencedInstanceID, Name: "FENCED_INSTANCE_ID", |
|||
Description: "Instance ID fenced", Retriable: false, |
|||
}, |
|||
ErrorCodeGroupMaxSizeReached: { |
|||
Code: ErrorCodeGroupMaxSizeReached, Name: "GROUP_MAX_SIZE_REACHED", |
|||
Description: "Group max size reached", Retriable: false, |
|||
}, |
|||
ErrorCodeUnstableOffsetCommit: { |
|||
Code: ErrorCodeUnstableOffsetCommit, Name: "UNSTABLE_OFFSET_COMMIT", |
|||
Description: "Offset commit during rebalance", Retriable: true, |
|||
}, |
|||
} |
|||
|
|||
// GetErrorInfo returns error information for the given error code
|
|||
func GetErrorInfo(code int16) ErrorInfo { |
|||
if info, exists := KafkaErrors[code]; exists { |
|||
return info |
|||
} |
|||
return ErrorInfo{ |
|||
Code: code, Name: "UNKNOWN", Description: "Unknown error code", Retriable: false, |
|||
} |
|||
} |
|||
|
|||
// IsRetriableError returns true if the error is retriable
|
|||
func IsRetriableError(code int16) bool { |
|||
return GetErrorInfo(code).Retriable |
|||
} |
|||
|
|||
// BuildErrorResponse builds a standard Kafka error response
|
|||
func BuildErrorResponse(correlationID uint32, errorCode int16) []byte { |
|||
response := make([]byte, 0, 8) |
|||
|
|||
// Correlation ID (4 bytes)
|
|||
correlationIDBytes := make([]byte, 4) |
|||
binary.BigEndian.PutUint32(correlationIDBytes, correlationID) |
|||
response = append(response, correlationIDBytes...) |
|||
|
|||
// Error code (2 bytes)
|
|||
errorCodeBytes := make([]byte, 2) |
|||
binary.BigEndian.PutUint16(errorCodeBytes, uint16(errorCode)) |
|||
response = append(response, errorCodeBytes...) |
|||
|
|||
return response |
|||
} |
|||
|
|||
// BuildErrorResponseWithMessage builds a Kafka error response with error message
|
|||
func BuildErrorResponseWithMessage(correlationID uint32, errorCode int16, message string) []byte { |
|||
response := BuildErrorResponse(correlationID, errorCode) |
|||
|
|||
// Error message (2 bytes length + message)
|
|||
if message == "" { |
|||
response = append(response, 0xFF, 0xFF) // Null string
|
|||
} else { |
|||
messageLen := uint16(len(message)) |
|||
messageLenBytes := make([]byte, 2) |
|||
binary.BigEndian.PutUint16(messageLenBytes, messageLen) |
|||
response = append(response, messageLenBytes...) |
|||
response = append(response, []byte(message)...) |
|||
} |
|||
|
|||
return response |
|||
} |
|||
|
|||
// ClassifyNetworkError classifies network errors into appropriate Kafka error codes
|
|||
func ClassifyNetworkError(err error) int16 { |
|||
if err == nil { |
|||
return ErrorCodeNone |
|||
} |
|||
|
|||
// Check for network errors
|
|||
if netErr, ok := err.(net.Error); ok { |
|||
if netErr.Timeout() { |
|||
return ErrorCodeRequestTimedOut |
|||
} |
|||
return ErrorCodeNetworkException |
|||
} |
|||
|
|||
// Check for specific error types
|
|||
switch err.Error() { |
|||
case "connection refused": |
|||
return ErrorCodeConnectionRefused |
|||
case "connection timeout": |
|||
return ErrorCodeConnectionTimeout |
|||
default: |
|||
return ErrorCodeUnknownServerError |
|||
} |
|||
} |
|||
|
|||
// TimeoutConfig holds timeout configuration for connections and operations
|
|||
type TimeoutConfig struct { |
|||
ConnectionTimeout time.Duration // Timeout for establishing connections
|
|||
ReadTimeout time.Duration // Timeout for read operations
|
|||
WriteTimeout time.Duration // Timeout for write operations
|
|||
RequestTimeout time.Duration // Overall request timeout
|
|||
} |
|||
|
|||
// DefaultTimeoutConfig returns default timeout configuration
|
|||
func DefaultTimeoutConfig() TimeoutConfig { |
|||
return TimeoutConfig{ |
|||
ConnectionTimeout: 30 * time.Second, |
|||
ReadTimeout: 10 * time.Second, |
|||
WriteTimeout: 10 * time.Second, |
|||
RequestTimeout: 30 * time.Second, |
|||
} |
|||
} |
|||
|
|||
// HandleTimeoutError handles timeout errors and returns appropriate error code
|
|||
func HandleTimeoutError(err error, operation string) int16 { |
|||
if err == nil { |
|||
return ErrorCodeNone |
|||
} |
|||
|
|||
if netErr, ok := err.(net.Error); ok && netErr.Timeout() { |
|||
switch operation { |
|||
case "read": |
|||
return ErrorCodeReadTimeout |
|||
case "write": |
|||
return ErrorCodeWriteTimeout |
|||
case "connect": |
|||
return ErrorCodeConnectionTimeout |
|||
default: |
|||
return ErrorCodeRequestTimedOut |
|||
} |
|||
} |
|||
|
|||
return ClassifyNetworkError(err) |
|||
} |
|||
|
|||
// SafeFormatError safely formats error messages to avoid information leakage
|
|||
func SafeFormatError(err error) string { |
|||
if err == nil { |
|||
return "" |
|||
} |
|||
|
|||
// For production, we might want to sanitize error messages
|
|||
// For now, return the full error for debugging
|
|||
return fmt.Sprintf("Error: %v", err) |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue