modelRT/distributedlock/constant/redis_result.go

package constants

import (
	"fmt"
)

type RedisCode int

const (
	LockSuccess                      = RedisCode(1)
	UnLockSuccess                    = RedisCode(1)
	RefreshLockSuccess               = RedisCode(1)
	UnRLockSuccess                   = RedisCode(0)
	UnWLockSuccess                   = RedisCode(0)
	RLockFailureWithWLockOccupancy   = RedisCode(-1)
	UnRLockFailureWithWLockOccupancy = RedisCode(-2)
	WLockFailureWithRLockOccupancy   = RedisCode(-3)
	WLockFailureWithWLockOccupancy   = RedisCode(-4)
	UnWLockFailureWithRLockOccupancy = RedisCode(-5)
	UnWLockFailureWithWLockOccupancy = RedisCode(-6)
	WLockFailureWithNotFirstPriority = RedisCode(-7)
	RefreshLockFailure               = RedisCode(-8)
	LockFailure                      = RedisCode(-9)
	UnLocakFailureWithLockOccupancy  = RedisCode(-10)
	UnknownInternalError             = RedisCode(-99)
)

type RedisLockType int

const (
	LockType = RedisLockType(iota)
	UnRLockType
	UnWLockType
	UnLockType
	RefreshLockType
)

type RedisResult struct {
	Code    RedisCode
	Message string
}

func (e *RedisResult) Error() string {
	return fmt.Sprintf("redis execution code:%d,message:%s\n", e.Code, e.Message)
}

func (e *RedisResult) OutputResultMessage() string {
	return e.Message
}

func (e *RedisResult) OutputResultCode() int {
	return int(e.Code)
}

func NewRedisResult(res RedisCode, lockType RedisLockType, redisMsg string) error {
	resInt := int(res)
	switch resInt {
	case 1:
		if lockType == LockType {
			return &RedisResult{Code: res, Message: "redis lock success"}
		} else if (lockType == UnRLockType) || (lockType == UnWLockType) || (lockType == UnLockType) {
			return &RedisResult{Code: res, Message: "redis unlock success"}
		} else {
			return &RedisResult{Code: res, Message: "redis refresh lock success"}
		}
	case 0:
		if lockType == UnRLockType {
			return &RedisResult{Code: res, Message: "redis unlock read lock success, the lock is still occupied by other processes read lock"}
		} else {
			return &RedisResult{Code: res, Message: "redis unlock write lock success, the lock is still occupied by other processes write lock"}
		}
	case -1:
		return &RedisResult{Code: res, Message: "redis lock read lock failure,the lock is already occupied by another processes write lock"}
	case -2:
		return &RedisResult{Code: res, Message: "redis un lock read lock failure,the lock is already occupied by another processes write lock"}
	case -3:
		return &RedisResult{Code: res, Message: "redis lock write lock failure,the lock is already occupied by anthor processes read lock"}
	case -4:
		return &RedisResult{Code: res, Message: "redis lock write lock failure,the lock is already occupied by anthor processes write lock"}
	case -5:
		return &RedisResult{Code: res, Message: "redis unlock write lock failure,the lock is already occupied by another processes read lock"}
	case -6:
		return &RedisResult{Code: res, Message: "redis unlock write lock failure,the lock is already occupied by another processes write lock"}
	case -7:
		return &RedisResult{Code: res, Message: "redis lock write lock failure,the first priority in the current process non-waiting queue"}
	case -8:
		return &RedisResult{Code: res, Message: "redis refresh lock failure,the lock not exist"}
	case -9:
		return &RedisResult{Code: res, Message: "redis lock failure,the lock is already occupied by another processes lock"}
	case -99:
		return &RedisResult{Code: res, Message: fmt.Sprintf("redis internal execution error:%v\n", redisMsg)}
	default:
		msg := "unkown redis execution result"
		if redisMsg != "" {
			msg = fmt.Sprintf("%s:%s\n", msg, redisMsg)
		}
		return &RedisResult{Code: res, Message: msg}
	}
}

func TranslateResultToStr(res RedisCode, lockType RedisLockType) string {
	resInt := int(res)
	switch resInt {
	case 1:
		if lockType == LockType {
			return "redis lock success"
		} else if (lockType == UnRLockType) || (lockType == UnWLockType) || (lockType == UnLockType) {
			return "redis unlock success"
		} else {
			return "redis refresh lock success"
		}
	case 0:
		if lockType == UnRLockType {
			return "redis unlock read lock success, the lock is still occupied by other processes read lock"
		} else {
			return "redis unlock write lock success, the lock is still occupied by other processes write lock"
		}
	case -1:
		return "redis lock read lock failure,the lock is already occupied by another processes write lock"
	case -2:
		return "redis un lock read lock failure,the lock is already occupied by another processes write lock"
	case -3:
		return "redis lock write lock failure,the lock is already occupied by anthor processes read lock"
	case -4:
		return "redis lock write lock failure,the lock is already occupied by anthor processes write lock"
	case -5:
		return "redis un lock write lock failure,the lock is already occupied by another processes read lock"
	case -6:
		return "redis un lock write lock failure,the lock is already occupied by another processes write lock"
	case -7:
		return "redis lock write lock failure,the first priority in the current process non-waiting queue"
	case -8:
		return "redis refresh lock failure,the lock not exist"
	}
	return "unkown redis execution result"
}