Files
mtusi2026lab2/service/internal/pkg/apperr/redis.go
T
2026-11-05 14:24:40 +03:00

171 lines
3.3 KiB
Go

package apperr
import (
"context"
"errors"
"fmt"
"net"
"strings"
"github.com/redis/go-redis/v9"
)
func WrapRedis(err error, msg string) error {
m := AppError{
err: err,
msg: msg,
meta: metadata{},
}
m.handleRedis()
return &m
}
func CodeFromRedisError(err error) Code {
code, ok := codeFromRedisError(err, true, true)
if !ok {
return CodeInternal
}
return code
}
func (e *AppError) handleRedis() {
if e.err == nil {
e.code = CodeOK
return
}
if code := redisErrorCode(e.err); code != "" {
e.meta[RedisErrorCode] = code
}
if errors.Is(e.err, redis.Nil) {
e.msg = fmt.Sprintf("not found: %s", e.msg)
}
e.code = CodeFromRedisError(e.err)
}
func (e *AppError) RedisCode() string {
if e == nil {
return ""
}
if e.meta == nil {
return ""
}
return e.meta.Get(RedisErrorCode)
}
func codeFromRedisError(err error, includeTransport bool, includeProtocolString bool) (Code, bool) {
if err == nil {
return CodeInternal, false
}
switch {
case errors.Is(err, redis.Nil):
return CodeNotFound, true
case errors.Is(err, redis.TxFailedErr):
return CodeConflict, true
case errors.Is(err, redis.ErrCrossSlot):
return CodeBadRequest, true
case errors.Is(err, redis.ErrPoolTimeout):
return CodeTimeout, true
case errors.Is(err, redis.ErrPoolExhausted):
return CodeTooManyRequests, true
case errors.Is(err, redis.ErrClosed):
return CodeServiceUnavailable, true
}
if includeTransport {
if errors.Is(err, context.Canceled) ||
errors.Is(err, context.DeadlineExceeded) {
return CodeTimeout, true
}
if netErr, ok := errors.AsType[net.Error](err); ok {
if netErr.Timeout() {
return CodeTimeout, true
}
return CodeServiceUnavailable, true
}
}
hasRedisError := isRedisError(err)
if !hasRedisError && !includeProtocolString {
return CodeInternal, false
}
switch {
case redis.IsExecAbortError(err):
return CodeConflict, true
case redis.IsMaxClientsError(err):
return CodeTooManyRequests, true
case redis.IsLoadingError(err),
redis.IsReadOnlyError(err),
redis.IsClusterDownError(err),
redis.IsTryAgainError(err),
redis.IsMasterDownError(err),
redis.IsNoReplicasError(err),
redis.IsOOMError(err):
return CodeServiceUnavailable, true
case redis.IsAuthError(err),
redis.IsPermissionError(err):
return CodeInternal, true
}
if _, ok := redis.IsMovedError(err); ok {
return CodeServiceUnavailable, true
}
if _, ok := redis.IsAskError(err); ok {
return CodeServiceUnavailable, true
}
if hasRedisError {
return CodeInternal, true
}
return CodeInternal, false
}
func isRedisError(err error) bool {
if err == nil {
return false
}
var redisErr redis.Error
return errors.As(err, &redisErr)
}
func redisErrorCode(err error) string {
switch {
case err == nil:
return ""
case errors.Is(err, redis.Nil):
return "nil"
case errors.Is(err, redis.TxFailedErr):
return "tx_failed"
case errors.Is(err, redis.ErrCrossSlot):
return "CROSSSLOT"
case errors.Is(err, redis.ErrPoolTimeout):
return "pool_timeout"
case errors.Is(err, redis.ErrPoolExhausted):
return "pool_exhausted"
case errors.Is(err, redis.ErrClosed):
return "closed"
}
var redisErr redis.Error
if !errors.As(err, &redisErr) {
return ""
}
msg := strings.TrimSpace(redisErr.Error())
msg = strings.TrimPrefix(msg, "ERR ")
parts := strings.Fields(msg)
if len(parts) == 0 {
return ""
}
return parts[0]
}