- update

- update WxaGetQrcode

.gitignore

@@ -4,6 +4,6 @@
 .idea
 .vscode
 *.log
-goinit.sh
 gomod.sh
-*_test.go
+*_test.go
+/vendor/

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Arran Walker
+Copyright (c) 2018 李光春
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

README.md

@@ -1,5 +1,5 @@
 <h1>
-<a href="https://www.dtapp.net/">Golang WeChatOpen</a>
+<a href="https://www.dtapp.net/">Golang</a>
 </h1>
 
 📦 Golang WeChatOpen
@@ -8,18 +8,10 @@
 [![godoc](https://pkg.go.dev/badge/go.dtapp.net/wechatopen?status.svg)](https://pkg.go.dev/go.dtapp.net/wechatopen)
 [![goproxy.cn](https://goproxy.cn/stats/go.dtapp.net/wechatopen/badges/download-count.svg)](https://goproxy.cn/stats/go.dtapp.net/wechatopen)
 [![goreportcard.com](https://goreportcard.com/badge/go.dtapp.net/wechatopen)](https://goreportcard.com/report/go.dtapp.net/wechatopen)
-[![deps.dev](https://img.shields.io/badge/deps-go-red.svg)](https://deps.dev/go/go.dtapp.net/wechatopen)
+[![deps.dev](https://img.shields.io/badge/deps-go-red.svg)](https://deps.dev/go/go.dtapp.net%2Fwechatopen)
 
-#### 安装使用
+#### 安装
 
 ```go
 go get -v -u go.dtapp.net/wechatopen
-```
-
-#### 导入
-
-```go
-import (
-    "go.dtapp.net/wechatopen"
-)
 ```

app.go

@@ -1,88 +0,0 @@
-package wechatopen
-
-import (
-	"go.dtapp.net/golog"
-	"go.dtapp.net/goredis"
-	"go.dtapp.net/gorequest"
-	"gorm.io/gorm"
-)
-
-// App 微信公众号服务
-type App struct {
-	componentAccessToken   string // 第三方平台 access_token
-	componentVerifyTicket  string // 微信后台推送的 ticket
-	preAuthCode            string // 预授权码
-	authorizerAccessToken  string // 接口调用令牌
-	authorizerRefreshToken string // 刷新令牌
-	authorizerAppid        string // 授权方 appid
-	componentAppId         string // 第三方平台 appid
-	componentAppSecret     string // 第三方平台 app_secret
-	messageToken           string
-	messageKey             string
-	redis                  *goredis.Client // 缓存数据库
-	pgsql                  *gorm.DB        // pgsql数据库
-	client                 *gorequest.App  // 请求客户端
-	log                    *golog.Api      // 日志服务
-	logTableName           string          // 日志表名
-	logStatus              bool            // 日志状态
-}
-
-// NewApp 实例化
-func NewApp(componentAppId string, componentAppSecret string, messageToken string, messageKey string, redis *goredis.Client, pgsql *gorm.DB) *App {
-	app := &App{componentAppId: componentAppId, componentAppSecret: componentAppSecret, messageToken: messageToken, messageKey: messageKey, redis: redis}
-	app.client = gorequest.NewHttp()
-	if pgsql != nil {
-		app.pgsql = pgsql
-		app.logStatus = true
-		app.logTableName = "wechatopen"
-		app.log = golog.NewApi(&golog.ApiConfig{
-			Db:        pgsql,
-			TableName: app.logTableName,
-		})
-	}
-	return app
-}
-
-// Config 配置
-func (app *App) Config(componentAppId, componentAppSecret string) *App {
-	app.componentAppId = componentAppId
-	app.componentAppSecret = componentAppSecret
-	return app
-}
-
-// ConfigAuthorizer 配置第三方
-func (app *App) ConfigAuthorizer(authorizerAppid string) *App {
-	app.authorizerAppid = authorizerAppid
-	return app
-}
-
-func (app *App) request(url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
-
-	// 创建请求
-	client := app.client
-
-	// 设置请求地址
-	client.SetUri(url)
-
-	// 设置方式
-	client.SetMethod(method)
-
-	// 设置格式
-	client.SetContentTypeJson()
-
-	// 设置参数
-	client.SetParams(params)
-
-	// 发起请求
-	request, err := client.Request()
-	if err != nil {
-		return gorequest.Response{}, err
-	}
-
-	// 日志
-	if app.logStatus == true {
-		go app.postgresqlLog(request)
-	}
-
-	return request, err
-}

cgi-bin.account.getaccountbasicinfo.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -46,20 +47,36 @@ type CgiBinAccountGetAccountBasicInfoResult struct {
 	Result CgiBinAccountGetAccountBasicInfoResponse // 结果
 	Body   []byte                                   // 内容
 	Http   gorequest.Response                       // 请求
-	Err    error                                    // 错误
 }
 
-func NewCgiBinAccountGetAccountBasicInfoResult(result CgiBinAccountGetAccountBasicInfoResponse, body []byte, http gorequest.Response, err error) *CgiBinAccountGetAccountBasicInfoResult {
-	return &CgiBinAccountGetAccountBasicInfoResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinAccountGetAccountBasicInfoResult(result CgiBinAccountGetAccountBasicInfoResponse, body []byte, http gorequest.Response) *CgiBinAccountGetAccountBasicInfoResult {
+	return &CgiBinAccountGetAccountBasicInfoResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinAccountGetAccountBasicInfo 获取基本信息
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/Mini_Program_Basic_Info/Mini_Program_Information_Settings.html
-func (app *App) CgiBinAccountGetAccountBasicInfo() *CgiBinAccountGetAccountBasicInfoResult {
+func (c *Client) CgiBinAccountGetAccountBasicInfo(ctx context.Context) (*CgiBinAccountGetAccountBasicInfoResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	// 参数
+	params := gorequest.NewParams()
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/account/getaccountbasicinfo?access_token=%v", app.GetAuthorizerAccessToken()), map[string]interface{}{}, http.MethodGet)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/account/getaccountbasicinfo?access_token=%v", c.GetAuthorizerAccessToken(ctx)), params, http.MethodGet)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinAccountGetAccountBasicInfoResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinAccountGetAccountBasicInfoResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinAccountGetAccountBasicInfoResult(response, request.ResponseBody, request), nil
 }

cgi-bin.component.api_authorizer_token.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -17,27 +18,41 @@ type CgiBinComponentApiAuthorizerTokenResult struct {
 	Result          CgiBinComponentApiAuthorizerTokenResponse // 结果
 	Body            []byte                                    // 内容
 	Http            gorequest.Response                        // 请求
-	Err             error                                     // 错误
 	authorizerAppid string                                    // 授权方 appid
 }
 
-func NewCgiBinComponentApiAuthorizerTokenResult(result CgiBinComponentApiAuthorizerTokenResponse, body []byte, http gorequest.Response, err error, authorizerAppid string) *CgiBinComponentApiAuthorizerTokenResult {
-	return &CgiBinComponentApiAuthorizerTokenResult{Result: result, Body: body, Http: http, Err: err, authorizerAppid: authorizerAppid}
+func newCgiBinComponentApiAuthorizerTokenResult(result CgiBinComponentApiAuthorizerTokenResponse, body []byte, http gorequest.Response, authorizerAppid string) *CgiBinComponentApiAuthorizerTokenResult {
+	return &CgiBinComponentApiAuthorizerTokenResult{Result: result, Body: body, Http: http, authorizerAppid: authorizerAppid}
 }
 
 // CgiBinComponentApiAuthorizerToken 获取/刷新接口调用令牌
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/ThirdParty/token/api_authorizer_token.html
-func (app *App) CgiBinComponentApiAuthorizerToken(authorizerRefreshToken string) *CgiBinComponentApiAuthorizerTokenResult {
+func (c *Client) CgiBinComponentApiAuthorizerToken(ctx context.Context, authorizerRefreshToken string) (*CgiBinComponentApiAuthorizerTokenResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	param := NewParams()
-	param["component_appid"] = app.componentAppId              // 第三方平台 appid
-	param["authorizer_appid"] = app.authorizerAppid            // 授权方 appid
+	param := gorequest.NewParams()
+	param["component_appid"] = c.GetComponentAppId()           // 第三方平台 appid
+	param["authorizer_appid"] = c.GetAuthorizerAppid()         // 授权方 appid
 	param["authorizer_refresh_token"] = authorizerRefreshToken // 授权码, 会在授权成功时返回给第三方平台
-	params := app.NewParamsWith(param)
+	params := gorequest.NewParamsWith(param)
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/component/api_authorizer_token?component_access_token=%v", app.GetComponentAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/component/api_authorizer_token?component_access_token=%v", c.GetComponentAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentApiAuthorizerTokenResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentApiAuthorizerTokenResult(response, request.ResponseBody, request, err, app.authorizerAppid)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentApiAuthorizerTokenResult(response, request.ResponseBody, request, param["authorizer_appid"].(string)), nil
 }

cgi-bin.component.api_component_token.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"go.dtapp.net/gorequest"
 	"net/http"
@@ -15,26 +16,36 @@ type CgiBinComponentApiComponentTokenResult struct {
 	Result CgiBinComponentApiComponentTokenResponse // 结果
 	Body   []byte                                   // 内容
 	Http   gorequest.Response                       // 请求
-	Err    error                                    // 错误
 }
 
-func NewCgiBinComponentApiComponentTokenResult(result CgiBinComponentApiComponentTokenResponse, body []byte, http gorequest.Response, err error) *CgiBinComponentApiComponentTokenResult {
-	return &CgiBinComponentApiComponentTokenResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinComponentApiComponentTokenResult(result CgiBinComponentApiComponentTokenResponse, body []byte, http gorequest.Response) *CgiBinComponentApiComponentTokenResult {
+	return &CgiBinComponentApiComponentTokenResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinComponentApiComponentToken 令牌
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/ThirdParty/token/component_access_token.html
-func (app *App) CgiBinComponentApiComponentToken() *CgiBinComponentApiComponentTokenResult {
+func (c *Client) CgiBinComponentApiComponentToken(ctx context.Context) (*CgiBinComponentApiComponentTokenResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	param := NewParams()
-	param["component_appid"] = app.componentAppId                     // 第三方平台 appid
-	param["component_appsecret"] = app.componentAppSecret             // 第三方平台 appsecret
-	param["component_verify_ticket"] = app.GetComponentVerifyTicket() // 微信后台推送的 ticket
-	params := app.NewParamsWith(param)
+	param := gorequest.NewParams()
+	param["component_appid"] = c.GetComponentAppId()                   // 第三方平台 appid
+	param["component_appsecret"] = c.GetComponentAppSecret()           // 第三方平台 appsecret
+	param["component_verify_ticket"] = c.GetComponentVerifyTicket(ctx) // 微信后台推送的 ticket
+	params := gorequest.NewParamsWith(param)
 	// 请求
-	request, err := app.request("https://api.weixin.qq.com/cgi-bin/component/api_component_token", params, http.MethodPost)
+	request, err := c.request(ctx, apiUrl+"/cgi-bin/component/api_component_token", params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentApiComponentTokenResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentApiComponentTokenResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentApiComponentTokenResult(response, request.ResponseBody, request), nil
 }

cgi-bin.component.api_create_preauthcode.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -16,24 +17,35 @@ type CgiBinComponentApiCreatePreAuthCodenResult struct {
 	Result CgiBinComponentApiCreatePreAuthCodenResponse // 结果
 	Body   []byte                                       // 内容
 	Http   gorequest.Response                           // 请求
-	Err    error                                        // 错误
 }
 
-func NewCgiBinComponentApiCreatePreAuthCodenResult(result CgiBinComponentApiCreatePreAuthCodenResponse, body []byte, http gorequest.Response, err error) *CgiBinComponentApiCreatePreAuthCodenResult {
-	return &CgiBinComponentApiCreatePreAuthCodenResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinComponentApiCreatePreAuthCodenResult(result CgiBinComponentApiCreatePreAuthCodenResponse, body []byte, http gorequest.Response) *CgiBinComponentApiCreatePreAuthCodenResult {
+	return &CgiBinComponentApiCreatePreAuthCodenResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinComponentApiCreatePreAuthCoden 预授权码
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/ThirdParty/token/pre_auth_code.html
-func (app *App) CgiBinComponentApiCreatePreAuthCoden() *CgiBinComponentApiCreatePreAuthCodenResult {
+func (c *Client) CgiBinComponentApiCreatePreAuthCoden(ctx context.Context) (*CgiBinComponentApiCreatePreAuthCodenResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	param := NewParams()
-	param["component_appid"] = app.componentAppId // 第三方平台 appid
-	params := app.NewParamsWith(param)
+	param := gorequest.NewParams()
+	param["component_appid"] = c.GetComponentAppId() // 第三方平台 appid
+	params := gorequest.NewParamsWith(param)
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/component/api_create_preauthcode?component_access_token=%v", app.GetComponentAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/component/api_create_preauthcode?component_access_token=%v", c.GetComponentAccessToken(ctx)), params, http.MethodPost)
+
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentApiCreatePreAuthCodenResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentApiCreatePreAuthCodenResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentApiCreatePreAuthCodenResult(response, request.ResponseBody, request), nil
 }

cgi-bin.component.api_get_authorizer_info.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -74,25 +75,39 @@ type CgiBinComponentApiGetAuthorizerInfoResult struct {
 	Result CgiBinComponentApiGetAuthorizerInfoResponse // 结果
 	Body   []byte                                      // 内容
 	Http   gorequest.Response                          // 请求
-	Err    error                                       // 错误
 }
 
-func NewCgiBinComponentApiGetAuthorizerInfoResult(result CgiBinComponentApiGetAuthorizerInfoResponse, body []byte, http gorequest.Response, err error) *CgiBinComponentApiGetAuthorizerInfoResult {
-	return &CgiBinComponentApiGetAuthorizerInfoResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinComponentApiGetAuthorizerInfoResult(result CgiBinComponentApiGetAuthorizerInfoResponse, body []byte, http gorequest.Response) *CgiBinComponentApiGetAuthorizerInfoResult {
+	return &CgiBinComponentApiGetAuthorizerInfoResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinComponentApiGetAuthorizerInfo 获取授权帐号详情
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/ThirdParty/token/api_get_authorizer_info.html
-func (app *App) CgiBinComponentApiGetAuthorizerInfo() *CgiBinComponentApiGetAuthorizerInfoResult {
+func (c *Client) CgiBinComponentApiGetAuthorizerInfo(ctx context.Context) (*CgiBinComponentApiGetAuthorizerInfoResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	param := NewParams()
-	param["component_appid"] = app.componentAppId   // 第三方平台 appid
-	param["authorizer_appid"] = app.authorizerAppid // 授权方 appid
-	params := app.NewParamsWith(param)
+	param := gorequest.NewParams()
+	param["component_appid"] = c.GetComponentAppId()   // 第三方平台 appid
+	param["authorizer_appid"] = c.GetAuthorizerAppid() // 授权方 appid
+	params := gorequest.NewParamsWith(param)
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/component/api_get_authorizer_info?component_access_token=%v", app.GetComponentAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/component/api_get_authorizer_info?component_access_token=%v", c.GetComponentAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentApiGetAuthorizerInfoResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentApiGetAuthorizerInfoResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentApiGetAuthorizerInfoResult(response, request.ResponseBody, request), nil
 }

cgi-bin.component.api_query_auth.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -30,25 +31,35 @@ type CgiBinComponentApiQueryAuthResult struct {
 	Result CgiBinComponentApiQueryAuthResponse // 结果
 	Body   []byte                              // 内容
 	Http   gorequest.Response                  // 请求
-	Err    error                               // 错误
 }
 
-func NewCgiBinComponentApiQueryAuthResult(result CgiBinComponentApiQueryAuthResponse, body []byte, http gorequest.Response, err error) *CgiBinComponentApiQueryAuthResult {
-	return &CgiBinComponentApiQueryAuthResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinComponentApiQueryAuthResult(result CgiBinComponentApiQueryAuthResponse, body []byte, http gorequest.Response) *CgiBinComponentApiQueryAuthResult {
+	return &CgiBinComponentApiQueryAuthResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinComponentApiQueryAuth 使用授权码获取授权信息
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/ThirdParty/token/authorization_info.html
-func (app *App) CgiBinComponentApiQueryAuth(authorizationCode string) *CgiBinComponentApiQueryAuthResult {
+func (c *Client) CgiBinComponentApiQueryAuth(ctx context.Context, authorizationCode string) (*CgiBinComponentApiQueryAuthResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	param := NewParams()
-	param["component_appid"] = app.componentAppId   // 第三方平台 appid
-	param["authorization_code"] = authorizationCode // 授权码, 会在授权成功时返回给第三方平台
-	params := app.NewParamsWith(param)
+	param := gorequest.NewParams()
+	param["component_appid"] = c.GetComponentAppId() // 第三方平台 appid
+	param["authorization_code"] = authorizationCode  // 授权码, 会在授权成功时返回给第三方平台
+	params := gorequest.NewParamsWith(param)
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/component/api_query_auth?component_access_token=%v", app.GetComponentAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/component/api_query_auth?component_access_token=%v", c.GetComponentAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentApiQueryAuthResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentApiQueryAuthResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentApiQueryAuthResult(response, request.ResponseBody, request), nil
 }

cgi-bin.component.api_start_push_ticket.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"go.dtapp.net/gorequest"
 	"net/http"
@@ -17,25 +18,35 @@ type CgiBinComponentApiStartPushTicketResult struct {
 	Result CgiBinComponentApiStartPushTicketResponse // 结果
 	Body   []byte                                    // 内容
 	Http   gorequest.Response                        // 请求
-	Err    error                                     // 错误
 }
 
-func NewCgiBinComponentApiStartPushTicketResult(result CgiBinComponentApiStartPushTicketResponse, body []byte, http gorequest.Response, err error) *CgiBinComponentApiStartPushTicketResult {
-	return &CgiBinComponentApiStartPushTicketResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinComponentApiStartPushTicketResult(result CgiBinComponentApiStartPushTicketResponse, body []byte, http gorequest.Response) *CgiBinComponentApiStartPushTicketResult {
+	return &CgiBinComponentApiStartPushTicketResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinComponentApiStartPushTicket 启动ticket推送服务
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/ThirdParty/token/component_verify_ticket_service.html
-func (app *App) CgiBinComponentApiStartPushTicket() *CgiBinComponentApiStartPushTicketResult {
+func (c *Client) CgiBinComponentApiStartPushTicket(ctx context.Context) (*CgiBinComponentApiStartPushTicketResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	param := NewParams()
-	param["component_appid"] = app.componentAppId      // 平台型第三方平台的appid
-	param["component_secret"] = app.componentAppSecret // 平台型第三方平台的APPSECRET
-	params := app.NewParamsWith(param)
+	param := gorequest.NewParams()
+	param["component_appid"] = c.GetComponentAppId()      // 平台型第三方平台的appid
+	param["component_secret"] = c.GetComponentAppSecret() // 平台型第三方平台的APPSECRET
+	params := gorequest.NewParamsWith(param)
 	// 请求
-	request, err := app.request("https://api.weixin.qq.com/cgi-bin/component/api_start_push_ticket", params, http.MethodPost)
+	request, err := c.request(ctx, apiUrl+"/cgi-bin/component/api_start_push_ticket", params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentApiStartPushTicketResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentApiStartPushTicketResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentApiStartPushTicketResult(response, request.ResponseBody, request), nil
 }

cgi-bin.component.fastregisterweapp.create.go

@@ -0,0 +1,120 @@
+package wechatopen
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go.dtapp.net/gorequest"
+	"net/http"
+)
+
+type CgiBinComponentFastRegisterWeAppCreateResponse struct {
+	Errcode int    `json:"errcode"` // 错误码
+	Errmsg  string `json:"errmsg"`  // 错误信息
+}
+
+type CgiBinComponentFastRegisterWeAppCreateResult struct {
+	Result CgiBinComponentFastRegisterWeAppCreateResponse // 结果
+	Body   []byte                                         // 内容
+	Http   gorequest.Response                             // 请求
+}
+
+func newCgiBinComponentFastRegisterWeAppCreateResult(result CgiBinComponentFastRegisterWeAppCreateResponse, body []byte, http gorequest.Response) *CgiBinComponentFastRegisterWeAppCreateResult {
+	return &CgiBinComponentFastRegisterWeAppCreateResult{Result: result, Body: body, Http: http}
+}
+
+// CgiBinComponentFastRegisterWeAppCreate 快速注册企业小程序
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/register-management/fast-registration-ent/registerMiniprogram.html
+func (c *Client) CgiBinComponentFastRegisterWeAppCreate(ctx context.Context, notMustParams ...gorequest.Params) (*CgiBinComponentFastRegisterWeAppCreateResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	// 参数
+	params := gorequest.NewParamsWith(notMustParams...)
+	// 请求
+	request, err := c.request(ctx, apiUrl+"/cgi-bin/component/fastregisterweapp?action=create&component_access_token="+c.GetComponentAccessToken(ctx), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
+	// 定义
+	var response CgiBinComponentFastRegisterWeAppCreateResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentFastRegisterWeAppCreateResult(response, request.ResponseBody, request), nil
+}
+
+// ErrcodeInfo 错误描述
+func (resp *CgiBinComponentFastRegisterWeAppCreateResult) ErrcodeInfo() string {
+	switch resp.Result.Errcode {
+	case 89249:
+		return "该 appid 已有转正任务执行中，距上次任务 24h 后再试"
+	case 89247:
+		return "系统内部错误"
+	case 86004:
+		return "无效微信号"
+	case 61070:
+		return "法人姓名与微信号不一致"
+	case 89248:
+		return "企业代码类型无效，请选择正确类型填写"
+	case 89250:
+		return "未找到该任务"
+	case 89251:
+		return "模板消息已下发，待法人人脸核身校验"
+	case 89252:
+		return "法人&企业信息一致性校验中"
+	case 89253:
+		return "缺少参数"
+	case 89254:
+		return "第三方权限集不全，请补充权限集后重试"
+	case 89255:
+		return "code参数无效，请检查 code 长度以及内容是否正确；注意code_type的值不同需要传的 code 长度不一样"
+	}
+	return "系统繁忙"
+}
+
+// StatusInfo 状态描述
+func (resp *CgiBinComponentFastRegisterWeAppCreateResult) StatusInfo(status int) string {
+	switch status {
+	case 100001:
+		return "已下发的模板消息法人并未确认且已超时（24h），未进行身份证校验"
+	case 100002:
+		return "已下发的模板消息法人并未确认且已超时（24h），未进行人脸识别校验"
+	case 100003:
+		return "已下发的模板消息法人并未确认且已超时（24h）"
+	case 101:
+		return "工商数据返回：“企业已注销”"
+	case 102:
+		return "工商数据返回：“企业不存在或企业信息未更新”"
+	case 103:
+		return "工商数据返回：“企业法定代表人姓名不一致”"
+	case 104:
+		return "工商数据返回：“企业法定代表人身份证号码不一致”"
+	case 105:
+		return "法定代表人身份证号码，工商数据未更新，请 5-15 个工作日之后尝试"
+	case 1000:
+		return "工商数据返回：“企业信息或法定代表人信息不一致”"
+	case 1001:
+		return "主体创建小程序数量达到上限"
+	case 1002:
+		return "主体违规命中黑名单"
+	case 1003:
+		return "管理员绑定账号数量达到上限"
+	case 1004:
+		return "管理员违规命中黑名单"
+	case 1005:
+		return "管理员手机绑定账号数量达到上限"
+	case 1006:
+		return "管理员手机号违规命中黑名单"
+	case 1007:
+		return "管理员身份证创建账号数量达到上限"
+	case 1008:
+		return "管理员身份证违规命中黑名单"
+	case -1:
+		return "企业与法人姓名不一致"
+	}
+	return fmt.Sprintf("%v", status)
+}

cgi-bin.component.fastregisterweapp.search.go

@@ -0,0 +1,120 @@
+package wechatopen
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go.dtapp.net/gorequest"
+	"net/http"
+)
+
+type CgiBinComponentFastRegisterWeAppSearchResponse struct {
+	Errcode int    `json:"errcode"` // 错误码
+	Errmsg  string `json:"errmsg"`  // 错误信息
+}
+
+type CgiBinComponentFastRegisterWeAppSearchResult struct {
+	Result CgiBinComponentFastRegisterWeAppSearchResponse // 结果
+	Body   []byte                                         // 内容
+	Http   gorequest.Response                             // 请求
+}
+
+func newCgiBinComponentFastRegisterWeAppSearchResult(result CgiBinComponentFastRegisterWeAppSearchResponse, body []byte, http gorequest.Response) *CgiBinComponentFastRegisterWeAppSearchResult {
+	return &CgiBinComponentFastRegisterWeAppSearchResult{Result: result, Body: body, Http: http}
+}
+
+// CgiBinComponentFastRegisterWeAppSearch 快速注册企业小程序
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/register-management/fast-registration-ent/registerMiniprogram.html#%E4%BA%8C%E3%80%81%E6%9F%A5%E8%AF%A2%E5%88%9B%E5%BB%BA%E4%BB%BB%E5%8A%A1%E7%8A%B6%E6%80%81
+func (c *Client) CgiBinComponentFastRegisterWeAppSearch(ctx context.Context, notMustParams ...gorequest.Params) (*CgiBinComponentFastRegisterWeAppSearchResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	// 参数
+	params := gorequest.NewParamsWith(notMustParams...)
+	// 请求
+	request, err := c.request(ctx, apiUrl+"/cgi-bin/component/fastregisterweapp?action=search&component_access_token="+c.GetComponentAccessToken(ctx), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
+	// 定义
+	var response CgiBinComponentFastRegisterWeAppSearchResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentFastRegisterWeAppSearchResult(response, request.ResponseBody, request), nil
+}
+
+// ErrcodeInfo 错误描述
+func (resp *CgiBinComponentFastRegisterWeAppSearchResult) ErrcodeInfo() string {
+	switch resp.Result.Errcode {
+	case 89249:
+		return "该 appid 已有转正任务执行中，距上次任务 24h 后再试"
+	case 89247:
+		return "系统内部错误"
+	case 86004:
+		return "无效微信号"
+	case 61070:
+		return "法人姓名与微信号不一致"
+	case 89248:
+		return "企业代码类型无效，请选择正确类型填写"
+	case 89250:
+		return "未找到该任务"
+	case 89251:
+		return "模板消息已下发，待法人人脸核身校验"
+	case 89252:
+		return "法人&企业信息一致性校验中"
+	case 89253:
+		return "缺少参数"
+	case 89254:
+		return "第三方权限集不全，请补充权限集后重试"
+	case 89255:
+		return "code参数无效，请检查 code 长度以及内容是否正确；注意code_type的值不同需要传的 code 长度不一样"
+	}
+	return "系统繁忙"
+}
+
+// StatusInfo 状态描述
+func (resp *CgiBinComponentFastRegisterWeAppSearchResult) StatusInfo(status int) string {
+	switch status {
+	case 100001:
+		return "已下发的模板消息法人并未确认且已超时（24h），未进行身份证校验"
+	case 100002:
+		return "已下发的模板消息法人并未确认且已超时（24h），未进行人脸识别校验"
+	case 100003:
+		return "已下发的模板消息法人并未确认且已超时（24h）"
+	case 101:
+		return "工商数据返回：“企业已注销”"
+	case 102:
+		return "工商数据返回：“企业不存在或企业信息未更新”"
+	case 103:
+		return "工商数据返回：“企业法定代表人姓名不一致”"
+	case 104:
+		return "工商数据返回：“企业法定代表人身份证号码不一致”"
+	case 105:
+		return "法定代表人身份证号码，工商数据未更新，请 5-15 个工作日之后尝试"
+	case 1000:
+		return "工商数据返回：“企业信息或法定代表人信息不一致”"
+	case 1001:
+		return "主体创建小程序数量达到上限"
+	case 1002:
+		return "主体违规命中黑名单"
+	case 1003:
+		return "管理员绑定账号数量达到上限"
+	case 1004:
+		return "管理员违规命中黑名单"
+	case 1005:
+		return "管理员手机绑定账号数量达到上限"
+	case 1006:
+		return "管理员手机号违规命中黑名单"
+	case 1007:
+		return "管理员身份证创建账号数量达到上限"
+	case 1008:
+		return "管理员身份证违规命中黑名单"
+	case -1:
+		return "企业与法人姓名不一致"
+	}
+	return fmt.Sprintf("%v", status)
+}

cgi-bin.component.getprivacysetting.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -48,24 +49,38 @@ type CgiBinComponentGetPrivacySettingResult struct {
 	Result CgiBinComponentGetPrivacySettingResponse // 结果
 	Body   []byte                                   // 内容
 	Http   gorequest.Response                       // 请求
-	Err    error                                    // 错误
 }
 
-func NewCgiBinComponentGetPrivacySettingResult(result CgiBinComponentGetPrivacySettingResponse, body []byte, http gorequest.Response, err error) *CgiBinComponentGetPrivacySettingResult {
-	return &CgiBinComponentGetPrivacySettingResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinComponentGetPrivacySettingResult(result CgiBinComponentGetPrivacySettingResponse, body []byte, http gorequest.Response) *CgiBinComponentGetPrivacySettingResult {
+	return &CgiBinComponentGetPrivacySettingResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinComponentGetPrivacySetting 查询小程序用户隐私保护指引
 // @privacyVer 1表示现网版本，即，传1则该接口返回的内容是现网版本的；2表示开发版，即，传2则该接口返回的内容是开发版本的。默认是2。
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/privacy_config/get_privacy_setting.html
-func (app *App) CgiBinComponentGetPrivacySetting(privacyVer int) *CgiBinComponentGetPrivacySettingResult {
+func (c *Client) CgiBinComponentGetPrivacySetting(ctx context.Context, privacyVer int) (*CgiBinComponentGetPrivacySettingResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := NewParams()
+	params := gorequest.NewParams()
 	params["privacy_ver"] = privacyVer
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/component/getprivacysetting?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/component/getprivacysetting?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentGetPrivacySettingResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentGetPrivacySettingResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentGetPrivacySettingResult(response, request.ResponseBody, request), nil
 }

cgi-bin.component.setprivacysetting.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -16,24 +17,38 @@ type CgiBinComponentSetPrivacySettingResult struct {
 	Result CgiBinComponentSetPrivacySettingResponse // 结果
 	Body   []byte                                   // 内容
 	Http   gorequest.Response                       // 请求
-	Err    error                                    // 错误
 }
 
-func NewCgiBinComponentSetPrivacySettingResult(result CgiBinComponentSetPrivacySettingResponse, body []byte, http gorequest.Response, err error) *CgiBinComponentSetPrivacySettingResult {
-	return &CgiBinComponentSetPrivacySettingResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinComponentSetPrivacySettingResult(result CgiBinComponentSetPrivacySettingResponse, body []byte, http gorequest.Response) *CgiBinComponentSetPrivacySettingResult {
+	return &CgiBinComponentSetPrivacySettingResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinComponentSetPrivacySetting 配置小程序用户隐私保护指引
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/privacy_config/set_privacy_setting.html
-func (app *App) CgiBinComponentSetPrivacySetting(notMustParams ...Params) *CgiBinComponentSetPrivacySettingResult {
+func (c *Client) CgiBinComponentSetPrivacySetting(ctx context.Context, notMustParams ...gorequest.Params) (*CgiBinComponentSetPrivacySettingResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := app.NewParamsWith(notMustParams...)
+	params := gorequest.NewParamsWith(notMustParams...)
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/component/setprivacysetting?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/component/setprivacysetting?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinComponentSetPrivacySettingResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinComponentSetPrivacySettingResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinComponentSetPrivacySettingResult(response, request.ResponseBody, request), nil
 }
 
 // ErrcodeInfo 错误描述

cgi-bin.get_api_domain_ip.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -15,20 +16,27 @@ type GetCallBackIpResult struct {
 	Result GetCallBackIpResponse // 结果
 	Body   []byte                // 内容
 	Http   gorequest.Response    // 请求
-	Err    error                 // 错误
 }
 
-func NewGetCallBackIpResult(result GetCallBackIpResponse, body []byte, http gorequest.Response, err error) *GetCallBackIpResult {
-	return &GetCallBackIpResult{Result: result, Body: body, Http: http, Err: err}
+func NewGetCallBackIpResult(result GetCallBackIpResponse, body []byte, http gorequest.Response) *GetCallBackIpResult {
+	return &GetCallBackIpResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinGetApiDomainIp 获取微信服务器IP地址
 // https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_the_WeChat_server_IP_address.html
-func (app *App) CgiBinGetApiDomainIp(componentAccessToken string) *GetCallBackIpResult {
+func (c *Client) CgiBinGetApiDomainIp(ctx context.Context, componentAccessToken string) (*GetCallBackIpResult, error) {
+	// 参数
+	params := gorequest.NewParams()
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/get_api_domain_ip?access_token=%s", componentAccessToken), map[string]interface{}{}, http.MethodGet)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/get_api_domain_ip?access_token=%s", componentAccessToken), params, http.MethodGet)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response GetCallBackIpResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewGetCallBackIpResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return NewGetCallBackIpResult(response, request.ResponseBody, request), nil
 }

cgi-bin.material.get_material.go

@@ -0,0 +1,70 @@
+package wechatopen
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go.dtapp.net/gorequest"
+	"go.dtapp.net/gostorage"
+	"net/http"
+)
+
+type CgiBinMaterialGetMaterialResponse struct {
+	Errcode int    `json:"errcode"`
+	Errmsg  string `json:"errmsg"`
+}
+
+type CgiBinMaterialGetMaterialResult struct {
+	Result CgiBinMaterialGetMaterialResponse // 结果
+	Body   []byte                            // 内容
+	Http   gorequest.Response                // 请求
+}
+
+func newCgiBinMaterialGetMaterialResult(result CgiBinMaterialGetMaterialResponse, body []byte, http gorequest.Response) *CgiBinMaterialGetMaterialResult {
+	return &CgiBinMaterialGetMaterialResult{Result: result, Body: body, Http: http}
+}
+
+// CgiBinMaterialGetMaterial 获取永久素材
+// https://developers.weixin.qq.com/doc/offiaccount/Asset_Management/Getting_Permanent_Assets.html
+func (c *Client) CgiBinMaterialGetMaterial(ctx context.Context, mediaId string) (*CgiBinMaterialGetMaterialResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	// 参数
+	params := gorequest.NewParams()
+	params["media_id"] = mediaId // 要获取的素材的media_id
+	// 请求
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/material/get_material?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
+	// 定义
+	var response CgiBinMaterialGetMaterialResponse
+	// 判断内容是否为图片
+	err = json.Unmarshal(request.ResponseBody, &response)
+	if err != nil {
+		// 可能是图片
+		return newCgiBinMaterialGetMaterialResult(CgiBinMaterialGetMaterialResponse{}, request.ResponseBody, request), nil
+	}
+	return newCgiBinMaterialGetMaterialResult(response, request.ResponseBody, request), err
+}
+
+func (cr *CgiBinMaterialGetMaterialResult) SaveImg(db *gostorage.AliYun, fileName, filePath string) error {
+	if cr.Result.Errcode != 0 {
+		return errors.New(cr.Result.Errmsg)
+	}
+	// 上传
+	_, err := db.PutObject(bytes.NewReader(cr.Body), filePath, fileName)
+	if err != nil {
+		return err
+	}
+	return nil
+}

cgi-bin.open.sameentity.go

@@ -0,0 +1,48 @@
+package wechatopen
+
+import (
+	"context"
+	"encoding/json"
+	"go.dtapp.net/gorequest"
+	"net/http"
+)
+
+type CgiBinOpenSameEnTityResponse struct {
+	Errcode    int    `json:"errcode"`
+	Errmsg     string `json:"errmsg"`
+	SameEntity bool   `json:"same_entity"` // 是否同主体；true表示同主体；false表示不同主体
+}
+
+type CgiBinOpenSameEnTityResult struct {
+	Result CgiBinOpenSameEnTityResponse // 结果
+	Body   []byte                       // 内容
+	Http   gorequest.Response           // 请求
+}
+
+func newCgiBinOpenSameEnTityResult(result CgiBinOpenSameEnTityResponse, body []byte, http gorequest.Response) *CgiBinOpenSameEnTityResult {
+	return &CgiBinOpenSameEnTityResult{Result: result, Body: body, Http: http}
+}
+
+// CgiBinOpenSameEnTity 获取授权绑定的商户号列表
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/cloudbase-common/wechatpay/getWechatPayList.html
+func (c *Client) CgiBinOpenSameEnTity(ctx context.Context) (*CgiBinOpenSameEnTityResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	// 参数
+	params := gorequest.NewParams()
+	// 请求
+	request, err := c.request(ctx, apiUrl+"/cgi-bin/open/sameentity?access_token="+c.GetComponentAccessToken(ctx), params, http.MethodGet)
+	if err != nil {
+		return nil, err
+	}
+	// 定义
+	var response CgiBinOpenSameEnTityResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinOpenSameEnTityResult(response, request.ResponseBody, request), nil
+}

cgi-bin.shorturl.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -17,24 +18,35 @@ type CgiBinShortUrlResult struct {
 	Result CgiBinShortUrlResponse // 结果
 	Body   []byte                 // 内容
 	Http   gorequest.Response     // 请求
-	Err    error                  // 错误
 }
 
-func NewCgiBinShortUrlResult(result CgiBinShortUrlResponse, body []byte, http gorequest.Response, err error) *CgiBinShortUrlResult {
-	return &CgiBinShortUrlResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinShortUrlResult(result CgiBinShortUrlResponse, body []byte, http gorequest.Response) *CgiBinShortUrlResult {
+	return &CgiBinShortUrlResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinShortUrl 将二维码长链接转成短链接
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/qrcode/shorturl.html
-func (app *App) CgiBinShortUrl(longUrl string) *CgiBinShortUrlResult {
+func (c *Client) CgiBinShortUrl(ctx context.Context, longUrl string) (*CgiBinShortUrlResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := NewParams()
+	params := gorequest.NewParams()
 	params["action"] = "long2short" // 此处填long2short，代表长链接转短链接
 	params["long_url"] = longUrl    // 需要转换的长链接，支持http://、https://、weixin://wxpay 格式的url
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/shorturl?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/shorturl?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
 	// 定义
 	var response CgiBinShortUrlResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinShortUrlResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinShortUrlResult(response, request.ResponseBody, request), nil
 }

cgi-bin.wxopen.qrcodejumpadd.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -16,24 +17,38 @@ type CgiBinWxOpenQrCodeJumpAddResult struct {
 	Result CgiBinWxOpenQrCodeJumpAddResponse // 结果
 	Body   []byte                            // 内容
 	Http   gorequest.Response                // 请求
-	Err    error                             // 错误
 }
 
-func NewCgiBinWxOpenQrCodeJumpAddResult(result CgiBinWxOpenQrCodeJumpAddResponse, body []byte, http gorequest.Response, err error) *CgiBinWxOpenQrCodeJumpAddResult {
-	return &CgiBinWxOpenQrCodeJumpAddResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinWxOpenQrCodeJumpAddResult(result CgiBinWxOpenQrCodeJumpAddResponse, body []byte, http gorequest.Response) *CgiBinWxOpenQrCodeJumpAddResult {
+	return &CgiBinWxOpenQrCodeJumpAddResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinWxOpenQrCodeJumpAdd 增加或修改二维码规则
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/qrcode/qrcodejumpadd.html
-func (app *App) CgiBinWxOpenQrCodeJumpAdd(notMustParams ...Params) *CgiBinWxOpenQrCodeJumpAddResult {
+func (c *Client) CgiBinWxOpenQrCodeJumpAdd(ctx context.Context, notMustParams ...gorequest.Params) (*CgiBinWxOpenQrCodeJumpAddResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := app.NewParamsWith(notMustParams...)
+	params := gorequest.NewParamsWith(notMustParams...)
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/wxopen/qrcodejumpadd?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/wxopen/qrcodejumpadd?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinWxOpenQrCodeJumpAddResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinWxOpenQrCodeJumpAddResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinWxOpenQrCodeJumpAddResult(response, request.ResponseBody, request), nil
 }
 
 // ErrcodeInfo 错误描述

cgi-bin.wxopen.qrcodejumpdelete.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -16,23 +17,37 @@ type CgiBinWxOpenQrCodeJumpDeleteResult struct {
 	Result CgiBinWxOpenQrCodeJumpDeleteResponse // 结果
 	Body   []byte                               // 内容
 	Http   gorequest.Response                   // 请求
-	Err    error                                // 错误
 }
 
-func NewCgiBinWxOpenQrCodeJumpDeleteResult(result CgiBinWxOpenQrCodeJumpDeleteResponse, body []byte, http gorequest.Response, err error) *CgiBinWxOpenQrCodeJumpDeleteResult {
-	return &CgiBinWxOpenQrCodeJumpDeleteResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinWxOpenQrCodeJumpDeleteResult(result CgiBinWxOpenQrCodeJumpDeleteResponse, body []byte, http gorequest.Response) *CgiBinWxOpenQrCodeJumpDeleteResult {
+	return &CgiBinWxOpenQrCodeJumpDeleteResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinWxOpenQrCodeJumpDelete 删除已设置的二维码规则
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/qrcode/qrcodejumpdelete.html
-func (app *App) CgiBinWxOpenQrCodeJumpDelete(prefix string) *CgiBinWxOpenQrCodeJumpDeleteResult {
+func (c *Client) CgiBinWxOpenQrCodeJumpDelete(ctx context.Context, prefix string) (*CgiBinWxOpenQrCodeJumpDeleteResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := NewParams()
+	params := gorequest.NewParams()
 	params["prefix"] = prefix
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/wxopen/qrcodejumpdelete?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/wxopen/qrcodejumpdelete?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinWxOpenQrCodeJumpDeleteResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinWxOpenQrCodeJumpDeleteResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinWxOpenQrCodeJumpDeleteResult(response, request.ResponseBody, request), nil
 }

cgi-bin.wxopen.qrcodejumpdownloa.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -18,22 +19,36 @@ type CgiBinWxOpenQrCodeJumpDownloadResult struct {
 	Result CgiBinWxOpenQrCodeJumpDownloadResponse // 结果
 	Body   []byte                                 // 内容
 	Http   gorequest.Response                     // 请求
-	Err    error                                  // 错误
 }
 
-func NewCgiBinWxOpenQrCodeJumpDownloadResult(result CgiBinWxOpenQrCodeJumpDownloadResponse, body []byte, http gorequest.Response, err error) *CgiBinWxOpenQrCodeJumpDownloadResult {
-	return &CgiBinWxOpenQrCodeJumpDownloadResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinWxOpenQrCodeJumpDownloadResult(result CgiBinWxOpenQrCodeJumpDownloadResponse, body []byte, http gorequest.Response) *CgiBinWxOpenQrCodeJumpDownloadResult {
+	return &CgiBinWxOpenQrCodeJumpDownloadResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinWxOpenQrCodeJumpDownload 获取校验文件名称及内容
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/qrcode/qrcodejumpdownload.html
-func (app *App) CgiBinWxOpenQrCodeJumpDownload() *CgiBinWxOpenQrCodeJumpDownloadResult {
+func (c *Client) CgiBinWxOpenQrCodeJumpDownload(ctx context.Context) (*CgiBinWxOpenQrCodeJumpDownloadResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := NewParams()
+	params := gorequest.NewParams()
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/wxopen/qrcodejumpdownload?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/wxopen/qrcodejumpdownload?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinWxOpenQrCodeJumpDownloadResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinWxOpenQrCodeJumpDownloadResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinWxOpenQrCodeJumpDownloadResult(response, request.ResponseBody, request), nil
 }

cgi-bin.wxopen.qrcodejumpget.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -27,22 +28,36 @@ type CgiBinWxOpenQrCodeJumpGetResult struct {
 	Result CgiBinWxOpenQrCodeJumpGetResponse // 结果
 	Body   []byte                            // 内容
 	Http   gorequest.Response                // 请求
-	Err    error                             // 错误
 }
 
-func NewCgiBinWxOpenQrCodeJumpGetResult(result CgiBinWxOpenQrCodeJumpGetResponse, body []byte, http gorequest.Response, err error) *CgiBinWxOpenQrCodeJumpGetResult {
-	return &CgiBinWxOpenQrCodeJumpGetResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinWxOpenQrCodeJumpGetResult(result CgiBinWxOpenQrCodeJumpGetResponse, body []byte, http gorequest.Response) *CgiBinWxOpenQrCodeJumpGetResult {
+	return &CgiBinWxOpenQrCodeJumpGetResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinWxOpenQrCodeJumpGet 获取已设置的二维码规则
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/qrcode/qrcodejumpadd.html
-func (app *App) CgiBinWxOpenQrCodeJumpGet() *CgiBinWxOpenQrCodeJumpGetResult {
+func (c *Client) CgiBinWxOpenQrCodeJumpGet(ctx context.Context) (*CgiBinWxOpenQrCodeJumpGetResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := NewParams()
+	params := gorequest.NewParams()
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/wxopen/qrcodejumpget?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/wxopen/qrcodejumpget?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinWxOpenQrCodeJumpGetResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinWxOpenQrCodeJumpGetResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinWxOpenQrCodeJumpGetResult(response, request.ResponseBody, request), nil
 }

cgi-bin.wxopen.qrcodejumppublish.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"go.dtapp.net/gorequest"
@@ -16,25 +17,39 @@ type CgiBinWxOpenQrCodeJumpPublishResult struct {
 	Result CgiBinWxOpenQrCodeJumpPublishResponse // 结果
 	Body   []byte                                // 内容
 	Http   gorequest.Response                    // 请求
-	Err    error                                 // 错误
 }
 
-func NewCgiBinWxOpenQrCodeJumpPublishResult(result CgiBinWxOpenQrCodeJumpPublishResponse, body []byte, http gorequest.Response, err error) *CgiBinWxOpenQrCodeJumpPublishResult {
-	return &CgiBinWxOpenQrCodeJumpPublishResult{Result: result, Body: body, Http: http, Err: err}
+func newCgiBinWxOpenQrCodeJumpPublishResult(result CgiBinWxOpenQrCodeJumpPublishResponse, body []byte, http gorequest.Response) *CgiBinWxOpenQrCodeJumpPublishResult {
+	return &CgiBinWxOpenQrCodeJumpPublishResult{Result: result, Body: body, Http: http}
 }
 
 // CgiBinWxOpenQrCodeJumpPublish 发布已设置的二维码规则
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/qrcode/qrcodejumppublish.html
-func (app *App) CgiBinWxOpenQrCodeJumpPublish(prefix string) *CgiBinWxOpenQrCodeJumpPublishResult {
+func (c *Client) CgiBinWxOpenQrCodeJumpPublish(ctx context.Context, prefix string) (*CgiBinWxOpenQrCodeJumpPublishResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := NewParams()
+	params := gorequest.NewParams()
 	params["prefix"] = prefix
 	// 请求
-	request, err := app.request(fmt.Sprintf("https://api.weixin.qq.com/cgi-bin/wxopen/qrcodejumppublish?access_token=%s", app.GetAuthorizerAccessToken()), params, http.MethodPost)
+	request, err := c.request(ctx, fmt.Sprintf(apiUrl+"/cgi-bin/wxopen/qrcodejumppublish?access_token=%s", c.GetAuthorizerAccessToken(ctx)), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response CgiBinWxOpenQrCodeJumpPublishResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewCgiBinWxOpenQrCodeJumpPublishResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newCgiBinWxOpenQrCodeJumpPublishResult(response, request.ResponseBody, request), nil
 }
 
 // ErrcodeInfo 错误描述

check.go

@@ -0,0 +1,21 @@
+package wechatopen
+
+func (c *Client) checkComponentIsConfig() error {
+	componentAppId := c.GetComponentAppId()
+	if componentAppId == "" {
+		return componentAppIdNoConfig
+	}
+	componentAppSecret := c.GetComponentAppSecret()
+	if componentAppSecret == "" {
+		return componentAppSecretNoConfig
+	}
+	return nil
+}
+
+func (c *Client) checkAuthorizerIsConfig() error {
+	authorizerAppid := c.GetAuthorizerAppid()
+	if authorizerAppid == "" {
+		return authorizerAppidNoConfig
+	}
+	return nil
+}

client.go

@@ -0,0 +1,75 @@
+package wechatopen
+
+import (
+	"go.dtapp.net/dorm"
+	"go.dtapp.net/golog"
+	"go.dtapp.net/gorequest"
+)
+
+// 缓存前缀
+// wechat_open:component_verify_ticket:
+// wechat_open:component_access_token:
+// wechat_open:authorizer_access_token:
+// wechat_open:pre_auth_code:
+type redisCachePrefixFun func() (componentVerifyTicket, componentAccessToken, authorizerAccessToken, preAuthCode string)
+
+// ClientConfig 实例配置
+type ClientConfig struct {
+	AuthorizerAppid     string // 授权方 appid
+	ComponentAppId      string // 第三方平台 appid
+	ComponentAppSecret  string // 第三方平台 app_secret
+	MessageToken        string
+	MessageKey          string
+	RedisClient         *dorm.RedisClient   // 缓存数据库
+	RedisCachePrefixFun redisCachePrefixFun // 缓存前缀
+}
+
+// Client 实例
+type Client struct {
+	requestClient *gorequest.App // 请求服务
+	config        struct {
+		componentAccessToken   string // 第三方平台 access_token
+		componentVerifyTicket  string // 微信后台推送的 ticket
+		preAuthCode            string // 预授权码
+		authorizerAccessToken  string // 接口调用令牌
+		authorizerRefreshToken string // 刷新令牌
+		authorizerAppid        string // 授权方 appid
+		componentAppId         string // 第三方平台appid
+		componentAppSecret     string // 第三方平台app_secret
+		messageToken           string
+		messageKey             string
+	}
+	cache struct {
+		redisClient                 *dorm.RedisClient // 缓存数据库
+		componentVerifyTicketPrefix string
+		componentAccessTokenPrefix  string
+		authorizerAccessTokenPrefix string
+		preAuthCodePrefix           string
+	}
+	log struct {
+		status bool             // 状态
+		client *golog.ApiClient // 日志服务
+	}
+}
+
+// NewClient 创建实例化
+func NewClient(config *ClientConfig) (*Client, error) {
+
+	c := &Client{}
+
+	c.config.componentAppId = config.ComponentAppId
+	c.config.componentAppSecret = config.ComponentAppSecret
+	c.config.messageToken = config.MessageToken
+	c.config.messageKey = config.MessageKey
+
+	c.requestClient = gorequest.NewHttp()
+
+	c.cache.redisClient = config.RedisClient
+
+	c.cache.componentVerifyTicketPrefix, c.cache.componentAccessTokenPrefix, c.cache.authorizerAccessTokenPrefix, c.cache.preAuthCodePrefix = config.RedisCachePrefixFun()
+	if c.cache.componentVerifyTicketPrefix == "" || c.cache.componentAccessTokenPrefix == "" || c.cache.authorizerAccessTokenPrefix == "" || c.cache.preAuthCodePrefix == "" {
+		return nil, redisCachePrefixNoConfig
+	}
+
+	return c, nil
+}

config.go

@@ -0,0 +1,25 @@
+package wechatopen
+
+import "go.dtapp.net/golog"
+
+// ConfigComponent 配置
+func (c *Client) ConfigComponent(componentAppId, componentAppSecret string) *Client {
+	c.config.componentAppId = componentAppId
+	c.config.componentAppSecret = componentAppSecret
+	return c
+}
+
+// ConfigAuthorizer 配置第三方
+func (c *Client) ConfigAuthorizer(authorizerAppid string) *Client {
+	c.config.authorizerAppid = authorizerAppid
+	return c
+}
+
+// ConfigApiClientFun 日志配置
+func (c *Client) ConfigApiClientFun(apiClientFun golog.ApiClientFun) {
+	apiClient := apiClientFun()
+	if apiClient != nil {
+		c.log.client = apiClient
+		c.log.status = true
+	}
+}

const.go

@@ -0,0 +1,10 @@
+package wechatopen
+
+const (
+	apiUrl = "https://api.weixin.qq.com"
+)
+
+const (
+	LogTable = "wechatopen"
+	Version  = "1.0.44"
+)

error.go

@@ -0,0 +1,16 @@
+package wechatopen
+
+import "errors"
+
+var (
+	redisCachePrefixNoConfig = errors.New("请配置 RedisCachePrefix")
+)
+
+var (
+	componentAppIdNoConfig     = errors.New("请配置 ComponentAppId")
+	componentAppSecretNoConfig = errors.New("请配置 ComponentAppSecret")
+)
+
+var (
+	authorizerAppidNoConfig = errors.New("请配置 AuthorizerAppid 或 ConfigAuthorizer")
+)

get.go

@@ -1,5 +1,47 @@
 package wechatopen
 
-func (app *App) GetComponentAppId() string {
-	return app.componentAppId
+import "go.dtapp.net/golog"
+
+//func (c *Client) GetComponentAccessToken() string {
+//	return c.config.componentAccessToken
+//}
+
+//func (c *Client) GetComponentVerifyTicket() string {
+//	return c.config.componentVerifyTicket
+//}
+
+//func (c *Client) GetPreAuthCode() string {
+//	return c.config.preAuthCode
+//}
+
+//func (c *Client) GetAuthorizerAccessToken() string {
+//	return c.config.authorizerAccessToken
+//}
+
+func (c *Client) GetAuthorizerRefreshToken() string {
+	return c.config.authorizerRefreshToken
+}
+
+func (c *Client) GetAuthorizerAppid() string {
+	return c.config.authorizerAppid
+}
+
+func (c *Client) GetComponentAppId() string {
+	return c.config.componentAppId
+}
+
+func (c *Client) GetComponentAppSecret() string {
+	return c.config.componentAppSecret
+}
+
+func (c *Client) GetMessageToken() string {
+	return c.config.messageToken
+}
+
+func (c *Client) GetMessageKey() string {
+	return c.config.messageKey
+}
+
+func (c *Client) GetLog() *golog.ApiClient {
+	return c.log.client
 }

go.mod

@@ -1,37 +1,129 @@
 module go.dtapp.net/wechatopen
 
-go 1.18
+go 1.19
 
 require (
+	github.com/gin-gonic/gin v1.8.1
 	github.com/mitchellh/mapstructure v1.5.0
-	go.dtapp.net/gojson v1.0.0
-	go.dtapp.net/golog v1.0.14
-	go.dtapp.net/goredis v1.0.1
-	go.dtapp.net/gorequest v1.0.20
-	gorm.io/datatypes v1.0.6
-	gorm.io/gorm v1.23.6
+	go.dtapp.net/dorm v1.0.54
+	go.dtapp.net/golog v1.0.102
+	go.dtapp.net/gorequest v1.0.38
+	go.dtapp.net/gostorage v1.0.13
 )
 
 require (
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/aliyun/aliyun-oss-go-sdk v2.2.6+incompatible // indirect
+	github.com/aws/aws-sdk-go v1.44.153 // indirect
+	github.com/aws/aws-sdk-go-v2 v1.17.2 // indirect
+	github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 // indirect
+	github.com/aws/aws-sdk-go-v2/config v1.18.4 // indirect
+	github.com/aws/aws-sdk-go-v2/credentials v1.13.4 // indirect
+	github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.12.20 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.26 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.20 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/ini v1.3.27 // indirect
+	github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.17 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.21 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.20 // indirect
+	github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.13.20 // indirect
+	github.com/aws/aws-sdk-go-v2/service/s3 v1.29.5 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sso v1.11.26 // indirect
+	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.13.9 // indirect
+	github.com/aws/aws-sdk-go-v2/service/sts v1.17.6 // indirect
+	github.com/aws/smithy-go v1.13.5 // indirect
+	github.com/baidubce/bce-sdk-go v0.9.138 // indirect
+	github.com/basgys/goxml2json v1.1.0 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/clbanning/mxj v1.8.4 // indirect
+	github.com/deckarep/golang-set v1.8.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/go-redis/redis/v8 v8.11.5 // indirect
-	github.com/go-sql-driver/mysql v1.6.0 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-playground/locales v0.14.0 // indirect
+	github.com/go-playground/universal-translator v0.18.0 // indirect
+	github.com/go-playground/validator/v10 v10.11.1 // indirect
+	github.com/go-redis/redis/v9 v9.0.0-rc.2 // indirect
+	github.com/go-sql-driver/mysql v1.7.0 // indirect
+	github.com/goccy/go-json v0.10.0 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/huaweicloud/huaweicloud-sdk-go-obs v3.22.11+incompatible // indirect
+	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
+	github.com/jackc/pgconn v1.13.0 // indirect
+	github.com/jackc/pgio v1.0.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgproto3/v2 v2.3.1 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b // indirect
+	github.com/jackc/pgtype v1.13.0 // indirect
+	github.com/jackc/pgx/v4 v4.17.2 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/jmespath/go-jmespath v0.4.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.15.12 // indirect
+	github.com/ks3sdklib/aws-sdk-go v1.1.8 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/lib/pq v1.10.7 // indirect
+	github.com/mattn/go-isatty v0.0.16 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/montanaflynn/stats v0.6.6 // indirect
+	github.com/mozillazg/go-httpheader v0.3.1 // indirect
 	github.com/natefinch/lumberjack v2.0.0+incompatible // indirect
+	github.com/oschwald/geoip2-golang v1.8.0 // indirect
+	github.com/oschwald/maxminddb-golang v1.10.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.6 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/qiniu/go-sdk/v7 v7.14.0 // indirect
 	github.com/saracen/go7z v0.0.0-20191010121135-9c09b6bd7fda // indirect
 	github.com/saracen/solidblock v0.0.0-20190426153529-45df20abab6f // indirect
+	github.com/segmentio/fasthash v1.0.3 // indirect
+	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
+	github.com/sirupsen/logrus v1.9.0 // indirect
+	github.com/syndtr/goleveldb v1.0.0 // indirect
+	github.com/tencentyun/cos-go-sdk-v5 v0.7.40 // indirect
+	github.com/tklauser/go-sysconf v0.3.11 // indirect
+	github.com/tklauser/numcpus v0.6.0 // indirect
+	github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc // indirect
+	github.com/ugorji/go/codec v1.2.7 // indirect
 	github.com/ulikunitz/xz v0.5.10 // indirect
-	go.dtapp.net/goip v1.0.18 // indirect
-	go.dtapp.net/gostring v1.0.3 // indirect
-	go.dtapp.net/gotime v1.0.2 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
+	github.com/upper/db/v4 v4.6.0 // indirect
+	github.com/uptrace/bun v1.1.9 // indirect
+	github.com/uptrace/bun/dialect/mysqldialect v1.1.9 // indirect
+	github.com/uptrace/bun/dialect/pgdialect v1.1.9 // indirect
+	github.com/uptrace/bun/driver/pgdriver v1.1.9 // indirect
+	github.com/upyun/go-sdk/v3 v3.0.3 // indirect
+	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
+	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
+	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
+	github.com/xdg-go/scram v1.1.1 // indirect
+	github.com/xdg-go/stringprep v1.0.3 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20201027041543-1326539a0a0a // indirect
+	github.com/yusufpapurcu/wmi v1.2.2 // indirect
+	go.dtapp.net/goip v1.0.40 // indirect
+	go.dtapp.net/gorandom v1.0.1 // indirect
+	go.dtapp.net/gostring v1.0.10 // indirect
+	go.dtapp.net/gotime v1.0.5 // indirect
+	go.dtapp.net/gotrace_id v1.0.6 // indirect
+	go.dtapp.net/gourl v1.0.0 // indirect
+	go.mongodb.org/mongo-driver v1.11.0 // indirect
+	go.uber.org/atomic v1.10.0 // indirect
 	go.uber.org/multierr v1.8.0 // indirect
-	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
-	golang.org/x/net v0.0.0-20220607020251-c690dde0001d // indirect
-	golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d // indirect
-	golang.org/x/text v0.3.7 // indirect
-	gorm.io/driver/mysql v1.3.4 // indirect
+	go.uber.org/zap v1.24.0 // indirect
+	golang.org/x/crypto v0.3.0 // indirect
+	golang.org/x/mod v0.7.0 // indirect
+	golang.org/x/net v0.3.0 // indirect
+	golang.org/x/sync v0.1.0 // indirect
+	golang.org/x/sys v0.3.0 // indirect
+	golang.org/x/text v0.5.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gorm.io/driver/mysql v1.4.4 // indirect
+	gorm.io/driver/postgres v1.4.5 // indirect
+	gorm.io/gorm v1.24.2 // indirect
+	mellium.im/sasl v0.3.0 // indirect
+	xorm.io/builder v0.3.12 // indirect
+	xorm.io/xorm v1.3.2 // indirect
 )

params.go

@@ -1,27 +0,0 @@
-package wechatopen
-
-// Params 请求参数
-type Params map[string]interface{}
-
-func NewParams() Params {
-	p := make(Params)
-	return p
-}
-
-func (app *App) NewParamsWith(params ...Params) Params {
-	p := make(Params)
-	for _, v := range params {
-		p.SetParams(v)
-	}
-	return p
-}
-
-func (p Params) Set(key string, value interface{}) {
-	p[key] = value
-}
-
-func (p Params) SetParams(params Params) {
-	for key, value := range params {
-		p[key] = value
-	}
-}

pgsql.go

@@ -1,26 +0,0 @@
-package wechatopen
-
-import (
-	"go.dtapp.net/gojson"
-	"go.dtapp.net/golog"
-	"go.dtapp.net/gorequest"
-	"gorm.io/datatypes"
-)
-
-// 记录日志
-func (app *App) postgresqlLog(request gorequest.Response) {
-	app.log.Record(golog.ApiPostgresqlLog{
-		RequestTime:           golog.TimeString{Time: request.RequestTime},                      //【请求】时间
-		RequestUri:            request.RequestUri,                                               //【请求】链接
-		RequestUrl:            gorequest.UriParse(request.RequestUri).Url,                       //【请求】链接
-		RequestApi:            gorequest.UriParse(request.RequestUri).Path,                      //【请求】接口
-		RequestMethod:         request.RequestMethod,                                            //【请求】方式
-		RequestParams:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestParams)),  //【请求】参数
-		RequestHeader:         datatypes.JSON(gojson.JsonEncodeNoError(request.RequestHeader)),  //【返回】头部
-		ResponseHeader:        datatypes.JSON(gojson.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
-		ResponseStatusCode:    request.ResponseStatusCode,                                       //【返回】状态码
-		ResponseBody:          request.ResponseBody,                                             //【返回】内容
-		ResponseContentLength: request.ResponseContentLength,                                    //【返回】大小
-		ResponseTime:          golog.TimeString{Time: request.ResponseTime},                     //【返回】时间
-	})
-}

redis.go

@@ -2,140 +2,145 @@ package wechatopen
 
 import (
 	"context"
-	"fmt"
 	"time"
 )
 
 // 微信后台推送的ticke
-func (app *App) getComponentVerifyTicketCacheKeyName() string {
-	return fmt.Sprintf("wechat_open:component_verify_ticket:%v", app.componentAppId)
+func (c *Client) getComponentVerifyTicketCacheKeyName() string {
+	return c.cache.componentVerifyTicketPrefix + c.GetComponentAppId()
 }
 
 // SetComponentVerifyTicket 设置微信后台推送的ticke
-func (app *App) SetComponentVerifyTicket(componentVerifyTicket string) string {
+func (c *Client) SetComponentVerifyTicket(ctx context.Context, componentVerifyTicket string) string {
 	if componentVerifyTicket == "" {
 		return ""
 	}
-	app.redis.Db.Set(context.Background(), app.getComponentVerifyTicketCacheKeyName(), componentVerifyTicket, time.Hour*12)
-	return app.GetComponentVerifyTicket()
+	c.cache.redisClient.Set(ctx, c.getComponentVerifyTicketCacheKeyName(), componentVerifyTicket, time.Hour*12)
+	return c.GetComponentVerifyTicket(ctx)
 }
 
 // GetComponentVerifyTicket 获取微信后台推送的ticke
-func (app *App) GetComponentVerifyTicket() string {
-	if app.redis.Db == nil {
-		return app.componentVerifyTicket
+func (c *Client) GetComponentVerifyTicket(ctx context.Context) string {
+	if c.cache.redisClient.Db == nil {
+		return c.config.componentVerifyTicket
 	}
-	result, _ := app.redis.Db.Get(context.Background(), app.getComponentVerifyTicketCacheKeyName()).Result()
+	result, _ := c.cache.redisClient.Get(ctx, c.getComponentVerifyTicketCacheKeyName()).Result()
 	return result
 }
 
 // 令牌
-func (app *App) getComponentAccessTokenCacheKeyName() string {
-	return fmt.Sprintf("wechat_open:component_access_token:%v", app.componentAppId)
+func (c *Client) getComponentAccessTokenCacheKeyName() string {
+	return c.cache.componentAccessTokenPrefix + c.GetComponentAppId()
 }
 
 // SetComponentAccessToken 设置令牌
-func (app *App) SetComponentAccessToken(componentAccessToken string) string {
+func (c *Client) SetComponentAccessToken(ctx context.Context, componentAccessToken string) string {
 	if componentAccessToken == "" {
 		return ""
 	}
-	app.redis.Db.Set(context.Background(), app.getComponentAccessTokenCacheKeyName(), componentAccessToken, time.Second*7200)
-	return app.GetComponentAccessToken()
+	c.cache.redisClient.Set(ctx, c.getComponentAccessTokenCacheKeyName(), componentAccessToken, time.Second*7200)
+	return c.GetComponentAccessToken(ctx)
 }
 
 // GetComponentAccessToken 获取令牌
-func (app *App) GetComponentAccessToken() string {
-	if app.redis.Db == nil {
-		return app.componentAccessToken
+func (c *Client) GetComponentAccessToken(ctx context.Context) string {
+	if c.cache.redisClient.Db == nil {
+		return c.config.componentAccessToken
 	}
-	result, _ := app.redis.Db.Get(context.Background(), app.getComponentAccessTokenCacheKeyName()).Result()
+	result, _ := c.cache.redisClient.Db.Get(ctx, c.getComponentAccessTokenCacheKeyName()).Result()
 	return result
 }
 
 // MonitorComponentAccessToken 监控令牌
-func (app *App) MonitorComponentAccessToken() string {
+func (c *Client) MonitorComponentAccessToken(ctx context.Context) (string, error) {
 	// 查询
-	componentAccessToken := app.GetComponentAccessToken()
+	componentAccessToken := c.GetComponentAccessToken(ctx)
 	// 判断
-	result := app.CgiBinGetApiDomainIp(componentAccessToken)
+	result, err := c.CgiBinGetApiDomainIp(ctx, componentAccessToken)
+	if err != nil {
+		return "", err
+	}
 	if len(result.Result.IpList) > 0 {
-		return componentAccessToken
+		return componentAccessToken, err
 	}
 	// 重新获取
-	return app.SetComponentAccessToken(app.CgiBinComponentApiComponentToken().Result.ComponentAccessToken)
+	resp, err := c.CgiBinComponentApiComponentToken(ctx)
+	return c.SetComponentAccessToken(ctx, resp.Result.ComponentAccessToken), err
 }
 
 // 授权方令牌
-func (app *App) getAuthorizerAccessTokenCacheKeyName() string {
-	return fmt.Sprintf("wechat_open:authorizer_access_token:%v:%v", app.componentAppId, app.authorizerAppid)
+func (c *Client) getAuthorizerAccessTokenCacheKeyName() string {
+	return c.cache.authorizerAccessTokenPrefix + c.GetComponentAppId() + ":" + c.GetAuthorizerAppid()
 }
 
 // SetAuthorizerAccessToken 设置授权方令牌
-func (app *App) SetAuthorizerAccessToken(authorizerAccessToken string) string {
+func (c *Client) SetAuthorizerAccessToken(ctx context.Context, authorizerAccessToken string) string {
 	if authorizerAccessToken == "" {
 		return ""
 	}
-	app.redis.Db.Set(context.Background(), app.getAuthorizerAccessTokenCacheKeyName(), authorizerAccessToken, time.Hour*2)
-	return app.GetComponentAccessToken()
+	c.cache.redisClient.Set(ctx, c.getAuthorizerAccessTokenCacheKeyName(), authorizerAccessToken, time.Hour*2)
+	return c.GetComponentAccessToken(ctx)
 }
 
 // GetAuthorizerAccessToken 获取授权方令牌
-func (app *App) GetAuthorizerAccessToken() string {
-	if app.redis.Db == nil {
-		return app.authorizerAccessToken
+func (c *Client) GetAuthorizerAccessToken(ctx context.Context) string {
+	if c.cache.redisClient.Db == nil {
+		return c.config.authorizerAccessToken
 	}
-	result, _ := app.redis.Db.Get(context.Background(), app.getAuthorizerAccessTokenCacheKeyName()).Result()
+	result, _ := c.cache.redisClient.Get(ctx, c.getAuthorizerAccessTokenCacheKeyName()).Result()
 	return result
 }
 
 // MonitorAuthorizerAccessToken 监控授权方令牌
-func (app *App) MonitorAuthorizerAccessToken(authorizerRefreshToken string) string {
+func (c *Client) MonitorAuthorizerAccessToken(ctx context.Context, authorizerRefreshToken string) (string, error) {
 	// 查询
-	authorizerAccessToken := app.GetAuthorizerAccessToken()
+	authorizerAccessToken := c.GetAuthorizerAccessToken(ctx)
 	// 判断
 	if authorizerAccessToken != "" {
-		return authorizerAccessToken
+		return authorizerAccessToken, nil
 	}
 	// 重新获取
-	return app.SetAuthorizerAccessToken(app.CgiBinComponentApiAuthorizerToken(authorizerRefreshToken).Result.AuthorizerAccessToken)
+	resp, err := c.CgiBinComponentApiAuthorizerToken(ctx, authorizerRefreshToken)
+	return c.SetAuthorizerAccessToken(ctx, resp.Result.AuthorizerAccessToken), err
 }
 
 // 预授权码
-func (app *App) getPreAuthCodeCacheKeyName() string {
-	return fmt.Sprintf("wechat_open:pre_auth_code:%v", app.componentAppId)
+func (c *Client) getPreAuthCodeCacheKeyName() string {
+	return c.cache.preAuthCodePrefix + c.GetComponentAppId()
 }
 
 // SetPreAuthCode 设置预授权码
-func (app *App) SetPreAuthCode(preAuthCode string) string {
+func (c *Client) SetPreAuthCode(ctx context.Context, preAuthCode string) string {
 	if preAuthCode == "" {
 		return ""
 	}
-	app.redis.Db.Set(context.Background(), app.getPreAuthCodeCacheKeyName(), preAuthCode, time.Second*1700)
-	return app.GetComponentAccessToken()
+	c.cache.redisClient.Set(ctx, c.getPreAuthCodeCacheKeyName(), preAuthCode, time.Second*1700)
+	return c.GetComponentAccessToken(ctx)
 }
 
 // GetPreAuthCode 获取预授权码
-func (app *App) GetPreAuthCode() string {
-	if app.redis.Db == nil {
-		return app.authorizerAccessToken
+func (c *Client) GetPreAuthCode(ctx context.Context) string {
+	if c.cache.redisClient.Db == nil {
+		return c.config.authorizerAccessToken
 	}
-	result, _ := app.redis.Db.Get(context.Background(), app.getPreAuthCodeCacheKeyName()).Result()
+	result, _ := c.cache.redisClient.Get(ctx, c.getPreAuthCodeCacheKeyName()).Result()
 	return result
 }
 
 // DelPreAuthCode 删除预授权码
-func (app *App) DelPreAuthCode() error {
-	return app.redis.Db.Del(context.Background(), app.getPreAuthCodeCacheKeyName()).Err()
+func (c *Client) DelPreAuthCode(ctx context.Context) error {
+	return c.cache.redisClient.Del(ctx, c.getPreAuthCodeCacheKeyName()).Err()
 }
 
 // MonitorPreAuthCode 监控预授权码
-func (app *App) MonitorPreAuthCode() string {
+func (c *Client) MonitorPreAuthCode(ctx context.Context) (string, error) {
 	// 查询
-	preAuthCode := app.GetPreAuthCode()
+	preAuthCode := c.GetPreAuthCode(ctx)
 	// 判断
 	if preAuthCode != "" {
-		return preAuthCode
+		return preAuthCode, nil
 	}
 	// 重新获取
-	return app.SetPreAuthCode(app.CgiBinComponentApiCreatePreAuthCoden().Result.PreAuthCode)
+	resp, err := c.CgiBinComponentApiCreatePreAuthCoden(ctx)
+	return c.SetPreAuthCode(ctx, resp.Result.PreAuthCode), err
 }

request.go

@@ -0,0 +1,40 @@
+package wechatopen
+
+import (
+	"context"
+	"go.dtapp.net/gorequest"
+)
+
+func (c *Client) request(ctx context.Context, url string, params map[string]interface{}, method string) (resp gorequest.Response, err error) {
+
+	// 创建请求
+	client := c.requestClient
+
+	// 设置请求地址
+	client.SetUri(url)
+
+	// 设置方式
+	client.SetMethod(method)
+
+	// 设置格式
+	client.SetContentTypeJson()
+
+	// 设置用户代理
+	client.SetUserAgent(gorequest.GetRandomUserAgentSystem())
+
+	// 设置参数
+	client.SetParams(params)
+
+	// 发起请求
+	request, err := client.Request(ctx)
+	if err != nil {
+		return gorequest.Response{}, err
+	}
+
+	// 记录日志
+	if c.log.status {
+		go c.log.client.Middleware(ctx, request, Version)
+	}
+
+	return request, err
+}

save_img.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"go.dtapp.net/gorequest"
 	"log"
 	"os"
@@ -11,7 +12,7 @@ type SaveImgResponse struct {
 	Name string
 }
 
-func (app *App) SaveImg(resp gorequest.Response, dir, saveName string) SaveImgResponse {
+func (c *Client) SaveImg(ctx context.Context, resp gorequest.Response, dir, saveName string) SaveImgResponse {
 	// 返回是二进制图片，或者json错误
 	if resp.ResponseHeader.Get("Content-Type") == "image/jpeg" || resp.ResponseHeader.Get("Content-Type") == "image/png" {
 		// 保存在output目录

service_http.authorizer_appid.go

@@ -1,13 +1,13 @@
 package wechatopen
 
 import (
+	"context"
 	"errors"
 	"net/http"
-	"strconv"
 )
 
 // ServeHttpAuthorizerAppid 授权跳转
-func (app *App) ServeHttpAuthorizerAppid(r *http.Request) (resp CgiBinComponentApiQueryAuthResponse, agentUserId string, err error) {
+func (c *Client) ServeHttpAuthorizerAppid(ctx context.Context, r *http.Request) (resp CgiBinComponentApiQueryAuthResponse, agentUserId string, err error) {
 	var (
 		query = r.URL.Query()
 
@@ -25,34 +25,13 @@ func (app *App) ServeHttpAuthorizerAppid(r *http.Request) (resp CgiBinComponentA
 		return resp, agentUserId, errors.New("找不到过期时间参数")
 	}
 
-	info := app.CgiBinComponentApiQueryAuth(authCode)
+	info, err := c.CgiBinComponentApiQueryAuth(ctx, authCode)
+	if err != nil {
+		return resp, agentUserId, err
+	}
 	if info.Result.AuthorizationInfo.AuthorizerAppid == "" {
 		return resp, agentUserId, errors.New("获取失败")
 	}
 
 	return info.Result, agentUserId, nil
 }
-
-// ToFloat64 string到float64
-func ToFloat64(s string) float64 {
-	i, _ := strconv.ParseFloat(s, 64)
-	return i
-}
-
-// ToInt64 string到int64
-func ToInt64(s string) int64 {
-	i, err := strconv.ParseInt(s, 10, 64)
-	if err == nil {
-		return i
-	}
-	return int64(ToFloat64(s))
-}
-
-// ToUint string到uint64
-func ToUint(s string) uint {
-	i, err := strconv.ParseUint(s, 10, 64)
-	if err == nil {
-		return uint(i)
-	}
-	return 0
-}

service_http.gin.go

@@ -0,0 +1,41 @@
+package wechatopen
+
+import (
+	"context"
+	"github.com/gin-gonic/gin"
+)
+
+// ResponseServeHttpGin 推送信息
+type ResponseServeHttpGin struct {
+	MsgSignature string // 签名串，对应 URL 参数的msg_signature
+	Timestamp    string // 时间戳，对应 URL 参数的timestamp
+	Nonce        string // 随机串，对应 URL 参数的nonce
+	Signature    string
+	EncryptType  string // 加密类型
+	AppId        string // 第三方平台 appid
+	Encrypt      string // 加密内容
+}
+
+// ServeHttpGin 验证票据推送
+func (c *Client) ServeHttpGin(ctx context.Context, ginCtx *gin.Context) (ResponseServeHttpGin, error) {
+
+	query := ginCtx.Request.URL.Query()
+
+	// 声明接收的变量
+	var validateJson struct {
+		AppId   string `form:"AppId" json:"AppId" xml:"AppId" uri:"AppId" binding:"omitempty"`         // 第三方平台 appid
+		Encrypt string `form:"Encrypt" json:"Encrypt" xml:"Encrypt" uri:"Encrypt" binding:"omitempty"` // 加密内容
+	}
+
+	err := ginCtx.ShouldBind(&validateJson)
+
+	return ResponseServeHttpGin{
+		MsgSignature: query.Get("msg_signature"),
+		Timestamp:    query.Get("timestamp"),
+		Nonce:        query.Get("nonce"),
+		Signature:    query.Get("signature"),
+		EncryptType:  query.Get("encrypt_type"),
+		AppId:        validateJson.AppId,
+		Encrypt:      validateJson.Encrypt,
+	}, err
+}

service_http.verify_ticket.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"encoding/base64"
 	"encoding/xml"
 	"errors"
@@ -26,7 +27,7 @@ type cipherRequestHttpBody struct {
 }
 
 // ServeHttpVerifyTicket 验证票据推送
-func (app *App) ServeHttpVerifyTicket(r *http.Request) (resp *ResponseServeHttpVerifyTicket, err error) {
+func (c *Client) ServeHttpVerifyTicket(ctx context.Context, r *http.Request) (resp *ResponseServeHttpVerifyTicket, err error) {
 	var (
 		query = r.URL.Query()
 
@@ -57,7 +58,7 @@ func (app *App) ServeHttpVerifyTicket(r *http.Request) (resp *ResponseServeHttpV
 		return resp, errors.New("未找到随机数参数")
 	}
 
-	wantSignature = Sign(app.messageToken, timestamp, nonce)
+	wantSignature = Sign(c.GetMessageToken(), timestamp, nonce)
 	if haveSignature != wantSignature {
 		return resp, errors.New("签名错误")
 	}
@@ -96,7 +97,7 @@ func (app *App) ServeHttpVerifyTicket(r *http.Request) (resp *ResponseServeHttpV
 		return resp, errors.New(fmt.Sprintf("Encrypt 解码字符串错误：%v", err))
 	}
 
-	AesKey, err := base64.StdEncoding.DecodeString(app.messageKey + "=")
+	AesKey, err := base64.StdEncoding.DecodeString(c.GetMessageKey() + "=")
 	if err != nil {
 		return resp, errors.New(fmt.Sprintf("messageKey 解码字符串错误：%v", err))
 	}

set.go

@@ -1,7 +0,0 @@
-package wechatopen
-
-// SetAuthorizerAppid 设置代理商小程序
-func (app *App) SetAuthorizerAppid(authorizerAppid string) {
-	app.authorizerAppid = authorizerAppid
-	return
-}

sign.decrypt.go

@@ -0,0 +1,82 @@
+package wechatopen
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// SignDecrypt 解密
+// ctx 上下文
+// params 入参
+// strXml 反射结构体
+// resp 加密数据
+// err 错误信息
+func (c *Client) SignDecrypt(ctx context.Context, params SignDecryptParams, strXml interface{}) (resp []byte, err error) {
+
+	if params.Signature == "" {
+		return nil, errors.New("找不到签名参数")
+	}
+
+	if params.Timestamp == "" {
+		return nil, errors.New("找不到时间戳参数")
+	}
+
+	if params.Nonce == "" {
+		return nil, errors.New("未找到随机数参数")
+	}
+
+	wantSignature := Sign(c.GetMessageToken(), params.Timestamp, params.Nonce)
+	if params.Signature != wantSignature {
+		return nil, errors.New("签名错误")
+	}
+
+	// 进入事件执行
+	if params.EncryptType != "aes" {
+		return nil, errors.New("未知的加密类型: " + params.EncryptType)
+	}
+	if params.Encrypt == "" {
+		return nil, errors.New("找不到签名参数")
+	}
+
+	cipherData, err := base64.StdEncoding.DecodeString(params.Encrypt)
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("Encrypt 解码字符串错误：%v", err))
+	}
+
+	AesKey, err := base64.StdEncoding.DecodeString(c.GetMessageKey() + "=")
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("messageKey 解码字符串错误：%v", err))
+	}
+
+	msg, err := AesDecrypt(cipherData, AesKey)
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("AES解密错误：%v", err))
+	}
+
+	str := string(msg)
+
+	left := strings.Index(str, "<xml>")
+	if left <= 0 {
+		return nil, errors.New(fmt.Sprintf("匹配不到<xml>：%v", left))
+	}
+	right := strings.Index(str, "</xml>")
+	if right <= 0 {
+		return nil, errors.New(fmt.Sprintf("匹配不到</xml>：%v", right))
+	}
+	msgStr := str[left:right]
+	if len(msgStr) == 0 {
+		return nil, errors.New(fmt.Sprintf("提取错误：%v", msgStr))
+	}
+
+	strByte := []byte(msgStr + "</xml>")
+	err = xml.Unmarshal(strByte, strXml)
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("解析错误：%v", err))
+	}
+
+	return strByte, nil
+}

sign.decrypt.params.go

@@ -0,0 +1,12 @@
+package wechatopen
+
+// SignDecryptParams 入参
+type SignDecryptParams struct {
+	Signature    string // 签名串，对应 URL 参数的msg_signature
+	Timestamp    string // 时间戳，对应 URL 参数的timestamp
+	Nonce        string // 随机串，对应 URL 参数的nonce
+	EncryptType  string // 加密类型
+	MsgSignature string
+	AppId        string // 第三方平台 appid
+	Encrypt      string // 加密内容
+}

sign.decrypt.response.go

@@ -0,0 +1,129 @@
+package wechatopen
+
+import "encoding/xml"
+
+// SignDecryptComponentVerifyTicket 验证票据
+// https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/Before_Develop/component_verify_ticket.html
+type SignDecryptComponentVerifyTicket struct {
+	XMLName               xml.Name
+	AppId                 string `xml:"appId,omitempty"`                 // 第三方平台 appid
+	CreateTime            int64  `xml:"CreateTime,omitempty"`            // 时间戳，单位：s
+	InfoType              string `xml:"InfoType,omitempty"`              // 固定为："component_verify_ticket"
+	ComponentVerifyTicket string `xml:"ComponentVerifyTicket,omitempty"` // Ticket 内容
+}
+
+// SignDecryptAuthorizeEvent 授权变更通知推送
+// https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/Before_Develop/authorize_event.html
+type SignDecryptAuthorizeEvent struct {
+	XMLName                      xml.Name
+	AppId                        string `xml:"appId,omitempty"`                        // 第三方平台 appid
+	CreateTime                   int64  `xml:"CreateTime,omitempty"`                   // 时间戳，单位：s
+	InfoType                     string `xml:"InfoType,omitempty"`                     // 通知类型 unauthorized=取消授权 updateauthorized=更新授权 authorized=授权成功
+	AuthorizerAppid              string `xml:"AuthorizerAppid,omitempty"`              // 公众号或小程序的 appid
+	AuthorizationCode            string `xml:"AuthorizationCode,omitempty"`            // 授权码，可用于获取授权信息
+	AuthorizationCodeExpiredTime string `xml:"AuthorizationCodeExpiredTime,omitempty"` // 授权码过期时间 单位秒
+	PreAuthCode                  string `xml:"PreAuthCode,omitempty"`                  // 预授权码
+}
+
+// SignDecryptNotifyThirdFasteRegister 快速注册企业/个人小程序
+// https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/Register_Mini_Programs/Fast_Registration_Interface_document.html
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/register-management/fast-registration-ind/fastRegisterPersonalMp.html
+type SignDecryptNotifyThirdFasteRegister struct {
+	XMLName    xml.Name
+	AppId      string `xml:"AppId,omitempty"`      // 第三方平台 appid
+	CreateTime int64  `xml:"CreateTime,omitempty"` // 时间戳，单位：s
+	InfoType   string `xml:"InfoType,omitempty"`   // 类型
+	Appid      string `xml:"appid,omitempty"`      // 创建小程序appid
+	Status     int64  `xml:"status,omitempty"`     // 状态
+	AuthCode   string `xml:"auth_code,omitempty"`  // 第三方授权码
+	Msg        string `xml:"msg,omitempty"`        // 信息
+	Info       struct {
+		Name               string `xml:"name,omitempty"` // 企业名称
+		Code               string `xml:"code,omitempty"` // 企业代码
+		CodeType           string `xml:"code_type,omitempty"`
+		LegalPersonaWechat string `xml:"legal_persona_wechat,omitempty"` // (企业)法人微信号
+		LegalPersonaName   string `xml:"legal_persona_name,omitempty"`   // (企业)法人姓名
+		ComponentPhone     string `xml:"component_phone,omitempty"`      // (企业/个人)第三方联系电话
+		Wxuser             string `xml:"wxuser"`                         // (个人)用户微信号
+		Idname             string `xml:"idname"`                         // (个人)用户姓名
+	} `xml:"info,omitempty"`
+}
+
+// SignDecryptNotifyThirdFastRegisterBetaApp 注册试用小程序
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/register-management/fast-regist-beta/registerBetaMiniprogram.html
+type SignDecryptNotifyThirdFastRegisterBetaApp struct {
+	XMLName    xml.Name
+	AppId      string `xml:"AppId,omitempty"`      // 第三方平台 appid
+	CreateTime int64  `xml:"CreateTime,omitempty"` // 时间戳，单位：s
+	InfoType   string `xml:"InfoType,omitempty"`   // 类型
+	Appid      string `xml:"appid,omitempty"`      // 创建小程序appid
+	Status     int64  `xml:"status,omitempty"`     // 状态
+	Msg        string `xml:"msg,omitempty"`        // 信息
+	Info       struct {
+		UniqueId string `xml:"unique_id,omitempty"`
+		Name     string `xml:"name,omitempty"` // 小程序名称
+	} `xml:"info,omitempty"`
+}
+
+// SignDecryptNotifyThirdFastVerifyBetaApp 试用小程序快速认证
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/register-management/fast-regist-beta/verfifyBetaMiniprogram.html
+type SignDecryptNotifyThirdFastVerifyBetaApp struct {
+	XMLName    xml.Name
+	AppId      string `xml:"AppId,omitempty"`      // 第三方平台 appid
+	CreateTime int64  `xml:"CreateTime,omitempty"` // 时间戳，单位：s
+	InfoType   string `xml:"InfoType,omitempty"`   // 类型
+	Appid      string `xml:"appid,omitempty"`      // 创建小程序appid
+	Status     int64  `xml:"status,omitempty"`     // 状态
+	Msg        string `xml:"msg,omitempty"`        // 信息
+	Info       struct {
+		Name               string `xml:"name,omitempty"` // 企业名称
+		Code               string `xml:"code,omitempty"` // 企业代码
+		CodeType           string `xml:"code_type,omitempty"`
+		LegalPersonaWechat string `xml:"legal_persona_wechat,omitempty"` // 法人微信号
+		LegalPersonaName   string `xml:"legal_persona_name,omitempty"`   // 法人姓名
+		ComponentPhone     string `xml:"component_phone,omitempty"`      // 第三方联系电话
+	} `xml:"info,omitempty"`
+}
+
+// SignDecryptWxaNicknameAudit 名称审核结果事件推送
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/miniprogram-management/basic-info-management/setNickName.html
+type SignDecryptWxaNicknameAudit struct {
+	XMLName      xml.Name
+	ToUserName   string `xml:"ToUserName,omitempty"`   // 小程序的原始 ID
+	FromUserName string `xml:"FromUserName,omitempty"` // 发送方帐号（一个 OpenID，此时发送方是系统帐号）
+	CreateTime   int64  `xml:"CreateTime,omitempty"`   // 消息创建时间 （整型），时间戳
+	MsgType      string `xml:"MsgType,omitempty"`      // 消息类型 event
+	Event        string `xml:"Event,omitempty"`        // 事件类型
+	Ret          string `xml:"ret,omitempty"`          // 审核结果 2：失败，3：成功
+	Nickname     string `xml:"nickname,omitempty"`     // 需要更改的昵称
+	Reason       string `xml:"reason,omitempty"`       // 审核失败的驳回原因
+}
+
+// SignDecryptWeAppAudit 代码审核结果推送
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/miniprogram-management/code-management/submitAudit.html
+type SignDecryptWeAppAudit struct {
+	XMLName      xml.Name
+	ToUserName   string `xml:"ToUserName,omitempty"`   // 小程序的原始 ID
+	FromUserName string `xml:"FromUserName,omitempty"` // 发送方帐号（一个 OpenID，此时发送方是系统帐号）
+	CreateTime   int64  `xml:"CreateTime,omitempty"`   // 消息创建时间 （整型），时间戳
+	MsgType      string `xml:"MsgType,omitempty"`      // 消息类型 event
+	Event        string `xml:"Event,omitempty"`        // 事件类型 weapp_audit_success=审核通过 weapp_audit_fail=审核不通过 weapp_audit_delay=审核延后
+	SuccTime     int64  `xml:"SuccTime,omitempty"`     // 审核成功时的时间戳
+	FailTime     int64  `xml:"FailTime,omitempty"`     // 审核不通过的时间戳
+	DelayTime    int64  `xml:"DelayTime,omitempty"`    // 审核延后时的时间戳
+	Reason       string `xml:"reason,omitempty"`       // 审核不通过的原因
+	ScreenShot   string `xml:"ScreenShot,omitempty"`   // 审核不通过的截图示例。用 | 分隔的 media_id 的列表，可通过获取永久素材接口拉取截图内容
+}
+
+// SignDecryptWxaSecurityApplySetOrderPathInfo 申请设置订单页 path 信息
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/miniprogram-management/basic-info-management/applySetOrderPathInfo.html
+type SignDecryptWxaSecurityApplySetOrderPathInfo struct {
+	XMLName   xml.Name
+	List      string `xml:"List,omitempty"`      // 申请结果列表
+	Appid     string `xml:"Appid,omitempty"`     // 申请的appid
+	AuditId   string `xml:"AuditId,omitempty"`   // 审核单id
+	Status    string `xml:"Status,omitempty"`    // 订单页 path 状态
+	ApplyTime int64  `xml:"ApplyTime,omitempty"` // 申请时间
+	AuditTime int64  `xml:"AuditTime,omitempty"` // 审核时间
+	Reason    string `xml:"Reason,omitempty"`    // 审核原因
+}

sns.component.jscode2session.go

@@ -1,6 +1,7 @@
 package wechatopen
 
 import (
+	"context"
 	"crypto/aes"
 	"crypto/cipher"
 	"encoding/base64"
@@ -21,29 +22,43 @@ type SnsComponentJsCode2sessionResult struct {
 	Result SnsComponentJsCode2sessionResponse // 结果
 	Body   []byte                             // 内容
 	Http   gorequest.Response                 // 请求
-	Err    error                              // 错误
 }
 
-func NewSnsComponentJsCode2sessionResult(result SnsComponentJsCode2sessionResponse, body []byte, http gorequest.Response, err error) *SnsComponentJsCode2sessionResult {
-	return &SnsComponentJsCode2sessionResult{Result: result, Body: body, Http: http, Err: err}
+func newSnsComponentJsCode2sessionResult(result SnsComponentJsCode2sessionResponse, body []byte, http gorequest.Response) *SnsComponentJsCode2sessionResult {
+	return &SnsComponentJsCode2sessionResult{Result: result, Body: body, Http: http}
 }
 
 // SnsComponentJsCode2session 小程序登录
 // https://developers.weixin.qq.com/doc/oplatform/Third-party_Platforms/2.0/api/others/WeChat_login.html
-func (app *App) SnsComponentJsCode2session(jsCode string) *SnsComponentJsCode2sessionResult {
+func (c *Client) SnsComponentJsCode2session(ctx context.Context, jsCode string) (*SnsComponentJsCode2sessionResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	err = c.checkAuthorizerIsConfig()
+	if err != nil {
+		return nil, err
+	}
 	// 参数
-	params := NewParams()
-	params["appid"] = app.authorizerAppid                            // 小程序的 appId
-	params["js_code"] = jsCode                                       // wx.login 获取的 code
-	params["grant_type"] = "authorization_code"                      // 填 authorization_code
-	params["component_appid"] = app.componentAppId                   // 第三方平台 appid
-	params["component_access_token"] = app.GetComponentAccessToken() // 第三方平台的component_access_token
+	params := gorequest.NewParams()
+	params["appid"] = c.GetAuthorizerAppid()                          // 小程序的 appId
+	params["js_code"] = jsCode                                        // wx.login 获取的 code
+	params["grant_type"] = "authorization_code"                       // 填 authorization_code
+	params["component_appid"] = c.GetComponentAppId()                 // 第三方平台 appid
+	params["component_access_token"] = c.GetComponentAccessToken(ctx) // 第三方平台的component_access_token
 	// 请求
-	request, err := app.request("https://api.weixin.qq.com/sns/component/jscode2session", params, http.MethodGet)
+	request, err := c.request(ctx, apiUrl+"/sns/component/jscode2session", params, http.MethodGet)
+	if err != nil {
+		return nil, err
+	}
 	// 定义
 	var response SnsComponentJsCode2sessionResponse
 	err = json.Unmarshal(request.ResponseBody, &response)
-	return NewSnsComponentJsCode2sessionResult(response, request.ResponseBody, request, err)
+	if err != nil {
+		return nil, err
+	}
+	return newSnsComponentJsCode2sessionResult(response, request.ResponseBody, request), nil
 }
 
 type UserInfo struct {
@@ -71,8 +86,8 @@ type UserInfoResult struct {
 	Err    error            // 错误
 }
 
-func NewUserInfoResult(result UserInfoResponse, err error) *UserInfoResult {
-	return &UserInfoResult{Result: result, Err: err}
+func newUserInfoResult(result UserInfoResponse, err error) *UserInfoResult {
+	return &UserInfoResult{Result: result}
 }
 
 // UserInfo 解密用户信息
@@ -80,35 +95,39 @@ func (r *SnsComponentJsCode2sessionResult) UserInfo(param UserInfo) *UserInfoRes
 	var response UserInfoResponse
 	aesKey, err := base64.StdEncoding.DecodeString(r.Result.SessionKey)
 	if err != nil {
-		return NewUserInfoResult(response, err)
+		return newUserInfoResult(response, err)
 	}
 	cipherText, err := base64.StdEncoding.DecodeString(param.EncryptedData)
 	if err != nil {
-		return NewUserInfoResult(response, err)
+		return newUserInfoResult(response, err)
 	}
 	ivBytes, err := base64.StdEncoding.DecodeString(param.Iv)
 	if err != nil {
-		return NewUserInfoResult(response, err)
+		return newUserInfoResult(response, err)
 	}
 	block, err := aes.NewCipher(aesKey)
 	if err != nil {
-		return NewUserInfoResult(response, err)
+		return newUserInfoResult(response, err)
 	}
 	mode := cipher.NewCBCDecrypter(block, ivBytes)
 	mode.CryptBlocks(cipherText, cipherText)
 	cipherText, err = r.pkcs7Unpaid(cipherText, block.BlockSize())
 	if err != nil {
-		return NewUserInfoResult(response, err)
+		return newUserInfoResult(response, err)
 	}
 	err = json.Unmarshal(cipherText, &response)
 	if err != nil {
-		return NewUserInfoResult(response, err)
+		return newUserInfoResult(response, err)
 	}
-	return NewUserInfoResult(response, err)
+	return newUserInfoResult(response, err)
 }
 
 func (u *UserInfoResponse) UserInfoAvatarUrlReal() string {
-	return strings.Replace(u.AvatarUrl, "/132", "/0", -1)
+	return UserInfoAvatarUrlReal(u.AvatarUrl)
+}
+
+func UserInfoAvatarUrlReal(avatarUrl string) string {
+	return strings.Replace(avatarUrl, "/132", "/0", -1)
 }
 
 func (r *SnsComponentJsCode2sessionResult) pkcs7Unpaid(data []byte, blockSize int) ([]byte, error) {

tcb.wxpaylist.go

@@ -0,0 +1,67 @@
+package wechatopen
+
+import (
+	"context"
+	"encoding/json"
+	"go.dtapp.net/gorequest"
+	"net/http"
+)
+
+type TckWxPayListResponse struct {
+	Errcode int    `json:"errcode"`
+	Errmsg  string `json:"errmsg"`
+	List    []struct {
+		MerchantCode     string `json:"merchant_code"`
+		MerchantName     string `json:"merchant_name"`
+		CompanyName      string `json:"company_name"`
+		MchRelationState string `json:"mch_relation_state"`
+		JsapiAuthState   string `json:"jsapi_auth_state"`
+		RefundAuthState  string `json:"refund_auth_state"`
+	} `json:"list"`
+}
+
+type TckWxPayListResult struct {
+	Result TckWxPayListResponse // 结果
+	Body   []byte               // 内容
+	Http   gorequest.Response   // 请求
+}
+
+func newTckWxPayListResult(result TckWxPayListResponse, body []byte, http gorequest.Response) *TckWxPayListResult {
+	return &TckWxPayListResult{Result: result, Body: body, Http: http}
+}
+
+// TckWxPayList 获取授权绑定的商户号列表
+// https://developers.weixin.qq.com/doc/oplatform/openApi/OpenApiDoc/cloudbase-common/wechatpay/getWechatPayList.html
+func (c *Client) TckWxPayList(ctx context.Context) (*TckWxPayListResult, error) {
+	// 检查
+	err := c.checkComponentIsConfig()
+	if err != nil {
+		return nil, err
+	}
+	// 参数
+	// 参数
+	params := gorequest.NewParams()
+	// 请求
+	request, err := c.request(ctx, apiUrl+"/tcb/wxpaylist?access_token="+c.GetComponentAccessToken(ctx), params, http.MethodPost)
+	if err != nil {
+		return nil, err
+	}
+	// 定义
+	var response TckWxPayListResponse
+	err = json.Unmarshal(request.ResponseBody, &response)
+	if err != nil {
+		return nil, err
+	}
+	return newTckWxPayListResult(response, request.ResponseBody, request), nil
+}
+
+// ErrcodeInfo 错误描述
+func (resp *TckWxPayListResult) ErrcodeInfo() string {
+	switch resp.Result.Errcode {
+	case 85064:
+		return "找不到草稿"
+	case 85065:
+		return "模板库已满"
+	}
+	return "系统繁忙"
+}

vendor/github.com/cespare/xxhash/v2/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2016 Caleb Spare
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/github.com/cespare/xxhash/v2/README.md

@@ -1,69 +0,0 @@
-# xxhash
-
-[![Go Reference](https://pkg.go.dev/badge/github.com/cespare/xxhash/v2.svg)](https://pkg.go.dev/github.com/cespare/xxhash/v2)
-[![Test](https://github.com/cespare/xxhash/actions/workflows/test.yml/badge.svg)](https://github.com/cespare/xxhash/actions/workflows/test.yml)
-
-xxhash is a Go implementation of the 64-bit
-[xxHash](http://cyan4973.github.io/xxHash/) algorithm, XXH64. This is a
-high-quality hashing algorithm that is much faster than anything in the Go
-standard library.
-
-This package provides a straightforward API:
-
-```
-func Sum64(b []byte) uint64
-func Sum64String(s string) uint64
-type Digest struct{ ... }
-    func New() *Digest
-```
-
-The `Digest` type implements hash.Hash64. Its key methods are:
-
-```
-func (*Digest) Write([]byte) (int, error)
-func (*Digest) WriteString(string) (int, error)
-func (*Digest) Sum64() uint64
-```
-
-This implementation provides a fast pure-Go implementation and an even faster
-assembly implementation for amd64.
-
-## Compatibility
-
-This package is in a module and the latest code is in version 2 of the module.
-You need a version of Go with at least "minimal module compatibility" to use
-github.com/cespare/xxhash/v2:
-
-* 1.9.7+ for Go 1.9
-* 1.10.3+ for Go 1.10
-* Go 1.11 or later
-
-I recommend using the latest release of Go.
-
-## Benchmarks
-
-Here are some quick benchmarks comparing the pure-Go and assembly
-implementations of Sum64.
-
-| input size | purego | asm |
-| --- | --- | --- |
-| 5 B   |  979.66 MB/s |  1291.17 MB/s  |
-| 100 B | 7475.26 MB/s | 7973.40 MB/s  |
-| 4 KB  | 17573.46 MB/s | 17602.65 MB/s |
-| 10 MB | 17131.46 MB/s | 17142.16 MB/s |
-
-These numbers were generated on Ubuntu 18.04 with an Intel i7-8700K CPU using
-the following commands under Go 1.11.2:
-
-```
-$ go test -tags purego -benchtime 10s -bench '/xxhash,direct,bytes'
-$ go test -benchtime 10s -bench '/xxhash,direct,bytes'
-```
-
-## Projects using this package
-
-- [InfluxDB](https://github.com/influxdata/influxdb)
-- [Prometheus](https://github.com/prometheus/prometheus)
-- [VictoriaMetrics](https://github.com/VictoriaMetrics/VictoriaMetrics)
-- [FreeCache](https://github.com/coocood/freecache)
-- [FastCache](https://github.com/VictoriaMetrics/fastcache)

vendor/github.com/cespare/xxhash/v2/xxhash.go

@@ -1,235 +0,0 @@
-// Package xxhash implements the 64-bit variant of xxHash (XXH64) as described
-// at http://cyan4973.github.io/xxHash/.
-package xxhash
-
-import (
-	"encoding/binary"
-	"errors"
-	"math/bits"
-)
-
-const (
-	prime1 uint64 = 11400714785074694791
-	prime2 uint64 = 14029467366897019727
-	prime3 uint64 = 1609587929392839161
-	prime4 uint64 = 9650029242287828579
-	prime5 uint64 = 2870177450012600261
-)
-
-// NOTE(caleb): I'm using both consts and vars of the primes. Using consts where
-// possible in the Go code is worth a small (but measurable) performance boost
-// by avoiding some MOVQs. Vars are needed for the asm and also are useful for
-// convenience in the Go code in a few places where we need to intentionally
-// avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the
-// result overflows a uint64).
-var (
-	prime1v = prime1
-	prime2v = prime2
-	prime3v = prime3
-	prime4v = prime4
-	prime5v = prime5
-)
-
-// Digest implements hash.Hash64.
-type Digest struct {
-	v1    uint64
-	v2    uint64
-	v3    uint64
-	v4    uint64
-	total uint64
-	mem   [32]byte
-	n     int // how much of mem is used
-}
-
-// New creates a new Digest that computes the 64-bit xxHash algorithm.
-func New() *Digest {
-	var d Digest
-	d.Reset()
-	return &d
-}
-
-// Reset clears the Digest's state so that it can be reused.
-func (d *Digest) Reset() {
-	d.v1 = prime1v + prime2
-	d.v2 = prime2
-	d.v3 = 0
-	d.v4 = -prime1v
-	d.total = 0
-	d.n = 0
-}
-
-// Size always returns 8 bytes.
-func (d *Digest) Size() int { return 8 }
-
-// BlockSize always returns 32 bytes.
-func (d *Digest) BlockSize() int { return 32 }
-
-// Write adds more data to d. It always returns len(b), nil.
-func (d *Digest) Write(b []byte) (n int, err error) {
-	n = len(b)
-	d.total += uint64(n)
-
-	if d.n+n < 32 {
-		// This new data doesn't even fill the current block.
-		copy(d.mem[d.n:], b)
-		d.n += n
-		return
-	}
-
-	if d.n > 0 {
-		// Finish off the partial block.
-		copy(d.mem[d.n:], b)
-		d.v1 = round(d.v1, u64(d.mem[0:8]))
-		d.v2 = round(d.v2, u64(d.mem[8:16]))
-		d.v3 = round(d.v3, u64(d.mem[16:24]))
-		d.v4 = round(d.v4, u64(d.mem[24:32]))
-		b = b[32-d.n:]
-		d.n = 0
-	}
-
-	if len(b) >= 32 {
-		// One or more full blocks left.
-		nw := writeBlocks(d, b)
-		b = b[nw:]
-	}
-
-	// Store any remaining partial block.
-	copy(d.mem[:], b)
-	d.n = len(b)
-
-	return
-}
-
-// Sum appends the current hash to b and returns the resulting slice.
-func (d *Digest) Sum(b []byte) []byte {
-	s := d.Sum64()
-	return append(
-		b,
-		byte(s>>56),
-		byte(s>>48),
-		byte(s>>40),
-		byte(s>>32),
-		byte(s>>24),
-		byte(s>>16),
-		byte(s>>8),
-		byte(s),
-	)
-}
-
-// Sum64 returns the current hash.
-func (d *Digest) Sum64() uint64 {
-	var h uint64
-
-	if d.total >= 32 {
-		v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4
-		h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4)
-		h = mergeRound(h, v1)
-		h = mergeRound(h, v2)
-		h = mergeRound(h, v3)
-		h = mergeRound(h, v4)
-	} else {
-		h = d.v3 + prime5
-	}
-
-	h += d.total
-
-	i, end := 0, d.n
-	for ; i+8 <= end; i += 8 {
-		k1 := round(0, u64(d.mem[i:i+8]))
-		h ^= k1
-		h = rol27(h)*prime1 + prime4
-	}
-	if i+4 <= end {
-		h ^= uint64(u32(d.mem[i:i+4])) * prime1
-		h = rol23(h)*prime2 + prime3
-		i += 4
-	}
-	for i < end {
-		h ^= uint64(d.mem[i]) * prime5
-		h = rol11(h) * prime1
-		i++
-	}
-
-	h ^= h >> 33
-	h *= prime2
-	h ^= h >> 29
-	h *= prime3
-	h ^= h >> 32
-
-	return h
-}
-
-const (
-	magic         = "xxh\x06"
-	marshaledSize = len(magic) + 8*5 + 32
-)
-
-// MarshalBinary implements the encoding.BinaryMarshaler interface.
-func (d *Digest) MarshalBinary() ([]byte, error) {
-	b := make([]byte, 0, marshaledSize)
-	b = append(b, magic...)
-	b = appendUint64(b, d.v1)
-	b = appendUint64(b, d.v2)
-	b = appendUint64(b, d.v3)
-	b = appendUint64(b, d.v4)
-	b = appendUint64(b, d.total)
-	b = append(b, d.mem[:d.n]...)
-	b = b[:len(b)+len(d.mem)-d.n]
-	return b, nil
-}
-
-// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
-func (d *Digest) UnmarshalBinary(b []byte) error {
-	if len(b) < len(magic) || string(b[:len(magic)]) != magic {
-		return errors.New("xxhash: invalid hash state identifier")
-	}
-	if len(b) != marshaledSize {
-		return errors.New("xxhash: invalid hash state size")
-	}
-	b = b[len(magic):]
-	b, d.v1 = consumeUint64(b)
-	b, d.v2 = consumeUint64(b)
-	b, d.v3 = consumeUint64(b)
-	b, d.v4 = consumeUint64(b)
-	b, d.total = consumeUint64(b)
-	copy(d.mem[:], b)
-	d.n = int(d.total % uint64(len(d.mem)))
-	return nil
-}
-
-func appendUint64(b []byte, x uint64) []byte {
-	var a [8]byte
-	binary.LittleEndian.PutUint64(a[:], x)
-	return append(b, a[:]...)
-}
-
-func consumeUint64(b []byte) ([]byte, uint64) {
-	x := u64(b)
-	return b[8:], x
-}
-
-func u64(b []byte) uint64 { return binary.LittleEndian.Uint64(b) }
-func u32(b []byte) uint32 { return binary.LittleEndian.Uint32(b) }
-
-func round(acc, input uint64) uint64 {
-	acc += input * prime2
-	acc = rol31(acc)
-	acc *= prime1
-	return acc
-}
-
-func mergeRound(acc, val uint64) uint64 {
-	val = round(0, val)
-	acc ^= val
-	acc = acc*prime1 + prime4
-	return acc
-}
-
-func rol1(x uint64) uint64  { return bits.RotateLeft64(x, 1) }
-func rol7(x uint64) uint64  { return bits.RotateLeft64(x, 7) }
-func rol11(x uint64) uint64 { return bits.RotateLeft64(x, 11) }
-func rol12(x uint64) uint64 { return bits.RotateLeft64(x, 12) }
-func rol18(x uint64) uint64 { return bits.RotateLeft64(x, 18) }
-func rol23(x uint64) uint64 { return bits.RotateLeft64(x, 23) }
-func rol27(x uint64) uint64 { return bits.RotateLeft64(x, 27) }
-func rol31(x uint64) uint64 { return bits.RotateLeft64(x, 31) }

vendor/github.com/cespare/xxhash/v2/xxhash_amd64.go

@@ -1,13 +0,0 @@
-// +build !appengine
-// +build gc
-// +build !purego
-
-package xxhash
-
-// Sum64 computes the 64-bit xxHash digest of b.
-//
-//go:noescape
-func Sum64(b []byte) uint64
-
-//go:noescape
-func writeBlocks(d *Digest, b []byte) int

vendor/github.com/cespare/xxhash/v2/xxhash_amd64.s

@@ -1,215 +0,0 @@
-// +build !appengine
-// +build gc
-// +build !purego
-
-#include "textflag.h"
-
-// Register allocation:
-// AX	h
-// SI	pointer to advance through b
-// DX	n
-// BX	loop end
-// R8	v1, k1
-// R9	v2
-// R10	v3
-// R11	v4
-// R12	tmp
-// R13	prime1v
-// R14	prime2v
-// DI	prime4v
-
-// round reads from and advances the buffer pointer in SI.
-// It assumes that R13 has prime1v and R14 has prime2v.
-#define round(r) \
-	MOVQ  (SI), R12 \
-	ADDQ  $8, SI    \
-	IMULQ R14, R12  \
-	ADDQ  R12, r    \
-	ROLQ  $31, r    \
-	IMULQ R13, r
-
-// mergeRound applies a merge round on the two registers acc and val.
-// It assumes that R13 has prime1v, R14 has prime2v, and DI has prime4v.
-#define mergeRound(acc, val) \
-	IMULQ R14, val \
-	ROLQ  $31, val \
-	IMULQ R13, val \
-	XORQ  val, acc \
-	IMULQ R13, acc \
-	ADDQ  DI, acc
-
-// func Sum64(b []byte) uint64
-TEXT ·Sum64(SB), NOSPLIT, $0-32
-	// Load fixed primes.
-	MOVQ ·prime1v(SB), R13
-	MOVQ ·prime2v(SB), R14
-	MOVQ ·prime4v(SB), DI
-
-	// Load slice.
-	MOVQ b_base+0(FP), SI
-	MOVQ b_len+8(FP), DX
-	LEAQ (SI)(DX*1), BX
-
-	// The first loop limit will be len(b)-32.
-	SUBQ $32, BX
-
-	// Check whether we have at least one block.
-	CMPQ DX, $32
-	JLT  noBlocks
-
-	// Set up initial state (v1, v2, v3, v4).
-	MOVQ R13, R8
-	ADDQ R14, R8
-	MOVQ R14, R9
-	XORQ R10, R10
-	XORQ R11, R11
-	SUBQ R13, R11
-
-	// Loop until SI > BX.
-blockLoop:
-	round(R8)
-	round(R9)
-	round(R10)
-	round(R11)
-
-	CMPQ SI, BX
-	JLE  blockLoop
-
-	MOVQ R8, AX
-	ROLQ $1, AX
-	MOVQ R9, R12
-	ROLQ $7, R12
-	ADDQ R12, AX
-	MOVQ R10, R12
-	ROLQ $12, R12
-	ADDQ R12, AX
-	MOVQ R11, R12
-	ROLQ $18, R12
-	ADDQ R12, AX
-
-	mergeRound(AX, R8)
-	mergeRound(AX, R9)
-	mergeRound(AX, R10)
-	mergeRound(AX, R11)
-
-	JMP afterBlocks
-
-noBlocks:
-	MOVQ ·prime5v(SB), AX
-
-afterBlocks:
-	ADDQ DX, AX
-
-	// Right now BX has len(b)-32, and we want to loop until SI > len(b)-8.
-	ADDQ $24, BX
-
-	CMPQ SI, BX
-	JG   fourByte
-
-wordLoop:
-	// Calculate k1.
-	MOVQ  (SI), R8
-	ADDQ  $8, SI
-	IMULQ R14, R8
-	ROLQ  $31, R8
-	IMULQ R13, R8
-
-	XORQ  R8, AX
-	ROLQ  $27, AX
-	IMULQ R13, AX
-	ADDQ  DI, AX
-
-	CMPQ SI, BX
-	JLE  wordLoop
-
-fourByte:
-	ADDQ $4, BX
-	CMPQ SI, BX
-	JG   singles
-
-	MOVL  (SI), R8
-	ADDQ  $4, SI
-	IMULQ R13, R8
-	XORQ  R8, AX
-
-	ROLQ  $23, AX
-	IMULQ R14, AX
-	ADDQ  ·prime3v(SB), AX
-
-singles:
-	ADDQ $4, BX
-	CMPQ SI, BX
-	JGE  finalize
-
-singlesLoop:
-	MOVBQZX (SI), R12
-	ADDQ    $1, SI
-	IMULQ   ·prime5v(SB), R12
-	XORQ    R12, AX
-
-	ROLQ  $11, AX
-	IMULQ R13, AX
-
-	CMPQ SI, BX
-	JL   singlesLoop
-
-finalize:
-	MOVQ  AX, R12
-	SHRQ  $33, R12
-	XORQ  R12, AX
-	IMULQ R14, AX
-	MOVQ  AX, R12
-	SHRQ  $29, R12
-	XORQ  R12, AX
-	IMULQ ·prime3v(SB), AX
-	MOVQ  AX, R12
-	SHRQ  $32, R12
-	XORQ  R12, AX
-
-	MOVQ AX, ret+24(FP)
-	RET
-
-// writeBlocks uses the same registers as above except that it uses AX to store
-// the d pointer.
-
-// func writeBlocks(d *Digest, b []byte) int
-TEXT ·writeBlocks(SB), NOSPLIT, $0-40
-	// Load fixed primes needed for round.
-	MOVQ ·prime1v(SB), R13
-	MOVQ ·prime2v(SB), R14
-
-	// Load slice.
-	MOVQ b_base+8(FP), SI
-	MOVQ b_len+16(FP), DX
-	LEAQ (SI)(DX*1), BX
-	SUBQ $32, BX
-
-	// Load vN from d.
-	MOVQ d+0(FP), AX
-	MOVQ 0(AX), R8   // v1
-	MOVQ 8(AX), R9   // v2
-	MOVQ 16(AX), R10 // v3
-	MOVQ 24(AX), R11 // v4
-
-	// We don't need to check the loop condition here; this function is
-	// always called with at least one block of data to process.
-blockLoop:
-	round(R8)
-	round(R9)
-	round(R10)
-	round(R11)
-
-	CMPQ SI, BX
-	JLE  blockLoop
-
-	// Copy vN back to d.
-	MOVQ R8, 0(AX)
-	MOVQ R9, 8(AX)
-	MOVQ R10, 16(AX)
-	MOVQ R11, 24(AX)
-
-	// The number of bytes written is SI minus the old base pointer.
-	SUBQ b_base+8(FP), SI
-	MOVQ SI, ret+32(FP)
-
-	RET

vendor/github.com/cespare/xxhash/v2/xxhash_other.go

@@ -1,76 +0,0 @@
-// +build !amd64 appengine !gc purego
-
-package xxhash
-
-// Sum64 computes the 64-bit xxHash digest of b.
-func Sum64(b []byte) uint64 {
-	// A simpler version would be
-	//   d := New()
-	//   d.Write(b)
-	//   return d.Sum64()
-	// but this is faster, particularly for small inputs.
-
-	n := len(b)
-	var h uint64
-
-	if n >= 32 {
-		v1 := prime1v + prime2
-		v2 := prime2
-		v3 := uint64(0)
-		v4 := -prime1v
-		for len(b) >= 32 {
-			v1 = round(v1, u64(b[0:8:len(b)]))
-			v2 = round(v2, u64(b[8:16:len(b)]))
-			v3 = round(v3, u64(b[16:24:len(b)]))
-			v4 = round(v4, u64(b[24:32:len(b)]))
-			b = b[32:len(b):len(b)]
-		}
-		h = rol1(v1) + rol7(v2) + rol12(v3) + rol18(v4)
-		h = mergeRound(h, v1)
-		h = mergeRound(h, v2)
-		h = mergeRound(h, v3)
-		h = mergeRound(h, v4)
-	} else {
-		h = prime5
-	}
-
-	h += uint64(n)
-
-	i, end := 0, len(b)
-	for ; i+8 <= end; i += 8 {
-		k1 := round(0, u64(b[i:i+8:len(b)]))
-		h ^= k1
-		h = rol27(h)*prime1 + prime4
-	}
-	if i+4 <= end {
-		h ^= uint64(u32(b[i:i+4:len(b)])) * prime1
-		h = rol23(h)*prime2 + prime3
-		i += 4
-	}
-	for ; i < end; i++ {
-		h ^= uint64(b[i]) * prime5
-		h = rol11(h) * prime1
-	}
-
-	h ^= h >> 33
-	h *= prime2
-	h ^= h >> 29
-	h *= prime3
-	h ^= h >> 32
-
-	return h
-}
-
-func writeBlocks(d *Digest, b []byte) int {
-	v1, v2, v3, v4 := d.v1, d.v2, d.v3, d.v4
-	n := len(b)
-	for len(b) >= 32 {
-		v1 = round(v1, u64(b[0:8:len(b)]))
-		v2 = round(v2, u64(b[8:16:len(b)]))
-		v3 = round(v3, u64(b[16:24:len(b)]))
-		v4 = round(v4, u64(b[24:32:len(b)]))
-		b = b[32:len(b):len(b)]
-	}
-	d.v1, d.v2, d.v3, d.v4 = v1, v2, v3, v4
-	return n - len(b)
-}

vendor/github.com/cespare/xxhash/v2/xxhash_safe.go

@@ -1,15 +0,0 @@
-// +build appengine
-
-// This file contains the safe implementations of otherwise unsafe-using code.
-
-package xxhash
-
-// Sum64String computes the 64-bit xxHash digest of s.
-func Sum64String(s string) uint64 {
-	return Sum64([]byte(s))
-}
-
-// WriteString adds more data to d. It always returns len(s), nil.
-func (d *Digest) WriteString(s string) (n int, err error) {
-	return d.Write([]byte(s))
-}

vendor/github.com/cespare/xxhash/v2/xxhash_unsafe.go

@@ -1,57 +0,0 @@
-// +build !appengine
-
-// This file encapsulates usage of unsafe.
-// xxhash_safe.go contains the safe implementations.
-
-package xxhash
-
-import (
-	"unsafe"
-)
-
-// In the future it's possible that compiler optimizations will make these
-// XxxString functions unnecessary by realizing that calls such as
-// Sum64([]byte(s)) don't need to copy s. See https://golang.org/issue/2205.
-// If that happens, even if we keep these functions they can be replaced with
-// the trivial safe code.
-
-// NOTE: The usual way of doing an unsafe string-to-[]byte conversion is:
-//
-//   var b []byte
-//   bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-//   bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data
-//   bh.Len = len(s)
-//   bh.Cap = len(s)
-//
-// Unfortunately, as of Go 1.15.3 the inliner's cost model assigns a high enough
-// weight to this sequence of expressions that any function that uses it will
-// not be inlined. Instead, the functions below use a different unsafe
-// conversion designed to minimize the inliner weight and allow both to be
-// inlined. There is also a test (TestInlining) which verifies that these are
-// inlined.
-//
-// See https://github.com/golang/go/issues/42739 for discussion.
-
-// Sum64String computes the 64-bit xxHash digest of s.
-// It may be faster than Sum64([]byte(s)) by avoiding a copy.
-func Sum64String(s string) uint64 {
-	b := *(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)}))
-	return Sum64(b)
-}
-
-// WriteString adds more data to d. It always returns len(s), nil.
-// It may be faster than Write([]byte(s)) by avoiding a copy.
-func (d *Digest) WriteString(s string) (n int, err error) {
-	d.Write(*(*[]byte)(unsafe.Pointer(&sliceHeader{s, len(s)})))
-	// d.Write always returns len(s), nil.
-	// Ignoring the return output and returning these fixed values buys a
-	// savings of 6 in the inliner's cost model.
-	return len(s), nil
-}
-
-// sliceHeader is similar to reflect.SliceHeader, but it assumes that the layout
-// of the first two words is the same as the layout of a string.
-type sliceHeader struct {
-	s   string
-	cap int
-}

vendor/github.com/dgryski/go-rendezvous/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2017-2020 Damian Gryski <damian@gryski.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

vendor/github.com/dgryski/go-rendezvous/rdv.go

@@ -1,79 +0,0 @@
-package rendezvous
-
-type Rendezvous struct {
-	nodes map[string]int
-	nstr  []string
-	nhash []uint64
-	hash  Hasher
-}
-
-type Hasher func(s string) uint64
-
-func New(nodes []string, hash Hasher) *Rendezvous {
-	r := &Rendezvous{
-		nodes: make(map[string]int, len(nodes)),
-		nstr:  make([]string, len(nodes)),
-		nhash: make([]uint64, len(nodes)),
-		hash:  hash,
-	}
-
-	for i, n := range nodes {
-		r.nodes[n] = i
-		r.nstr[i] = n
-		r.nhash[i] = hash(n)
-	}
-
-	return r
-}
-
-func (r *Rendezvous) Lookup(k string) string {
-	// short-circuit if we're empty
-	if len(r.nodes) == 0 {
-		return ""
-	}
-
-	khash := r.hash(k)
-
-	var midx int
-	var mhash = xorshiftMult64(khash ^ r.nhash[0])
-
-	for i, nhash := range r.nhash[1:] {
-		if h := xorshiftMult64(khash ^ nhash); h > mhash {
-			midx = i + 1
-			mhash = h
-		}
-	}
-
-	return r.nstr[midx]
-}
-
-func (r *Rendezvous) Add(node string) {
-	r.nodes[node] = len(r.nstr)
-	r.nstr = append(r.nstr, node)
-	r.nhash = append(r.nhash, r.hash(node))
-}
-
-func (r *Rendezvous) Remove(node string) {
-	// find index of node to remove
-	nidx := r.nodes[node]
-
-	// remove from the slices
-	l := len(r.nstr)
-	r.nstr[nidx] = r.nstr[l]
-	r.nstr = r.nstr[:l]
-
-	r.nhash[nidx] = r.nhash[l]
-	r.nhash = r.nhash[:l]
-
-	// update the map
-	delete(r.nodes, node)
-	moved := r.nstr[nidx]
-	r.nodes[moved] = nidx
-}
-
-func xorshiftMult64(x uint64) uint64 {
-	x ^= x >> 12 // a
-	x ^= x << 25 // b
-	x ^= x >> 27 // c
-	return x * 2685821657736338717
-}

vendor/github.com/go-redis/redis/v8/.gitignore

@@ -1,3 +0,0 @@
-*.rdb
-testdata/*/
-.idea/

vendor/github.com/go-redis/redis/v8/.golangci.yml

@@ -1,4 +0,0 @@
-run:
-  concurrency: 8
-  deadline: 5m
-  tests: false

vendor/github.com/go-redis/redis/v8/.prettierrc.yml

@@ -1,4 +0,0 @@
-semi: false
-singleQuote: true
-proseWrap: always
-printWidth: 100

vendor/github.com/go-redis/redis/v8/CHANGELOG.md

@@ -1,177 +0,0 @@
-## [8.11.5](https://github.com/go-redis/redis/compare/v8.11.4...v8.11.5) (2022-03-17)
-
-
-### Bug Fixes
-
-* add missing Expire methods to Cmdable ([17e3b43](https://github.com/go-redis/redis/commit/17e3b43879d516437ada71cf9c0deac6a382ed9a))
-* add whitespace for avoid unlikely colisions ([7f7c181](https://github.com/go-redis/redis/commit/7f7c1817617cfec909efb13d14ad22ef05a6ad4c))
-* example/otel compile error ([#2028](https://github.com/go-redis/redis/issues/2028)) ([187c07c](https://github.com/go-redis/redis/commit/187c07c41bf68dc3ab280bc3a925e960bbef6475))
-* **extra/redisotel:** set span.kind attribute to client ([065b200](https://github.com/go-redis/redis/commit/065b200070b41e6e949710b4f9e01b50ccc60ab2))
-* format ([96f53a0](https://github.com/go-redis/redis/commit/96f53a0159a28affa94beec1543a62234e7f8b32))
-* invalid type assert in stringArg ([de6c131](https://github.com/go-redis/redis/commit/de6c131865b8263400c8491777b295035f2408e4))
-* rename Golang to Go ([#2030](https://github.com/go-redis/redis/issues/2030)) ([b82a2d9](https://github.com/go-redis/redis/commit/b82a2d9d4d2de7b7cbe8fcd4895be62dbcacacbc))
-* set timeout for WAIT command. Fixes [#1963](https://github.com/go-redis/redis/issues/1963) ([333fee1](https://github.com/go-redis/redis/commit/333fee1a8fd98a2fbff1ab187c1b03246a7eb01f))
-* update some argument counts in pre-allocs ([f6974eb](https://github.com/go-redis/redis/commit/f6974ebb5c40a8adf90d2cacab6dc297f4eba4c2))
-
-
-### Features
-
-* Add redis v7's NX, XX, GT, LT expire variants ([e19bbb2](https://github.com/go-redis/redis/commit/e19bbb26e2e395c6e077b48d80d79e99f729a8b8))
-* add support for acl sentinel auth in universal client ([ab0ccc4](https://github.com/go-redis/redis/commit/ab0ccc47413f9b2a6eabc852fed5005a3ee1af6e))
-* add support for COPY command ([#2016](https://github.com/go-redis/redis/issues/2016)) ([730afbc](https://github.com/go-redis/redis/commit/730afbcffb93760e8a36cc06cfe55ab102b693a7))
-* add support for passing extra attributes added to spans ([39faaa1](https://github.com/go-redis/redis/commit/39faaa171523834ba527c9789710c4fde87f5a2e))
-* add support for time.Duration write and scan ([2f1b74e](https://github.com/go-redis/redis/commit/2f1b74e20cdd7719b2aecf0768d3e3ae7c3e781b))
-* **redisotel:** ability to override TracerProvider ([#1998](https://github.com/go-redis/redis/issues/1998)) ([bf8d4aa](https://github.com/go-redis/redis/commit/bf8d4aa60c00366cda2e98c3ddddc8cf68507417))
-* set net.peer.name and net.peer.port in otel example ([69bf454](https://github.com/go-redis/redis/commit/69bf454f706204211cd34835f76b2e8192d3766d))
-
-
-
-## [8.11.4](https://github.com/go-redis/redis/compare/v8.11.3...v8.11.4) (2021-10-04)
-
-
-### Features
-
-* add acl auth support for sentinels ([f66582f](https://github.com/go-redis/redis/commit/f66582f44f3dc3a4705a5260f982043fde4aa634))
-* add Cmd.{String,Int,Float,Bool}Slice helpers and an example ([5d3d293](https://github.com/go-redis/redis/commit/5d3d293cc9c60b90871e2420602001463708ce24))
-* add SetVal method for each command ([168981d](https://github.com/go-redis/redis/commit/168981da2d84ee9e07d15d3e74d738c162e264c4))
-
-
-
-## v8.11
-
-- Remove OpenTelemetry metrics.
-- Supports more redis commands and options.
-
-## v8.10
-
-- Removed extra OpenTelemetry spans from go-redis core. Now go-redis instrumentation only adds a
-  single span with a Redis command (instead of 4 spans). There are multiple reasons behind this
-  decision:
-
-  - Traces become smaller and less noisy.
-  - It may be costly to process those 3 extra spans for each query.
-  - go-redis no longer depends on OpenTelemetry.
-
-  Eventually we hope to replace the information that we no longer collect with OpenTelemetry
-  Metrics.
-
-## v8.9
-
-- Changed `PubSub.Channel` to only rely on `Ping` result. You can now use `WithChannelSize`,
-  `WithChannelHealthCheckInterval`, and `WithChannelSendTimeout` to override default settings.
-
-## v8.8
-
-- To make updating easier, extra modules now have the same version as go-redis does. That means that
-  you need to update your imports:
-
-```
-github.com/go-redis/redis/extra/redisotel -> github.com/go-redis/redis/extra/redisotel/v8
-github.com/go-redis/redis/extra/rediscensus -> github.com/go-redis/redis/extra/rediscensus/v8
-```
-
-## v8.5
-
-- [knadh](https://github.com/knadh) contributed long-awaited ability to scan Redis Hash into a
-  struct:
-
-```go
-err := rdb.HGetAll(ctx, "hash").Scan(&data)
-
-err := rdb.MGet(ctx, "key1", "key2").Scan(&data)
-```
-
-- Please check [redismock](https://github.com/go-redis/redismock) by
-  [monkey92t](https://github.com/monkey92t) if you are looking for mocking Redis Client.
-
-## v8
-
-- All commands require `context.Context` as a first argument, e.g. `rdb.Ping(ctx)`. If you are not
-  using `context.Context` yet, the simplest option is to define global package variable
-  `var ctx = context.TODO()` and use it when `ctx` is required.
-
-- Full support for `context.Context` canceling.
-
-- Added `redis.NewFailoverClusterClient` that supports routing read-only commands to a slave node.
-
-- Added `redisext.OpenTemetryHook` that adds
-  [Redis OpenTelemetry instrumentation](https://redis.uptrace.dev/tracing/).
-
-- Redis slow log support.
-
-- Ring uses Rendezvous Hashing by default which provides better distribution. You need to move
-  existing keys to a new location or keys will be inaccessible / lost. To use old hashing scheme:
-
-```go
-import "github.com/golang/groupcache/consistenthash"
-
-ring := redis.NewRing(&redis.RingOptions{
-    NewConsistentHash: func() {
-        return consistenthash.New(100, crc32.ChecksumIEEE)
-    },
-})
-```
-
-- `ClusterOptions.MaxRedirects` default value is changed from 8 to 3.
-- `Options.MaxRetries` default value is changed from 0 to 3.
-
-- `Cluster.ForEachNode` is renamed to `ForEachShard` for consistency with `Ring`.
-
-## v7.3
-
-- New option `Options.Username` which causes client to use `AuthACL`. Be aware if your connection
-  URL contains username.
-
-## v7.2
-
-- Existing `HMSet` is renamed to `HSet` and old deprecated `HMSet` is restored for Redis 3 users.
-
-## v7.1
-
-- Existing `Cmd.String` is renamed to `Cmd.Text`. New `Cmd.String` implements `fmt.Stringer`
-  interface.
-
-## v7
-
-- _Important_. Tx.Pipeline now returns a non-transactional pipeline. Use Tx.TxPipeline for a
-  transactional pipeline.
-- WrapProcess is replaced with more convenient AddHook that has access to context.Context.
-- WithContext now can not be used to create a shallow copy of the client.
-- New methods ProcessContext, DoContext, and ExecContext.
-- Client respects Context.Deadline when setting net.Conn deadline.
-- Client listens on Context.Done while waiting for a connection from the pool and returns an error
-  when context context is cancelled.
-- Add PubSub.ChannelWithSubscriptions that sends `*Subscription` in addition to `*Message` to allow
-  detecting reconnections.
-- `time.Time` is now marshalled in RFC3339 format. `rdb.Get("foo").Time()` helper is added to parse
-  the time.
-- `SetLimiter` is removed and added `Options.Limiter` instead.
-- `HMSet` is deprecated as of Redis v4.
-
-## v6.15
-
-- Cluster and Ring pipelines process commands for each node in its own goroutine.
-
-## 6.14
-
-- Added Options.MinIdleConns.
-- Added Options.MaxConnAge.
-- PoolStats.FreeConns is renamed to PoolStats.IdleConns.
-- Add Client.Do to simplify creating custom commands.
-- Add Cmd.String, Cmd.Int, Cmd.Int64, Cmd.Uint64, Cmd.Float64, and Cmd.Bool helpers.
-- Lower memory usage.
-
-## v6.13
-
-- Ring got new options called `HashReplicas` and `Hash`. It is recommended to set
-  `HashReplicas = 1000` for better keys distribution between shards.
-- Cluster client was optimized to use much less memory when reloading cluster state.
-- PubSub.ReceiveMessage is re-worked to not use ReceiveTimeout so it does not lose data when timeout
-  occurres. In most cases it is recommended to use PubSub.Channel instead.
-- Dialer.KeepAlive is set to 5 minutes by default.
-
-## v6.12
-
-- ClusterClient got new option called `ClusterSlots` which allows to build cluster of normal Redis
-  Servers that don't have cluster mode enabled. See
-  https://godoc.org/github.com/go-redis/redis#example-NewClusterClient--ManualSetup

vendor/github.com/go-redis/redis/v8/LICENSE

@@ -1,25 +0,0 @@
-Copyright (c) 2013 The github.com/go-redis/redis Authors.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/go-redis/redis/v8/Makefile

@@ -1,35 +0,0 @@
-PACKAGE_DIRS := $(shell find . -mindepth 2 -type f -name 'go.mod' -exec dirname {} \; | sort)
-
-test: testdeps
-	go test ./...
-	go test ./... -short -race
-	go test ./... -run=NONE -bench=. -benchmem
-	env GOOS=linux GOARCH=386 go test ./...
-	go vet
-
-testdeps: testdata/redis/src/redis-server
-
-bench: testdeps
-	go test ./... -test.run=NONE -test.bench=. -test.benchmem
-
-.PHONY: all test testdeps bench
-
-testdata/redis:
-	mkdir -p $@
-	wget -qO- https://download.redis.io/releases/redis-6.2.5.tar.gz | tar xvz --strip-components=1 -C $@
-
-testdata/redis/src/redis-server: testdata/redis
-	cd $< && make all
-
-fmt:
-	gofmt -w -s ./
-	goimports -w  -local github.com/go-redis/redis ./
-
-go_mod_tidy:
-	go get -u && go mod tidy
-	set -e; for dir in $(PACKAGE_DIRS); do \
-	  echo "go mod tidy in $${dir}"; \
-	  (cd "$${dir}" && \
-	    go get -u && \
-	    go mod tidy); \
-	done

vendor/github.com/go-redis/redis/v8/README.md

@@ -1,175 +0,0 @@
-# Redis client for Go
-
-![build workflow](https://github.com/go-redis/redis/actions/workflows/build.yml/badge.svg)
-[![PkgGoDev](https://pkg.go.dev/badge/github.com/go-redis/redis/v8)](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc)
-[![Documentation](https://img.shields.io/badge/redis-documentation-informational)](https://redis.uptrace.dev/)
-
-go-redis is brought to you by :star: [**uptrace/uptrace**](https://github.com/uptrace/uptrace).
-Uptrace is an open source and blazingly fast **distributed tracing** backend powered by
-OpenTelemetry and ClickHouse. Give it a star as well!
-
-## Resources
-
-- [Discussions](https://github.com/go-redis/redis/discussions)
-- [Documentation](https://redis.uptrace.dev)
-- [Reference](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc)
-- [Examples](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#pkg-examples)
-- [RealWorld example app](https://github.com/uptrace/go-treemux-realworld-example-app)
-
-Other projects you may like:
-
-- [Bun](https://bun.uptrace.dev) - fast and simple SQL client for PostgreSQL, MySQL, and SQLite.
-- [BunRouter](https://bunrouter.uptrace.dev/) - fast and flexible HTTP router for Go.
-
-## Ecosystem
-
-- [Redis Mock](https://github.com/go-redis/redismock)
-- [Distributed Locks](https://github.com/bsm/redislock)
-- [Redis Cache](https://github.com/go-redis/cache)
-- [Rate limiting](https://github.com/go-redis/redis_rate)
-
-## Features
-
-- Redis 3 commands except QUIT, MONITOR, and SYNC.
-- Automatic connection pooling with
-  [circuit breaker](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern) support.
-- [Pub/Sub](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#PubSub).
-- [Transactions](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-Client-TxPipeline).
-- [Pipeline](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-Client.Pipeline) and
-  [TxPipeline](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-Client.TxPipeline).
-- [Scripting](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#Script).
-- [Timeouts](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#Options).
-- [Redis Sentinel](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#NewFailoverClient).
-- [Redis Cluster](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#NewClusterClient).
-- [Cluster of Redis Servers](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-NewClusterClient-ManualSetup)
-  without using cluster mode and Redis Sentinel.
-- [Ring](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#NewRing).
-- [Instrumentation](https://pkg.go.dev/github.com/go-redis/redis/v8?tab=doc#example-package-Instrumentation).
-
-## Installation
-
-go-redis supports 2 last Go versions and requires a Go version with
-[modules](https://github.com/golang/go/wiki/Modules) support. So make sure to initialize a Go
-module:
-
-```shell
-go mod init github.com/my/repo
-```
-
-And then install go-redis/v8 (note _v8_ in the import; omitting it is a popular mistake):
-
-```shell
-go get github.com/go-redis/redis/v8
-```
-
-## Quickstart
-
-```go
-import (
-    "context"
-    "github.com/go-redis/redis/v8"
-    "fmt"
-)
-
-var ctx = context.Background()
-
-func ExampleClient() {
-    rdb := redis.NewClient(&redis.Options{
-        Addr:     "localhost:6379",
-        Password: "", // no password set
-        DB:       0,  // use default DB
-    })
-
-    err := rdb.Set(ctx, "key", "value", 0).Err()
-    if err != nil {
-        panic(err)
-    }
-
-    val, err := rdb.Get(ctx, "key").Result()
-    if err != nil {
-        panic(err)
-    }
-    fmt.Println("key", val)
-
-    val2, err := rdb.Get(ctx, "key2").Result()
-    if err == redis.Nil {
-        fmt.Println("key2 does not exist")
-    } else if err != nil {
-        panic(err)
-    } else {
-        fmt.Println("key2", val2)
-    }
-    // Output: key value
-    // key2 does not exist
-}
-```
-
-## Look and feel
-
-Some corner cases:
-
-```go
-// SET key value EX 10 NX
-set, err := rdb.SetNX(ctx, "key", "value", 10*time.Second).Result()
-
-// SET key value keepttl NX
-set, err := rdb.SetNX(ctx, "key", "value", redis.KeepTTL).Result()
-
-// SORT list LIMIT 0 2 ASC
-vals, err := rdb.Sort(ctx, "list", &redis.Sort{Offset: 0, Count: 2, Order: "ASC"}).Result()
-
-// ZRANGEBYSCORE zset -inf +inf WITHSCORES LIMIT 0 2
-vals, err := rdb.ZRangeByScoreWithScores(ctx, "zset", &redis.ZRangeBy{
-    Min: "-inf",
-    Max: "+inf",
-    Offset: 0,
-    Count: 2,
-}).Result()
-
-// ZINTERSTORE out 2 zset1 zset2 WEIGHTS 2 3 AGGREGATE SUM
-vals, err := rdb.ZInterStore(ctx, "out", &redis.ZStore{
-    Keys: []string{"zset1", "zset2"},
-    Weights: []int64{2, 3}
-}).Result()
-
-// EVAL "return {KEYS[1],ARGV[1]}" 1 "key" "hello"
-vals, err := rdb.Eval(ctx, "return {KEYS[1],ARGV[1]}", []string{"key"}, "hello").Result()
-
-// custom command
-res, err := rdb.Do(ctx, "set", "key", "value").Result()
-```
-
-## Run the test
-
-go-redis will start a redis-server and run the test cases.
-
-The paths of redis-server bin file and redis config file are defined in `main_test.go`:
-
-```
-var (
-	redisServerBin, _  = filepath.Abs(filepath.Join("testdata", "redis", "src", "redis-server"))
-	redisServerConf, _ = filepath.Abs(filepath.Join("testdata", "redis", "redis.conf"))
-)
-```
-
-For local testing, you can change the variables to refer to your local files, or create a soft link
-to the corresponding folder for redis-server and copy the config file to `testdata/redis/`:
-
-```
-ln -s /usr/bin/redis-server ./go-redis/testdata/redis/src
-cp ./go-redis/testdata/redis.conf ./go-redis/testdata/redis/
-```
-
-Lastly, run:
-
-```
-go test
-```
-
-## Contributors
-
-Thanks to all the people who already contributed!
-
-<a href="https://github.com/go-redis/redis/graphs/contributors">
-  <img src="https://contributors-img.web.app/image?repo=go-redis/redis" />
-</a>

vendor/github.com/go-redis/redis/v8/RELEASING.md

@@ -1,15 +0,0 @@
-# Releasing
-
-1. Run `release.sh` script which updates versions in go.mod files and pushes a new branch to GitHub:
-
-```shell
-TAG=v1.0.0 ./scripts/release.sh
-```
-
-2. Open a pull request and wait for the build to finish.
-
-3. Merge the pull request and run `tag.sh` to create tags for packages:
-
-```shell
-TAG=v1.0.0 ./scripts/tag.sh
-```

vendor/github.com/go-redis/redis/v8/cluster_commands.go

@@ -1,109 +0,0 @@
-package redis
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-)
-
-func (c *ClusterClient) DBSize(ctx context.Context) *IntCmd {
-	cmd := NewIntCmd(ctx, "dbsize")
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		var size int64
-		err := c.ForEachMaster(ctx, func(ctx context.Context, master *Client) error {
-			n, err := master.DBSize(ctx).Result()
-			if err != nil {
-				return err
-			}
-			atomic.AddInt64(&size, n)
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		} else {
-			cmd.val = size
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptLoad(ctx context.Context, script string) *StringCmd {
-	cmd := NewStringCmd(ctx, "script", "load", script)
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		mu := &sync.Mutex{}
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			val, err := shard.ScriptLoad(ctx, script).Result()
-			if err != nil {
-				return err
-			}
-
-			mu.Lock()
-			if cmd.Val() == "" {
-				cmd.val = val
-			}
-			mu.Unlock()
-
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptFlush(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "script", "flush")
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			return shard.ScriptFlush(ctx).Err()
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
-	args := make([]interface{}, 2+len(hashes))
-	args[0] = "script"
-	args[1] = "exists"
-	for i, hash := range hashes {
-		args[2+i] = hash
-	}
-	cmd := NewBoolSliceCmd(ctx, args...)
-
-	result := make([]bool, len(hashes))
-	for i := range result {
-		result[i] = true
-	}
-
-	_ = c.hooks.process(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		mu := &sync.Mutex{}
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			val, err := shard.ScriptExists(ctx, hashes...).Result()
-			if err != nil {
-				return err
-			}
-
-			mu.Lock()
-			for i, v := range val {
-				result[i] = result[i] && v
-			}
-			mu.Unlock()
-
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		} else {
-			cmd.val = result
-		}
-		return nil
-	})
-	return cmd
-}

vendor/github.com/go-redis/redis/v8/doc.go

@@ -1,4 +0,0 @@
-/*
-Package redis implements a Redis client.
-*/
-package redis

vendor/github.com/go-redis/redis/v8/error.go

@@ -1,144 +0,0 @@
-package redis
-
-import (
-	"context"
-	"io"
-	"net"
-	"strings"
-
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-// ErrClosed performs any operation on the closed client will return this error.
-var ErrClosed = pool.ErrClosed
-
-type Error interface {
-	error
-
-	// RedisError is a no-op function but
-	// serves to distinguish types that are Redis
-	// errors from ordinary errors: a type is a
-	// Redis error if it has a RedisError method.
-	RedisError()
-}
-
-var _ Error = proto.RedisError("")
-
-func shouldRetry(err error, retryTimeout bool) bool {
-	switch err {
-	case io.EOF, io.ErrUnexpectedEOF:
-		return true
-	case nil, context.Canceled, context.DeadlineExceeded:
-		return false
-	}
-
-	if v, ok := err.(timeoutError); ok {
-		if v.Timeout() {
-			return retryTimeout
-		}
-		return true
-	}
-
-	s := err.Error()
-	if s == "ERR max number of clients reached" {
-		return true
-	}
-	if strings.HasPrefix(s, "LOADING ") {
-		return true
-	}
-	if strings.HasPrefix(s, "READONLY ") {
-		return true
-	}
-	if strings.HasPrefix(s, "CLUSTERDOWN ") {
-		return true
-	}
-	if strings.HasPrefix(s, "TRYAGAIN ") {
-		return true
-	}
-
-	return false
-}
-
-func isRedisError(err error) bool {
-	_, ok := err.(proto.RedisError)
-	return ok
-}
-
-func isBadConn(err error, allowTimeout bool, addr string) bool {
-	switch err {
-	case nil:
-		return false
-	case context.Canceled, context.DeadlineExceeded:
-		return true
-	}
-
-	if isRedisError(err) {
-		switch {
-		case isReadOnlyError(err):
-			// Close connections in read only state in case domain addr is used
-			// and domain resolves to a different Redis Server. See #790.
-			return true
-		case isMovedSameConnAddr(err, addr):
-			// Close connections when we are asked to move to the same addr
-			// of the connection. Force a DNS resolution when all connections
-			// of the pool are recycled
-			return true
-		default:
-			return false
-		}
-	}
-
-	if allowTimeout {
-		if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
-			return !netErr.Temporary()
-		}
-	}
-
-	return true
-}
-
-func isMovedError(err error) (moved bool, ask bool, addr string) {
-	if !isRedisError(err) {
-		return
-	}
-
-	s := err.Error()
-	switch {
-	case strings.HasPrefix(s, "MOVED "):
-		moved = true
-	case strings.HasPrefix(s, "ASK "):
-		ask = true
-	default:
-		return
-	}
-
-	ind := strings.LastIndex(s, " ")
-	if ind == -1 {
-		return false, false, ""
-	}
-	addr = s[ind+1:]
-	return
-}
-
-func isLoadingError(err error) bool {
-	return strings.HasPrefix(err.Error(), "LOADING ")
-}
-
-func isReadOnlyError(err error) bool {
-	return strings.HasPrefix(err.Error(), "READONLY ")
-}
-
-func isMovedSameConnAddr(err error, addr string) bool {
-	redisError := err.Error()
-	if !strings.HasPrefix(redisError, "MOVED ") {
-		return false
-	}
-	return strings.HasSuffix(redisError, " "+addr)
-}
-
-//------------------------------------------------------------------------------
-
-type timeoutError interface {
-	Timeout() bool
-}

vendor/github.com/go-redis/redis/v8/internal/arg.go

@@ -1,56 +0,0 @@
-package internal
-
-import (
-	"fmt"
-	"strconv"
-	"time"
-)
-
-func AppendArg(b []byte, v interface{}) []byte {
-	switch v := v.(type) {
-	case nil:
-		return append(b, "<nil>"...)
-	case string:
-		return appendUTF8String(b, Bytes(v))
-	case []byte:
-		return appendUTF8String(b, v)
-	case int:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int8:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int16:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int32:
-		return strconv.AppendInt(b, int64(v), 10)
-	case int64:
-		return strconv.AppendInt(b, v, 10)
-	case uint:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint8:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint16:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint32:
-		return strconv.AppendUint(b, uint64(v), 10)
-	case uint64:
-		return strconv.AppendUint(b, v, 10)
-	case float32:
-		return strconv.AppendFloat(b, float64(v), 'f', -1, 64)
-	case float64:
-		return strconv.AppendFloat(b, v, 'f', -1, 64)
-	case bool:
-		if v {
-			return append(b, "true"...)
-		}
-		return append(b, "false"...)
-	case time.Time:
-		return v.AppendFormat(b, time.RFC3339Nano)
-	default:
-		return append(b, fmt.Sprint(v)...)
-	}
-}
-
-func appendUTF8String(dst []byte, src []byte) []byte {
-	dst = append(dst, src...)
-	return dst
-}

vendor/github.com/go-redis/redis/v8/internal/hashtag/hashtag.go

@@ -1,78 +0,0 @@
-package hashtag
-
-import (
-	"strings"
-
-	"github.com/go-redis/redis/v8/internal/rand"
-)
-
-const slotNumber = 16384
-
-// CRC16 implementation according to CCITT standards.
-// Copyright 2001-2010 Georges Menie (www.menie.org)
-// Copyright 2013 The Go Authors. All rights reserved.
-// http://redis.io/topics/cluster-spec#appendix-a-crc16-reference-implementation-in-ansi-c
-var crc16tab = [256]uint16{
-	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
-	0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
-	0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
-	0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
-	0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
-	0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
-	0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
-	0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
-	0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
-	0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
-	0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
-	0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
-	0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
-	0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
-	0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
-	0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
-	0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
-	0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
-	0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
-	0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
-	0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
-	0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
-	0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
-	0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
-	0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
-	0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
-	0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
-	0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
-	0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
-	0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
-	0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
-	0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
-}
-
-func Key(key string) string {
-	if s := strings.IndexByte(key, '{'); s > -1 {
-		if e := strings.IndexByte(key[s+1:], '}'); e > 0 {
-			return key[s+1 : s+e+1]
-		}
-	}
-	return key
-}
-
-func RandomSlot() int {
-	return rand.Intn(slotNumber)
-}
-
-// Slot returns a consistent slot number between 0 and 16383
-// for any given string key.
-func Slot(key string) int {
-	if key == "" {
-		return RandomSlot()
-	}
-	key = Key(key)
-	return int(crc16sum(key)) % slotNumber
-}
-
-func crc16sum(key string) (crc uint16) {
-	for i := 0; i < len(key); i++ {
-		crc = (crc << 8) ^ crc16tab[(byte(crc>>8)^key[i])&0x00ff]
-	}
-	return
-}

vendor/github.com/go-redis/redis/v8/internal/hscan/hscan.go

@@ -1,201 +0,0 @@
-package hscan
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"strconv"
-)
-
-// decoderFunc represents decoding functions for default built-in types.
-type decoderFunc func(reflect.Value, string) error
-
-var (
-	// List of built-in decoders indexed by their numeric constant values (eg: reflect.Bool = 1).
-	decoders = []decoderFunc{
-		reflect.Bool:          decodeBool,
-		reflect.Int:           decodeInt,
-		reflect.Int8:          decodeInt8,
-		reflect.Int16:         decodeInt16,
-		reflect.Int32:         decodeInt32,
-		reflect.Int64:         decodeInt64,
-		reflect.Uint:          decodeUint,
-		reflect.Uint8:         decodeUint8,
-		reflect.Uint16:        decodeUint16,
-		reflect.Uint32:        decodeUint32,
-		reflect.Uint64:        decodeUint64,
-		reflect.Float32:       decodeFloat32,
-		reflect.Float64:       decodeFloat64,
-		reflect.Complex64:     decodeUnsupported,
-		reflect.Complex128:    decodeUnsupported,
-		reflect.Array:         decodeUnsupported,
-		reflect.Chan:          decodeUnsupported,
-		reflect.Func:          decodeUnsupported,
-		reflect.Interface:     decodeUnsupported,
-		reflect.Map:           decodeUnsupported,
-		reflect.Ptr:           decodeUnsupported,
-		reflect.Slice:         decodeSlice,
-		reflect.String:        decodeString,
-		reflect.Struct:        decodeUnsupported,
-		reflect.UnsafePointer: decodeUnsupported,
-	}
-
-	// Global map of struct field specs that is populated once for every new
-	// struct type that is scanned. This caches the field types and the corresponding
-	// decoder functions to avoid iterating through struct fields on subsequent scans.
-	globalStructMap = newStructMap()
-)
-
-func Struct(dst interface{}) (StructValue, error) {
-	v := reflect.ValueOf(dst)
-
-	// The destination to scan into should be a struct pointer.
-	if v.Kind() != reflect.Ptr || v.IsNil() {
-		return StructValue{}, fmt.Errorf("redis.Scan(non-pointer %T)", dst)
-	}
-
-	v = v.Elem()
-	if v.Kind() != reflect.Struct {
-		return StructValue{}, fmt.Errorf("redis.Scan(non-struct %T)", dst)
-	}
-
-	return StructValue{
-		spec:  globalStructMap.get(v.Type()),
-		value: v,
-	}, nil
-}
-
-// Scan scans the results from a key-value Redis map result set to a destination struct.
-// The Redis keys are matched to the struct's field with the `redis` tag.
-func Scan(dst interface{}, keys []interface{}, vals []interface{}) error {
-	if len(keys) != len(vals) {
-		return errors.New("args should have the same number of keys and vals")
-	}
-
-	strct, err := Struct(dst)
-	if err != nil {
-		return err
-	}
-
-	// Iterate through the (key, value) sequence.
-	for i := 0; i < len(vals); i++ {
-		key, ok := keys[i].(string)
-		if !ok {
-			continue
-		}
-
-		val, ok := vals[i].(string)
-		if !ok {
-			continue
-		}
-
-		if err := strct.Scan(key, val); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func decodeBool(f reflect.Value, s string) error {
-	b, err := strconv.ParseBool(s)
-	if err != nil {
-		return err
-	}
-	f.SetBool(b)
-	return nil
-}
-
-func decodeInt8(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 8)
-}
-
-func decodeInt16(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 16)
-}
-
-func decodeInt32(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 32)
-}
-
-func decodeInt64(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 64)
-}
-
-func decodeInt(f reflect.Value, s string) error {
-	return decodeNumber(f, s, 0)
-}
-
-func decodeNumber(f reflect.Value, s string, bitSize int) error {
-	v, err := strconv.ParseInt(s, 10, bitSize)
-	if err != nil {
-		return err
-	}
-	f.SetInt(v)
-	return nil
-}
-
-func decodeUint8(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 8)
-}
-
-func decodeUint16(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 16)
-}
-
-func decodeUint32(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 32)
-}
-
-func decodeUint64(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 64)
-}
-
-func decodeUint(f reflect.Value, s string) error {
-	return decodeUnsignedNumber(f, s, 0)
-}
-
-func decodeUnsignedNumber(f reflect.Value, s string, bitSize int) error {
-	v, err := strconv.ParseUint(s, 10, bitSize)
-	if err != nil {
-		return err
-	}
-	f.SetUint(v)
-	return nil
-}
-
-func decodeFloat32(f reflect.Value, s string) error {
-	v, err := strconv.ParseFloat(s, 32)
-	if err != nil {
-		return err
-	}
-	f.SetFloat(v)
-	return nil
-}
-
-// although the default is float64, but we better define it.
-func decodeFloat64(f reflect.Value, s string) error {
-	v, err := strconv.ParseFloat(s, 64)
-	if err != nil {
-		return err
-	}
-	f.SetFloat(v)
-	return nil
-}
-
-func decodeString(f reflect.Value, s string) error {
-	f.SetString(s)
-	return nil
-}
-
-func decodeSlice(f reflect.Value, s string) error {
-	// []byte slice ([]uint8).
-	if f.Type().Elem().Kind() == reflect.Uint8 {
-		f.SetBytes([]byte(s))
-	}
-	return nil
-}
-
-func decodeUnsupported(v reflect.Value, s string) error {
-	return fmt.Errorf("redis.Scan(unsupported %s)", v.Type())
-}

vendor/github.com/go-redis/redis/v8/internal/hscan/structmap.go

@@ -1,93 +0,0 @@
-package hscan
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"sync"
-)
-
-// structMap contains the map of struct fields for target structs
-// indexed by the struct type.
-type structMap struct {
-	m sync.Map
-}
-
-func newStructMap() *structMap {
-	return new(structMap)
-}
-
-func (s *structMap) get(t reflect.Type) *structSpec {
-	if v, ok := s.m.Load(t); ok {
-		return v.(*structSpec)
-	}
-
-	spec := newStructSpec(t, "redis")
-	s.m.Store(t, spec)
-	return spec
-}
-
-//------------------------------------------------------------------------------
-
-// structSpec contains the list of all fields in a target struct.
-type structSpec struct {
-	m map[string]*structField
-}
-
-func (s *structSpec) set(tag string, sf *structField) {
-	s.m[tag] = sf
-}
-
-func newStructSpec(t reflect.Type, fieldTag string) *structSpec {
-	numField := t.NumField()
-	out := &structSpec{
-		m: make(map[string]*structField, numField),
-	}
-
-	for i := 0; i < numField; i++ {
-		f := t.Field(i)
-
-		tag := f.Tag.Get(fieldTag)
-		if tag == "" || tag == "-" {
-			continue
-		}
-
-		tag = strings.Split(tag, ",")[0]
-		if tag == "" {
-			continue
-		}
-
-		// Use the built-in decoder.
-		out.set(tag, &structField{index: i, fn: decoders[f.Type.Kind()]})
-	}
-
-	return out
-}
-
-//------------------------------------------------------------------------------
-
-// structField represents a single field in a target struct.
-type structField struct {
-	index int
-	fn    decoderFunc
-}
-
-//------------------------------------------------------------------------------
-
-type StructValue struct {
-	spec  *structSpec
-	value reflect.Value
-}
-
-func (s StructValue) Scan(key string, value string) error {
-	field, ok := s.spec.m[key]
-	if !ok {
-		return nil
-	}
-	if err := field.fn(s.value.Field(field.index), value); err != nil {
-		t := s.value.Type()
-		return fmt.Errorf("cannot scan redis.result %s into struct field %s.%s of type %s, error-%s",
-			value, t.Name(), t.Field(field.index).Name, t.Field(field.index).Type, err.Error())
-	}
-	return nil
-}

vendor/github.com/go-redis/redis/v8/internal/internal.go

@@ -1,29 +0,0 @@
-package internal
-
-import (
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/rand"
-)
-
-func RetryBackoff(retry int, minBackoff, maxBackoff time.Duration) time.Duration {
-	if retry < 0 {
-		panic("not reached")
-	}
-	if minBackoff == 0 {
-		return 0
-	}
-
-	d := minBackoff << uint(retry)
-	if d < minBackoff {
-		return maxBackoff
-	}
-
-	d = minBackoff + time.Duration(rand.Int63n(int64(d)))
-
-	if d > maxBackoff || d < minBackoff {
-		d = maxBackoff
-	}
-
-	return d
-}

vendor/github.com/go-redis/redis/v8/internal/log.go

@@ -1,26 +0,0 @@
-package internal
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"os"
-)
-
-type Logging interface {
-	Printf(ctx context.Context, format string, v ...interface{})
-}
-
-type logger struct {
-	log *log.Logger
-}
-
-func (l *logger) Printf(ctx context.Context, format string, v ...interface{}) {
-	_ = l.log.Output(2, fmt.Sprintf(format, v...))
-}
-
-// Logger calls Output to print to the stderr.
-// Arguments are handled in the manner of fmt.Print.
-var Logger Logging = &logger{
-	log: log.New(os.Stderr, "redis: ", log.LstdFlags|log.Lshortfile),
-}

vendor/github.com/go-redis/redis/v8/internal/once.go

@@ -1,60 +0,0 @@
-/*
-Copyright 2014 The Camlistore Authors
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package internal
-
-import (
-	"sync"
-	"sync/atomic"
-)
-
-// A Once will perform a successful action exactly once.
-//
-// Unlike a sync.Once, this Once's func returns an error
-// and is re-armed on failure.
-type Once struct {
-	m    sync.Mutex
-	done uint32
-}
-
-// Do calls the function f if and only if Do has not been invoked
-// without error for this instance of Once.  In other words, given
-// 	var once Once
-// if once.Do(f) is called multiple times, only the first call will
-// invoke f, even if f has a different value in each invocation unless
-// f returns an error.  A new instance of Once is required for each
-// function to execute.
-//
-// Do is intended for initialization that must be run exactly once.  Since f
-// is niladic, it may be necessary to use a function literal to capture the
-// arguments to a function to be invoked by Do:
-// 	err := config.once.Do(func() error { return config.init(filename) })
-func (o *Once) Do(f func() error) error {
-	if atomic.LoadUint32(&o.done) == 1 {
-		return nil
-	}
-	// Slow-path.
-	o.m.Lock()
-	defer o.m.Unlock()
-	var err error
-	if o.done == 0 {
-		err = f()
-		if err == nil {
-			atomic.StoreUint32(&o.done, 1)
-		}
-	}
-	return err
-}

vendor/github.com/go-redis/redis/v8/internal/pool/conn.go

@@ -1,121 +0,0 @@
-package pool
-
-import (
-	"bufio"
-	"context"
-	"net"
-	"sync/atomic"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-var noDeadline = time.Time{}
-
-type Conn struct {
-	usedAt  int64 // atomic
-	netConn net.Conn
-
-	rd *proto.Reader
-	bw *bufio.Writer
-	wr *proto.Writer
-
-	Inited    bool
-	pooled    bool
-	createdAt time.Time
-}
-
-func NewConn(netConn net.Conn) *Conn {
-	cn := &Conn{
-		netConn:   netConn,
-		createdAt: time.Now(),
-	}
-	cn.rd = proto.NewReader(netConn)
-	cn.bw = bufio.NewWriter(netConn)
-	cn.wr = proto.NewWriter(cn.bw)
-	cn.SetUsedAt(time.Now())
-	return cn
-}
-
-func (cn *Conn) UsedAt() time.Time {
-	unix := atomic.LoadInt64(&cn.usedAt)
-	return time.Unix(unix, 0)
-}
-
-func (cn *Conn) SetUsedAt(tm time.Time) {
-	atomic.StoreInt64(&cn.usedAt, tm.Unix())
-}
-
-func (cn *Conn) SetNetConn(netConn net.Conn) {
-	cn.netConn = netConn
-	cn.rd.Reset(netConn)
-	cn.bw.Reset(netConn)
-}
-
-func (cn *Conn) Write(b []byte) (int, error) {
-	return cn.netConn.Write(b)
-}
-
-func (cn *Conn) RemoteAddr() net.Addr {
-	if cn.netConn != nil {
-		return cn.netConn.RemoteAddr()
-	}
-	return nil
-}
-
-func (cn *Conn) WithReader(ctx context.Context, timeout time.Duration, fn func(rd *proto.Reader) error) error {
-	if err := cn.netConn.SetReadDeadline(cn.deadline(ctx, timeout)); err != nil {
-		return err
-	}
-	return fn(cn.rd)
-}
-
-func (cn *Conn) WithWriter(
-	ctx context.Context, timeout time.Duration, fn func(wr *proto.Writer) error,
-) error {
-	if err := cn.netConn.SetWriteDeadline(cn.deadline(ctx, timeout)); err != nil {
-		return err
-	}
-
-	if cn.bw.Buffered() > 0 {
-		cn.bw.Reset(cn.netConn)
-	}
-
-	if err := fn(cn.wr); err != nil {
-		return err
-	}
-
-	return cn.bw.Flush()
-}
-
-func (cn *Conn) Close() error {
-	return cn.netConn.Close()
-}
-
-func (cn *Conn) deadline(ctx context.Context, timeout time.Duration) time.Time {
-	tm := time.Now()
-	cn.SetUsedAt(tm)
-
-	if timeout > 0 {
-		tm = tm.Add(timeout)
-	}
-
-	if ctx != nil {
-		deadline, ok := ctx.Deadline()
-		if ok {
-			if timeout == 0 {
-				return deadline
-			}
-			if deadline.Before(tm) {
-				return deadline
-			}
-			return tm
-		}
-	}
-
-	if timeout > 0 {
-		return tm
-	}
-
-	return noDeadline
-}

vendor/github.com/go-redis/redis/v8/internal/pool/pool.go

@@ -1,557 +0,0 @@
-package pool
-
-import (
-	"context"
-	"errors"
-	"net"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal"
-)
-
-var (
-	// ErrClosed performs any operation on the closed client will return this error.
-	ErrClosed = errors.New("redis: client is closed")
-
-	// ErrPoolTimeout timed out waiting to get a connection from the connection pool.
-	ErrPoolTimeout = errors.New("redis: connection pool timeout")
-)
-
-var timers = sync.Pool{
-	New: func() interface{} {
-		t := time.NewTimer(time.Hour)
-		t.Stop()
-		return t
-	},
-}
-
-// Stats contains pool state information and accumulated stats.
-type Stats struct {
-	Hits     uint32 // number of times free connection was found in the pool
-	Misses   uint32 // number of times free connection was NOT found in the pool
-	Timeouts uint32 // number of times a wait timeout occurred
-
-	TotalConns uint32 // number of total connections in the pool
-	IdleConns  uint32 // number of idle connections in the pool
-	StaleConns uint32 // number of stale connections removed from the pool
-}
-
-type Pooler interface {
-	NewConn(context.Context) (*Conn, error)
-	CloseConn(*Conn) error
-
-	Get(context.Context) (*Conn, error)
-	Put(context.Context, *Conn)
-	Remove(context.Context, *Conn, error)
-
-	Len() int
-	IdleLen() int
-	Stats() *Stats
-
-	Close() error
-}
-
-type Options struct {
-	Dialer  func(context.Context) (net.Conn, error)
-	OnClose func(*Conn) error
-
-	PoolFIFO           bool
-	PoolSize           int
-	MinIdleConns       int
-	MaxConnAge         time.Duration
-	PoolTimeout        time.Duration
-	IdleTimeout        time.Duration
-	IdleCheckFrequency time.Duration
-}
-
-type lastDialErrorWrap struct {
-	err error
-}
-
-type ConnPool struct {
-	opt *Options
-
-	dialErrorsNum uint32 // atomic
-
-	lastDialError atomic.Value
-
-	queue chan struct{}
-
-	connsMu      sync.Mutex
-	conns        []*Conn
-	idleConns    []*Conn
-	poolSize     int
-	idleConnsLen int
-
-	stats Stats
-
-	_closed  uint32 // atomic
-	closedCh chan struct{}
-}
-
-var _ Pooler = (*ConnPool)(nil)
-
-func NewConnPool(opt *Options) *ConnPool {
-	p := &ConnPool{
-		opt: opt,
-
-		queue:     make(chan struct{}, opt.PoolSize),
-		conns:     make([]*Conn, 0, opt.PoolSize),
-		idleConns: make([]*Conn, 0, opt.PoolSize),
-		closedCh:  make(chan struct{}),
-	}
-
-	p.connsMu.Lock()
-	p.checkMinIdleConns()
-	p.connsMu.Unlock()
-
-	if opt.IdleTimeout > 0 && opt.IdleCheckFrequency > 0 {
-		go p.reaper(opt.IdleCheckFrequency)
-	}
-
-	return p
-}
-
-func (p *ConnPool) checkMinIdleConns() {
-	if p.opt.MinIdleConns == 0 {
-		return
-	}
-	for p.poolSize < p.opt.PoolSize && p.idleConnsLen < p.opt.MinIdleConns {
-		p.poolSize++
-		p.idleConnsLen++
-
-		go func() {
-			err := p.addIdleConn()
-			if err != nil && err != ErrClosed {
-				p.connsMu.Lock()
-				p.poolSize--
-				p.idleConnsLen--
-				p.connsMu.Unlock()
-			}
-		}()
-	}
-}
-
-func (p *ConnPool) addIdleConn() error {
-	cn, err := p.dialConn(context.TODO(), true)
-	if err != nil {
-		return err
-	}
-
-	p.connsMu.Lock()
-	defer p.connsMu.Unlock()
-
-	// It is not allowed to add new connections to the closed connection pool.
-	if p.closed() {
-		_ = cn.Close()
-		return ErrClosed
-	}
-
-	p.conns = append(p.conns, cn)
-	p.idleConns = append(p.idleConns, cn)
-	return nil
-}
-
-func (p *ConnPool) NewConn(ctx context.Context) (*Conn, error) {
-	return p.newConn(ctx, false)
-}
-
-func (p *ConnPool) newConn(ctx context.Context, pooled bool) (*Conn, error) {
-	cn, err := p.dialConn(ctx, pooled)
-	if err != nil {
-		return nil, err
-	}
-
-	p.connsMu.Lock()
-	defer p.connsMu.Unlock()
-
-	// It is not allowed to add new connections to the closed connection pool.
-	if p.closed() {
-		_ = cn.Close()
-		return nil, ErrClosed
-	}
-
-	p.conns = append(p.conns, cn)
-	if pooled {
-		// If pool is full remove the cn on next Put.
-		if p.poolSize >= p.opt.PoolSize {
-			cn.pooled = false
-		} else {
-			p.poolSize++
-		}
-	}
-
-	return cn, nil
-}
-
-func (p *ConnPool) dialConn(ctx context.Context, pooled bool) (*Conn, error) {
-	if p.closed() {
-		return nil, ErrClosed
-	}
-
-	if atomic.LoadUint32(&p.dialErrorsNum) >= uint32(p.opt.PoolSize) {
-		return nil, p.getLastDialError()
-	}
-
-	netConn, err := p.opt.Dialer(ctx)
-	if err != nil {
-		p.setLastDialError(err)
-		if atomic.AddUint32(&p.dialErrorsNum, 1) == uint32(p.opt.PoolSize) {
-			go p.tryDial()
-		}
-		return nil, err
-	}
-
-	cn := NewConn(netConn)
-	cn.pooled = pooled
-	return cn, nil
-}
-
-func (p *ConnPool) tryDial() {
-	for {
-		if p.closed() {
-			return
-		}
-
-		conn, err := p.opt.Dialer(context.Background())
-		if err != nil {
-			p.setLastDialError(err)
-			time.Sleep(time.Second)
-			continue
-		}
-
-		atomic.StoreUint32(&p.dialErrorsNum, 0)
-		_ = conn.Close()
-		return
-	}
-}
-
-func (p *ConnPool) setLastDialError(err error) {
-	p.lastDialError.Store(&lastDialErrorWrap{err: err})
-}
-
-func (p *ConnPool) getLastDialError() error {
-	err, _ := p.lastDialError.Load().(*lastDialErrorWrap)
-	if err != nil {
-		return err.err
-	}
-	return nil
-}
-
-// Get returns existed connection from the pool or creates a new one.
-func (p *ConnPool) Get(ctx context.Context) (*Conn, error) {
-	if p.closed() {
-		return nil, ErrClosed
-	}
-
-	if err := p.waitTurn(ctx); err != nil {
-		return nil, err
-	}
-
-	for {
-		p.connsMu.Lock()
-		cn, err := p.popIdle()
-		p.connsMu.Unlock()
-
-		if err != nil {
-			return nil, err
-		}
-
-		if cn == nil {
-			break
-		}
-
-		if p.isStaleConn(cn) {
-			_ = p.CloseConn(cn)
-			continue
-		}
-
-		atomic.AddUint32(&p.stats.Hits, 1)
-		return cn, nil
-	}
-
-	atomic.AddUint32(&p.stats.Misses, 1)
-
-	newcn, err := p.newConn(ctx, true)
-	if err != nil {
-		p.freeTurn()
-		return nil, err
-	}
-
-	return newcn, nil
-}
-
-func (p *ConnPool) getTurn() {
-	p.queue <- struct{}{}
-}
-
-func (p *ConnPool) waitTurn(ctx context.Context) error {
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	default:
-	}
-
-	select {
-	case p.queue <- struct{}{}:
-		return nil
-	default:
-	}
-
-	timer := timers.Get().(*time.Timer)
-	timer.Reset(p.opt.PoolTimeout)
-
-	select {
-	case <-ctx.Done():
-		if !timer.Stop() {
-			<-timer.C
-		}
-		timers.Put(timer)
-		return ctx.Err()
-	case p.queue <- struct{}{}:
-		if !timer.Stop() {
-			<-timer.C
-		}
-		timers.Put(timer)
-		return nil
-	case <-timer.C:
-		timers.Put(timer)
-		atomic.AddUint32(&p.stats.Timeouts, 1)
-		return ErrPoolTimeout
-	}
-}
-
-func (p *ConnPool) freeTurn() {
-	<-p.queue
-}
-
-func (p *ConnPool) popIdle() (*Conn, error) {
-	if p.closed() {
-		return nil, ErrClosed
-	}
-	n := len(p.idleConns)
-	if n == 0 {
-		return nil, nil
-	}
-
-	var cn *Conn
-	if p.opt.PoolFIFO {
-		cn = p.idleConns[0]
-		copy(p.idleConns, p.idleConns[1:])
-		p.idleConns = p.idleConns[:n-1]
-	} else {
-		idx := n - 1
-		cn = p.idleConns[idx]
-		p.idleConns = p.idleConns[:idx]
-	}
-	p.idleConnsLen--
-	p.checkMinIdleConns()
-	return cn, nil
-}
-
-func (p *ConnPool) Put(ctx context.Context, cn *Conn) {
-	if cn.rd.Buffered() > 0 {
-		internal.Logger.Printf(ctx, "Conn has unread data")
-		p.Remove(ctx, cn, BadConnError{})
-		return
-	}
-
-	if !cn.pooled {
-		p.Remove(ctx, cn, nil)
-		return
-	}
-
-	p.connsMu.Lock()
-	p.idleConns = append(p.idleConns, cn)
-	p.idleConnsLen++
-	p.connsMu.Unlock()
-	p.freeTurn()
-}
-
-func (p *ConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
-	p.removeConnWithLock(cn)
-	p.freeTurn()
-	_ = p.closeConn(cn)
-}
-
-func (p *ConnPool) CloseConn(cn *Conn) error {
-	p.removeConnWithLock(cn)
-	return p.closeConn(cn)
-}
-
-func (p *ConnPool) removeConnWithLock(cn *Conn) {
-	p.connsMu.Lock()
-	p.removeConn(cn)
-	p.connsMu.Unlock()
-}
-
-func (p *ConnPool) removeConn(cn *Conn) {
-	for i, c := range p.conns {
-		if c == cn {
-			p.conns = append(p.conns[:i], p.conns[i+1:]...)
-			if cn.pooled {
-				p.poolSize--
-				p.checkMinIdleConns()
-			}
-			return
-		}
-	}
-}
-
-func (p *ConnPool) closeConn(cn *Conn) error {
-	if p.opt.OnClose != nil {
-		_ = p.opt.OnClose(cn)
-	}
-	return cn.Close()
-}
-
-// Len returns total number of connections.
-func (p *ConnPool) Len() int {
-	p.connsMu.Lock()
-	n := len(p.conns)
-	p.connsMu.Unlock()
-	return n
-}
-
-// IdleLen returns number of idle connections.
-func (p *ConnPool) IdleLen() int {
-	p.connsMu.Lock()
-	n := p.idleConnsLen
-	p.connsMu.Unlock()
-	return n
-}
-
-func (p *ConnPool) Stats() *Stats {
-	idleLen := p.IdleLen()
-	return &Stats{
-		Hits:     atomic.LoadUint32(&p.stats.Hits),
-		Misses:   atomic.LoadUint32(&p.stats.Misses),
-		Timeouts: atomic.LoadUint32(&p.stats.Timeouts),
-
-		TotalConns: uint32(p.Len()),
-		IdleConns:  uint32(idleLen),
-		StaleConns: atomic.LoadUint32(&p.stats.StaleConns),
-	}
-}
-
-func (p *ConnPool) closed() bool {
-	return atomic.LoadUint32(&p._closed) == 1
-}
-
-func (p *ConnPool) Filter(fn func(*Conn) bool) error {
-	p.connsMu.Lock()
-	defer p.connsMu.Unlock()
-
-	var firstErr error
-	for _, cn := range p.conns {
-		if fn(cn) {
-			if err := p.closeConn(cn); err != nil && firstErr == nil {
-				firstErr = err
-			}
-		}
-	}
-	return firstErr
-}
-
-func (p *ConnPool) Close() error {
-	if !atomic.CompareAndSwapUint32(&p._closed, 0, 1) {
-		return ErrClosed
-	}
-	close(p.closedCh)
-
-	var firstErr error
-	p.connsMu.Lock()
-	for _, cn := range p.conns {
-		if err := p.closeConn(cn); err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-	p.conns = nil
-	p.poolSize = 0
-	p.idleConns = nil
-	p.idleConnsLen = 0
-	p.connsMu.Unlock()
-
-	return firstErr
-}
-
-func (p *ConnPool) reaper(frequency time.Duration) {
-	ticker := time.NewTicker(frequency)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			// It is possible that ticker and closedCh arrive together,
-			// and select pseudo-randomly pick ticker case, we double
-			// check here to prevent being executed after closed.
-			if p.closed() {
-				return
-			}
-			_, err := p.ReapStaleConns()
-			if err != nil {
-				internal.Logger.Printf(context.Background(), "ReapStaleConns failed: %s", err)
-				continue
-			}
-		case <-p.closedCh:
-			return
-		}
-	}
-}
-
-func (p *ConnPool) ReapStaleConns() (int, error) {
-	var n int
-	for {
-		p.getTurn()
-
-		p.connsMu.Lock()
-		cn := p.reapStaleConn()
-		p.connsMu.Unlock()
-
-		p.freeTurn()
-
-		if cn != nil {
-			_ = p.closeConn(cn)
-			n++
-		} else {
-			break
-		}
-	}
-	atomic.AddUint32(&p.stats.StaleConns, uint32(n))
-	return n, nil
-}
-
-func (p *ConnPool) reapStaleConn() *Conn {
-	if len(p.idleConns) == 0 {
-		return nil
-	}
-
-	cn := p.idleConns[0]
-	if !p.isStaleConn(cn) {
-		return nil
-	}
-
-	p.idleConns = append(p.idleConns[:0], p.idleConns[1:]...)
-	p.idleConnsLen--
-	p.removeConn(cn)
-
-	return cn
-}
-
-func (p *ConnPool) isStaleConn(cn *Conn) bool {
-	if p.opt.IdleTimeout == 0 && p.opt.MaxConnAge == 0 {
-		return false
-	}
-
-	now := time.Now()
-	if p.opt.IdleTimeout > 0 && now.Sub(cn.UsedAt()) >= p.opt.IdleTimeout {
-		return true
-	}
-	if p.opt.MaxConnAge > 0 && now.Sub(cn.createdAt) >= p.opt.MaxConnAge {
-		return true
-	}
-
-	return false
-}

vendor/github.com/go-redis/redis/v8/internal/pool/pool_single.go

@@ -1,58 +0,0 @@
-package pool
-
-import "context"
-
-type SingleConnPool struct {
-	pool      Pooler
-	cn        *Conn
-	stickyErr error
-}
-
-var _ Pooler = (*SingleConnPool)(nil)
-
-func NewSingleConnPool(pool Pooler, cn *Conn) *SingleConnPool {
-	return &SingleConnPool{
-		pool: pool,
-		cn:   cn,
-	}
-}
-
-func (p *SingleConnPool) NewConn(ctx context.Context) (*Conn, error) {
-	return p.pool.NewConn(ctx)
-}
-
-func (p *SingleConnPool) CloseConn(cn *Conn) error {
-	return p.pool.CloseConn(cn)
-}
-
-func (p *SingleConnPool) Get(ctx context.Context) (*Conn, error) {
-	if p.stickyErr != nil {
-		return nil, p.stickyErr
-	}
-	return p.cn, nil
-}
-
-func (p *SingleConnPool) Put(ctx context.Context, cn *Conn) {}
-
-func (p *SingleConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
-	p.cn = nil
-	p.stickyErr = reason
-}
-
-func (p *SingleConnPool) Close() error {
-	p.cn = nil
-	p.stickyErr = ErrClosed
-	return nil
-}
-
-func (p *SingleConnPool) Len() int {
-	return 0
-}
-
-func (p *SingleConnPool) IdleLen() int {
-	return 0
-}
-
-func (p *SingleConnPool) Stats() *Stats {
-	return &Stats{}
-}

vendor/github.com/go-redis/redis/v8/internal/pool/pool_sticky.go

@@ -1,201 +0,0 @@
-package pool
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"sync/atomic"
-)
-
-const (
-	stateDefault = 0
-	stateInited  = 1
-	stateClosed  = 2
-)
-
-type BadConnError struct {
-	wrapped error
-}
-
-var _ error = (*BadConnError)(nil)
-
-func (e BadConnError) Error() string {
-	s := "redis: Conn is in a bad state"
-	if e.wrapped != nil {
-		s += ": " + e.wrapped.Error()
-	}
-	return s
-}
-
-func (e BadConnError) Unwrap() error {
-	return e.wrapped
-}
-
-//------------------------------------------------------------------------------
-
-type StickyConnPool struct {
-	pool   Pooler
-	shared int32 // atomic
-
-	state uint32 // atomic
-	ch    chan *Conn
-
-	_badConnError atomic.Value
-}
-
-var _ Pooler = (*StickyConnPool)(nil)
-
-func NewStickyConnPool(pool Pooler) *StickyConnPool {
-	p, ok := pool.(*StickyConnPool)
-	if !ok {
-		p = &StickyConnPool{
-			pool: pool,
-			ch:   make(chan *Conn, 1),
-		}
-	}
-	atomic.AddInt32(&p.shared, 1)
-	return p
-}
-
-func (p *StickyConnPool) NewConn(ctx context.Context) (*Conn, error) {
-	return p.pool.NewConn(ctx)
-}
-
-func (p *StickyConnPool) CloseConn(cn *Conn) error {
-	return p.pool.CloseConn(cn)
-}
-
-func (p *StickyConnPool) Get(ctx context.Context) (*Conn, error) {
-	// In worst case this races with Close which is not a very common operation.
-	for i := 0; i < 1000; i++ {
-		switch atomic.LoadUint32(&p.state) {
-		case stateDefault:
-			cn, err := p.pool.Get(ctx)
-			if err != nil {
-				return nil, err
-			}
-			if atomic.CompareAndSwapUint32(&p.state, stateDefault, stateInited) {
-				return cn, nil
-			}
-			p.pool.Remove(ctx, cn, ErrClosed)
-		case stateInited:
-			if err := p.badConnError(); err != nil {
-				return nil, err
-			}
-			cn, ok := <-p.ch
-			if !ok {
-				return nil, ErrClosed
-			}
-			return cn, nil
-		case stateClosed:
-			return nil, ErrClosed
-		default:
-			panic("not reached")
-		}
-	}
-	return nil, fmt.Errorf("redis: StickyConnPool.Get: infinite loop")
-}
-
-func (p *StickyConnPool) Put(ctx context.Context, cn *Conn) {
-	defer func() {
-		if recover() != nil {
-			p.freeConn(ctx, cn)
-		}
-	}()
-	p.ch <- cn
-}
-
-func (p *StickyConnPool) freeConn(ctx context.Context, cn *Conn) {
-	if err := p.badConnError(); err != nil {
-		p.pool.Remove(ctx, cn, err)
-	} else {
-		p.pool.Put(ctx, cn)
-	}
-}
-
-func (p *StickyConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
-	defer func() {
-		if recover() != nil {
-			p.pool.Remove(ctx, cn, ErrClosed)
-		}
-	}()
-	p._badConnError.Store(BadConnError{wrapped: reason})
-	p.ch <- cn
-}
-
-func (p *StickyConnPool) Close() error {
-	if shared := atomic.AddInt32(&p.shared, -1); shared > 0 {
-		return nil
-	}
-
-	for i := 0; i < 1000; i++ {
-		state := atomic.LoadUint32(&p.state)
-		if state == stateClosed {
-			return ErrClosed
-		}
-		if atomic.CompareAndSwapUint32(&p.state, state, stateClosed) {
-			close(p.ch)
-			cn, ok := <-p.ch
-			if ok {
-				p.freeConn(context.TODO(), cn)
-			}
-			return nil
-		}
-	}
-
-	return errors.New("redis: StickyConnPool.Close: infinite loop")
-}
-
-func (p *StickyConnPool) Reset(ctx context.Context) error {
-	if p.badConnError() == nil {
-		return nil
-	}
-
-	select {
-	case cn, ok := <-p.ch:
-		if !ok {
-			return ErrClosed
-		}
-		p.pool.Remove(ctx, cn, ErrClosed)
-		p._badConnError.Store(BadConnError{wrapped: nil})
-	default:
-		return errors.New("redis: StickyConnPool does not have a Conn")
-	}
-
-	if !atomic.CompareAndSwapUint32(&p.state, stateInited, stateDefault) {
-		state := atomic.LoadUint32(&p.state)
-		return fmt.Errorf("redis: invalid StickyConnPool state: %d", state)
-	}
-
-	return nil
-}
-
-func (p *StickyConnPool) badConnError() error {
-	if v := p._badConnError.Load(); v != nil {
-		if err := v.(BadConnError); err.wrapped != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (p *StickyConnPool) Len() int {
-	switch atomic.LoadUint32(&p.state) {
-	case stateDefault:
-		return 0
-	case stateInited:
-		return 1
-	case stateClosed:
-		return 0
-	default:
-		panic("not reached")
-	}
-}
-
-func (p *StickyConnPool) IdleLen() int {
-	return len(p.ch)
-}
-
-func (p *StickyConnPool) Stats() *Stats {
-	return &Stats{}
-}

vendor/github.com/go-redis/redis/v8/internal/proto/reader.go

@@ -1,332 +0,0 @@
-package proto
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-// redis resp protocol data type.
-const (
-	ErrorReply  = '-'
-	StatusReply = '+'
-	IntReply    = ':'
-	StringReply = '$'
-	ArrayReply  = '*'
-)
-
-//------------------------------------------------------------------------------
-
-const Nil = RedisError("redis: nil") // nolint:errname
-
-type RedisError string
-
-func (e RedisError) Error() string { return string(e) }
-
-func (RedisError) RedisError() {}
-
-//------------------------------------------------------------------------------
-
-type MultiBulkParse func(*Reader, int64) (interface{}, error)
-
-type Reader struct {
-	rd   *bufio.Reader
-	_buf []byte
-}
-
-func NewReader(rd io.Reader) *Reader {
-	return &Reader{
-		rd:   bufio.NewReader(rd),
-		_buf: make([]byte, 64),
-	}
-}
-
-func (r *Reader) Buffered() int {
-	return r.rd.Buffered()
-}
-
-func (r *Reader) Peek(n int) ([]byte, error) {
-	return r.rd.Peek(n)
-}
-
-func (r *Reader) Reset(rd io.Reader) {
-	r.rd.Reset(rd)
-}
-
-func (r *Reader) ReadLine() ([]byte, error) {
-	line, err := r.readLine()
-	if err != nil {
-		return nil, err
-	}
-	if isNilReply(line) {
-		return nil, Nil
-	}
-	return line, nil
-}
-
-// readLine that returns an error if:
-//   - there is a pending read error;
-//   - or line does not end with \r\n.
-func (r *Reader) readLine() ([]byte, error) {
-	b, err := r.rd.ReadSlice('\n')
-	if err != nil {
-		if err != bufio.ErrBufferFull {
-			return nil, err
-		}
-
-		full := make([]byte, len(b))
-		copy(full, b)
-
-		b, err = r.rd.ReadBytes('\n')
-		if err != nil {
-			return nil, err
-		}
-
-		full = append(full, b...) //nolint:makezero
-		b = full
-	}
-	if len(b) <= 2 || b[len(b)-1] != '\n' || b[len(b)-2] != '\r' {
-		return nil, fmt.Errorf("redis: invalid reply: %q", b)
-	}
-	return b[:len(b)-2], nil
-}
-
-func (r *Reader) ReadReply(m MultiBulkParse) (interface{}, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return nil, err
-	}
-
-	switch line[0] {
-	case ErrorReply:
-		return nil, ParseErrorReply(line)
-	case StatusReply:
-		return string(line[1:]), nil
-	case IntReply:
-		return util.ParseInt(line[1:], 10, 64)
-	case StringReply:
-		return r.readStringReply(line)
-	case ArrayReply:
-		n, err := parseArrayLen(line)
-		if err != nil {
-			return nil, err
-		}
-		if m == nil {
-			err := fmt.Errorf("redis: got %.100q, but multi bulk parser is nil", line)
-			return nil, err
-		}
-		return m(r, n)
-	}
-	return nil, fmt.Errorf("redis: can't parse %.100q", line)
-}
-
-func (r *Reader) ReadIntReply() (int64, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return 0, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return 0, ParseErrorReply(line)
-	case IntReply:
-		return util.ParseInt(line[1:], 10, 64)
-	default:
-		return 0, fmt.Errorf("redis: can't parse int reply: %.100q", line)
-	}
-}
-
-func (r *Reader) ReadString() (string, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return "", err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return "", ParseErrorReply(line)
-	case StringReply:
-		return r.readStringReply(line)
-	case StatusReply:
-		return string(line[1:]), nil
-	case IntReply:
-		return string(line[1:]), nil
-	default:
-		return "", fmt.Errorf("redis: can't parse reply=%.100q reading string", line)
-	}
-}
-
-func (r *Reader) readStringReply(line []byte) (string, error) {
-	if isNilReply(line) {
-		return "", Nil
-	}
-
-	replyLen, err := util.Atoi(line[1:])
-	if err != nil {
-		return "", err
-	}
-
-	b := make([]byte, replyLen+2)
-	_, err = io.ReadFull(r.rd, b)
-	if err != nil {
-		return "", err
-	}
-
-	return util.BytesToString(b[:replyLen]), nil
-}
-
-func (r *Reader) ReadArrayReply(m MultiBulkParse) (interface{}, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return nil, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return nil, ParseErrorReply(line)
-	case ArrayReply:
-		n, err := parseArrayLen(line)
-		if err != nil {
-			return nil, err
-		}
-		return m(r, n)
-	default:
-		return nil, fmt.Errorf("redis: can't parse array reply: %.100q", line)
-	}
-}
-
-func (r *Reader) ReadArrayLen() (int, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return 0, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return 0, ParseErrorReply(line)
-	case ArrayReply:
-		n, err := parseArrayLen(line)
-		if err != nil {
-			return 0, err
-		}
-		return int(n), nil
-	default:
-		return 0, fmt.Errorf("redis: can't parse array reply: %.100q", line)
-	}
-}
-
-func (r *Reader) ReadScanReply() ([]string, uint64, error) {
-	n, err := r.ReadArrayLen()
-	if err != nil {
-		return nil, 0, err
-	}
-	if n != 2 {
-		return nil, 0, fmt.Errorf("redis: got %d elements in scan reply, expected 2", n)
-	}
-
-	cursor, err := r.ReadUint()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	n, err = r.ReadArrayLen()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	keys := make([]string, n)
-
-	for i := 0; i < n; i++ {
-		key, err := r.ReadString()
-		if err != nil {
-			return nil, 0, err
-		}
-		keys[i] = key
-	}
-
-	return keys, cursor, err
-}
-
-func (r *Reader) ReadInt() (int64, error) {
-	b, err := r.readTmpBytesReply()
-	if err != nil {
-		return 0, err
-	}
-	return util.ParseInt(b, 10, 64)
-}
-
-func (r *Reader) ReadUint() (uint64, error) {
-	b, err := r.readTmpBytesReply()
-	if err != nil {
-		return 0, err
-	}
-	return util.ParseUint(b, 10, 64)
-}
-
-func (r *Reader) ReadFloatReply() (float64, error) {
-	b, err := r.readTmpBytesReply()
-	if err != nil {
-		return 0, err
-	}
-	return util.ParseFloat(b, 64)
-}
-
-func (r *Reader) readTmpBytesReply() ([]byte, error) {
-	line, err := r.ReadLine()
-	if err != nil {
-		return nil, err
-	}
-	switch line[0] {
-	case ErrorReply:
-		return nil, ParseErrorReply(line)
-	case StringReply:
-		return r._readTmpBytesReply(line)
-	case StatusReply:
-		return line[1:], nil
-	default:
-		return nil, fmt.Errorf("redis: can't parse string reply: %.100q", line)
-	}
-}
-
-func (r *Reader) _readTmpBytesReply(line []byte) ([]byte, error) {
-	if isNilReply(line) {
-		return nil, Nil
-	}
-
-	replyLen, err := util.Atoi(line[1:])
-	if err != nil {
-		return nil, err
-	}
-
-	buf := r.buf(replyLen + 2)
-	_, err = io.ReadFull(r.rd, buf)
-	if err != nil {
-		return nil, err
-	}
-
-	return buf[:replyLen], nil
-}
-
-func (r *Reader) buf(n int) []byte {
-	if n <= cap(r._buf) {
-		return r._buf[:n]
-	}
-	d := n - cap(r._buf)
-	r._buf = append(r._buf, make([]byte, d)...)
-	return r._buf
-}
-
-func isNilReply(b []byte) bool {
-	return len(b) == 3 &&
-		(b[0] == StringReply || b[0] == ArrayReply) &&
-		b[1] == '-' && b[2] == '1'
-}
-
-func ParseErrorReply(line []byte) error {
-	return RedisError(string(line[1:]))
-}
-
-func parseArrayLen(line []byte) (int64, error) {
-	if isNilReply(line) {
-		return 0, Nil
-	}
-	return util.ParseInt(line[1:], 10, 64)
-}

vendor/github.com/go-redis/redis/v8/internal/proto/scan.go

@@ -1,180 +0,0 @@
-package proto
-
-import (
-	"encoding"
-	"fmt"
-	"reflect"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-// Scan parses bytes `b` to `v` with appropriate type.
-//nolint:gocyclo
-func Scan(b []byte, v interface{}) error {
-	switch v := v.(type) {
-	case nil:
-		return fmt.Errorf("redis: Scan(nil)")
-	case *string:
-		*v = util.BytesToString(b)
-		return nil
-	case *[]byte:
-		*v = b
-		return nil
-	case *int:
-		var err error
-		*v, err = util.Atoi(b)
-		return err
-	case *int8:
-		n, err := util.ParseInt(b, 10, 8)
-		if err != nil {
-			return err
-		}
-		*v = int8(n)
-		return nil
-	case *int16:
-		n, err := util.ParseInt(b, 10, 16)
-		if err != nil {
-			return err
-		}
-		*v = int16(n)
-		return nil
-	case *int32:
-		n, err := util.ParseInt(b, 10, 32)
-		if err != nil {
-			return err
-		}
-		*v = int32(n)
-		return nil
-	case *int64:
-		n, err := util.ParseInt(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = n
-		return nil
-	case *uint:
-		n, err := util.ParseUint(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = uint(n)
-		return nil
-	case *uint8:
-		n, err := util.ParseUint(b, 10, 8)
-		if err != nil {
-			return err
-		}
-		*v = uint8(n)
-		return nil
-	case *uint16:
-		n, err := util.ParseUint(b, 10, 16)
-		if err != nil {
-			return err
-		}
-		*v = uint16(n)
-		return nil
-	case *uint32:
-		n, err := util.ParseUint(b, 10, 32)
-		if err != nil {
-			return err
-		}
-		*v = uint32(n)
-		return nil
-	case *uint64:
-		n, err := util.ParseUint(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = n
-		return nil
-	case *float32:
-		n, err := util.ParseFloat(b, 32)
-		if err != nil {
-			return err
-		}
-		*v = float32(n)
-		return err
-	case *float64:
-		var err error
-		*v, err = util.ParseFloat(b, 64)
-		return err
-	case *bool:
-		*v = len(b) == 1 && b[0] == '1'
-		return nil
-	case *time.Time:
-		var err error
-		*v, err = time.Parse(time.RFC3339Nano, util.BytesToString(b))
-		return err
-	case *time.Duration:
-		n, err := util.ParseInt(b, 10, 64)
-		if err != nil {
-			return err
-		}
-		*v = time.Duration(n)
-		return nil
-	case encoding.BinaryUnmarshaler:
-		return v.UnmarshalBinary(b)
-	default:
-		return fmt.Errorf(
-			"redis: can't unmarshal %T (consider implementing BinaryUnmarshaler)", v)
-	}
-}
-
-func ScanSlice(data []string, slice interface{}) error {
-	v := reflect.ValueOf(slice)
-	if !v.IsValid() {
-		return fmt.Errorf("redis: ScanSlice(nil)")
-	}
-	if v.Kind() != reflect.Ptr {
-		return fmt.Errorf("redis: ScanSlice(non-pointer %T)", slice)
-	}
-	v = v.Elem()
-	if v.Kind() != reflect.Slice {
-		return fmt.Errorf("redis: ScanSlice(non-slice %T)", slice)
-	}
-
-	next := makeSliceNextElemFunc(v)
-	for i, s := range data {
-		elem := next()
-		if err := Scan([]byte(s), elem.Addr().Interface()); err != nil {
-			err = fmt.Errorf("redis: ScanSlice index=%d value=%q failed: %w", i, s, err)
-			return err
-		}
-	}
-
-	return nil
-}
-
-func makeSliceNextElemFunc(v reflect.Value) func() reflect.Value {
-	elemType := v.Type().Elem()
-
-	if elemType.Kind() == reflect.Ptr {
-		elemType = elemType.Elem()
-		return func() reflect.Value {
-			if v.Len() < v.Cap() {
-				v.Set(v.Slice(0, v.Len()+1))
-				elem := v.Index(v.Len() - 1)
-				if elem.IsNil() {
-					elem.Set(reflect.New(elemType))
-				}
-				return elem.Elem()
-			}
-
-			elem := reflect.New(elemType)
-			v.Set(reflect.Append(v, elem))
-			return elem.Elem()
-		}
-	}
-
-	zero := reflect.Zero(elemType)
-	return func() reflect.Value {
-		if v.Len() < v.Cap() {
-			v.Set(v.Slice(0, v.Len()+1))
-			return v.Index(v.Len() - 1)
-		}
-
-		v.Set(reflect.Append(v, zero))
-		return v.Index(v.Len() - 1)
-	}
-}

vendor/github.com/go-redis/redis/v8/internal/proto/writer.go

@@ -1,155 +0,0 @@
-package proto
-
-import (
-	"encoding"
-	"fmt"
-	"io"
-	"strconv"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-type writer interface {
-	io.Writer
-	io.ByteWriter
-	// io.StringWriter
-	WriteString(s string) (n int, err error)
-}
-
-type Writer struct {
-	writer
-
-	lenBuf []byte
-	numBuf []byte
-}
-
-func NewWriter(wr writer) *Writer {
-	return &Writer{
-		writer: wr,
-
-		lenBuf: make([]byte, 64),
-		numBuf: make([]byte, 64),
-	}
-}
-
-func (w *Writer) WriteArgs(args []interface{}) error {
-	if err := w.WriteByte(ArrayReply); err != nil {
-		return err
-	}
-
-	if err := w.writeLen(len(args)); err != nil {
-		return err
-	}
-
-	for _, arg := range args {
-		if err := w.WriteArg(arg); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (w *Writer) writeLen(n int) error {
-	w.lenBuf = strconv.AppendUint(w.lenBuf[:0], uint64(n), 10)
-	w.lenBuf = append(w.lenBuf, '\r', '\n')
-	_, err := w.Write(w.lenBuf)
-	return err
-}
-
-func (w *Writer) WriteArg(v interface{}) error {
-	switch v := v.(type) {
-	case nil:
-		return w.string("")
-	case string:
-		return w.string(v)
-	case []byte:
-		return w.bytes(v)
-	case int:
-		return w.int(int64(v))
-	case int8:
-		return w.int(int64(v))
-	case int16:
-		return w.int(int64(v))
-	case int32:
-		return w.int(int64(v))
-	case int64:
-		return w.int(v)
-	case uint:
-		return w.uint(uint64(v))
-	case uint8:
-		return w.uint(uint64(v))
-	case uint16:
-		return w.uint(uint64(v))
-	case uint32:
-		return w.uint(uint64(v))
-	case uint64:
-		return w.uint(v)
-	case float32:
-		return w.float(float64(v))
-	case float64:
-		return w.float(v)
-	case bool:
-		if v {
-			return w.int(1)
-		}
-		return w.int(0)
-	case time.Time:
-		w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
-		return w.bytes(w.numBuf)
-	case time.Duration:
-		return w.int(v.Nanoseconds())
-	case encoding.BinaryMarshaler:
-		b, err := v.MarshalBinary()
-		if err != nil {
-			return err
-		}
-		return w.bytes(b)
-	default:
-		return fmt.Errorf(
-			"redis: can't marshal %T (implement encoding.BinaryMarshaler)", v)
-	}
-}
-
-func (w *Writer) bytes(b []byte) error {
-	if err := w.WriteByte(StringReply); err != nil {
-		return err
-	}
-
-	if err := w.writeLen(len(b)); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(b); err != nil {
-		return err
-	}
-
-	return w.crlf()
-}
-
-func (w *Writer) string(s string) error {
-	return w.bytes(util.StringToBytes(s))
-}
-
-func (w *Writer) uint(n uint64) error {
-	w.numBuf = strconv.AppendUint(w.numBuf[:0], n, 10)
-	return w.bytes(w.numBuf)
-}
-
-func (w *Writer) int(n int64) error {
-	w.numBuf = strconv.AppendInt(w.numBuf[:0], n, 10)
-	return w.bytes(w.numBuf)
-}
-
-func (w *Writer) float(f float64) error {
-	w.numBuf = strconv.AppendFloat(w.numBuf[:0], f, 'f', -1, 64)
-	return w.bytes(w.numBuf)
-}
-
-func (w *Writer) crlf() error {
-	if err := w.WriteByte('\r'); err != nil {
-		return err
-	}
-	return w.WriteByte('\n')
-}

vendor/github.com/go-redis/redis/v8/internal/rand/rand.go

@@ -1,50 +0,0 @@
-package rand
-
-import (
-	"math/rand"
-	"sync"
-)
-
-// Int returns a non-negative pseudo-random int.
-func Int() int { return pseudo.Int() }
-
-// Intn returns, as an int, a non-negative pseudo-random number in [0,n).
-// It panics if n <= 0.
-func Intn(n int) int { return pseudo.Intn(n) }
-
-// Int63n returns, as an int64, a non-negative pseudo-random number in [0,n).
-// It panics if n <= 0.
-func Int63n(n int64) int64 { return pseudo.Int63n(n) }
-
-// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers [0,n).
-func Perm(n int) []int { return pseudo.Perm(n) }
-
-// Seed uses the provided seed value to initialize the default Source to a
-// deterministic state. If Seed is not called, the generator behaves as if
-// seeded by Seed(1).
-func Seed(n int64) { pseudo.Seed(n) }
-
-var pseudo = rand.New(&source{src: rand.NewSource(1)})
-
-type source struct {
-	src rand.Source
-	mu  sync.Mutex
-}
-
-func (s *source) Int63() int64 {
-	s.mu.Lock()
-	n := s.src.Int63()
-	s.mu.Unlock()
-	return n
-}
-
-func (s *source) Seed(seed int64) {
-	s.mu.Lock()
-	s.src.Seed(seed)
-	s.mu.Unlock()
-}
-
-// Shuffle pseudo-randomizes the order of elements.
-// n is the number of elements.
-// swap swaps the elements with indexes i and j.
-func Shuffle(n int, swap func(i, j int)) { pseudo.Shuffle(n, swap) }

vendor/github.com/go-redis/redis/v8/internal/safe.go

@@ -1,12 +0,0 @@
-//go:build appengine
-// +build appengine
-
-package internal
-
-func String(b []byte) string {
-	return string(b)
-}
-
-func Bytes(s string) []byte {
-	return []byte(s)
-}

vendor/github.com/go-redis/redis/v8/internal/unsafe.go

@@ -1,21 +0,0 @@
-//go:build !appengine
-// +build !appengine
-
-package internal
-
-import "unsafe"
-
-// String converts byte slice to string.
-func String(b []byte) string {
-	return *(*string)(unsafe.Pointer(&b))
-}
-
-// Bytes converts string to byte slice.
-func Bytes(s string) []byte {
-	return *(*[]byte)(unsafe.Pointer(
-		&struct {
-			string
-			Cap int
-		}{s, len(s)},
-	))
-}

vendor/github.com/go-redis/redis/v8/internal/util.go

@@ -1,46 +0,0 @@
-package internal
-
-import (
-	"context"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/util"
-)
-
-func Sleep(ctx context.Context, dur time.Duration) error {
-	t := time.NewTimer(dur)
-	defer t.Stop()
-
-	select {
-	case <-t.C:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
-}
-
-func ToLower(s string) string {
-	if isLower(s) {
-		return s
-	}
-
-	b := make([]byte, len(s))
-	for i := range b {
-		c := s[i]
-		if c >= 'A' && c <= 'Z' {
-			c += 'a' - 'A'
-		}
-		b[i] = c
-	}
-	return util.BytesToString(b)
-}
-
-func isLower(s string) bool {
-	for i := 0; i < len(s); i++ {
-		c := s[i]
-		if c >= 'A' && c <= 'Z' {
-			return false
-		}
-	}
-	return true
-}

vendor/github.com/go-redis/redis/v8/internal/util/safe.go

@@ -1,12 +0,0 @@
-//go:build appengine
-// +build appengine
-
-package util
-
-func BytesToString(b []byte) string {
-	return string(b)
-}
-
-func StringToBytes(s string) []byte {
-	return []byte(s)
-}

vendor/github.com/go-redis/redis/v8/internal/util/strconv.go

@@ -1,19 +0,0 @@
-package util
-
-import "strconv"
-
-func Atoi(b []byte) (int, error) {
-	return strconv.Atoi(BytesToString(b))
-}
-
-func ParseInt(b []byte, base int, bitSize int) (int64, error) {
-	return strconv.ParseInt(BytesToString(b), base, bitSize)
-}
-
-func ParseUint(b []byte, base int, bitSize int) (uint64, error) {
-	return strconv.ParseUint(BytesToString(b), base, bitSize)
-}
-
-func ParseFloat(b []byte, bitSize int) (float64, error) {
-	return strconv.ParseFloat(BytesToString(b), bitSize)
-}

vendor/github.com/go-redis/redis/v8/internal/util/unsafe.go

@@ -1,23 +0,0 @@
-//go:build !appengine
-// +build !appengine
-
-package util
-
-import (
-	"unsafe"
-)
-
-// BytesToString converts byte slice to string.
-func BytesToString(b []byte) string {
-	return *(*string)(unsafe.Pointer(&b))
-}
-
-// StringToBytes converts string to byte slice.
-func StringToBytes(s string) []byte {
-	return *(*[]byte)(unsafe.Pointer(
-		&struct {
-			string
-			Cap int
-		}{s, len(s)},
-	))
-}

vendor/github.com/go-redis/redis/v8/iterator.go

@@ -1,77 +0,0 @@
-package redis
-
-import (
-	"context"
-	"sync"
-)
-
-// ScanIterator is used to incrementally iterate over a collection of elements.
-// It's safe for concurrent use by multiple goroutines.
-type ScanIterator struct {
-	mu  sync.Mutex // protects Scanner and pos
-	cmd *ScanCmd
-	pos int
-}
-
-// Err returns the last iterator error, if any.
-func (it *ScanIterator) Err() error {
-	it.mu.Lock()
-	err := it.cmd.Err()
-	it.mu.Unlock()
-	return err
-}
-
-// Next advances the cursor and returns true if more values can be read.
-func (it *ScanIterator) Next(ctx context.Context) bool {
-	it.mu.Lock()
-	defer it.mu.Unlock()
-
-	// Instantly return on errors.
-	if it.cmd.Err() != nil {
-		return false
-	}
-
-	// Advance cursor, check if we are still within range.
-	if it.pos < len(it.cmd.page) {
-		it.pos++
-		return true
-	}
-
-	for {
-		// Return if there is no more data to fetch.
-		if it.cmd.cursor == 0 {
-			return false
-		}
-
-		// Fetch next page.
-		switch it.cmd.args[0] {
-		case "scan", "qscan":
-			it.cmd.args[1] = it.cmd.cursor
-		default:
-			it.cmd.args[2] = it.cmd.cursor
-		}
-
-		err := it.cmd.process(ctx, it.cmd)
-		if err != nil {
-			return false
-		}
-
-		it.pos = 1
-
-		// Redis can occasionally return empty page.
-		if len(it.cmd.page) > 0 {
-			return true
-		}
-	}
-}
-
-// Val returns the key/field at the current cursor position.
-func (it *ScanIterator) Val() string {
-	var v string
-	it.mu.Lock()
-	if it.cmd.Err() == nil && it.pos > 0 && it.pos <= len(it.cmd.page) {
-		v = it.cmd.page[it.pos-1]
-	}
-	it.mu.Unlock()
-	return v
-}

vendor/github.com/go-redis/redis/v8/options.go

@@ -1,429 +0,0 @@
-package redis
-
-import (
-	"context"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net"
-	"net/url"
-	"runtime"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal/pool"
-)
-
-// Limiter is the interface of a rate limiter or a circuit breaker.
-type Limiter interface {
-	// Allow returns nil if operation is allowed or an error otherwise.
-	// If operation is allowed client must ReportResult of the operation
-	// whether it is a success or a failure.
-	Allow() error
-	// ReportResult reports the result of the previously allowed operation.
-	// nil indicates a success, non-nil error usually indicates a failure.
-	ReportResult(result error)
-}
-
-// Options keeps the settings to setup redis connection.
-type Options struct {
-	// The network type, either tcp or unix.
-	// Default is tcp.
-	Network string
-	// host:port address.
-	Addr string
-
-	// Dialer creates new network connection and has priority over
-	// Network and Addr options.
-	Dialer func(ctx context.Context, network, addr string) (net.Conn, error)
-
-	// Hook that is called when new connection is established.
-	OnConnect func(ctx context.Context, cn *Conn) error
-
-	// Use the specified Username to authenticate the current connection
-	// with one of the connections defined in the ACL list when connecting
-	// to a Redis 6.0 instance, or greater, that is using the Redis ACL system.
-	Username string
-	// Optional password. Must match the password specified in the
-	// requirepass server configuration option (if connecting to a Redis 5.0 instance, or lower),
-	// or the User Password when connecting to a Redis 6.0 instance, or greater,
-	// that is using the Redis ACL system.
-	Password string
-
-	// Database to be selected after connecting to the server.
-	DB int
-
-	// Maximum number of retries before giving up.
-	// Default is 3 retries; -1 (not 0) disables retries.
-	MaxRetries int
-	// Minimum backoff between each retry.
-	// Default is 8 milliseconds; -1 disables backoff.
-	MinRetryBackoff time.Duration
-	// Maximum backoff between each retry.
-	// Default is 512 milliseconds; -1 disables backoff.
-	MaxRetryBackoff time.Duration
-
-	// Dial timeout for establishing new connections.
-	// Default is 5 seconds.
-	DialTimeout time.Duration
-	// Timeout for socket reads. If reached, commands will fail
-	// with a timeout instead of blocking. Use value -1 for no timeout and 0 for default.
-	// Default is 3 seconds.
-	ReadTimeout time.Duration
-	// Timeout for socket writes. If reached, commands will fail
-	// with a timeout instead of blocking.
-	// Default is ReadTimeout.
-	WriteTimeout time.Duration
-
-	// Type of connection pool.
-	// true for FIFO pool, false for LIFO pool.
-	// Note that fifo has higher overhead compared to lifo.
-	PoolFIFO bool
-	// Maximum number of socket connections.
-	// Default is 10 connections per every available CPU as reported by runtime.GOMAXPROCS.
-	PoolSize int
-	// Minimum number of idle connections which is useful when establishing
-	// new connection is slow.
-	MinIdleConns int
-	// Connection age at which client retires (closes) the connection.
-	// Default is to not close aged connections.
-	MaxConnAge time.Duration
-	// Amount of time client waits for connection if all connections
-	// are busy before returning an error.
-	// Default is ReadTimeout + 1 second.
-	PoolTimeout time.Duration
-	// Amount of time after which client closes idle connections.
-	// Should be less than server's timeout.
-	// Default is 5 minutes. -1 disables idle timeout check.
-	IdleTimeout time.Duration
-	// Frequency of idle checks made by idle connections reaper.
-	// Default is 1 minute. -1 disables idle connections reaper,
-	// but idle connections are still discarded by the client
-	// if IdleTimeout is set.
-	IdleCheckFrequency time.Duration
-
-	// Enables read only queries on slave nodes.
-	readOnly bool
-
-	// TLS Config to use. When set TLS will be negotiated.
-	TLSConfig *tls.Config
-
-	// Limiter interface used to implemented circuit breaker or rate limiter.
-	Limiter Limiter
-}
-
-func (opt *Options) init() {
-	if opt.Addr == "" {
-		opt.Addr = "localhost:6379"
-	}
-	if opt.Network == "" {
-		if strings.HasPrefix(opt.Addr, "/") {
-			opt.Network = "unix"
-		} else {
-			opt.Network = "tcp"
-		}
-	}
-	if opt.DialTimeout == 0 {
-		opt.DialTimeout = 5 * time.Second
-	}
-	if opt.Dialer == nil {
-		opt.Dialer = func(ctx context.Context, network, addr string) (net.Conn, error) {
-			netDialer := &net.Dialer{
-				Timeout:   opt.DialTimeout,
-				KeepAlive: 5 * time.Minute,
-			}
-			if opt.TLSConfig == nil {
-				return netDialer.DialContext(ctx, network, addr)
-			}
-			return tls.DialWithDialer(netDialer, network, addr, opt.TLSConfig)
-		}
-	}
-	if opt.PoolSize == 0 {
-		opt.PoolSize = 10 * runtime.GOMAXPROCS(0)
-	}
-	switch opt.ReadTimeout {
-	case -1:
-		opt.ReadTimeout = 0
-	case 0:
-		opt.ReadTimeout = 3 * time.Second
-	}
-	switch opt.WriteTimeout {
-	case -1:
-		opt.WriteTimeout = 0
-	case 0:
-		opt.WriteTimeout = opt.ReadTimeout
-	}
-	if opt.PoolTimeout == 0 {
-		opt.PoolTimeout = opt.ReadTimeout + time.Second
-	}
-	if opt.IdleTimeout == 0 {
-		opt.IdleTimeout = 5 * time.Minute
-	}
-	if opt.IdleCheckFrequency == 0 {
-		opt.IdleCheckFrequency = time.Minute
-	}
-
-	if opt.MaxRetries == -1 {
-		opt.MaxRetries = 0
-	} else if opt.MaxRetries == 0 {
-		opt.MaxRetries = 3
-	}
-	switch opt.MinRetryBackoff {
-	case -1:
-		opt.MinRetryBackoff = 0
-	case 0:
-		opt.MinRetryBackoff = 8 * time.Millisecond
-	}
-	switch opt.MaxRetryBackoff {
-	case -1:
-		opt.MaxRetryBackoff = 0
-	case 0:
-		opt.MaxRetryBackoff = 512 * time.Millisecond
-	}
-}
-
-func (opt *Options) clone() *Options {
-	clone := *opt
-	return &clone
-}
-
-// ParseURL parses an URL into Options that can be used to connect to Redis.
-// Scheme is required.
-// There are two connection types: by tcp socket and by unix socket.
-// Tcp connection:
-//		redis://<user>:<password>@<host>:<port>/<db_number>
-// Unix connection:
-//		unix://<user>:<password>@</path/to/redis.sock>?db=<db_number>
-// Most Option fields can be set using query parameters, with the following restrictions:
-//	- field names are mapped using snake-case conversion: to set MaxRetries, use max_retries
-//	- only scalar type fields are supported (bool, int, time.Duration)
-//	- for time.Duration fields, values must be a valid input for time.ParseDuration();
-//	  additionally a plain integer as value (i.e. without unit) is intepreted as seconds
-//	- to disable a duration field, use value less than or equal to 0; to use the default
-//	  value, leave the value blank or remove the parameter
-//	- only the last value is interpreted if a parameter is given multiple times
-//	- fields "network", "addr", "username" and "password" can only be set using other
-//	  URL attributes (scheme, host, userinfo, resp.), query paremeters using these
-//	  names will be treated as unknown parameters
-//	- unknown parameter names will result in an error
-// Examples:
-//		redis://user:password@localhost:6789/3?dial_timeout=3&db=1&read_timeout=6s&max_retries=2
-//		is equivalent to:
-//		&Options{
-//			Network:     "tcp",
-//			Addr:        "localhost:6789",
-//			DB:          1,               // path "/3" was overridden by "&db=1"
-//			DialTimeout: 3 * time.Second, // no time unit = seconds
-//			ReadTimeout: 6 * time.Second,
-//			MaxRetries:  2,
-//		}
-func ParseURL(redisURL string) (*Options, error) {
-	u, err := url.Parse(redisURL)
-	if err != nil {
-		return nil, err
-	}
-
-	switch u.Scheme {
-	case "redis", "rediss":
-		return setupTCPConn(u)
-	case "unix":
-		return setupUnixConn(u)
-	default:
-		return nil, fmt.Errorf("redis: invalid URL scheme: %s", u.Scheme)
-	}
-}
-
-func setupTCPConn(u *url.URL) (*Options, error) {
-	o := &Options{Network: "tcp"}
-
-	o.Username, o.Password = getUserPassword(u)
-
-	h, p, err := net.SplitHostPort(u.Host)
-	if err != nil {
-		h = u.Host
-	}
-	if h == "" {
-		h = "localhost"
-	}
-	if p == "" {
-		p = "6379"
-	}
-	o.Addr = net.JoinHostPort(h, p)
-
-	f := strings.FieldsFunc(u.Path, func(r rune) bool {
-		return r == '/'
-	})
-	switch len(f) {
-	case 0:
-		o.DB = 0
-	case 1:
-		if o.DB, err = strconv.Atoi(f[0]); err != nil {
-			return nil, fmt.Errorf("redis: invalid database number: %q", f[0])
-		}
-	default:
-		return nil, fmt.Errorf("redis: invalid URL path: %s", u.Path)
-	}
-
-	if u.Scheme == "rediss" {
-		o.TLSConfig = &tls.Config{ServerName: h}
-	}
-
-	return setupConnParams(u, o)
-}
-
-func setupUnixConn(u *url.URL) (*Options, error) {
-	o := &Options{
-		Network: "unix",
-	}
-
-	if strings.TrimSpace(u.Path) == "" { // path is required with unix connection
-		return nil, errors.New("redis: empty unix socket path")
-	}
-	o.Addr = u.Path
-	o.Username, o.Password = getUserPassword(u)
-	return setupConnParams(u, o)
-}
-
-type queryOptions struct {
-	q   url.Values
-	err error
-}
-
-func (o *queryOptions) string(name string) string {
-	vs := o.q[name]
-	if len(vs) == 0 {
-		return ""
-	}
-	delete(o.q, name) // enable detection of unknown parameters
-	return vs[len(vs)-1]
-}
-
-func (o *queryOptions) int(name string) int {
-	s := o.string(name)
-	if s == "" {
-		return 0
-	}
-	i, err := strconv.Atoi(s)
-	if err == nil {
-		return i
-	}
-	if o.err == nil {
-		o.err = fmt.Errorf("redis: invalid %s number: %s", name, err)
-	}
-	return 0
-}
-
-func (o *queryOptions) duration(name string) time.Duration {
-	s := o.string(name)
-	if s == "" {
-		return 0
-	}
-	// try plain number first
-	if i, err := strconv.Atoi(s); err == nil {
-		if i <= 0 {
-			// disable timeouts
-			return -1
-		}
-		return time.Duration(i) * time.Second
-	}
-	dur, err := time.ParseDuration(s)
-	if err == nil {
-		return dur
-	}
-	if o.err == nil {
-		o.err = fmt.Errorf("redis: invalid %s duration: %w", name, err)
-	}
-	return 0
-}
-
-func (o *queryOptions) bool(name string) bool {
-	switch s := o.string(name); s {
-	case "true", "1":
-		return true
-	case "false", "0", "":
-		return false
-	default:
-		if o.err == nil {
-			o.err = fmt.Errorf("redis: invalid %s boolean: expected true/false/1/0 or an empty string, got %q", name, s)
-		}
-		return false
-	}
-}
-
-func (o *queryOptions) remaining() []string {
-	if len(o.q) == 0 {
-		return nil
-	}
-	keys := make([]string, 0, len(o.q))
-	for k := range o.q {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	return keys
-}
-
-// setupConnParams converts query parameters in u to option value in o.
-func setupConnParams(u *url.URL, o *Options) (*Options, error) {
-	q := queryOptions{q: u.Query()}
-
-	// compat: a future major release may use q.int("db")
-	if tmp := q.string("db"); tmp != "" {
-		db, err := strconv.Atoi(tmp)
-		if err != nil {
-			return nil, fmt.Errorf("redis: invalid database number: %w", err)
-		}
-		o.DB = db
-	}
-
-	o.MaxRetries = q.int("max_retries")
-	o.MinRetryBackoff = q.duration("min_retry_backoff")
-	o.MaxRetryBackoff = q.duration("max_retry_backoff")
-	o.DialTimeout = q.duration("dial_timeout")
-	o.ReadTimeout = q.duration("read_timeout")
-	o.WriteTimeout = q.duration("write_timeout")
-	o.PoolFIFO = q.bool("pool_fifo")
-	o.PoolSize = q.int("pool_size")
-	o.MinIdleConns = q.int("min_idle_conns")
-	o.MaxConnAge = q.duration("max_conn_age")
-	o.PoolTimeout = q.duration("pool_timeout")
-	o.IdleTimeout = q.duration("idle_timeout")
-	o.IdleCheckFrequency = q.duration("idle_check_frequency")
-	if q.err != nil {
-		return nil, q.err
-	}
-
-	// any parameters left?
-	if r := q.remaining(); len(r) > 0 {
-		return nil, fmt.Errorf("redis: unexpected option: %s", strings.Join(r, ", "))
-	}
-
-	return o, nil
-}
-
-func getUserPassword(u *url.URL) (string, string) {
-	var user, password string
-	if u.User != nil {
-		user = u.User.Username()
-		if p, ok := u.User.Password(); ok {
-			password = p
-		}
-	}
-	return user, password
-}
-
-func newConnPool(opt *Options) *pool.ConnPool {
-	return pool.NewConnPool(&pool.Options{
-		Dialer: func(ctx context.Context) (net.Conn, error) {
-			return opt.Dialer(ctx, opt.Network, opt.Addr)
-		},
-		PoolFIFO:           opt.PoolFIFO,
-		PoolSize:           opt.PoolSize,
-		MinIdleConns:       opt.MinIdleConns,
-		MaxConnAge:         opt.MaxConnAge,
-		PoolTimeout:        opt.PoolTimeout,
-		IdleTimeout:        opt.IdleTimeout,
-		IdleCheckFrequency: opt.IdleCheckFrequency,
-	})
-}

vendor/github.com/go-redis/redis/v8/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "redis",
-  "version": "8.11.5",
-  "main": "index.js",
-  "repository": "git@github.com:go-redis/redis.git",
-  "author": "Vladimir Mihailenco <vladimir.webdev@gmail.com>",
-  "license": "BSD-2-clause"
-}

vendor/github.com/go-redis/redis/v8/pipeline.go

@@ -1,147 +0,0 @@
-package redis
-
-import (
-	"context"
-	"sync"
-
-	"github.com/go-redis/redis/v8/internal/pool"
-)
-
-type pipelineExecer func(context.Context, []Cmder) error
-
-// Pipeliner is an mechanism to realise Redis Pipeline technique.
-//
-// Pipelining is a technique to extremely speed up processing by packing
-// operations to batches, send them at once to Redis and read a replies in a
-// singe step.
-// See https://redis.io/topics/pipelining
-//
-// Pay attention, that Pipeline is not a transaction, so you can get unexpected
-// results in case of big pipelines and small read/write timeouts.
-// Redis client has retransmission logic in case of timeouts, pipeline
-// can be retransmitted and commands can be executed more then once.
-// To avoid this: it is good idea to use reasonable bigger read/write timeouts
-// depends of your batch size and/or use TxPipeline.
-type Pipeliner interface {
-	StatefulCmdable
-	Len() int
-	Do(ctx context.Context, args ...interface{}) *Cmd
-	Process(ctx context.Context, cmd Cmder) error
-	Close() error
-	Discard() error
-	Exec(ctx context.Context) ([]Cmder, error)
-}
-
-var _ Pipeliner = (*Pipeline)(nil)
-
-// Pipeline implements pipelining as described in
-// http://redis.io/topics/pipelining. It's safe for concurrent use
-// by multiple goroutines.
-type Pipeline struct {
-	cmdable
-	statefulCmdable
-
-	ctx  context.Context
-	exec pipelineExecer
-
-	mu     sync.Mutex
-	cmds   []Cmder
-	closed bool
-}
-
-func (c *Pipeline) init() {
-	c.cmdable = c.Process
-	c.statefulCmdable = c.Process
-}
-
-// Len returns the number of queued commands.
-func (c *Pipeline) Len() int {
-	c.mu.Lock()
-	ln := len(c.cmds)
-	c.mu.Unlock()
-	return ln
-}
-
-// Do queues the custom command for later execution.
-func (c *Pipeline) Do(ctx context.Context, args ...interface{}) *Cmd {
-	cmd := NewCmd(ctx, args...)
-	_ = c.Process(ctx, cmd)
-	return cmd
-}
-
-// Process queues the cmd for later execution.
-func (c *Pipeline) Process(ctx context.Context, cmd Cmder) error {
-	c.mu.Lock()
-	c.cmds = append(c.cmds, cmd)
-	c.mu.Unlock()
-	return nil
-}
-
-// Close closes the pipeline, releasing any open resources.
-func (c *Pipeline) Close() error {
-	c.mu.Lock()
-	_ = c.discard()
-	c.closed = true
-	c.mu.Unlock()
-	return nil
-}
-
-// Discard resets the pipeline and discards queued commands.
-func (c *Pipeline) Discard() error {
-	c.mu.Lock()
-	err := c.discard()
-	c.mu.Unlock()
-	return err
-}
-
-func (c *Pipeline) discard() error {
-	if c.closed {
-		return pool.ErrClosed
-	}
-	c.cmds = c.cmds[:0]
-	return nil
-}
-
-// Exec executes all previously queued commands using one
-// client-server roundtrip.
-//
-// Exec always returns list of commands and error of the first failed
-// command if any.
-func (c *Pipeline) Exec(ctx context.Context) ([]Cmder, error) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return nil, pool.ErrClosed
-	}
-
-	if len(c.cmds) == 0 {
-		return nil, nil
-	}
-
-	cmds := c.cmds
-	c.cmds = nil
-
-	return cmds, c.exec(ctx, cmds)
-}
-
-func (c *Pipeline) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	if err := fn(c); err != nil {
-		return nil, err
-	}
-	cmds, err := c.Exec(ctx)
-	_ = c.Close()
-	return cmds, err
-}
-
-func (c *Pipeline) Pipeline() Pipeliner {
-	return c
-}
-
-func (c *Pipeline) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipelined(ctx, fn)
-}
-
-func (c *Pipeline) TxPipeline() Pipeliner {
-	return c
-}

vendor/github.com/go-redis/redis/v8/pubsub.go

@@ -1,668 +0,0 @@
-package redis
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal"
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-// PubSub implements Pub/Sub commands as described in
-// http://redis.io/topics/pubsub. Message receiving is NOT safe
-// for concurrent use by multiple goroutines.
-//
-// PubSub automatically reconnects to Redis Server and resubscribes
-// to the channels in case of network errors.
-type PubSub struct {
-	opt *Options
-
-	newConn   func(ctx context.Context, channels []string) (*pool.Conn, error)
-	closeConn func(*pool.Conn) error
-
-	mu       sync.Mutex
-	cn       *pool.Conn
-	channels map[string]struct{}
-	patterns map[string]struct{}
-
-	closed bool
-	exit   chan struct{}
-
-	cmd *Cmd
-
-	chOnce sync.Once
-	msgCh  *channel
-	allCh  *channel
-}
-
-func (c *PubSub) init() {
-	c.exit = make(chan struct{})
-}
-
-func (c *PubSub) String() string {
-	channels := mapKeys(c.channels)
-	channels = append(channels, mapKeys(c.patterns)...)
-	return fmt.Sprintf("PubSub(%s)", strings.Join(channels, ", "))
-}
-
-func (c *PubSub) connWithLock(ctx context.Context) (*pool.Conn, error) {
-	c.mu.Lock()
-	cn, err := c.conn(ctx, nil)
-	c.mu.Unlock()
-	return cn, err
-}
-
-func (c *PubSub) conn(ctx context.Context, newChannels []string) (*pool.Conn, error) {
-	if c.closed {
-		return nil, pool.ErrClosed
-	}
-	if c.cn != nil {
-		return c.cn, nil
-	}
-
-	channels := mapKeys(c.channels)
-	channels = append(channels, newChannels...)
-
-	cn, err := c.newConn(ctx, channels)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := c.resubscribe(ctx, cn); err != nil {
-		_ = c.closeConn(cn)
-		return nil, err
-	}
-
-	c.cn = cn
-	return cn, nil
-}
-
-func (c *PubSub) writeCmd(ctx context.Context, cn *pool.Conn, cmd Cmder) error {
-	return cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-		return writeCmd(wr, cmd)
-	})
-}
-
-func (c *PubSub) resubscribe(ctx context.Context, cn *pool.Conn) error {
-	var firstErr error
-
-	if len(c.channels) > 0 {
-		firstErr = c._subscribe(ctx, cn, "subscribe", mapKeys(c.channels))
-	}
-
-	if len(c.patterns) > 0 {
-		err := c._subscribe(ctx, cn, "psubscribe", mapKeys(c.patterns))
-		if err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-
-	return firstErr
-}
-
-func mapKeys(m map[string]struct{}) []string {
-	s := make([]string, len(m))
-	i := 0
-	for k := range m {
-		s[i] = k
-		i++
-	}
-	return s
-}
-
-func (c *PubSub) _subscribe(
-	ctx context.Context, cn *pool.Conn, redisCmd string, channels []string,
-) error {
-	args := make([]interface{}, 0, 1+len(channels))
-	args = append(args, redisCmd)
-	for _, channel := range channels {
-		args = append(args, channel)
-	}
-	cmd := NewSliceCmd(ctx, args...)
-	return c.writeCmd(ctx, cn, cmd)
-}
-
-func (c *PubSub) releaseConnWithLock(
-	ctx context.Context,
-	cn *pool.Conn,
-	err error,
-	allowTimeout bool,
-) {
-	c.mu.Lock()
-	c.releaseConn(ctx, cn, err, allowTimeout)
-	c.mu.Unlock()
-}
-
-func (c *PubSub) releaseConn(ctx context.Context, cn *pool.Conn, err error, allowTimeout bool) {
-	if c.cn != cn {
-		return
-	}
-	if isBadConn(err, allowTimeout, c.opt.Addr) {
-		c.reconnect(ctx, err)
-	}
-}
-
-func (c *PubSub) reconnect(ctx context.Context, reason error) {
-	_ = c.closeTheCn(reason)
-	_, _ = c.conn(ctx, nil)
-}
-
-func (c *PubSub) closeTheCn(reason error) error {
-	if c.cn == nil {
-		return nil
-	}
-	if !c.closed {
-		internal.Logger.Printf(c.getContext(), "redis: discarding bad PubSub connection: %s", reason)
-	}
-	err := c.closeConn(c.cn)
-	c.cn = nil
-	return err
-}
-
-func (c *PubSub) Close() error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return pool.ErrClosed
-	}
-	c.closed = true
-	close(c.exit)
-
-	return c.closeTheCn(pool.ErrClosed)
-}
-
-// Subscribe the client to the specified channels. It returns
-// empty subscription if there are no channels.
-func (c *PubSub) Subscribe(ctx context.Context, channels ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	err := c.subscribe(ctx, "subscribe", channels...)
-	if c.channels == nil {
-		c.channels = make(map[string]struct{})
-	}
-	for _, s := range channels {
-		c.channels[s] = struct{}{}
-	}
-	return err
-}
-
-// PSubscribe the client to the given patterns. It returns
-// empty subscription if there are no patterns.
-func (c *PubSub) PSubscribe(ctx context.Context, patterns ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	err := c.subscribe(ctx, "psubscribe", patterns...)
-	if c.patterns == nil {
-		c.patterns = make(map[string]struct{})
-	}
-	for _, s := range patterns {
-		c.patterns[s] = struct{}{}
-	}
-	return err
-}
-
-// Unsubscribe the client from the given channels, or from all of
-// them if none is given.
-func (c *PubSub) Unsubscribe(ctx context.Context, channels ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	for _, channel := range channels {
-		delete(c.channels, channel)
-	}
-	err := c.subscribe(ctx, "unsubscribe", channels...)
-	return err
-}
-
-// PUnsubscribe the client from the given patterns, or from all of
-// them if none is given.
-func (c *PubSub) PUnsubscribe(ctx context.Context, patterns ...string) error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	for _, pattern := range patterns {
-		delete(c.patterns, pattern)
-	}
-	err := c.subscribe(ctx, "punsubscribe", patterns...)
-	return err
-}
-
-func (c *PubSub) subscribe(ctx context.Context, redisCmd string, channels ...string) error {
-	cn, err := c.conn(ctx, channels)
-	if err != nil {
-		return err
-	}
-
-	err = c._subscribe(ctx, cn, redisCmd, channels)
-	c.releaseConn(ctx, cn, err, false)
-	return err
-}
-
-func (c *PubSub) Ping(ctx context.Context, payload ...string) error {
-	args := []interface{}{"ping"}
-	if len(payload) == 1 {
-		args = append(args, payload[0])
-	}
-	cmd := NewCmd(ctx, args...)
-
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	cn, err := c.conn(ctx, nil)
-	if err != nil {
-		return err
-	}
-
-	err = c.writeCmd(ctx, cn, cmd)
-	c.releaseConn(ctx, cn, err, false)
-	return err
-}
-
-// Subscription received after a successful subscription to channel.
-type Subscription struct {
-	// Can be "subscribe", "unsubscribe", "psubscribe" or "punsubscribe".
-	Kind string
-	// Channel name we have subscribed to.
-	Channel string
-	// Number of channels we are currently subscribed to.
-	Count int
-}
-
-func (m *Subscription) String() string {
-	return fmt.Sprintf("%s: %s", m.Kind, m.Channel)
-}
-
-// Message received as result of a PUBLISH command issued by another client.
-type Message struct {
-	Channel      string
-	Pattern      string
-	Payload      string
-	PayloadSlice []string
-}
-
-func (m *Message) String() string {
-	return fmt.Sprintf("Message<%s: %s>", m.Channel, m.Payload)
-}
-
-// Pong received as result of a PING command issued by another client.
-type Pong struct {
-	Payload string
-}
-
-func (p *Pong) String() string {
-	if p.Payload != "" {
-		return fmt.Sprintf("Pong<%s>", p.Payload)
-	}
-	return "Pong"
-}
-
-func (c *PubSub) newMessage(reply interface{}) (interface{}, error) {
-	switch reply := reply.(type) {
-	case string:
-		return &Pong{
-			Payload: reply,
-		}, nil
-	case []interface{}:
-		switch kind := reply[0].(string); kind {
-		case "subscribe", "unsubscribe", "psubscribe", "punsubscribe":
-			// Can be nil in case of "unsubscribe".
-			channel, _ := reply[1].(string)
-			return &Subscription{
-				Kind:    kind,
-				Channel: channel,
-				Count:   int(reply[2].(int64)),
-			}, nil
-		case "message":
-			switch payload := reply[2].(type) {
-			case string:
-				return &Message{
-					Channel: reply[1].(string),
-					Payload: payload,
-				}, nil
-			case []interface{}:
-				ss := make([]string, len(payload))
-				for i, s := range payload {
-					ss[i] = s.(string)
-				}
-				return &Message{
-					Channel:      reply[1].(string),
-					PayloadSlice: ss,
-				}, nil
-			default:
-				return nil, fmt.Errorf("redis: unsupported pubsub message payload: %T", payload)
-			}
-		case "pmessage":
-			return &Message{
-				Pattern: reply[1].(string),
-				Channel: reply[2].(string),
-				Payload: reply[3].(string),
-			}, nil
-		case "pong":
-			return &Pong{
-				Payload: reply[1].(string),
-			}, nil
-		default:
-			return nil, fmt.Errorf("redis: unsupported pubsub message: %q", kind)
-		}
-	default:
-		return nil, fmt.Errorf("redis: unsupported pubsub message: %#v", reply)
-	}
-}
-
-// ReceiveTimeout acts like Receive but returns an error if message
-// is not received in time. This is low-level API and in most cases
-// Channel should be used instead.
-func (c *PubSub) ReceiveTimeout(ctx context.Context, timeout time.Duration) (interface{}, error) {
-	if c.cmd == nil {
-		c.cmd = NewCmd(ctx)
-	}
-
-	// Don't hold the lock to allow subscriptions and pings.
-
-	cn, err := c.connWithLock(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	err = cn.WithReader(ctx, timeout, func(rd *proto.Reader) error {
-		return c.cmd.readReply(rd)
-	})
-
-	c.releaseConnWithLock(ctx, cn, err, timeout > 0)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return c.newMessage(c.cmd.Val())
-}
-
-// Receive returns a message as a Subscription, Message, Pong or error.
-// See PubSub example for details. This is low-level API and in most cases
-// Channel should be used instead.
-func (c *PubSub) Receive(ctx context.Context) (interface{}, error) {
-	return c.ReceiveTimeout(ctx, 0)
-}
-
-// ReceiveMessage returns a Message or error ignoring Subscription and Pong
-// messages. This is low-level API and in most cases Channel should be used
-// instead.
-func (c *PubSub) ReceiveMessage(ctx context.Context) (*Message, error) {
-	for {
-		msg, err := c.Receive(ctx)
-		if err != nil {
-			return nil, err
-		}
-
-		switch msg := msg.(type) {
-		case *Subscription:
-			// Ignore.
-		case *Pong:
-			// Ignore.
-		case *Message:
-			return msg, nil
-		default:
-			err := fmt.Errorf("redis: unknown message: %T", msg)
-			return nil, err
-		}
-	}
-}
-
-func (c *PubSub) getContext() context.Context {
-	if c.cmd != nil {
-		return c.cmd.ctx
-	}
-	return context.Background()
-}
-
-//------------------------------------------------------------------------------
-
-// Channel returns a Go channel for concurrently receiving messages.
-// The channel is closed together with the PubSub. If the Go channel
-// is blocked full for 30 seconds the message is dropped.
-// Receive* APIs can not be used after channel is created.
-//
-// go-redis periodically sends ping messages to test connection health
-// and re-subscribes if ping can not not received for 30 seconds.
-func (c *PubSub) Channel(opts ...ChannelOption) <-chan *Message {
-	c.chOnce.Do(func() {
-		c.msgCh = newChannel(c, opts...)
-		c.msgCh.initMsgChan()
-	})
-	if c.msgCh == nil {
-		err := fmt.Errorf("redis: Channel can't be called after ChannelWithSubscriptions")
-		panic(err)
-	}
-	return c.msgCh.msgCh
-}
-
-// ChannelSize is like Channel, but creates a Go channel
-// with specified buffer size.
-//
-// Deprecated: use Channel(WithChannelSize(size)), remove in v9.
-func (c *PubSub) ChannelSize(size int) <-chan *Message {
-	return c.Channel(WithChannelSize(size))
-}
-
-// ChannelWithSubscriptions is like Channel, but message type can be either
-// *Subscription or *Message. Subscription messages can be used to detect
-// reconnections.
-//
-// ChannelWithSubscriptions can not be used together with Channel or ChannelSize.
-func (c *PubSub) ChannelWithSubscriptions(_ context.Context, size int) <-chan interface{} {
-	c.chOnce.Do(func() {
-		c.allCh = newChannel(c, WithChannelSize(size))
-		c.allCh.initAllChan()
-	})
-	if c.allCh == nil {
-		err := fmt.Errorf("redis: ChannelWithSubscriptions can't be called after Channel")
-		panic(err)
-	}
-	return c.allCh.allCh
-}
-
-type ChannelOption func(c *channel)
-
-// WithChannelSize specifies the Go chan size that is used to buffer incoming messages.
-//
-// The default is 100 messages.
-func WithChannelSize(size int) ChannelOption {
-	return func(c *channel) {
-		c.chanSize = size
-	}
-}
-
-// WithChannelHealthCheckInterval specifies the health check interval.
-// PubSub will ping Redis Server if it does not receive any messages within the interval.
-// To disable health check, use zero interval.
-//
-// The default is 3 seconds.
-func WithChannelHealthCheckInterval(d time.Duration) ChannelOption {
-	return func(c *channel) {
-		c.checkInterval = d
-	}
-}
-
-// WithChannelSendTimeout specifies the channel send timeout after which
-// the message is dropped.
-//
-// The default is 60 seconds.
-func WithChannelSendTimeout(d time.Duration) ChannelOption {
-	return func(c *channel) {
-		c.chanSendTimeout = d
-	}
-}
-
-type channel struct {
-	pubSub *PubSub
-
-	msgCh chan *Message
-	allCh chan interface{}
-	ping  chan struct{}
-
-	chanSize        int
-	chanSendTimeout time.Duration
-	checkInterval   time.Duration
-}
-
-func newChannel(pubSub *PubSub, opts ...ChannelOption) *channel {
-	c := &channel{
-		pubSub: pubSub,
-
-		chanSize:        100,
-		chanSendTimeout: time.Minute,
-		checkInterval:   3 * time.Second,
-	}
-	for _, opt := range opts {
-		opt(c)
-	}
-	if c.checkInterval > 0 {
-		c.initHealthCheck()
-	}
-	return c
-}
-
-func (c *channel) initHealthCheck() {
-	ctx := context.TODO()
-	c.ping = make(chan struct{}, 1)
-
-	go func() {
-		timer := time.NewTimer(time.Minute)
-		timer.Stop()
-
-		for {
-			timer.Reset(c.checkInterval)
-			select {
-			case <-c.ping:
-				if !timer.Stop() {
-					<-timer.C
-				}
-			case <-timer.C:
-				if pingErr := c.pubSub.Ping(ctx); pingErr != nil {
-					c.pubSub.mu.Lock()
-					c.pubSub.reconnect(ctx, pingErr)
-					c.pubSub.mu.Unlock()
-				}
-			case <-c.pubSub.exit:
-				return
-			}
-		}
-	}()
-}
-
-// initMsgChan must be in sync with initAllChan.
-func (c *channel) initMsgChan() {
-	ctx := context.TODO()
-	c.msgCh = make(chan *Message, c.chanSize)
-
-	go func() {
-		timer := time.NewTimer(time.Minute)
-		timer.Stop()
-
-		var errCount int
-		for {
-			msg, err := c.pubSub.Receive(ctx)
-			if err != nil {
-				if err == pool.ErrClosed {
-					close(c.msgCh)
-					return
-				}
-				if errCount > 0 {
-					time.Sleep(100 * time.Millisecond)
-				}
-				errCount++
-				continue
-			}
-
-			errCount = 0
-
-			// Any message is as good as a ping.
-			select {
-			case c.ping <- struct{}{}:
-			default:
-			}
-
-			switch msg := msg.(type) {
-			case *Subscription:
-				// Ignore.
-			case *Pong:
-				// Ignore.
-			case *Message:
-				timer.Reset(c.chanSendTimeout)
-				select {
-				case c.msgCh <- msg:
-					if !timer.Stop() {
-						<-timer.C
-					}
-				case <-timer.C:
-					internal.Logger.Printf(
-						ctx, "redis: %s channel is full for %s (message is dropped)",
-						c, c.chanSendTimeout)
-				}
-			default:
-				internal.Logger.Printf(ctx, "redis: unknown message type: %T", msg)
-			}
-		}
-	}()
-}
-
-// initAllChan must be in sync with initMsgChan.
-func (c *channel) initAllChan() {
-	ctx := context.TODO()
-	c.allCh = make(chan interface{}, c.chanSize)
-
-	go func() {
-		timer := time.NewTimer(time.Minute)
-		timer.Stop()
-
-		var errCount int
-		for {
-			msg, err := c.pubSub.Receive(ctx)
-			if err != nil {
-				if err == pool.ErrClosed {
-					close(c.allCh)
-					return
-				}
-				if errCount > 0 {
-					time.Sleep(100 * time.Millisecond)
-				}
-				errCount++
-				continue
-			}
-
-			errCount = 0
-
-			// Any message is as good as a ping.
-			select {
-			case c.ping <- struct{}{}:
-			default:
-			}
-
-			switch msg := msg.(type) {
-			case *Pong:
-				// Ignore.
-			case *Subscription, *Message:
-				timer.Reset(c.chanSendTimeout)
-				select {
-				case c.allCh <- msg:
-					if !timer.Stop() {
-						<-timer.C
-					}
-				case <-timer.C:
-					internal.Logger.Printf(
-						ctx, "redis: %s channel is full for %s (message is dropped)",
-						c, c.chanSendTimeout)
-				}
-			default:
-				internal.Logger.Printf(ctx, "redis: unknown message type: %T", msg)
-			}
-		}
-	}()
-}

vendor/github.com/go-redis/redis/v8/redis.go

@@ -1,773 +0,0 @@
-package redis
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"sync/atomic"
-	"time"
-
-	"github.com/go-redis/redis/v8/internal"
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/proto"
-)
-
-// Nil reply returned by Redis when key does not exist.
-const Nil = proto.Nil
-
-func SetLogger(logger internal.Logging) {
-	internal.Logger = logger
-}
-
-//------------------------------------------------------------------------------
-
-type Hook interface {
-	BeforeProcess(ctx context.Context, cmd Cmder) (context.Context, error)
-	AfterProcess(ctx context.Context, cmd Cmder) error
-
-	BeforeProcessPipeline(ctx context.Context, cmds []Cmder) (context.Context, error)
-	AfterProcessPipeline(ctx context.Context, cmds []Cmder) error
-}
-
-type hooks struct {
-	hooks []Hook
-}
-
-func (hs *hooks) lock() {
-	hs.hooks = hs.hooks[:len(hs.hooks):len(hs.hooks)]
-}
-
-func (hs hooks) clone() hooks {
-	clone := hs
-	clone.lock()
-	return clone
-}
-
-func (hs *hooks) AddHook(hook Hook) {
-	hs.hooks = append(hs.hooks, hook)
-}
-
-func (hs hooks) process(
-	ctx context.Context, cmd Cmder, fn func(context.Context, Cmder) error,
-) error {
-	if len(hs.hooks) == 0 {
-		err := fn(ctx, cmd)
-		cmd.SetErr(err)
-		return err
-	}
-
-	var hookIndex int
-	var retErr error
-
-	for ; hookIndex < len(hs.hooks) && retErr == nil; hookIndex++ {
-		ctx, retErr = hs.hooks[hookIndex].BeforeProcess(ctx, cmd)
-		if retErr != nil {
-			cmd.SetErr(retErr)
-		}
-	}
-
-	if retErr == nil {
-		retErr = fn(ctx, cmd)
-		cmd.SetErr(retErr)
-	}
-
-	for hookIndex--; hookIndex >= 0; hookIndex-- {
-		if err := hs.hooks[hookIndex].AfterProcess(ctx, cmd); err != nil {
-			retErr = err
-			cmd.SetErr(retErr)
-		}
-	}
-
-	return retErr
-}
-
-func (hs hooks) processPipeline(
-	ctx context.Context, cmds []Cmder, fn func(context.Context, []Cmder) error,
-) error {
-	if len(hs.hooks) == 0 {
-		err := fn(ctx, cmds)
-		return err
-	}
-
-	var hookIndex int
-	var retErr error
-
-	for ; hookIndex < len(hs.hooks) && retErr == nil; hookIndex++ {
-		ctx, retErr = hs.hooks[hookIndex].BeforeProcessPipeline(ctx, cmds)
-		if retErr != nil {
-			setCmdsErr(cmds, retErr)
-		}
-	}
-
-	if retErr == nil {
-		retErr = fn(ctx, cmds)
-	}
-
-	for hookIndex--; hookIndex >= 0; hookIndex-- {
-		if err := hs.hooks[hookIndex].AfterProcessPipeline(ctx, cmds); err != nil {
-			retErr = err
-			setCmdsErr(cmds, retErr)
-		}
-	}
-
-	return retErr
-}
-
-func (hs hooks) processTxPipeline(
-	ctx context.Context, cmds []Cmder, fn func(context.Context, []Cmder) error,
-) error {
-	cmds = wrapMultiExec(ctx, cmds)
-	return hs.processPipeline(ctx, cmds, fn)
-}
-
-//------------------------------------------------------------------------------
-
-type baseClient struct {
-	opt      *Options
-	connPool pool.Pooler
-
-	onClose func() error // hook called when client is closed
-}
-
-func newBaseClient(opt *Options, connPool pool.Pooler) *baseClient {
-	return &baseClient{
-		opt:      opt,
-		connPool: connPool,
-	}
-}
-
-func (c *baseClient) clone() *baseClient {
-	clone := *c
-	return &clone
-}
-
-func (c *baseClient) withTimeout(timeout time.Duration) *baseClient {
-	opt := c.opt.clone()
-	opt.ReadTimeout = timeout
-	opt.WriteTimeout = timeout
-
-	clone := c.clone()
-	clone.opt = opt
-
-	return clone
-}
-
-func (c *baseClient) String() string {
-	return fmt.Sprintf("Redis<%s db:%d>", c.getAddr(), c.opt.DB)
-}
-
-func (c *baseClient) newConn(ctx context.Context) (*pool.Conn, error) {
-	cn, err := c.connPool.NewConn(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	err = c.initConn(ctx, cn)
-	if err != nil {
-		_ = c.connPool.CloseConn(cn)
-		return nil, err
-	}
-
-	return cn, nil
-}
-
-func (c *baseClient) getConn(ctx context.Context) (*pool.Conn, error) {
-	if c.opt.Limiter != nil {
-		err := c.opt.Limiter.Allow()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	cn, err := c._getConn(ctx)
-	if err != nil {
-		if c.opt.Limiter != nil {
-			c.opt.Limiter.ReportResult(err)
-		}
-		return nil, err
-	}
-
-	return cn, nil
-}
-
-func (c *baseClient) _getConn(ctx context.Context) (*pool.Conn, error) {
-	cn, err := c.connPool.Get(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if cn.Inited {
-		return cn, nil
-	}
-
-	if err := c.initConn(ctx, cn); err != nil {
-		c.connPool.Remove(ctx, cn, err)
-		if err := errors.Unwrap(err); err != nil {
-			return nil, err
-		}
-		return nil, err
-	}
-
-	return cn, nil
-}
-
-func (c *baseClient) initConn(ctx context.Context, cn *pool.Conn) error {
-	if cn.Inited {
-		return nil
-	}
-	cn.Inited = true
-
-	if c.opt.Password == "" &&
-		c.opt.DB == 0 &&
-		!c.opt.readOnly &&
-		c.opt.OnConnect == nil {
-		return nil
-	}
-
-	connPool := pool.NewSingleConnPool(c.connPool, cn)
-	conn := newConn(ctx, c.opt, connPool)
-
-	_, err := conn.Pipelined(ctx, func(pipe Pipeliner) error {
-		if c.opt.Password != "" {
-			if c.opt.Username != "" {
-				pipe.AuthACL(ctx, c.opt.Username, c.opt.Password)
-			} else {
-				pipe.Auth(ctx, c.opt.Password)
-			}
-		}
-
-		if c.opt.DB > 0 {
-			pipe.Select(ctx, c.opt.DB)
-		}
-
-		if c.opt.readOnly {
-			pipe.ReadOnly(ctx)
-		}
-
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	if c.opt.OnConnect != nil {
-		return c.opt.OnConnect(ctx, conn)
-	}
-	return nil
-}
-
-func (c *baseClient) releaseConn(ctx context.Context, cn *pool.Conn, err error) {
-	if c.opt.Limiter != nil {
-		c.opt.Limiter.ReportResult(err)
-	}
-
-	if isBadConn(err, false, c.opt.Addr) {
-		c.connPool.Remove(ctx, cn, err)
-	} else {
-		c.connPool.Put(ctx, cn)
-	}
-}
-
-func (c *baseClient) withConn(
-	ctx context.Context, fn func(context.Context, *pool.Conn) error,
-) error {
-	cn, err := c.getConn(ctx)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		c.releaseConn(ctx, cn, err)
-	}()
-
-	done := ctx.Done() //nolint:ifshort
-
-	if done == nil {
-		err = fn(ctx, cn)
-		return err
-	}
-
-	errc := make(chan error, 1)
-	go func() { errc <- fn(ctx, cn) }()
-
-	select {
-	case <-done:
-		_ = cn.Close()
-		// Wait for the goroutine to finish and send something.
-		<-errc
-
-		err = ctx.Err()
-		return err
-	case err = <-errc:
-		return err
-	}
-}
-
-func (c *baseClient) process(ctx context.Context, cmd Cmder) error {
-	var lastErr error
-	for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
-		attempt := attempt
-
-		retry, err := c._process(ctx, cmd, attempt)
-		if err == nil || !retry {
-			return err
-		}
-
-		lastErr = err
-	}
-	return lastErr
-}
-
-func (c *baseClient) _process(ctx context.Context, cmd Cmder, attempt int) (bool, error) {
-	if attempt > 0 {
-		if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
-			return false, err
-		}
-	}
-
-	retryTimeout := uint32(1)
-	err := c.withConn(ctx, func(ctx context.Context, cn *pool.Conn) error {
-		err := cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-			return writeCmd(wr, cmd)
-		})
-		if err != nil {
-			return err
-		}
-
-		err = cn.WithReader(ctx, c.cmdTimeout(cmd), cmd.readReply)
-		if err != nil {
-			if cmd.readTimeout() == nil {
-				atomic.StoreUint32(&retryTimeout, 1)
-			}
-			return err
-		}
-
-		return nil
-	})
-	if err == nil {
-		return false, nil
-	}
-
-	retry := shouldRetry(err, atomic.LoadUint32(&retryTimeout) == 1)
-	return retry, err
-}
-
-func (c *baseClient) retryBackoff(attempt int) time.Duration {
-	return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
-}
-
-func (c *baseClient) cmdTimeout(cmd Cmder) time.Duration {
-	if timeout := cmd.readTimeout(); timeout != nil {
-		t := *timeout
-		if t == 0 {
-			return 0
-		}
-		return t + 10*time.Second
-	}
-	return c.opt.ReadTimeout
-}
-
-// Close closes the client, releasing any open resources.
-//
-// It is rare to Close a Client, as the Client is meant to be
-// long-lived and shared between many goroutines.
-func (c *baseClient) Close() error {
-	var firstErr error
-	if c.onClose != nil {
-		if err := c.onClose(); err != nil {
-			firstErr = err
-		}
-	}
-	if err := c.connPool.Close(); err != nil && firstErr == nil {
-		firstErr = err
-	}
-	return firstErr
-}
-
-func (c *baseClient) getAddr() string {
-	return c.opt.Addr
-}
-
-func (c *baseClient) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.generalProcessPipeline(ctx, cmds, c.pipelineProcessCmds)
-}
-
-func (c *baseClient) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.generalProcessPipeline(ctx, cmds, c.txPipelineProcessCmds)
-}
-
-type pipelineProcessor func(context.Context, *pool.Conn, []Cmder) (bool, error)
-
-func (c *baseClient) generalProcessPipeline(
-	ctx context.Context, cmds []Cmder, p pipelineProcessor,
-) error {
-	err := c._generalProcessPipeline(ctx, cmds, p)
-	if err != nil {
-		setCmdsErr(cmds, err)
-		return err
-	}
-	return cmdsFirstErr(cmds)
-}
-
-func (c *baseClient) _generalProcessPipeline(
-	ctx context.Context, cmds []Cmder, p pipelineProcessor,
-) error {
-	var lastErr error
-	for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
-		if attempt > 0 {
-			if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
-				return err
-			}
-		}
-
-		var canRetry bool
-		lastErr = c.withConn(ctx, func(ctx context.Context, cn *pool.Conn) error {
-			var err error
-			canRetry, err = p(ctx, cn, cmds)
-			return err
-		})
-		if lastErr == nil || !canRetry || !shouldRetry(lastErr, true) {
-			return lastErr
-		}
-	}
-	return lastErr
-}
-
-func (c *baseClient) pipelineProcessCmds(
-	ctx context.Context, cn *pool.Conn, cmds []Cmder,
-) (bool, error) {
-	err := cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-		return writeCmds(wr, cmds)
-	})
-	if err != nil {
-		return true, err
-	}
-
-	err = cn.WithReader(ctx, c.opt.ReadTimeout, func(rd *proto.Reader) error {
-		return pipelineReadCmds(rd, cmds)
-	})
-	return true, err
-}
-
-func pipelineReadCmds(rd *proto.Reader, cmds []Cmder) error {
-	for _, cmd := range cmds {
-		err := cmd.readReply(rd)
-		cmd.SetErr(err)
-		if err != nil && !isRedisError(err) {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *baseClient) txPipelineProcessCmds(
-	ctx context.Context, cn *pool.Conn, cmds []Cmder,
-) (bool, error) {
-	err := cn.WithWriter(ctx, c.opt.WriteTimeout, func(wr *proto.Writer) error {
-		return writeCmds(wr, cmds)
-	})
-	if err != nil {
-		return true, err
-	}
-
-	err = cn.WithReader(ctx, c.opt.ReadTimeout, func(rd *proto.Reader) error {
-		statusCmd := cmds[0].(*StatusCmd)
-		// Trim multi and exec.
-		cmds = cmds[1 : len(cmds)-1]
-
-		err := txPipelineReadQueued(rd, statusCmd, cmds)
-		if err != nil {
-			return err
-		}
-
-		return pipelineReadCmds(rd, cmds)
-	})
-	return false, err
-}
-
-func wrapMultiExec(ctx context.Context, cmds []Cmder) []Cmder {
-	if len(cmds) == 0 {
-		panic("not reached")
-	}
-	cmdCopy := make([]Cmder, len(cmds)+2)
-	cmdCopy[0] = NewStatusCmd(ctx, "multi")
-	copy(cmdCopy[1:], cmds)
-	cmdCopy[len(cmdCopy)-1] = NewSliceCmd(ctx, "exec")
-	return cmdCopy
-}
-
-func txPipelineReadQueued(rd *proto.Reader, statusCmd *StatusCmd, cmds []Cmder) error {
-	// Parse queued replies.
-	if err := statusCmd.readReply(rd); err != nil {
-		return err
-	}
-
-	for range cmds {
-		if err := statusCmd.readReply(rd); err != nil && !isRedisError(err) {
-			return err
-		}
-	}
-
-	// Parse number of replies.
-	line, err := rd.ReadLine()
-	if err != nil {
-		if err == Nil {
-			err = TxFailedErr
-		}
-		return err
-	}
-
-	switch line[0] {
-	case proto.ErrorReply:
-		return proto.ParseErrorReply(line)
-	case proto.ArrayReply:
-		// ok
-	default:
-		err := fmt.Errorf("redis: expected '*', but got line %q", line)
-		return err
-	}
-
-	return nil
-}
-
-//------------------------------------------------------------------------------
-
-// Client is a Redis client representing a pool of zero or more
-// underlying connections. It's safe for concurrent use by multiple
-// goroutines.
-type Client struct {
-	*baseClient
-	cmdable
-	hooks
-	ctx context.Context
-}
-
-// NewClient returns a client to the Redis Server specified by Options.
-func NewClient(opt *Options) *Client {
-	opt.init()
-
-	c := Client{
-		baseClient: newBaseClient(opt, newConnPool(opt)),
-		ctx:        context.Background(),
-	}
-	c.cmdable = c.Process
-
-	return &c
-}
-
-func (c *Client) clone() *Client {
-	clone := *c
-	clone.cmdable = clone.Process
-	clone.hooks.lock()
-	return &clone
-}
-
-func (c *Client) WithTimeout(timeout time.Duration) *Client {
-	clone := c.clone()
-	clone.baseClient = c.baseClient.withTimeout(timeout)
-	return clone
-}
-
-func (c *Client) Context() context.Context {
-	return c.ctx
-}
-
-func (c *Client) WithContext(ctx context.Context) *Client {
-	if ctx == nil {
-		panic("nil context")
-	}
-	clone := c.clone()
-	clone.ctx = ctx
-	return clone
-}
-
-func (c *Client) Conn(ctx context.Context) *Conn {
-	return newConn(ctx, c.opt, pool.NewStickyConnPool(c.connPool))
-}
-
-// Do creates a Cmd from the args and processes the cmd.
-func (c *Client) Do(ctx context.Context, args ...interface{}) *Cmd {
-	cmd := NewCmd(ctx, args...)
-	_ = c.Process(ctx, cmd)
-	return cmd
-}
-
-func (c *Client) Process(ctx context.Context, cmd Cmder) error {
-	return c.hooks.process(ctx, cmd, c.baseClient.process)
-}
-
-func (c *Client) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, c.baseClient.processPipeline)
-}
-
-func (c *Client) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processTxPipeline(ctx, cmds, c.baseClient.processTxPipeline)
-}
-
-// Options returns read-only Options that were used to create the client.
-func (c *Client) Options() *Options {
-	return c.opt
-}
-
-type PoolStats pool.Stats
-
-// PoolStats returns connection pool stats.
-func (c *Client) PoolStats() *PoolStats {
-	stats := c.connPool.Stats()
-	return (*PoolStats)(stats)
-}
-
-func (c *Client) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipeline().Pipelined(ctx, fn)
-}
-
-func (c *Client) Pipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Client) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.TxPipeline().Pipelined(ctx, fn)
-}
-
-// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
-func (c *Client) TxPipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processTxPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Client) pubSub() *PubSub {
-	pubsub := &PubSub{
-		opt: c.opt,
-
-		newConn: func(ctx context.Context, channels []string) (*pool.Conn, error) {
-			return c.newConn(ctx)
-		},
-		closeConn: c.connPool.CloseConn,
-	}
-	pubsub.init()
-	return pubsub
-}
-
-// Subscribe subscribes the client to the specified channels.
-// Channels can be omitted to create empty subscription.
-// Note that this method does not wait on a response from Redis, so the
-// subscription may not be active immediately. To force the connection to wait,
-// you may call the Receive() method on the returned *PubSub like so:
-//
-//    sub := client.Subscribe(queryResp)
-//    iface, err := sub.Receive()
-//    if err != nil {
-//        // handle error
-//    }
-//
-//    // Should be *Subscription, but others are possible if other actions have been
-//    // taken on sub since it was created.
-//    switch iface.(type) {
-//    case *Subscription:
-//        // subscribe succeeded
-//    case *Message:
-//        // received first message
-//    case *Pong:
-//        // pong received
-//    default:
-//        // handle error
-//    }
-//
-//    ch := sub.Channel()
-func (c *Client) Subscribe(ctx context.Context, channels ...string) *PubSub {
-	pubsub := c.pubSub()
-	if len(channels) > 0 {
-		_ = pubsub.Subscribe(ctx, channels...)
-	}
-	return pubsub
-}
-
-// PSubscribe subscribes the client to the given patterns.
-// Patterns can be omitted to create empty subscription.
-func (c *Client) PSubscribe(ctx context.Context, channels ...string) *PubSub {
-	pubsub := c.pubSub()
-	if len(channels) > 0 {
-		_ = pubsub.PSubscribe(ctx, channels...)
-	}
-	return pubsub
-}
-
-//------------------------------------------------------------------------------
-
-type conn struct {
-	baseClient
-	cmdable
-	statefulCmdable
-	hooks // TODO: inherit hooks
-}
-
-// Conn represents a single Redis connection rather than a pool of connections.
-// Prefer running commands from Client unless there is a specific need
-// for a continuous single Redis connection.
-type Conn struct {
-	*conn
-	ctx context.Context
-}
-
-func newConn(ctx context.Context, opt *Options, connPool pool.Pooler) *Conn {
-	c := Conn{
-		conn: &conn{
-			baseClient: baseClient{
-				opt:      opt,
-				connPool: connPool,
-			},
-		},
-		ctx: ctx,
-	}
-	c.cmdable = c.Process
-	c.statefulCmdable = c.Process
-	return &c
-}
-
-func (c *Conn) Process(ctx context.Context, cmd Cmder) error {
-	return c.hooks.process(ctx, cmd, c.baseClient.process)
-}
-
-func (c *Conn) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, c.baseClient.processPipeline)
-}
-
-func (c *Conn) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processTxPipeline(ctx, cmds, c.baseClient.processTxPipeline)
-}
-
-func (c *Conn) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipeline().Pipelined(ctx, fn)
-}
-
-func (c *Conn) Pipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Conn) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.TxPipeline().Pipelined(ctx, fn)
-}
-
-// TxPipeline acts like Pipeline, but wraps queued commands with MULTI/EXEC.
-func (c *Conn) TxPipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processTxPipeline,
-	}
-	pipe.init()
-	return &pipe
-}

vendor/github.com/go-redis/redis/v8/result.go

@@ -1,180 +0,0 @@
-package redis
-
-import "time"
-
-// NewCmdResult returns a Cmd initialised with val and err for testing.
-func NewCmdResult(val interface{}, err error) *Cmd {
-	var cmd Cmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewSliceResult returns a SliceCmd initialised with val and err for testing.
-func NewSliceResult(val []interface{}, err error) *SliceCmd {
-	var cmd SliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStatusResult returns a StatusCmd initialised with val and err for testing.
-func NewStatusResult(val string, err error) *StatusCmd {
-	var cmd StatusCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewIntResult returns an IntCmd initialised with val and err for testing.
-func NewIntResult(val int64, err error) *IntCmd {
-	var cmd IntCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewDurationResult returns a DurationCmd initialised with val and err for testing.
-func NewDurationResult(val time.Duration, err error) *DurationCmd {
-	var cmd DurationCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewBoolResult returns a BoolCmd initialised with val and err for testing.
-func NewBoolResult(val bool, err error) *BoolCmd {
-	var cmd BoolCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringResult returns a StringCmd initialised with val and err for testing.
-func NewStringResult(val string, err error) *StringCmd {
-	var cmd StringCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewFloatResult returns a FloatCmd initialised with val and err for testing.
-func NewFloatResult(val float64, err error) *FloatCmd {
-	var cmd FloatCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringSliceResult returns a StringSliceCmd initialised with val and err for testing.
-func NewStringSliceResult(val []string, err error) *StringSliceCmd {
-	var cmd StringSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing.
-func NewBoolSliceResult(val []bool, err error) *BoolSliceCmd {
-	var cmd BoolSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringStringMapResult returns a StringStringMapCmd initialised with val and err for testing.
-func NewStringStringMapResult(val map[string]string, err error) *StringStringMapCmd {
-	var cmd StringStringMapCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewStringIntMapCmdResult returns a StringIntMapCmd initialised with val and err for testing.
-func NewStringIntMapCmdResult(val map[string]int64, err error) *StringIntMapCmd {
-	var cmd StringIntMapCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewTimeCmdResult returns a TimeCmd initialised with val and err for testing.
-func NewTimeCmdResult(val time.Time, err error) *TimeCmd {
-	var cmd TimeCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewZSliceCmdResult returns a ZSliceCmd initialised with val and err for testing.
-func NewZSliceCmdResult(val []Z, err error) *ZSliceCmd {
-	var cmd ZSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewZWithKeyCmdResult returns a NewZWithKeyCmd initialised with val and err for testing.
-func NewZWithKeyCmdResult(val *ZWithKey, err error) *ZWithKeyCmd {
-	var cmd ZWithKeyCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewScanCmdResult returns a ScanCmd initialised with val and err for testing.
-func NewScanCmdResult(keys []string, cursor uint64, err error) *ScanCmd {
-	var cmd ScanCmd
-	cmd.page = keys
-	cmd.cursor = cursor
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewClusterSlotsCmdResult returns a ClusterSlotsCmd initialised with val and err for testing.
-func NewClusterSlotsCmdResult(val []ClusterSlot, err error) *ClusterSlotsCmd {
-	var cmd ClusterSlotsCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewGeoLocationCmdResult returns a GeoLocationCmd initialised with val and err for testing.
-func NewGeoLocationCmdResult(val []GeoLocation, err error) *GeoLocationCmd {
-	var cmd GeoLocationCmd
-	cmd.locations = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewGeoPosCmdResult returns a GeoPosCmd initialised with val and err for testing.
-func NewGeoPosCmdResult(val []*GeoPos, err error) *GeoPosCmd {
-	var cmd GeoPosCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewCommandsInfoCmdResult returns a CommandsInfoCmd initialised with val and err for testing.
-func NewCommandsInfoCmdResult(val map[string]*CommandInfo, err error) *CommandsInfoCmd {
-	var cmd CommandsInfoCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewXMessageSliceCmdResult returns a XMessageSliceCmd initialised with val and err for testing.
-func NewXMessageSliceCmdResult(val []XMessage, err error) *XMessageSliceCmd {
-	var cmd XMessageSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}
-
-// NewXStreamSliceCmdResult returns a XStreamSliceCmd initialised with val and err for testing.
-func NewXStreamSliceCmdResult(val []XStream, err error) *XStreamSliceCmd {
-	var cmd XStreamSliceCmd
-	cmd.val = val
-	cmd.SetErr(err)
-	return &cmd
-}

vendor/github.com/go-redis/redis/v8/ring.go

@@ -1,736 +0,0 @@
-package redis
-
-import (
-	"context"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net"
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/cespare/xxhash/v2"
-	rendezvous "github.com/dgryski/go-rendezvous" //nolint
-
-	"github.com/go-redis/redis/v8/internal"
-	"github.com/go-redis/redis/v8/internal/hashtag"
-	"github.com/go-redis/redis/v8/internal/pool"
-	"github.com/go-redis/redis/v8/internal/rand"
-)
-
-var errRingShardsDown = errors.New("redis: all ring shards are down")
-
-//------------------------------------------------------------------------------
-
-type ConsistentHash interface {
-	Get(string) string
-}
-
-type rendezvousWrapper struct {
-	*rendezvous.Rendezvous
-}
-
-func (w rendezvousWrapper) Get(key string) string {
-	return w.Lookup(key)
-}
-
-func newRendezvous(shards []string) ConsistentHash {
-	return rendezvousWrapper{rendezvous.New(shards, xxhash.Sum64String)}
-}
-
-//------------------------------------------------------------------------------
-
-// RingOptions are used to configure a ring client and should be
-// passed to NewRing.
-type RingOptions struct {
-	// Map of name => host:port addresses of ring shards.
-	Addrs map[string]string
-
-	// NewClient creates a shard client with provided name and options.
-	NewClient func(name string, opt *Options) *Client
-
-	// Frequency of PING commands sent to check shards availability.
-	// Shard is considered down after 3 subsequent failed checks.
-	HeartbeatFrequency time.Duration
-
-	// NewConsistentHash returns a consistent hash that is used
-	// to distribute keys across the shards.
-	//
-	// See https://medium.com/@dgryski/consistent-hashing-algorithmic-tradeoffs-ef6b8e2fcae8
-	// for consistent hashing algorithmic tradeoffs.
-	NewConsistentHash func(shards []string) ConsistentHash
-
-	// Following options are copied from Options struct.
-
-	Dialer    func(ctx context.Context, network, addr string) (net.Conn, error)
-	OnConnect func(ctx context.Context, cn *Conn) error
-
-	Username string
-	Password string
-	DB       int
-
-	MaxRetries      int
-	MinRetryBackoff time.Duration
-	MaxRetryBackoff time.Duration
-
-	DialTimeout  time.Duration
-	ReadTimeout  time.Duration
-	WriteTimeout time.Duration
-
-	// PoolFIFO uses FIFO mode for each node connection pool GET/PUT (default LIFO).
-	PoolFIFO bool
-
-	PoolSize           int
-	MinIdleConns       int
-	MaxConnAge         time.Duration
-	PoolTimeout        time.Duration
-	IdleTimeout        time.Duration
-	IdleCheckFrequency time.Duration
-
-	TLSConfig *tls.Config
-	Limiter   Limiter
-}
-
-func (opt *RingOptions) init() {
-	if opt.NewClient == nil {
-		opt.NewClient = func(name string, opt *Options) *Client {
-			return NewClient(opt)
-		}
-	}
-
-	if opt.HeartbeatFrequency == 0 {
-		opt.HeartbeatFrequency = 500 * time.Millisecond
-	}
-
-	if opt.NewConsistentHash == nil {
-		opt.NewConsistentHash = newRendezvous
-	}
-
-	if opt.MaxRetries == -1 {
-		opt.MaxRetries = 0
-	} else if opt.MaxRetries == 0 {
-		opt.MaxRetries = 3
-	}
-	switch opt.MinRetryBackoff {
-	case -1:
-		opt.MinRetryBackoff = 0
-	case 0:
-		opt.MinRetryBackoff = 8 * time.Millisecond
-	}
-	switch opt.MaxRetryBackoff {
-	case -1:
-		opt.MaxRetryBackoff = 0
-	case 0:
-		opt.MaxRetryBackoff = 512 * time.Millisecond
-	}
-}
-
-func (opt *RingOptions) clientOptions() *Options {
-	return &Options{
-		Dialer:    opt.Dialer,
-		OnConnect: opt.OnConnect,
-
-		Username: opt.Username,
-		Password: opt.Password,
-		DB:       opt.DB,
-
-		MaxRetries: -1,
-
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
-
-		PoolFIFO:           opt.PoolFIFO,
-		PoolSize:           opt.PoolSize,
-		MinIdleConns:       opt.MinIdleConns,
-		MaxConnAge:         opt.MaxConnAge,
-		PoolTimeout:        opt.PoolTimeout,
-		IdleTimeout:        opt.IdleTimeout,
-		IdleCheckFrequency: opt.IdleCheckFrequency,
-
-		TLSConfig: opt.TLSConfig,
-		Limiter:   opt.Limiter,
-	}
-}
-
-//------------------------------------------------------------------------------
-
-type ringShard struct {
-	Client *Client
-	down   int32
-}
-
-func newRingShard(opt *RingOptions, name, addr string) *ringShard {
-	clopt := opt.clientOptions()
-	clopt.Addr = addr
-
-	return &ringShard{
-		Client: opt.NewClient(name, clopt),
-	}
-}
-
-func (shard *ringShard) String() string {
-	var state string
-	if shard.IsUp() {
-		state = "up"
-	} else {
-		state = "down"
-	}
-	return fmt.Sprintf("%s is %s", shard.Client, state)
-}
-
-func (shard *ringShard) IsDown() bool {
-	const threshold = 3
-	return atomic.LoadInt32(&shard.down) >= threshold
-}
-
-func (shard *ringShard) IsUp() bool {
-	return !shard.IsDown()
-}
-
-// Vote votes to set shard state and returns true if state was changed.
-func (shard *ringShard) Vote(up bool) bool {
-	if up {
-		changed := shard.IsDown()
-		atomic.StoreInt32(&shard.down, 0)
-		return changed
-	}
-
-	if shard.IsDown() {
-		return false
-	}
-
-	atomic.AddInt32(&shard.down, 1)
-	return shard.IsDown()
-}
-
-//------------------------------------------------------------------------------
-
-type ringShards struct {
-	opt *RingOptions
-
-	mu       sync.RWMutex
-	hash     ConsistentHash
-	shards   map[string]*ringShard // read only
-	list     []*ringShard          // read only
-	numShard int
-	closed   bool
-}
-
-func newRingShards(opt *RingOptions) *ringShards {
-	shards := make(map[string]*ringShard, len(opt.Addrs))
-	list := make([]*ringShard, 0, len(shards))
-
-	for name, addr := range opt.Addrs {
-		shard := newRingShard(opt, name, addr)
-		shards[name] = shard
-
-		list = append(list, shard)
-	}
-
-	c := &ringShards{
-		opt: opt,
-
-		shards: shards,
-		list:   list,
-	}
-	c.rebalance()
-
-	return c
-}
-
-func (c *ringShards) List() []*ringShard {
-	var list []*ringShard
-
-	c.mu.RLock()
-	if !c.closed {
-		list = c.list
-	}
-	c.mu.RUnlock()
-
-	return list
-}
-
-func (c *ringShards) Hash(key string) string {
-	key = hashtag.Key(key)
-
-	var hash string
-
-	c.mu.RLock()
-	if c.numShard > 0 {
-		hash = c.hash.Get(key)
-	}
-	c.mu.RUnlock()
-
-	return hash
-}
-
-func (c *ringShards) GetByKey(key string) (*ringShard, error) {
-	key = hashtag.Key(key)
-
-	c.mu.RLock()
-
-	if c.closed {
-		c.mu.RUnlock()
-		return nil, pool.ErrClosed
-	}
-
-	if c.numShard == 0 {
-		c.mu.RUnlock()
-		return nil, errRingShardsDown
-	}
-
-	hash := c.hash.Get(key)
-	if hash == "" {
-		c.mu.RUnlock()
-		return nil, errRingShardsDown
-	}
-
-	shard := c.shards[hash]
-	c.mu.RUnlock()
-
-	return shard, nil
-}
-
-func (c *ringShards) GetByName(shardName string) (*ringShard, error) {
-	if shardName == "" {
-		return c.Random()
-	}
-
-	c.mu.RLock()
-	shard := c.shards[shardName]
-	c.mu.RUnlock()
-	return shard, nil
-}
-
-func (c *ringShards) Random() (*ringShard, error) {
-	return c.GetByKey(strconv.Itoa(rand.Int()))
-}
-
-// heartbeat monitors state of each shard in the ring.
-func (c *ringShards) Heartbeat(frequency time.Duration) {
-	ticker := time.NewTicker(frequency)
-	defer ticker.Stop()
-
-	ctx := context.Background()
-	for range ticker.C {
-		var rebalance bool
-
-		for _, shard := range c.List() {
-			err := shard.Client.Ping(ctx).Err()
-			isUp := err == nil || err == pool.ErrPoolTimeout
-			if shard.Vote(isUp) {
-				internal.Logger.Printf(context.Background(), "ring shard state changed: %s", shard)
-				rebalance = true
-			}
-		}
-
-		if rebalance {
-			c.rebalance()
-		}
-	}
-}
-
-// rebalance removes dead shards from the Ring.
-func (c *ringShards) rebalance() {
-	c.mu.RLock()
-	shards := c.shards
-	c.mu.RUnlock()
-
-	liveShards := make([]string, 0, len(shards))
-
-	for name, shard := range shards {
-		if shard.IsUp() {
-			liveShards = append(liveShards, name)
-		}
-	}
-
-	hash := c.opt.NewConsistentHash(liveShards)
-
-	c.mu.Lock()
-	c.hash = hash
-	c.numShard = len(liveShards)
-	c.mu.Unlock()
-}
-
-func (c *ringShards) Len() int {
-	c.mu.RLock()
-	l := c.numShard
-	c.mu.RUnlock()
-	return l
-}
-
-func (c *ringShards) Close() error {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if c.closed {
-		return nil
-	}
-	c.closed = true
-
-	var firstErr error
-	for _, shard := range c.shards {
-		if err := shard.Client.Close(); err != nil && firstErr == nil {
-			firstErr = err
-		}
-	}
-	c.hash = nil
-	c.shards = nil
-	c.list = nil
-
-	return firstErr
-}
-
-//------------------------------------------------------------------------------
-
-type ring struct {
-	opt           *RingOptions
-	shards        *ringShards
-	cmdsInfoCache *cmdsInfoCache //nolint:structcheck
-}
-
-// Ring is a Redis client that uses consistent hashing to distribute
-// keys across multiple Redis servers (shards). It's safe for
-// concurrent use by multiple goroutines.
-//
-// Ring monitors the state of each shard and removes dead shards from
-// the ring. When a shard comes online it is added back to the ring. This
-// gives you maximum availability and partition tolerance, but no
-// consistency between different shards or even clients. Each client
-// uses shards that are available to the client and does not do any
-// coordination when shard state is changed.
-//
-// Ring should be used when you need multiple Redis servers for caching
-// and can tolerate losing data when one of the servers dies.
-// Otherwise you should use Redis Cluster.
-type Ring struct {
-	*ring
-	cmdable
-	hooks
-	ctx context.Context
-}
-
-func NewRing(opt *RingOptions) *Ring {
-	opt.init()
-
-	ring := Ring{
-		ring: &ring{
-			opt:    opt,
-			shards: newRingShards(opt),
-		},
-		ctx: context.Background(),
-	}
-
-	ring.cmdsInfoCache = newCmdsInfoCache(ring.cmdsInfo)
-	ring.cmdable = ring.Process
-
-	go ring.shards.Heartbeat(opt.HeartbeatFrequency)
-
-	return &ring
-}
-
-func (c *Ring) Context() context.Context {
-	return c.ctx
-}
-
-func (c *Ring) WithContext(ctx context.Context) *Ring {
-	if ctx == nil {
-		panic("nil context")
-	}
-	clone := *c
-	clone.cmdable = clone.Process
-	clone.hooks.lock()
-	clone.ctx = ctx
-	return &clone
-}
-
-// Do creates a Cmd from the args and processes the cmd.
-func (c *Ring) Do(ctx context.Context, args ...interface{}) *Cmd {
-	cmd := NewCmd(ctx, args...)
-	_ = c.Process(ctx, cmd)
-	return cmd
-}
-
-func (c *Ring) Process(ctx context.Context, cmd Cmder) error {
-	return c.hooks.process(ctx, cmd, c.process)
-}
-
-// Options returns read-only Options that were used to create the client.
-func (c *Ring) Options() *RingOptions {
-	return c.opt
-}
-
-func (c *Ring) retryBackoff(attempt int) time.Duration {
-	return internal.RetryBackoff(attempt, c.opt.MinRetryBackoff, c.opt.MaxRetryBackoff)
-}
-
-// PoolStats returns accumulated connection pool stats.
-func (c *Ring) PoolStats() *PoolStats {
-	shards := c.shards.List()
-	var acc PoolStats
-	for _, shard := range shards {
-		s := shard.Client.connPool.Stats()
-		acc.Hits += s.Hits
-		acc.Misses += s.Misses
-		acc.Timeouts += s.Timeouts
-		acc.TotalConns += s.TotalConns
-		acc.IdleConns += s.IdleConns
-	}
-	return &acc
-}
-
-// Len returns the current number of shards in the ring.
-func (c *Ring) Len() int {
-	return c.shards.Len()
-}
-
-// Subscribe subscribes the client to the specified channels.
-func (c *Ring) Subscribe(ctx context.Context, channels ...string) *PubSub {
-	if len(channels) == 0 {
-		panic("at least one channel is required")
-	}
-
-	shard, err := c.shards.GetByKey(channels[0])
-	if err != nil {
-		// TODO: return PubSub with sticky error
-		panic(err)
-	}
-	return shard.Client.Subscribe(ctx, channels...)
-}
-
-// PSubscribe subscribes the client to the given patterns.
-func (c *Ring) PSubscribe(ctx context.Context, channels ...string) *PubSub {
-	if len(channels) == 0 {
-		panic("at least one channel is required")
-	}
-
-	shard, err := c.shards.GetByKey(channels[0])
-	if err != nil {
-		// TODO: return PubSub with sticky error
-		panic(err)
-	}
-	return shard.Client.PSubscribe(ctx, channels...)
-}
-
-// ForEachShard concurrently calls the fn on each live shard in the ring.
-// It returns the first error if any.
-func (c *Ring) ForEachShard(
-	ctx context.Context,
-	fn func(ctx context.Context, client *Client) error,
-) error {
-	shards := c.shards.List()
-	var wg sync.WaitGroup
-	errCh := make(chan error, 1)
-	for _, shard := range shards {
-		if shard.IsDown() {
-			continue
-		}
-
-		wg.Add(1)
-		go func(shard *ringShard) {
-			defer wg.Done()
-			err := fn(ctx, shard.Client)
-			if err != nil {
-				select {
-				case errCh <- err:
-				default:
-				}
-			}
-		}(shard)
-	}
-	wg.Wait()
-
-	select {
-	case err := <-errCh:
-		return err
-	default:
-		return nil
-	}
-}
-
-func (c *Ring) cmdsInfo(ctx context.Context) (map[string]*CommandInfo, error) {
-	shards := c.shards.List()
-	var firstErr error
-	for _, shard := range shards {
-		cmdsInfo, err := shard.Client.Command(ctx).Result()
-		if err == nil {
-			return cmdsInfo, nil
-		}
-		if firstErr == nil {
-			firstErr = err
-		}
-	}
-	if firstErr == nil {
-		return nil, errRingShardsDown
-	}
-	return nil, firstErr
-}
-
-func (c *Ring) cmdInfo(ctx context.Context, name string) *CommandInfo {
-	cmdsInfo, err := c.cmdsInfoCache.Get(ctx)
-	if err != nil {
-		return nil
-	}
-	info := cmdsInfo[name]
-	if info == nil {
-		internal.Logger.Printf(ctx, "info for cmd=%s not found", name)
-	}
-	return info
-}
-
-func (c *Ring) cmdShard(ctx context.Context, cmd Cmder) (*ringShard, error) {
-	cmdInfo := c.cmdInfo(ctx, cmd.Name())
-	pos := cmdFirstKeyPos(cmd, cmdInfo)
-	if pos == 0 {
-		return c.shards.Random()
-	}
-	firstKey := cmd.stringArg(pos)
-	return c.shards.GetByKey(firstKey)
-}
-
-func (c *Ring) process(ctx context.Context, cmd Cmder) error {
-	var lastErr error
-	for attempt := 0; attempt <= c.opt.MaxRetries; attempt++ {
-		if attempt > 0 {
-			if err := internal.Sleep(ctx, c.retryBackoff(attempt)); err != nil {
-				return err
-			}
-		}
-
-		shard, err := c.cmdShard(ctx, cmd)
-		if err != nil {
-			return err
-		}
-
-		lastErr = shard.Client.Process(ctx, cmd)
-		if lastErr == nil || !shouldRetry(lastErr, cmd.readTimeout() == nil) {
-			return lastErr
-		}
-	}
-	return lastErr
-}
-
-func (c *Ring) Pipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.Pipeline().Pipelined(ctx, fn)
-}
-
-func (c *Ring) Pipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Ring) processPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, func(ctx context.Context, cmds []Cmder) error {
-		return c.generalProcessPipeline(ctx, cmds, false)
-	})
-}
-
-func (c *Ring) TxPipelined(ctx context.Context, fn func(Pipeliner) error) ([]Cmder, error) {
-	return c.TxPipeline().Pipelined(ctx, fn)
-}
-
-func (c *Ring) TxPipeline() Pipeliner {
-	pipe := Pipeline{
-		ctx:  c.ctx,
-		exec: c.processTxPipeline,
-	}
-	pipe.init()
-	return &pipe
-}
-
-func (c *Ring) processTxPipeline(ctx context.Context, cmds []Cmder) error {
-	return c.hooks.processPipeline(ctx, cmds, func(ctx context.Context, cmds []Cmder) error {
-		return c.generalProcessPipeline(ctx, cmds, true)
-	})
-}
-
-func (c *Ring) generalProcessPipeline(
-	ctx context.Context, cmds []Cmder, tx bool,
-) error {
-	cmdsMap := make(map[string][]Cmder)
-	for _, cmd := range cmds {
-		cmdInfo := c.cmdInfo(ctx, cmd.Name())
-		hash := cmd.stringArg(cmdFirstKeyPos(cmd, cmdInfo))
-		if hash != "" {
-			hash = c.shards.Hash(hash)
-		}
-		cmdsMap[hash] = append(cmdsMap[hash], cmd)
-	}
-
-	var wg sync.WaitGroup
-	for hash, cmds := range cmdsMap {
-		wg.Add(1)
-		go func(hash string, cmds []Cmder) {
-			defer wg.Done()
-
-			_ = c.processShardPipeline(ctx, hash, cmds, tx)
-		}(hash, cmds)
-	}
-
-	wg.Wait()
-	return cmdsFirstErr(cmds)
-}
-
-func (c *Ring) processShardPipeline(
-	ctx context.Context, hash string, cmds []Cmder, tx bool,
-) error {
-	// TODO: retry?
-	shard, err := c.shards.GetByName(hash)
-	if err != nil {
-		setCmdsErr(cmds, err)
-		return err
-	}
-
-	if tx {
-		return shard.Client.processTxPipeline(ctx, cmds)
-	}
-	return shard.Client.processPipeline(ctx, cmds)
-}
-
-func (c *Ring) Watch(ctx context.Context, fn func(*Tx) error, keys ...string) error {
-	if len(keys) == 0 {
-		return fmt.Errorf("redis: Watch requires at least one key")
-	}
-
-	var shards []*ringShard
-	for _, key := range keys {
-		if key != "" {
-			shard, err := c.shards.GetByKey(hashtag.Key(key))
-			if err != nil {
-				return err
-			}
-
-			shards = append(shards, shard)
-		}
-	}
-
-	if len(shards) == 0 {
-		return fmt.Errorf("redis: Watch requires at least one shard")
-	}
-
-	if len(shards) > 1 {
-		for _, shard := range shards[1:] {
-			if shard.Client != shards[0].Client {
-				err := fmt.Errorf("redis: Watch requires all keys to be in the same shard")
-				return err
-			}
-		}
-	}
-
-	return shards[0].Client.Watch(ctx, fn, keys...)
-}
-
-// Close closes the ring client, releasing any open resources.
-//
-// It is rare to Close a Ring, as the Ring is meant to be long-lived
-// and shared between many goroutines.
-func (c *Ring) Close() error {
-	return c.shards.Close()
-}

vendor/github.com/go-redis/redis/v8/script.go

@@ -1,65 +0,0 @@
-package redis
-
-import (
-	"context"
-	"crypto/sha1"
-	"encoding/hex"
-	"io"
-	"strings"
-)
-
-type Scripter interface {
-	Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
-	EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
-	ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd
-	ScriptLoad(ctx context.Context, script string) *StringCmd
-}
-
-var (
-	_ Scripter = (*Client)(nil)
-	_ Scripter = (*Ring)(nil)
-	_ Scripter = (*ClusterClient)(nil)
-)
-
-type Script struct {
-	src, hash string
-}
-
-func NewScript(src string) *Script {
-	h := sha1.New()
-	_, _ = io.WriteString(h, src)
-	return &Script{
-		src:  src,
-		hash: hex.EncodeToString(h.Sum(nil)),
-	}
-}
-
-func (s *Script) Hash() string {
-	return s.hash
-}
-
-func (s *Script) Load(ctx context.Context, c Scripter) *StringCmd {
-	return c.ScriptLoad(ctx, s.src)
-}
-
-func (s *Script) Exists(ctx context.Context, c Scripter) *BoolSliceCmd {
-	return c.ScriptExists(ctx, s.hash)
-}
-
-func (s *Script) Eval(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
-	return c.Eval(ctx, s.src, keys, args...)
-}
-
-func (s *Script) EvalSha(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
-	return c.EvalSha(ctx, s.hash, keys, args...)
-}
-
-// Run optimistically uses EVALSHA to run the script. If script does not exist
-// it is retried using EVAL.
-func (s *Script) Run(ctx context.Context, c Scripter, keys []string, args ...interface{}) *Cmd {
-	r := s.EvalSha(ctx, c, keys, args...)
-	if err := r.Err(); err != nil && strings.HasPrefix(err.Error(), "NOSCRIPT ") {
-		return s.Eval(ctx, c, keys, args...)
-	}
-	return r
-}