Dragonfly2

1
/*
2
 *     Copyright 2020 The Dragonfly Authors
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package dferrors
18

19
import (
20
	"errors"
21
	"fmt"
22

23
	"google.golang.org/grpc/status"
24

25
	commonv1 "d7y.io/api/v2/pkg/apis/common/v1"
26
)
27

28
// common and framework errors
29
var (
30
	ErrInvalidArgument = errors.New("invalid argument")
31
	ErrInvalidHeader   = errors.New("invalid Header")
32
	ErrDataNotFound    = errors.New("data not found")
33
	ErrEmptyValue      = errors.New("empty value")
34
	ErrConvertFailed   = errors.New("convert failed")
35
	ErrEndOfStream     = errors.New("end of stream")
36
	ErrNoCandidateNode = errors.New("no candidate server node")
37
)
38

39
func IsEndOfStream(err error) bool {
40
	return err == ErrEndOfStream
41
}
42

43
type DfError struct {
44
	Code    commonv1.Code
45
	Message string
46
}
47

48
func (s *DfError) Error() string {
49
	return fmt.Sprintf("[%d]%s", s.Code, s.Message)
50
}
51

52
func New(code commonv1.Code, msg string) *DfError {
53
	return &DfError{
54
		Code:    code,
55
		Message: msg,
56
	}
57
}
58

59
func Newf(code commonv1.Code, format string, a ...any) *DfError {
60
	return &DfError{
61
		Code:    code,
62
		Message: fmt.Sprintf(format, a...),
63
	}
64
}
65

66
func CheckError(err error, code commonv1.Code) bool {
67
	if err == nil {
68
		return false
69
	}
70

71
	e, ok := err.(*DfError)
72

73
	return ok && e.Code == code
74
}
75

76
// ConvertGRPCErrorToDfError converts grpc error to DfError, if it exists.
77
func ConvertGRPCErrorToDfError(err error) error {
78
	for _, d := range status.Convert(err).Details() {
79
		switch internal := d.(type) {
80
		case *commonv1.GrpcDfError:
81
			return &DfError{
82
				Code:    internal.Code,
83
				Message: internal.Message,
84
			}
85
		}
86
	}
87

88
	return err
89
}
90

91
func IsGRPCDfError(err error) (*DfError, bool) {
92
	for _, d := range status.Convert(err).Details() {
93
		switch internal := d.(type) {
94
		case *commonv1.GrpcDfError:
95
			return &DfError{
96
				Code:    internal.Code,
97
				Message: internal.Message,
98
			}, true
99
		}
100
	}
101

102
	var de *DfError
103
	ok := errors.As(err, &de)
104
	if ok {
105
		return de, true
106
	}
107

108
	return nil, false
109
}
110

111
// ConvertDfErrorToGRPCError converts DfError to grpc error, if it is.
112
func ConvertDfErrorToGRPCError(err error) error {
113
	if v, ok := err.(*DfError); ok {
114
		s, e := status.Convert(err).WithDetails(
115
			&commonv1.GrpcDfError{
116
				Code:    v.Code,
117
				Message: v.Message,
118
			})
119
		if e == nil {
120
			err = s.Err()
121
		}
122
	}
123
	return err
124
}
125