update

gin/ctxUtils/ctx.go

@@ -159,7 +159,7 @@ func GetGinCtxTid(c *gin.Context) string {
 }
 
 func GenerateTid() string {
-	return xsf.Generate().String()
+	return xsf.GenerateID().String()
 }
 
 func GetCtxTid(ctx context.Context) string {

gin/middleware/breaker_test.go

@@ -64,11 +64,10 @@ func TestCircuitBreaker(t *testing.T) {
 			defer wg.Done()
 			for i := 0; i < 100; i++ {
 				result := &httpcli.StdResult{}
-				err := httpcli.Get(context.Background(), result, requestAddr+"/hello")
+				req := httpcli.New()
+				req.SetURL(requestAddr + "/hello")
+				err := req.GET(context.Background()).Err()
 				if err != nil {
-					//if errors.Is(err, ErrNotAllowed) {
-					//	atomic.AddInt32(&countBreaker, 1)
-					//}
 					atomic.AddInt32(&failures, 1)
 					continue
 				}

gin/middleware/logging_test.go

@@ -81,7 +81,7 @@ func TestRequest(t *testing.T) {
 	}
 
 	t.Run("get ping", func(t *testing.T) {
-		err := httpcli.Get(context.Background(), result, requestAddr+"/ping")
+		err := httpcli.New().SetURL(requestAddr + "/ping").GET(context.Background()).BindJSON(result).Err()
 		if err != nil {
 			t.Error(err)
 			return
@@ -93,7 +93,7 @@ func TestRequest(t *testing.T) {
 	})
 
 	t.Run("get hello", func(t *testing.T) {
-		err := httpcli.Get(context.Background(), result, requestAddr+"/hello", httpcli.WithParams(map[string]interface{}{"id": "100"}))
+		err := httpcli.New().SetURL(requestAddr + "/hello").SetParams(map[string]interface{}{"id": "100"}).GET(context.Background()).BindJSON(result).Err()
 		if err != nil {
 			t.Error(err)
 			return
@@ -105,7 +105,7 @@ func TestRequest(t *testing.T) {
 	})
 
 	t.Run("delete hello", func(t *testing.T) {
-		err := httpcli.Delete(context.Background(), result, requestAddr+"/hello", httpcli.WithParams(map[string]interface{}{"id": "100"}))
+		err := httpcli.New().SetURL(requestAddr + "/hello").SetParams(map[string]interface{}{"id": "100"}).DELETE(context.Background()).BindJSON(result).Err()
 		if err != nil {
 			t.Error(err)
 			return
@@ -117,7 +117,7 @@ func TestRequest(t *testing.T) {
 	})
 
 	t.Run("post hello", func(t *testing.T) {
-		err := httpcli.Post(context.Background(), result, requestAddr+"/hello", &User{"foo"})
+		err := httpcli.New().SetURL(requestAddr + "/hello").SetBody(User{"foo"}).POST(context.Background()).BindJSON(result).Err()
 		if err != nil {
 			t.Error(err)
 			return
@@ -129,7 +129,7 @@ func TestRequest(t *testing.T) {
 	})
 
 	t.Run("put hello", func(t *testing.T) {
-		err := httpcli.Put(context.Background(), result, requestAddr+"/hello", &User{"foo"})
+		err := httpcli.New().SetURL(requestAddr + "/hello").SetBody(User{"foo"}).PUT(context.Background()).BindJSON(result).Err()
 		if err != nil {
 			t.Error(err)
 			return
@@ -141,7 +141,7 @@ func TestRequest(t *testing.T) {
 	})
 
 	t.Run("patch hello", func(t *testing.T) {
-		err := httpcli.Patch(context.Background(), result, requestAddr+"/hello", &User{"foo"})
+		err := httpcli.New().SetURL(requestAddr + "/hello").SetBody(User{"foo"}).PATCH(context.Background()).BindJSON(result).Err()
 		if err != nil {
 			t.Error(err)
 			return
@@ -188,7 +188,7 @@ func TestRequest2(t *testing.T) {
 	requestAddr := runLogHTTPServer2()
 	result := &httpcli.StdResult{}
 	t.Run("get ping", func(t *testing.T) {
-		err := httpcli.Get(context.Background(), result, requestAddr+"/ping")
+		err := httpcli.New().SetURL(requestAddr + "/ping").GET(context.Background()).BindJSON(result).Err()
 		if err != nil {
 			t.Error(err)
 			return

gin/middleware/ratelimit_test.go

@@ -65,7 +65,7 @@ func TestRateLimiter(t *testing.T) {
 			defer wg.Done()
 			for i := 0; i < 100; i++ {
 				result := &httpcli.StdResult{}
-				if err := httpcli.Get(context.Background(), result, requestAddr+"/hello"); err != nil {
+				if err := httpcli.New().SetURL(requestAddr + "/hello").GET(context.Background()).BindJSON(result).Err(); err != nil {
 					atomic.AddInt32(&failures, 1)
 				} else {
 					atomic.AddInt32(&success, 1)

gin/middleware/requstid_test.go

@@ -62,7 +62,7 @@ func TestFieldRequestIDFromContext(t *testing.T) {
 		t.Log(GetFromCtx(ctx, "foo"))
 		t.Log(ctxUtil.CtxTraceIDField(ctx))
 		t.Log(GetFromCtx(ctx, "not-exist"))
-		t.Log(GetFromHeader(ctx, ctxUtil.HeaderXRequestIDKey))
+		t.Log(GetFromHeader(ctx, ctxUtil.HeaderXRequestIDKey.String()))
 		t.Log(GetFromHeader(ctx, "Accept"))
 		t.Log(GetFromHeader(ctx, "not-exist"))
 		t.Log(GetFromHeaders(ctx, "Accept"))
@@ -81,7 +81,7 @@ func TestFieldRequestIDFromContext(t *testing.T) {
 	req, _ := http.NewRequest("GET", requestAddr+"/ping", nil)
 	req.Header.Add("Accept", "application/json")
 	req.Header.Add("Accept", "text/html")
-	req.Header.Set(ctxUtil.HeaderXRequestIDKey, "2ab996de-cc03-412d-ba0a-79596efa6947")
+	req.Header.Set(ctxUtil.HeaderXRequestIDKey.String(), "2ab996de-cc03-412d-ba0a-79596efa6947")
 	resp, err := http.DefaultClient.Do(req)
 	assert.NoError(t, err)
 	defer resp.Body.Close()

gin/middleware/tracing_test.go

@@ -36,7 +36,7 @@ func TestTracing(t *testing.T) {
 
 	time.Sleep(time.Millisecond * 200)
 	result := &httpcli.StdResult{}
-	err := httpcli.Get(context.Background(), result, requestAddr+"/hello")
+	err := httpcli.New().SetURL(requestAddr + "/hello").GET(context.Background()).BindJSON(result).Err()
 	assert.NoError(t, err)
 	t.Log(result)
 }

gin/response/response_test.go

@@ -57,20 +57,21 @@ func runResponseHTTPServer() string {
 func TestRespond(t *testing.T) {
 	requestAddr := runResponseHTTPServer()
 
+	var err error
 	result := &httpcli.StdResult{}
-	err := httpcli.Get(context.Background(), result, requestAddr+"/success")
+	err = httpcli.New().GET(context.Background()).SetURL(requestAddr + "/success").BindJSON(result).Err()
 	assert.NoError(t, err)
 	assert.NotEmpty(t, result.Data)
 
 	result = &httpcli.StdResult{}
-	err = httpcli.Get(context.Background(), result, requestAddr+"/error")
+	err = httpcli.New().GET(context.Background()).SetURL(requestAddr + "/error").BindJSON(result).Err()
 	assert.NoError(t, err)
 	assert.NotEqual(t, errcode.Success.Code(), result.Code)
 
 	for _, code := range httpResponseCodes {
 		result := &httpcli.StdResult{}
 		url := fmt.Sprintf("%s/code/%d", requestAddr, code)
-		err := httpcli.Get(context.Background(), result, url)
+		err := httpcli.New().GET(context.Background()).SetURL(url).BindJSON(result).Err()
 		if code == http.StatusOK {
 			assert.NoError(t, err)
 			assert.Equal(t, http.StatusOK, result.Code)
@@ -81,7 +82,7 @@ func TestRespond(t *testing.T) {
 	for _, out := range outs {
 		result := &httpcli.StdResult{}
 		url := fmt.Sprintf("%s/out/code/%d", requestAddr, out.ToHTTPCode())
-		err := httpcli.Get(context.Background(), result, url)
+		err := httpcli.New().GET(context.Background()).SetURL(url).BindJSON(result).Err()
 		if out.ToHTTPCode() == http.StatusOK {
 			assert.NoError(t, err)
 			assert.Equal(t, http.StatusOK, result.Code)

grpc/interceptor/jwtAuth_test.go

@@ -58,7 +58,7 @@ func customVerifyHandler(claims *jwt.CustomClaims, tokenTail32 string) error {
 func TestJwtVerify(t *testing.T) {
 	jwt.Init()
 	ctx := context.Background()
-	token, _ := jwt.GenerateToken(expectedUid, expectedName)
+	token, _, _ := jwt.GenerateToken(expectedUid, expectedName)
 
 	// success test
 	ctx = metadata.NewIncomingContext(ctx, metadata.MD{headerAuthorize: []string{GetAuthorization(token)}})
@@ -130,7 +130,7 @@ func TestUnaryServerJwtAuth(t *testing.T) {
 
 	// mock client ctx
 	jwt.Init()
-	token, _ := jwt.GenerateToken(expectedUid, expectedName)
+	token, _, _ := jwt.GenerateToken(expectedUid, expectedName)
 	ctx := metadata.NewIncomingContext(context.Background(), metadata.MD{headerAuthorize: []string{GetAuthorization(token)}})
 
 	_, err := interceptor(ctx, nil, unaryServerInfo, unaryServerHandler)
@@ -163,7 +163,7 @@ func TestStreamServerJwtAuth(t *testing.T) {
 	assert.NotNil(t, interceptor)
 
 	jwt.Init()
-	token, _ := jwt.GenerateToken(expectedUid, expectedName)
+	token, _, _ := jwt.GenerateToken(expectedUid, expectedName)
 	ctx := metadata.NewIncomingContext(context.Background(), metadata.MD{headerAuthorize: []string{authScheme + " " + token}})
 	err := interceptor(nil, newStreamServer(ctx), streamServerInfo, streamServerHandler)
 	assert.NoError(t, err)
@@ -225,7 +225,7 @@ func TestAuthOptions(t *testing.T) {
 func TestSetJWTTokenToCtx(t *testing.T) {
 	jwt.Init()
 	ctx := context.Background()
-	token, _ := jwt.GenerateToken(expectedUid, expectedName)
+	token, _, _ := jwt.GenerateToken(expectedUid, expectedName)
 	expected := []string{GetAuthorization(token)}
 
 	ctx = SetJwtTokenToCtx(ctx, token)
@@ -236,7 +236,7 @@ func TestSetJWTTokenToCtx(t *testing.T) {
 func TestSetAuthToCtx(t *testing.T) {
 	jwt.Init()
 	ctx := context.Background()
-	token, _ := jwt.GenerateToken(expectedUid, expectedName)
+	token, _, _ := jwt.GenerateToken(expectedUid, expectedName)
 	authorization := GetAuthorization(token)
 	expected := []string{authorization}
 

jwt/jwt.go

@@ -27,27 +27,28 @@ type Claims struct {
 }
 
 // GenerateToken generate token by uid and name, use universal Claims
-func GenerateToken(uid string, name ...string) (string, error) {
+func GenerateToken(uid string, name string) (string, time.Time, error) {
+	expireAt := time.Now()
 	if opt == nil {
-		return "", errInit
-	}
-
-	nameVal := ""
-	if len(name) > 0 {
-		nameVal = name[0]
+		return "", expireAt, errInit
 	}
+	expireAt = time.Now().Add(opt.expire)
 	claims := Claims{
 		uid,
-		nameVal,
+		name,
 		jwt.RegisteredClaims{
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(opt.expire)),
+			ExpiresAt: jwt.NewNumericDate(expireAt),
 			IssuedAt:  jwt.NewNumericDate(time.Now()),
 			Issuer:    opt.issuer,
 		},
 	}
 
 	token := jwt.NewWithClaims(opt.signingMethod, claims)
-	return token.SignedString(opt.signingKey)
+	tk, err := token.SignedString(opt.signingKey)
+	if err != nil {
+		return tk, expireAt, err
+	}
+	return tk, expireAt, nil
 }
 
 // ParseToken parse token, return universal Claims

jwt/jwt_test.go

@@ -11,11 +11,11 @@ import (
 
 func TestGenerateToken(t *testing.T) {
 	opt = nil
-	token, err := GenerateToken("123")
+	token, _, err := GenerateToken("123", "")
 	assert.Error(t, err)
 
 	Init()
-	token, err = GenerateToken("123")
+	token, _, err = GenerateToken("123", "")
 	assert.NoError(t, err)
 
 	v, err := ParseToken(token)
@@ -47,7 +47,7 @@ func TestParseToken(t *testing.T) {
 	)
 
 	// success
-	token, err := GenerateToken(uid, name)
+	token, _, err := GenerateToken(uid, name)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -69,7 +69,7 @@ func TestParseToken(t *testing.T) {
 	assert.Error(t, err)
 
 	// token has expired
-	token, err = GenerateToken(uid, name)
+	token, _, err = GenerateToken(uid, name)
 	if err != nil {
 		t.Fatal(err)
 	}

utils/dxsf/dxsf.go

+package dxsf
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"time"
+
+	"gitlab.wanzhuangkj.com/tush/xpkg/httpcli"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+var (
+	host       string
+	httpClient = &client{
+		cli: httpcli.NewClient(
+			&http.Client{
+				Transport: &http.Transport{
+					MaxIdleConnsPerHost: 4,
+					MaxIdleConns:        4,
+					IdleConnTimeout:     90 * time.Second,
+				},
+			}),
+	}
+)
+
+type client struct {
+	cli *httpcli.Client
+}
+
+func init() {
+	host = os.Getenv("XSF_HOST")
+}
+
+func GenerateApiID(ctx context.Context, bizTag string) (xsf.ID, error) {
+	url := fmt.Sprintf(`http://%s/api/leaf?biz_tag=%s`, host, bizTag)
+	reply := &IDReply{}
+	if err := httpClient.cli.NewRequest().SetRetry(3).SetContentType("application/json").SetURL(url).GET(ctx).BindJSON(reply).Err(); err != nil {
+		return xsf.ID(0), err
+	}
+	if reply.Code == 0 {
+		return xsf.ParseInt64(reply.Data.ID), nil
+	}
+	return xsf.ID(0), errors.New(reply.Msg)
+}
+
+type IDReply struct {
+	Code int `json:"code"`
+	Data struct {
+		ID int64 `json:"ID"`
+	} `json:"data"`
+	Msg string `json:"msg"`
+}

utils/xsf/xsf.go

@@ -2,13 +2,16 @@ package xsf
 
 import (
 	"fmt"
+	"os"
 	"strconv"
 
 	"github.com/bwmarrin/snowflake"
 	"gitlab.wanzhuangkj.com/tush/xpkg/xerrors/xerror"
 )
 
-var node *snowflake.Node
+var (
+	node *snowflake.Node
+)
 
 type ID snowflake.ID
 
@@ -66,33 +69,32 @@ func (j JSONSyntaxError) Error() string {
 }
 
 // n [1,1023]
-func Init(n int64) (err error) {
-	node, err = snowflake.NewNode(n)
-	if err != nil {
-		return err
+func init() {
+	n, e := strconv.ParseInt(os.Getenv("XSF_NODE"), 10, 64)
+	if e != nil {
+		panic(e)
 	}
-	return nil
-}
-
-func Generate() ID {
-	return ID(node.Generate())
+	nod, e := snowflake.NewNode(n)
+	if e != nil {
+		panic(e)
+	}
+	node = nod
 }
 
 func (x ID) String() string {
 	return snowflake.ID(x).String()
 }
 
-func (x ID) ToInt64() int64 {
+func (x ID) Int64() int64 {
 	return snowflake.ID(x).Int64()
 }
 
-func (x ID) ToInt() int {
+func (x ID) Int() int {
 	return int(snowflake.ID(x).Int64())
 }
 
 func GenerateID() ID {
-	sid := Generate()
-	return ID(sid)
+	return ID(node.Generate())
 }
 
 func ParseInt64(val int64) ID {

utils/xsf/xsf_test.go

@@ -36,8 +36,7 @@ func TestID_MarshalJSON(t *testing.T) {
 }
 
 func TestID_String(t *testing.T) {
-	Init(10)
 	for i := 0; i < 10; i++ {
-		fmt.Println(Generate().String())
+		fmt.Println(GenerateID().String())
 	}
 }