forked from mtusi2026/mtusi2026lab2
171 lines
3.3 KiB
Go
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]
|
|
}
|