Fix/conn check (#38)

Author: kooksee

errors/err_wrap.go

@@ -49,8 +49,14 @@ func (e *ErrWrap) String() string {
 func (e *ErrWrap) MarshalJSON() ([]byte, error) {
 	data := errJsonify(e.err)
 	data["kind"] = e.Kind()
-	data["fields"] = e.pb.Tags
-	data["stacks"] = e.pb.Stacks
+	if len(e.pb.Tags) > 0 {
+		data["fields"] = e.pb.Tags
+	}
+
+	if len(e.pb.Stacks) > 0 {
+		data["stacks"] = e.pb.Stacks
+	}
+
 	data["caller"] = e.pb.Caller
 	return jjson.Marshal(data)
 }

errors/errcheck/check.go

@@ -0,0 +1,154 @@
+package errcheck
+
+import (
+	"context"
+	"runtime/debug"
+
+	"github.com/pubgo/funk/errors"
+	"github.com/pubgo/funk/log"
+	"github.com/samber/lo"
+)
+
+func RecoveryAndCheck(setter *error, callbacks ...func(err error) error) {
+	if setter == nil {
+		debug.PrintStack()
+		panic("setter is nil")
+	}
+
+	err := errors.Parse(recover())
+	gErr := *setter
+	if err == nil && gErr == nil {
+		return
+	}
+
+	if err == nil {
+		err = gErr
+	}
+
+	for _, fn := range callbacks {
+		err = fn(err)
+		if err == nil {
+			return
+		}
+	}
+
+	*setter = errors.WrapCaller(err, 1)
+}
+
+func Check(errSetter *error, err error, contexts ...context.Context) bool {
+	if errSetter == nil {
+		debug.PrintStack()
+		panic("errSetter is nil")
+	}
+
+	if err == nil {
+		return false
+	}
+
+	if (*errSetter) != nil {
+		log.Err(*errSetter).Msgf("errcheck: setter is not nil, err=%v", *errSetter)
+		return true
+	}
+
+	var ctx = lo.FirstOr(contexts, context.Background())
+	for _, fn := range GetCheckersFromCtx(ctx) {
+		err = fn(ctx, err)
+		if err == nil {
+			return false
+		}
+	}
+
+	*errSetter = errors.WrapCaller(err, 1)
+	return true
+}
+
+func CheckCtx(ctx context.Context, errSetter *error, err error, errCheckers ...ErrChecker) bool {
+	if errSetter == nil {
+		debug.PrintStack()
+		panic("errSetter is nil")
+	}
+
+	if err == nil {
+		return false
+	}
+
+	// err No checking, repeat setting
+	if (*errSetter) != nil {
+		log.Err(*errSetter, ctx).Msgf("setter is not nil, err=%v", *errSetter)
+		return true
+	}
+
+	for _, fn := range append(GetCheckersFromCtx(ctx), errCheckers...) {
+		err = fn(ctx, err)
+		if err == nil {
+			return false
+		}
+	}
+
+	*errSetter = errors.WrapCaller(err, 1)
+	return true
+}
+
+func NewChecker(ctx context.Context, errSetter *error, errCheckers ...ErrChecker) *Checker {
+	if errSetter == nil {
+		debug.PrintStack()
+		panic("errSetter is nil")
+	}
+
+	if ctx == nil {
+		ctx = context.Background()
+	}
+
+	return &Checker{ctx: ctx, errSetter: errSetter, errCheckers: errCheckers}
+}
+
+type Checker struct {
+	ctx         context.Context
+	errSetter   *error
+	errCheckers []ErrChecker
+}
+
+func (c *Checker) Check(err error, errCheckers ...ErrChecker) bool {
+	if err == nil {
+		return false
+	}
+
+	// err No checking, repeat setting
+	if (*c.errSetter) != nil {
+		log.Err(*c.errSetter, c.ctx).Msgf("setter is not nil, err=%v", *c.errSetter)
+		return true
+	}
+
+	checkers := append(append(GetCheckersFromCtx(c.ctx), c.errCheckers...), errCheckers...)
+	for _, fn := range checkers {
+		err = fn(c.ctx, err)
+		if err == nil {
+			return false
+		}
+	}
+
+	*c.errSetter = errors.WrapCaller(err, 1)
+	return true
+}
+
+func (c *Checker) Recovery() {
+	err := errors.Parse(recover())
+	gErr := *c.errSetter
+	if err == nil && gErr == nil {
+		return
+	}
+
+	if err == nil {
+		err = gErr
+	}
+
+	checkers := append(GetCheckersFromCtx(c.ctx), c.errCheckers...)
+	for _, fn := range checkers {
+		err = fn(c.ctx, err)
+		if err == nil {
+			return
+		}
+	}
+
+	*c.errSetter = errors.WrapCaller(err, 1)
+}

errors/errcheck/context.go

@@ -0,0 +1,29 @@
+package errcheck
+
+import (
+	"context"
+)
+
+type checkCtx struct{}
+
+type ErrChecker func(context.Context, error) error
+
+func CreateCtx(ctx context.Context, errChecks []ErrChecker) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return context.WithValue(ctx, checkCtx{}, errChecks)
+}
+
+func GetCheckersFromCtx(ctx context.Context) []ErrChecker {
+	if ctx == nil {
+		return nil
+	}
+
+	checkers, ok := ctx.Value(checkCtx{}).([]ErrChecker)
+	if !ok {
+		return nil
+	}
+
+	return checkers
+}

errors/errors.go

@@ -13,7 +13,7 @@ import (
 )
 
 func IfErr(err error, fn func(err error) error) error {
-	if generic.IsNil(err) {
+	if err == nil {
 		return nil
 	}
 

internal/anyhow/aherrcheck/errcheck.go

@@ -0,0 +1,46 @@
+package aherrcheck
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/pubgo/funk/stack"
+)
+
+var errChecks []func(context.Context, error) error
+
+func RegisterErrCheck(f func(context.Context, error) error) {
+	var checkFrame = stack.CallerWithFunc(f)
+	for _, errFunc := range errChecks {
+		if reflect.DeepEqual(checkFrame, stack.CallerWithFunc(errFunc)) {
+			return
+		}
+	}
+
+	errChecks = append(errChecks, f)
+}
+
+func GetErrChecks() []func(context.Context, error) error { return errChecks }
+
+func GetErrCheckFrames() []*stack.Frame {
+	var frames []*stack.Frame
+	for _, err := range errChecks {
+		frames = append(frames, stack.CallerWithFunc(err))
+	}
+	return frames
+}
+
+func RemoveErrCheck(f func(context.Context, error) error) {
+	var checkFrame = stack.CallerWithFunc(f)
+	var index = -1
+	for idx, errFunc := range errChecks {
+		if reflect.DeepEqual(checkFrame, stack.CallerWithFunc(errFunc)) {
+			index = idx
+			break
+		}
+	}
+
+	if index != -1 {
+		errChecks = append(errChecks[:index], errChecks[index+1:]...)
+	}
+}

internal/anyhow/aherrcheck/errcheck_test.go

@@ -0,0 +1,25 @@
+package aherrcheck
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func errCheck1(ctx context.Context, err error) error {
+	return err
+}
+
+func TestErrCheck(t *testing.T) {
+	assert.Equal(t, len(GetErrCheckFrames()), 0)
+
+	RegisterErrCheck(errCheck1)
+	assert.Equal(t, len(GetErrCheckFrames()), 1)
+
+	RegisterErrCheck(errCheck1)
+	assert.Equal(t, len(GetErrCheckFrames()), 1)
+
+	RemoveErrCheck(errCheck1)
+	assert.Equal(t, len(GetErrCheckFrames()), 0)
+}