Browse Source
- 整包删除（只有自身测试引用）：lego/sys/{gin,timewheel,lghttp,sdk/bytedance/tos}、
lego/utils/crypto/{gm,gm_java,sra,base64}、lego/utils/container 根目录及 addr/ip/sortslice/version
（container/id 保留）、sys/{dify,deepseek,qweather,coze,axml,haifanwu,aliyun/sts,websearch/bingsearch,websearch/bravesearch}
- mcp 的 tool_finance / tool_spotify_music_* 从未 RegisterComp，连带 sys/juhe、sys/spotify 一起删；
sys/openai 测试里依赖 juhe 的 finance 工具用例随之去掉
- modules/timer/timer_uselog.go 从未装上；comm/const.go 四个零引用的 Module* 常量
- 配置模板去掉没人读的段：home 的 deepseek/ali_filetrans、mcp 的 juhe/spotify/bravesearch、
console 的 cos、gateway 白名单里没有对应路由的 public_info
验证：go build/vet 通过；go test 除两个本来就依赖本机 MySQL / 外部 HTTP 的集成测试
（lego/sys/mysql、modules/agents，改前同样失败）外全部通过。
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
(cherry picked from commit 990c09f066e63a31c483adff1a6d2e3c9ab72c3e)
main
Rodger-Wang
2 weeks ago
129 changed files with 2 additions and 11748 deletions
@ -1,73 +0,0 @@ |
|||||
package binding |
|
||||
|
|
||||
import "net/http" |
|
||||
|
|
||||
// Content-Type MIME of the most common data formats.
|
|
||||
const ( |
|
||||
MIMEJSON = "application/json" |
|
||||
MIMEHTML = "text/html" |
|
||||
MIMEXML = "application/xml" |
|
||||
MIMEXML2 = "text/xml" |
|
||||
MIMEPlain = "text/plain" |
|
||||
MIMEPOSTForm = "application/x-www-form-urlencoded" |
|
||||
MIMEMultipartPOSTForm = "multipart/form-data" |
|
||||
MIMEPROTOBUF = "application/x-protobuf" |
|
||||
MIMEMSGPACK = "application/x-msgpack" |
|
||||
MIMEMSGPACK2 = "application/msgpack" |
|
||||
MIMEYAML = "application/x-yaml" |
|
||||
) |
|
||||
|
|
||||
type Binding interface { |
|
||||
Name() string |
|
||||
Bind(*http.Request, interface{}) error |
|
||||
} |
|
||||
|
|
||||
type StructValidator interface { |
|
||||
ValidateStruct(interface{}) error |
|
||||
Engine() interface{} |
|
||||
} |
|
||||
|
|
||||
var Validator StructValidator = &defaultValidator{} |
|
||||
var ( |
|
||||
JSON = jsonBinding{} |
|
||||
XML = xmlBinding{} |
|
||||
Form = formBinding{} |
|
||||
Query = queryBinding{} |
|
||||
FormPost = formPostBinding{} |
|
||||
FormMultipart = formMultipartBinding{} |
|
||||
ProtoBuf = protobufBinding{} |
|
||||
MsgPack = msgpackBinding{} |
|
||||
YAML = yamlBinding{} |
|
||||
Uri = uriBinding{} |
|
||||
Header = headerBinding{} |
|
||||
) |
|
||||
|
|
||||
func Default(method, contentType string) Binding { |
|
||||
if method == http.MethodGet { |
|
||||
return Form |
|
||||
} |
|
||||
|
|
||||
switch contentType { |
|
||||
case MIMEJSON: |
|
||||
return JSON |
|
||||
case MIMEXML, MIMEXML2: |
|
||||
return XML |
|
||||
case MIMEPROTOBUF: |
|
||||
return ProtoBuf |
|
||||
case MIMEMSGPACK, MIMEMSGPACK2: |
|
||||
return MsgPack |
|
||||
case MIMEYAML: |
|
||||
return YAML |
|
||||
case MIMEMultipartPOSTForm: |
|
||||
return FormMultipart |
|
||||
default: // case MIMEPOSTForm:
|
|
||||
return Form |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func validate(obj interface{}) error { |
|
||||
if Validator == nil { |
|
||||
return nil |
|
||||
} |
|
||||
return Validator.ValidateStruct(obj) |
|
||||
} |
|
||||
@ -1,97 +0,0 @@ |
|||||
// Copyright 2017 Manu Martinez-Almeida. All rights reserved.
|
|
||||
// Use of this source code is governed by a MIT style
|
|
||||
// license that can be found in the LICENSE file.
|
|
||||
|
|
||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"reflect" |
|
||||
"strings" |
|
||||
"sync" |
|
||||
|
|
||||
"github.com/go-playground/validator/v10" |
|
||||
) |
|
||||
|
|
||||
type defaultValidator struct { |
|
||||
once sync.Once |
|
||||
validate *validator.Validate |
|
||||
} |
|
||||
|
|
||||
type SliceValidationError []error |
|
||||
|
|
||||
// Error concatenates all error elements in SliceValidationError into a single string separated by \n.
|
|
||||
func (err SliceValidationError) Error() string { |
|
||||
n := len(err) |
|
||||
switch n { |
|
||||
case 0: |
|
||||
return "" |
|
||||
default: |
|
||||
var b strings.Builder |
|
||||
if err[0] != nil { |
|
||||
fmt.Fprintf(&b, "[%d]: %s", 0, err[0].Error()) |
|
||||
} |
|
||||
if n > 1 { |
|
||||
for i := 1; i < n; i++ { |
|
||||
if err[i] != nil { |
|
||||
b.WriteString("\n") |
|
||||
fmt.Fprintf(&b, "[%d]: %s", i, err[i].Error()) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
return b.String() |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
var _ StructValidator = &defaultValidator{} |
|
||||
|
|
||||
// ValidateStruct receives any kind of type, but only performed struct or pointer to struct type.
|
|
||||
func (v *defaultValidator) ValidateStruct(obj interface{}) error { |
|
||||
if obj == nil { |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
value := reflect.ValueOf(obj) |
|
||||
switch value.Kind() { |
|
||||
case reflect.Ptr: |
|
||||
return v.ValidateStruct(value.Elem().Interface()) |
|
||||
case reflect.Struct: |
|
||||
return v.validateStruct(obj) |
|
||||
case reflect.Slice, reflect.Array: |
|
||||
count := value.Len() |
|
||||
validateRet := make(SliceValidationError, 0) |
|
||||
for i := 0; i < count; i++ { |
|
||||
if err := v.ValidateStruct(value.Index(i).Interface()); err != nil { |
|
||||
validateRet = append(validateRet, err) |
|
||||
} |
|
||||
} |
|
||||
if len(validateRet) == 0 { |
|
||||
return nil |
|
||||
} |
|
||||
return validateRet |
|
||||
default: |
|
||||
return nil |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// validateStruct receives struct type
|
|
||||
func (v *defaultValidator) validateStruct(obj interface{}) error { |
|
||||
v.lazyinit() |
|
||||
return v.validate.Struct(obj) |
|
||||
} |
|
||||
|
|
||||
// Engine returns the underlying validator engine which powers the default
|
|
||||
// Validator instance. This is useful if you want to register custom validations
|
|
||||
// or struct level validations. See validator GoDoc for more info -
|
|
||||
// https://pkg.go.dev/github.com/go-playground/validator/v10
|
|
||||
func (v *defaultValidator) Engine() interface{} { |
|
||||
v.lazyinit() |
|
||||
return v.validate |
|
||||
} |
|
||||
|
|
||||
func (v *defaultValidator) lazyinit() { |
|
||||
v.once.Do(func() { |
|
||||
v.validate = validator.New() |
|
||||
v.validate.SetTagName("binding") |
|
||||
}) |
|
||||
} |
|
||||
@ -1,62 +0,0 @@ |
|||||
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
|
||||
// Use of this source code is governed by a MIT style
|
|
||||
// license that can be found in the LICENSE file.
|
|
||||
|
|
||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"errors" |
|
||||
"net/http" |
|
||||
) |
|
||||
|
|
||||
const defaultMemory = 32 << 20 |
|
||||
|
|
||||
type formBinding struct{} |
|
||||
type formPostBinding struct{} |
|
||||
type formMultipartBinding struct{} |
|
||||
|
|
||||
func (formBinding) Name() string { |
|
||||
return "form" |
|
||||
} |
|
||||
|
|
||||
func (formBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
if err := req.ParseForm(); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
if err := req.ParseMultipartForm(defaultMemory); err != nil && !errors.Is(err, http.ErrNotMultipart) { |
|
||||
return err |
|
||||
} |
|
||||
if err := mapForm(obj, req.Form); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
|
|
||||
func (formPostBinding) Name() string { |
|
||||
return "form-urlencoded" |
|
||||
} |
|
||||
|
|
||||
func (formPostBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
if err := req.ParseForm(); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
if err := mapForm(obj, req.PostForm); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
|
|
||||
func (formMultipartBinding) Name() string { |
|
||||
return "multipart/form-data" |
|
||||
} |
|
||||
|
|
||||
func (formMultipartBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
if err := req.ParseMultipartForm(defaultMemory); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
if err := mappingByPtr(obj, (*multipartRequest)(req), "form"); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
return validate(obj) |
|
||||
} |
|
||||
@ -1,404 +0,0 @@ |
|||||
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
|
||||
// Use of this source code is governed by a MIT style
|
|
||||
// license that can be found in the LICENSE file.
|
|
||||
|
|
||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"errors" |
|
||||
"fmt" |
|
||||
"reflect" |
|
||||
"strconv" |
|
||||
"strings" |
|
||||
"time" |
|
||||
|
|
||||
json "github.com/json-iterator/go" |
|
||||
|
|
||||
"yunyan/lego/utils" |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
errUnknownType = errors.New("unknown type") |
|
||||
|
|
||||
// ErrConvertMapStringSlice can not covert to map[string][]string
|
|
||||
ErrConvertMapStringSlice = errors.New("can not convert to map slices of strings") |
|
||||
|
|
||||
// ErrConvertToMapString can not convert to map[string]string
|
|
||||
ErrConvertToMapString = errors.New("can not convert to map of strings") |
|
||||
) |
|
||||
|
|
||||
func mapURI(ptr interface{}, m map[string][]string) error { |
|
||||
return mapFormByTag(ptr, m, "uri") |
|
||||
} |
|
||||
|
|
||||
func mapForm(ptr interface{}, form map[string][]string) error { |
|
||||
return mapFormByTag(ptr, form, "form") |
|
||||
} |
|
||||
|
|
||||
func MapFormWithTag(ptr interface{}, form map[string][]string, tag string) error { |
|
||||
return mapFormByTag(ptr, form, tag) |
|
||||
} |
|
||||
|
|
||||
var emptyField = reflect.StructField{} |
|
||||
|
|
||||
func mapFormByTag(ptr interface{}, form map[string][]string, tag string) error { |
|
||||
// Check if ptr is a map
|
|
||||
ptrVal := reflect.ValueOf(ptr) |
|
||||
var pointed interface{} |
|
||||
if ptrVal.Kind() == reflect.Ptr { |
|
||||
ptrVal = ptrVal.Elem() |
|
||||
pointed = ptrVal.Interface() |
|
||||
} |
|
||||
if ptrVal.Kind() == reflect.Map && |
|
||||
ptrVal.Type().Key().Kind() == reflect.String { |
|
||||
if pointed != nil { |
|
||||
ptr = pointed |
|
||||
} |
|
||||
return setFormMap(ptr, form) |
|
||||
} |
|
||||
|
|
||||
return mappingByPtr(ptr, formSource(form), tag) |
|
||||
} |
|
||||
|
|
||||
// setter tries to set value on a walking by fields of a struct
|
|
||||
type setter interface { |
|
||||
TrySet(value reflect.Value, field reflect.StructField, key string, opt setOptions) (isSet bool, err error) |
|
||||
} |
|
||||
|
|
||||
type formSource map[string][]string |
|
||||
|
|
||||
var _ setter = formSource(nil) |
|
||||
|
|
||||
// TrySet tries to set a value by request's form source (like map[string][]string)
|
|
||||
func (form formSource) TrySet(value reflect.Value, field reflect.StructField, tagValue string, opt setOptions) (isSet bool, err error) { |
|
||||
return setByForm(value, field, form, tagValue, opt) |
|
||||
} |
|
||||
|
|
||||
func mappingByPtr(ptr interface{}, setter setter, tag string) error { |
|
||||
_, err := mapping(reflect.ValueOf(ptr), emptyField, setter, tag) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) { |
|
||||
if field.Tag.Get(tag) == "-" { // just ignoring this field
|
|
||||
return false, nil |
|
||||
} |
|
||||
|
|
||||
vKind := value.Kind() |
|
||||
|
|
||||
if vKind == reflect.Ptr { |
|
||||
var isNew bool |
|
||||
vPtr := value |
|
||||
if value.IsNil() { |
|
||||
isNew = true |
|
||||
vPtr = reflect.New(value.Type().Elem()) |
|
||||
} |
|
||||
isSet, err := mapping(vPtr.Elem(), field, setter, tag) |
|
||||
if err != nil { |
|
||||
return false, err |
|
||||
} |
|
||||
if isNew && isSet { |
|
||||
value.Set(vPtr) |
|
||||
} |
|
||||
return isSet, nil |
|
||||
} |
|
||||
|
|
||||
if vKind != reflect.Struct || !field.Anonymous { |
|
||||
ok, err := tryToSetValue(value, field, setter, tag) |
|
||||
if err != nil { |
|
||||
return false, err |
|
||||
} |
|
||||
if ok { |
|
||||
return true, nil |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if vKind == reflect.Struct { |
|
||||
tValue := value.Type() |
|
||||
|
|
||||
var isSet bool |
|
||||
for i := 0; i < value.NumField(); i++ { |
|
||||
sf := tValue.Field(i) |
|
||||
if sf.PkgPath != "" && !sf.Anonymous { // unexported
|
|
||||
continue |
|
||||
} |
|
||||
ok, err := mapping(value.Field(i), sf, setter, tag) |
|
||||
if err != nil { |
|
||||
return false, err |
|
||||
} |
|
||||
isSet = isSet || ok |
|
||||
} |
|
||||
return isSet, nil |
|
||||
} |
|
||||
return false, nil |
|
||||
} |
|
||||
|
|
||||
type setOptions struct { |
|
||||
isDefaultExists bool |
|
||||
defaultValue string |
|
||||
} |
|
||||
|
|
||||
func tryToSetValue(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) { |
|
||||
var tagValue string |
|
||||
var setOpt setOptions |
|
||||
|
|
||||
tagValue = field.Tag.Get(tag) |
|
||||
tagValue, opts := head(tagValue, ",") |
|
||||
|
|
||||
if tagValue == "" { // default value is FieldName
|
|
||||
tagValue = field.Name |
|
||||
} |
|
||||
if tagValue == "" { // when field is "emptyField" variable
|
|
||||
return false, nil |
|
||||
} |
|
||||
|
|
||||
var opt string |
|
||||
for len(opts) > 0 { |
|
||||
opt, opts = head(opts, ",") |
|
||||
|
|
||||
if k, v := head(opt, "="); k == "default" { |
|
||||
setOpt.isDefaultExists = true |
|
||||
setOpt.defaultValue = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return setter.TrySet(value, field, tagValue, setOpt) |
|
||||
} |
|
||||
|
|
||||
func setByForm(value reflect.Value, field reflect.StructField, form map[string][]string, tagValue string, opt setOptions) (isSet bool, err error) { |
|
||||
vs, ok := form[tagValue] |
|
||||
if !ok && !opt.isDefaultExists { |
|
||||
return false, nil |
|
||||
} |
|
||||
|
|
||||
switch value.Kind() { |
|
||||
case reflect.Slice: |
|
||||
if !ok { |
|
||||
vs = []string{opt.defaultValue} |
|
||||
} |
|
||||
return true, setSlice(vs, value, field) |
|
||||
case reflect.Array: |
|
||||
if !ok { |
|
||||
vs = []string{opt.defaultValue} |
|
||||
} |
|
||||
if len(vs) != value.Len() { |
|
||||
return false, fmt.Errorf("%q is not valid value for %s", vs, value.Type().String()) |
|
||||
} |
|
||||
return true, setArray(vs, value, field) |
|
||||
default: |
|
||||
var val string |
|
||||
if !ok { |
|
||||
val = opt.defaultValue |
|
||||
} |
|
||||
|
|
||||
if len(vs) > 0 { |
|
||||
val = vs[0] |
|
||||
} |
|
||||
return true, setWithProperType(val, value, field) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func setWithProperType(val string, value reflect.Value, field reflect.StructField) error { |
|
||||
switch value.Kind() { |
|
||||
case reflect.Int: |
|
||||
return setIntField(val, 0, value) |
|
||||
case reflect.Int8: |
|
||||
return setIntField(val, 8, value) |
|
||||
case reflect.Int16: |
|
||||
return setIntField(val, 16, value) |
|
||||
case reflect.Int32: |
|
||||
return setIntField(val, 32, value) |
|
||||
case reflect.Int64: |
|
||||
switch value.Interface().(type) { |
|
||||
case time.Duration: |
|
||||
return setTimeDuration(val, value) |
|
||||
} |
|
||||
return setIntField(val, 64, value) |
|
||||
case reflect.Uint: |
|
||||
return setUintField(val, 0, value) |
|
||||
case reflect.Uint8: |
|
||||
return setUintField(val, 8, value) |
|
||||
case reflect.Uint16: |
|
||||
return setUintField(val, 16, value) |
|
||||
case reflect.Uint32: |
|
||||
return setUintField(val, 32, value) |
|
||||
case reflect.Uint64: |
|
||||
return setUintField(val, 64, value) |
|
||||
case reflect.Bool: |
|
||||
return setBoolField(val, value) |
|
||||
case reflect.Float32: |
|
||||
return setFloatField(val, 32, value) |
|
||||
case reflect.Float64: |
|
||||
return setFloatField(val, 64, value) |
|
||||
case reflect.String: |
|
||||
value.SetString(val) |
|
||||
case reflect.Struct: |
|
||||
switch value.Interface().(type) { |
|
||||
case time.Time: |
|
||||
return setTimeField(val, field, value) |
|
||||
} |
|
||||
return json.Unmarshal(utils.StringToBytes(val), value.Addr().Interface()) |
|
||||
case reflect.Map: |
|
||||
return json.Unmarshal(utils.StringToBytes(val), value.Addr().Interface()) |
|
||||
default: |
|
||||
return errUnknownType |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
func setIntField(val string, bitSize int, field reflect.Value) error { |
|
||||
if val == "" { |
|
||||
val = "0" |
|
||||
} |
|
||||
intVal, err := strconv.ParseInt(val, 10, bitSize) |
|
||||
if err == nil { |
|
||||
field.SetInt(intVal) |
|
||||
} |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
func setUintField(val string, bitSize int, field reflect.Value) error { |
|
||||
if val == "" { |
|
||||
val = "0" |
|
||||
} |
|
||||
uintVal, err := strconv.ParseUint(val, 10, bitSize) |
|
||||
if err == nil { |
|
||||
field.SetUint(uintVal) |
|
||||
} |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
func setBoolField(val string, field reflect.Value) error { |
|
||||
if val == "" { |
|
||||
val = "false" |
|
||||
} |
|
||||
boolVal, err := strconv.ParseBool(val) |
|
||||
if err == nil { |
|
||||
field.SetBool(boolVal) |
|
||||
} |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
func setFloatField(val string, bitSize int, field reflect.Value) error { |
|
||||
if val == "" { |
|
||||
val = "0.0" |
|
||||
} |
|
||||
floatVal, err := strconv.ParseFloat(val, bitSize) |
|
||||
if err == nil { |
|
||||
field.SetFloat(floatVal) |
|
||||
} |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
func setTimeField(val string, structField reflect.StructField, value reflect.Value) error { |
|
||||
timeFormat := structField.Tag.Get("time_format") |
|
||||
if timeFormat == "" { |
|
||||
timeFormat = time.RFC3339 |
|
||||
} |
|
||||
|
|
||||
switch tf := strings.ToLower(timeFormat); tf { |
|
||||
case "unix", "unixnano": |
|
||||
tv, err := strconv.ParseInt(val, 10, 64) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
d := time.Duration(1) |
|
||||
if tf == "unixnano" { |
|
||||
d = time.Second |
|
||||
} |
|
||||
|
|
||||
t := time.Unix(tv/int64(d), tv%int64(d)) |
|
||||
value.Set(reflect.ValueOf(t)) |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
if val == "" { |
|
||||
value.Set(reflect.ValueOf(time.Time{})) |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
l := time.Local |
|
||||
if isUTC, _ := strconv.ParseBool(structField.Tag.Get("time_utc")); isUTC { |
|
||||
l = time.UTC |
|
||||
} |
|
||||
|
|
||||
if locTag := structField.Tag.Get("time_location"); locTag != "" { |
|
||||
loc, err := time.LoadLocation(locTag) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
l = loc |
|
||||
} |
|
||||
|
|
||||
t, err := time.ParseInLocation(timeFormat, val, l) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
value.Set(reflect.ValueOf(t)) |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
func setArray(vals []string, value reflect.Value, field reflect.StructField) error { |
|
||||
for i, s := range vals { |
|
||||
err := setWithProperType(s, value.Index(i), field) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
func setSlice(vals []string, value reflect.Value, field reflect.StructField) error { |
|
||||
slice := reflect.MakeSlice(value.Type(), len(vals), len(vals)) |
|
||||
err := setArray(vals, slice, field) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
value.Set(slice) |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
func setTimeDuration(val string, value reflect.Value) error { |
|
||||
d, err := time.ParseDuration(val) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
value.Set(reflect.ValueOf(d)) |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
func head(str, sep string) (head string, tail string) { |
|
||||
idx := strings.Index(str, sep) |
|
||||
if idx < 0 { |
|
||||
return str, "" |
|
||||
} |
|
||||
return str[:idx], str[idx+len(sep):] |
|
||||
} |
|
||||
|
|
||||
func setFormMap(ptr interface{}, form map[string][]string) error { |
|
||||
el := reflect.TypeOf(ptr).Elem() |
|
||||
|
|
||||
if el.Kind() == reflect.Slice { |
|
||||
ptrMap, ok := ptr.(map[string][]string) |
|
||||
if !ok { |
|
||||
return ErrConvertMapStringSlice |
|
||||
} |
|
||||
for k, v := range form { |
|
||||
ptrMap[k] = v |
|
||||
} |
|
||||
|
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
ptrMap, ok := ptr.(map[string]string) |
|
||||
if !ok { |
|
||||
return ErrConvertToMapString |
|
||||
} |
|
||||
for k, v := range form { |
|
||||
ptrMap[k] = v[len(v)-1] // pick last
|
|
||||
} |
|
||||
|
|
||||
return nil |
|
||||
} |
|
||||
@ -1,34 +0,0 @@ |
|||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
"net/textproto" |
|
||||
"reflect" |
|
||||
) |
|
||||
|
|
||||
type headerBinding struct{} |
|
||||
|
|
||||
func (headerBinding) Name() string { |
|
||||
return "header" |
|
||||
} |
|
||||
|
|
||||
func (headerBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
|
|
||||
if err := mapHeader(obj, req.Header); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
return validate(obj) |
|
||||
} |
|
||||
|
|
||||
func mapHeader(ptr interface{}, h map[string][]string) error { |
|
||||
return mappingByPtr(ptr, headerSource(h), "header") |
|
||||
} |
|
||||
|
|
||||
type headerSource map[string][]string |
|
||||
|
|
||||
var _ setter = headerSource(nil) |
|
||||
|
|
||||
func (hs headerSource) TrySet(value reflect.Value, field reflect.StructField, tagValue string, opt setOptions) (bool, error) { |
|
||||
return setByForm(value, field, hs, textproto.CanonicalMIMEHeaderKey(tagValue), opt) |
|
||||
} |
|
||||
@ -1,56 +0,0 @@ |
|||||
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
|
||||
// Use of this source code is governed by a MIT style
|
|
||||
// license that can be found in the LICENSE file.
|
|
||||
|
|
||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"errors" |
|
||||
"io" |
|
||||
"net/http" |
|
||||
|
|
||||
json "github.com/json-iterator/go" |
|
||||
) |
|
||||
|
|
||||
// EnableDecoderUseNumber is used to call the UseNumber method on the JSON
|
|
||||
// Decoder instance. UseNumber causes the Decoder to unmarshal a number into an
|
|
||||
// interface{} as a Number instead of as a float64.
|
|
||||
var EnableDecoderUseNumber = false |
|
||||
|
|
||||
// EnableDecoderDisallowUnknownFields is used to call the DisallowUnknownFields method
|
|
||||
// on the JSON Decoder instance. DisallowUnknownFields causes the Decoder to
|
|
||||
// return an error when the destination is a struct and the input contains object
|
|
||||
// keys which do not match any non-ignored, exported fields in the destination.
|
|
||||
var EnableDecoderDisallowUnknownFields = false |
|
||||
|
|
||||
type jsonBinding struct{} |
|
||||
|
|
||||
func (jsonBinding) Name() string { |
|
||||
return "json" |
|
||||
} |
|
||||
|
|
||||
func (jsonBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
if req == nil || req.Body == nil { |
|
||||
return errors.New("invalid request") |
|
||||
} |
|
||||
return decodeJSON(req.Body, obj) |
|
||||
} |
|
||||
|
|
||||
func (jsonBinding) BindBody(body []byte, obj interface{}) error { |
|
||||
return decodeJSON(bytes.NewReader(body), obj) |
|
||||
} |
|
||||
|
|
||||
func decodeJSON(r io.Reader, obj interface{}) error { |
|
||||
decoder := json.NewDecoder(r) |
|
||||
if EnableDecoderUseNumber { |
|
||||
decoder.UseNumber() |
|
||||
} |
|
||||
if EnableDecoderDisallowUnknownFields { |
|
||||
decoder.DisallowUnknownFields() |
|
||||
} |
|
||||
if err := decoder.Decode(obj); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
@ -1,31 +0,0 @@ |
|||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"io" |
|
||||
"net/http" |
|
||||
|
|
||||
"github.com/ugorji/go/codec" |
|
||||
) |
|
||||
|
|
||||
type msgpackBinding struct{} |
|
||||
|
|
||||
func (msgpackBinding) Name() string { |
|
||||
return "msgpack" |
|
||||
} |
|
||||
|
|
||||
func (msgpackBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
return decodeMsgPack(req.Body, obj) |
|
||||
} |
|
||||
|
|
||||
func (msgpackBinding) BindBody(body []byte, obj interface{}) error { |
|
||||
return decodeMsgPack(bytes.NewReader(body), obj) |
|
||||
} |
|
||||
|
|
||||
func decodeMsgPack(r io.Reader, obj interface{}) error { |
|
||||
cdc := new(codec.MsgpackHandle) |
|
||||
if err := codec.NewDecoder(r, cdc).Decode(&obj); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
@ -1,74 +0,0 @@ |
|||||
// Copyright 2019 Gin Core Team. All rights reserved.
|
|
||||
// Use of this source code is governed by a MIT style
|
|
||||
// license that can be found in the LICENSE file.
|
|
||||
|
|
||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"errors" |
|
||||
"mime/multipart" |
|
||||
"net/http" |
|
||||
"reflect" |
|
||||
) |
|
||||
|
|
||||
type multipartRequest http.Request |
|
||||
|
|
||||
var _ setter = (*multipartRequest)(nil) |
|
||||
|
|
||||
var ( |
|
||||
// ErrMultiFileHeader multipart.FileHeader invalid
|
|
||||
ErrMultiFileHeader = errors.New("unsupported field type for multipart.FileHeader") |
|
||||
|
|
||||
// ErrMultiFileHeaderLenInvalid array for []*multipart.FileHeader len invalid
|
|
||||
ErrMultiFileHeaderLenInvalid = errors.New("unsupported len of array for []*multipart.FileHeader") |
|
||||
) |
|
||||
|
|
||||
// TrySet tries to set a value by the multipart request with the binding a form file
|
|
||||
func (r *multipartRequest) TrySet(value reflect.Value, field reflect.StructField, key string, opt setOptions) (bool, error) { |
|
||||
if files := r.MultipartForm.File[key]; len(files) != 0 { |
|
||||
return setByMultipartFormFile(value, field, files) |
|
||||
} |
|
||||
|
|
||||
return setByForm(value, field, r.MultipartForm.Value, key, opt) |
|
||||
} |
|
||||
|
|
||||
func setByMultipartFormFile(value reflect.Value, field reflect.StructField, files []*multipart.FileHeader) (isSet bool, err error) { |
|
||||
switch value.Kind() { |
|
||||
case reflect.Ptr: |
|
||||
switch value.Interface().(type) { |
|
||||
case *multipart.FileHeader: |
|
||||
value.Set(reflect.ValueOf(files[0])) |
|
||||
return true, nil |
|
||||
} |
|
||||
case reflect.Struct: |
|
||||
switch value.Interface().(type) { |
|
||||
case multipart.FileHeader: |
|
||||
value.Set(reflect.ValueOf(*files[0])) |
|
||||
return true, nil |
|
||||
} |
|
||||
case reflect.Slice: |
|
||||
slice := reflect.MakeSlice(value.Type(), len(files), len(files)) |
|
||||
isSet, err = setArrayOfMultipartFormFiles(slice, field, files) |
|
||||
if err != nil || !isSet { |
|
||||
return isSet, err |
|
||||
} |
|
||||
value.Set(slice) |
|
||||
return true, nil |
|
||||
case reflect.Array: |
|
||||
return setArrayOfMultipartFormFiles(value, field, files) |
|
||||
} |
|
||||
return false, ErrMultiFileHeader |
|
||||
} |
|
||||
|
|
||||
func setArrayOfMultipartFormFiles(value reflect.Value, field reflect.StructField, files []*multipart.FileHeader) (isSet bool, err error) { |
|
||||
if value.Len() != len(files) { |
|
||||
return false, ErrMultiFileHeaderLenInvalid |
|
||||
} |
|
||||
for i := range files { |
|
||||
set, err := setByMultipartFormFile(value.Index(i), field, files[i:i+1]) |
|
||||
if err != nil || !set { |
|
||||
return set, err |
|
||||
} |
|
||||
} |
|
||||
return true, nil |
|
||||
} |
|
||||
@ -1,35 +0,0 @@ |
|||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"errors" |
|
||||
"io/ioutil" |
|
||||
"net/http" |
|
||||
|
|
||||
"google.golang.org/protobuf/proto" |
|
||||
) |
|
||||
|
|
||||
type protobufBinding struct{} |
|
||||
|
|
||||
func (protobufBinding) Name() string { |
|
||||
return "protobuf" |
|
||||
} |
|
||||
|
|
||||
func (b protobufBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
buf, err := ioutil.ReadAll(req.Body) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return b.BindBody(buf, obj) |
|
||||
} |
|
||||
|
|
||||
func (protobufBinding) BindBody(body []byte, obj interface{}) error { |
|
||||
msg, ok := obj.(proto.Message) |
|
||||
if !ok { |
|
||||
return errors.New("obj is not ProtoMessage") |
|
||||
} |
|
||||
if err := proto.Unmarshal(body, msg); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return nil |
|
||||
|
|
||||
} |
|
||||
@ -1,17 +0,0 @@ |
|||||
package binding |
|
||||
|
|
||||
import "net/http" |
|
||||
|
|
||||
type queryBinding struct{} |
|
||||
|
|
||||
func (queryBinding) Name() string { |
|
||||
return "query" |
|
||||
} |
|
||||
|
|
||||
func (queryBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
values := req.URL.Query() |
|
||||
if err := mapForm(obj, values); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
@ -1,14 +0,0 @@ |
|||||
package binding |
|
||||
|
|
||||
type uriBinding struct{} |
|
||||
|
|
||||
func (uriBinding) Name() string { |
|
||||
return "uri" |
|
||||
} |
|
||||
|
|
||||
func (uriBinding) BindUri(m map[string][]string, obj interface{}) error { |
|
||||
if err := mapURI(obj, m); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
@ -1,33 +0,0 @@ |
|||||
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
|
||||
// Use of this source code is governed by a MIT style
|
|
||||
// license that can be found in the LICENSE file.
|
|
||||
|
|
||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"encoding/xml" |
|
||||
"io" |
|
||||
"net/http" |
|
||||
) |
|
||||
|
|
||||
type xmlBinding struct{} |
|
||||
|
|
||||
func (xmlBinding) Name() string { |
|
||||
return "xml" |
|
||||
} |
|
||||
|
|
||||
func (xmlBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
return decodeXML(req.Body, obj) |
|
||||
} |
|
||||
|
|
||||
func (xmlBinding) BindBody(body []byte, obj interface{}) error { |
|
||||
return decodeXML(bytes.NewReader(body), obj) |
|
||||
} |
|
||||
func decodeXML(r io.Reader, obj interface{}) error { |
|
||||
decoder := xml.NewDecoder(r) |
|
||||
if err := decoder.Decode(obj); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
@ -1,31 +0,0 @@ |
|||||
package binding |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"io" |
|
||||
"net/http" |
|
||||
|
|
||||
"gopkg.in/yaml.v2" |
|
||||
) |
|
||||
|
|
||||
type yamlBinding struct{} |
|
||||
|
|
||||
func (yamlBinding) Name() string { |
|
||||
return "yaml" |
|
||||
} |
|
||||
|
|
||||
func (yamlBinding) Bind(req *http.Request, obj interface{}) error { |
|
||||
return decodeYAML(req.Body, obj) |
|
||||
} |
|
||||
|
|
||||
func (yamlBinding) BindBody(body []byte, obj interface{}) error { |
|
||||
return decodeYAML(bytes.NewReader(body), obj) |
|
||||
} |
|
||||
|
|
||||
func decodeYAML(r io.Reader, obj interface{}) error { |
|
||||
decoder := yaml.NewDecoder(r) |
|
||||
if err := decoder.Decode(obj); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
return validate(obj) |
|
||||
} |
|
||||
@ -1,153 +0,0 @@ |
|||||
package gin |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"net/http" |
|
||||
"reflect" |
|
||||
"sort" |
|
||||
"strings" |
|
||||
|
|
||||
"yunyan/lego/sys/gin/engine" |
|
||||
"yunyan/lego/utils/crypto/md5" |
|
||||
) |
|
||||
|
|
||||
/* |
|
||||
系统描述:开源gin框架的重构版本 |
|
||||
*/ |
|
||||
type ISys interface { |
|
||||
engine.IRoutes |
|
||||
HandleContext(c *engine.Context) |
|
||||
LoadHTMLGlob(pattern string) |
|
||||
Close() (err error) |
|
||||
} |
|
||||
|
|
||||
var defsys ISys |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, opt ...Option) (err error) { |
|
||||
var option *Options |
|
||||
if option, err = newOptions(config, opt...); err != nil { |
|
||||
return |
|
||||
} |
|
||||
defsys, err = newSys(option) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(opt ...Option) (sys ISys, err error) { |
|
||||
var option *Options |
|
||||
if option, err = newOptionsByOption(opt...); err != nil { |
|
||||
return |
|
||||
} |
|
||||
sys, err = newSys(option) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func LoadHTMLGlob(pattern string) { |
|
||||
defsys.LoadHTMLGlob(pattern) |
|
||||
} |
|
||||
|
|
||||
func HandleContext(c *engine.Context) { |
|
||||
defsys.HandleContext(c) |
|
||||
} |
|
||||
|
|
||||
func Close() (err error) { |
|
||||
return defsys.Close() |
|
||||
} |
|
||||
func NoRoute(handlers ...engine.HandlerFunc) { |
|
||||
defsys.NoRoute(handlers...) |
|
||||
} |
|
||||
func Use(handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.Use(handlers...) |
|
||||
} |
|
||||
func Handle(httpMethod string, relativePath string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.Handle(httpMethod, relativePath, handlers...) |
|
||||
} |
|
||||
func Any(relativePath string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.Any(relativePath, handlers...) |
|
||||
} |
|
||||
func GET(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.GET(httpMethod, handlers...) |
|
||||
} |
|
||||
func POST(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.POST(httpMethod, handlers...) |
|
||||
} |
|
||||
func DELETE(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.DELETE(httpMethod, handlers...) |
|
||||
} |
|
||||
func PATCH(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.PATCH(httpMethod, handlers...) |
|
||||
} |
|
||||
func PUT(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.PUT(httpMethod, handlers...) |
|
||||
} |
|
||||
func OPTIONS(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.OPTIONS(httpMethod, handlers...) |
|
||||
} |
|
||||
func HEAD(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.HEAD(httpMethod, handlers...) |
|
||||
} |
|
||||
func StaticFile(relativePath string, filepath string) engine.IRoutes { |
|
||||
return defsys.StaticFile(relativePath, filepath) |
|
||||
} |
|
||||
func StaticFileFS(relativePath string, filepath string, fs http.FileSystem) engine.IRoutes { |
|
||||
return defsys.StaticFileFS(relativePath, filepath, fs) |
|
||||
} |
|
||||
|
|
||||
func Static(relativePath string, root string) engine.IRoutes { |
|
||||
return defsys.Static(relativePath, root) |
|
||||
} |
|
||||
|
|
||||
func StaticFS(relativePath string, fs http.FileSystem) engine.IRoutes { |
|
||||
return defsys.StaticFS(relativePath, fs) |
|
||||
} |
|
||||
|
|
||||
// 签名接口
|
|
||||
func ParamSign(key string, param map[string]interface{}) (origin, sign string) { |
|
||||
var keys []string |
|
||||
for k, _ := range param { |
|
||||
keys = append(keys, k) |
|
||||
} |
|
||||
sort.Strings(keys) |
|
||||
builder := strings.Builder{} |
|
||||
for _, v := range keys { |
|
||||
builder.WriteString(v) |
|
||||
builder.WriteString("=") |
|
||||
switch reflect.TypeOf(param[v]).Kind() { |
|
||||
case reflect.Int, |
|
||||
reflect.Int8, |
|
||||
reflect.Int16, |
|
||||
reflect.Int32, |
|
||||
reflect.Int64, |
|
||||
reflect.Uint, |
|
||||
reflect.Uint8, |
|
||||
reflect.Uint16, |
|
||||
reflect.Uint32, |
|
||||
reflect.Uint64: |
|
||||
builder.WriteString(fmt.Sprintf("%d", param[v])) |
|
||||
break |
|
||||
case reflect.Float32, |
|
||||
reflect.Float64: |
|
||||
builder.WriteString(fmt.Sprintf("%v", param[v])) |
|
||||
case reflect.Bool: |
|
||||
builder.WriteString(fmt.Sprintf("%v", param[v])) |
|
||||
case reflect.Slice, reflect.Array: |
|
||||
s := reflect.ValueOf(param[v]) |
|
||||
valueStr := "" |
|
||||
for i := 0; i < s.Len(); i++ { |
|
||||
valueStr += fmt.Sprintf("%v,", s.Index(i).Interface()) |
|
||||
} |
|
||||
if s.Len() > 0 { |
|
||||
valueStr = valueStr[0 : len(valueStr)-1] |
|
||||
} |
|
||||
builder.WriteString(fmt.Sprintf("%s", valueStr)) |
|
||||
break |
|
||||
default: |
|
||||
builder.WriteString(fmt.Sprintf("%s", param[v])) |
|
||||
break |
|
||||
} |
|
||||
builder.WriteString("&") |
|
||||
} |
|
||||
builder.WriteString("key=" + key) |
|
||||
origin = builder.String() |
|
||||
sign = md5.MD5EncToLower(origin) |
|
||||
return |
|
||||
} |
|
||||
@ -1,883 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"errors" |
|
||||
"io" |
|
||||
"io/ioutil" |
|
||||
"math" |
|
||||
"mime/multipart" |
|
||||
"net" |
|
||||
"net/http" |
|
||||
"net/url" |
|
||||
"os" |
|
||||
"strings" |
|
||||
"sync" |
|
||||
"time" |
|
||||
|
|
||||
"yunyan/lego/sys/gin/binding" |
|
||||
"yunyan/lego/sys/gin/render" |
|
||||
"yunyan/lego/sys/log" |
|
||||
) |
|
||||
|
|
||||
const ( |
|
||||
MIMEJSON = binding.MIMEJSON |
|
||||
MIMEHTML = binding.MIMEHTML |
|
||||
MIMEXML = binding.MIMEXML |
|
||||
MIMEXML2 = binding.MIMEXML2 |
|
||||
MIMEPlain = binding.MIMEPlain |
|
||||
MIMEPOSTForm = binding.MIMEPOSTForm |
|
||||
MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm |
|
||||
MIMEYAML = binding.MIMEYAML |
|
||||
) |
|
||||
const abortIndex int8 = math.MaxInt8 >> 1 |
|
||||
|
|
||||
func newContext(log log.ILogger, engine *Engine, params *Params, skippedNodes *[]skippedNode) *Context { |
|
||||
return &Context{ |
|
||||
Log: log, |
|
||||
engine: engine, |
|
||||
params: params, |
|
||||
skippedNodes: skippedNodes, |
|
||||
writermem: ResponseWriter{log: log}, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
type Context struct { |
|
||||
Log log.ILogger |
|
||||
engine *Engine |
|
||||
writermem ResponseWriter |
|
||||
Request *http.Request |
|
||||
Writer IResponseWriter |
|
||||
Params Params |
|
||||
handlers HandlersChain |
|
||||
index int8 |
|
||||
fullPath string |
|
||||
params *Params |
|
||||
skippedNodes *[]skippedNode |
|
||||
mu sync.RWMutex |
|
||||
Keys map[string]interface{} |
|
||||
Errors errorMsgs |
|
||||
Accepted []string |
|
||||
queryCache url.Values |
|
||||
formCache url.Values |
|
||||
sameSite http.SameSite |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Copy() *Context { |
|
||||
cp := Context{ |
|
||||
writermem: this.writermem, |
|
||||
Request: this.Request, |
|
||||
Params: this.Params, |
|
||||
engine: this.engine, |
|
||||
} |
|
||||
cp.writermem.ResponseWriter = nil |
|
||||
cp.Writer = &cp.writermem |
|
||||
cp.index = abortIndex |
|
||||
cp.handlers = nil |
|
||||
cp.Keys = map[string]interface{}{} |
|
||||
for k, v := range this.Keys { |
|
||||
cp.Keys[k] = v |
|
||||
} |
|
||||
paramCopy := make([]Param, len(cp.Params)) |
|
||||
copy(paramCopy, cp.Params) |
|
||||
cp.Params = paramCopy |
|
||||
return &cp |
|
||||
} |
|
||||
|
|
||||
func (this *Context) HandlerName() string { |
|
||||
return nameOfFunction(this.handlers.Last()) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) HandlerNames() []string { |
|
||||
hn := make([]string, 0, len(this.handlers)) |
|
||||
for _, val := range this.handlers { |
|
||||
hn = append(hn, nameOfFunction(val)) |
|
||||
} |
|
||||
return hn |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Handler() HandlerFunc { |
|
||||
return this.handlers.Last() |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
FullPath 返回匹配的路由完整路径。 对于未找到的路线 |
|
||||
返回一个空字符串。 |
|
||||
*/ |
|
||||
func (c *Context) FullPath() string { |
|
||||
return c.fullPath |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Next() { |
|
||||
this.index++ |
|
||||
for this.index < int8(len(this.handlers)) { |
|
||||
this.handlers[this.index](this) |
|
||||
this.index++ |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
如果当前上下文被中止，IsAborted 返回 true。 |
|
||||
*/ |
|
||||
func (this *Context) IsAborted() bool { |
|
||||
return this.index >= abortIndex |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
Abort 防止挂起的处理程序被调用。 请注意，这不会停止当前处理程序。 |
|
||||
假设你有一个授权中间件来验证当前请求是否被授权。 |
|
||||
如果授权失败（例如：密码不匹配），调用 Abort 以确保剩余的 handlers |
|
||||
因为这个请求没有被调用。 |
|
||||
*/ |
|
||||
func (this *Context) Abort() { |
|
||||
this.index = abortIndex |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
AbortWithStatus 调用 `Abort()` 并使用指定的状态代码写入标头。 |
|
||||
例如，验证请求失败的尝试可以使用：context.AbortWithStatus(401)。 |
|
||||
*/ |
|
||||
func (this *Context) AbortWithStatus(code int) { |
|
||||
this.Status(code) |
|
||||
this.Writer.WriteHeaderNow() |
|
||||
this.Abort() |
|
||||
} |
|
||||
|
|
||||
func (this *Context) AbortWithStatusJSON(code int, jsonObj interface{}) { |
|
||||
this.Abort() |
|
||||
this.JSON(code, jsonObj) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) AbortWithError(code int, err error) *Error { |
|
||||
this.AbortWithStatus(code) |
|
||||
return this.Error(err) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Set(key string, value interface{}) { |
|
||||
this.mu.Lock() |
|
||||
if this.Keys == nil { |
|
||||
this.Keys = make(map[string]interface{}) |
|
||||
} |
|
||||
|
|
||||
this.Keys[key] = value |
|
||||
this.mu.Unlock() |
|
||||
} |
|
||||
|
|
||||
func (this *Context) SetUserId(uid string) { |
|
||||
this.Set("UserId", uid) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Get(key string) (value interface{}, exists bool) { |
|
||||
this.mu.RLock() |
|
||||
value, exists = this.Keys[key] |
|
||||
this.mu.RUnlock() |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
如果存在，MustGet 返回给定键的值，否则抛出异常。 |
|
||||
*/ |
|
||||
func (this *Context) MustGet(key string) interface{} { |
|
||||
if value, exists := this.Get(key); exists { |
|
||||
return value |
|
||||
} |
|
||||
panic("Key \"" + key + "\" does not exist") |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetString(key string) (s string) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
s, _ = val.(string) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetBool(key string) (b bool) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
b, _ = val.(bool) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetInt(key string) (i int) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
i, _ = val.(int) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetInt64(key string) (i64 int64) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
i64, _ = val.(int64) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetUint(key string) (ui uint) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
ui, _ = val.(uint) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (c *Context) GetUInt32(key string) (i uint32) { |
|
||||
if val, ok := c.Get(key); ok && val != nil { |
|
||||
i, _ = val.(uint32) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetUint64(key string) (ui64 uint64) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
ui64, _ = val.(uint64) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetFloat64(key string) (f64 float64) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
f64, _ = val.(float64) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetTime(key string) (t time.Time) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
t, _ = val.(time.Time) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetDuration(key string) (d time.Duration) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
d, _ = val.(time.Duration) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetStringSlice(key string) (ss []string) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
ss, _ = val.([]string) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetStringMap(key string) (sm map[string]interface{}) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
sm, _ = val.(map[string]interface{}) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *Context) GetStringMapString(key string) (sms map[string]string) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
sms, _ = val.(map[string]string) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetStringMapStringSlice(key string) (smss map[string][]string) { |
|
||||
if val, ok := this.Get(key); ok && val != nil { |
|
||||
smss, _ = val.(map[string][]string) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetUserId() string { |
|
||||
return this.GetString("UserId") |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Header(key, value string) { |
|
||||
if value == "" { |
|
||||
this.Writer.Header().Del(key) |
|
||||
return |
|
||||
} |
|
||||
this.Writer.Header().Set(key, value) |
|
||||
} |
|
||||
|
|
||||
// Status sets the HTTP response code.
|
|
||||
func (this *Context) Status(code int) { |
|
||||
this.Writer.WriteHeader(code) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Param(key string) string { |
|
||||
return this.Params.ByName(key) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) AddParam(key, value string) { |
|
||||
this.Params = append(this.Params, Param{Key: key, Value: value}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Query(key string) (value string) { |
|
||||
value, _ = this.GetQuery(key) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) DefaultQuery(key, defaultValue string) string { |
|
||||
if value, ok := this.GetQuery(key); ok { |
|
||||
return value |
|
||||
} |
|
||||
return defaultValue |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetQuery(key string) (string, bool) { |
|
||||
if values, ok := this.GetQueryArray(key); ok { |
|
||||
return values[0], ok |
|
||||
} |
|
||||
return "", false |
|
||||
} |
|
||||
|
|
||||
func (this *Context) initQueryCache() { |
|
||||
if this.queryCache == nil { |
|
||||
if this.Request != nil { |
|
||||
this.queryCache = this.Request.URL.Query() |
|
||||
} else { |
|
||||
this.queryCache = url.Values{} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetQueryArray(key string) (values []string, ok bool) { |
|
||||
this.initQueryCache() |
|
||||
values, ok = this.queryCache[key] |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) QueryMap(key string) (dicts map[string]string) { |
|
||||
dicts, _ = this.GetQueryMap(key) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetQueryMap(key string) (map[string]string, bool) { |
|
||||
this.initQueryCache() |
|
||||
return this.get(this.queryCache, key) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) PostForm(key string) (value string) { |
|
||||
value, _ = this.GetPostForm(key) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetPostForm(key string) (string, bool) { |
|
||||
if values, ok := this.GetPostFormArray(key); ok { |
|
||||
return values[0], ok |
|
||||
} |
|
||||
return "", false |
|
||||
} |
|
||||
|
|
||||
func (this *Context) initFormCache() { |
|
||||
if this.formCache == nil { |
|
||||
this.formCache = make(url.Values) |
|
||||
req := this.Request |
|
||||
if err := req.ParseMultipartForm(this.engine.MaxMultipartMemory); err != nil { |
|
||||
if !errors.Is(err, http.ErrNotMultipart) { |
|
||||
this.Log.Errorf("error on parse multipart form array: %v", err) |
|
||||
} |
|
||||
} |
|
||||
this.formCache = req.PostForm |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetPostFormArray(key string) (values []string, ok bool) { |
|
||||
this.initFormCache() |
|
||||
values, ok = this.formCache[key] |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) PostFormMap(key string) (dicts map[string]string) { |
|
||||
dicts, _ = this.GetPostFormMap(key) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetPostFormMap(key string) (map[string]string, bool) { |
|
||||
this.initFormCache() |
|
||||
return this.get(this.formCache, key) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) FormFile(name string) (multipart.File, *multipart.FileHeader, error) { |
|
||||
if this.Request.MultipartForm == nil { |
|
||||
if err := this.Request.ParseMultipartForm(this.engine.MaxMultipartMemory); err != nil { |
|
||||
return nil, nil, err |
|
||||
} |
|
||||
} |
|
||||
f, fh, err := this.Request.FormFile(name) |
|
||||
if err != nil { |
|
||||
return nil, nil, err |
|
||||
} |
|
||||
return f, fh, err |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
MultipartForm 是解析后的多部分表单，包括文件上传。 |
|
||||
*/ |
|
||||
func (this *Context) MultipartForm() (*multipart.Form, error) { |
|
||||
err := this.Request.ParseMultipartForm(this.engine.MaxMultipartMemory) |
|
||||
return this.Request.MultipartForm, err |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
保存上传文件 |
|
||||
*/ |
|
||||
func (this *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error { |
|
||||
src, err := file.Open() |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
defer src.Close() |
|
||||
|
|
||||
out, err := os.Create(dst) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
defer out.Close() |
|
||||
|
|
||||
_, err = io.Copy(out, src) |
|
||||
return err |
|
||||
} |
|
||||
func (this *Context) GetHeader(key string) string { |
|
||||
return this.requestHeader(key) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) GetRawData() ([]byte, error) { |
|
||||
return ioutil.ReadAll(this.Request.Body) |
|
||||
} |
|
||||
|
|
||||
// 序列化--------------------------------------------------------------------------------------------
|
|
||||
func (this *Context) Bind(obj interface{}) error { |
|
||||
b := binding.Default(this.Request.Method, this.ContentType()) |
|
||||
return this.MustBindWith(obj, b) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) ShouldBindJSON(obj interface{}) error { |
|
||||
return this.ShouldBindWith(obj, binding.JSON) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) MustBindWith(obj interface{}, b binding.Binding) error { |
|
||||
if err := this.ShouldBindWith(obj, b); err != nil { |
|
||||
this.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) // nolint: errcheck
|
|
||||
return err |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
func (this *Context) ShouldBindWith(obj interface{}, b binding.Binding) error { |
|
||||
return b.Bind(this.Request, obj) |
|
||||
} |
|
||||
func (this *Context) ShouldBindUri(obj interface{}) error { |
|
||||
m := make(map[string][]string) |
|
||||
for _, v := range this.Params { |
|
||||
m[v.Key] = []string{v.Value} |
|
||||
} |
|
||||
return binding.Uri.BindUri(m, obj) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) BindJSON(obj interface{}) error { |
|
||||
return this.MustBindWith(obj, binding.JSON) |
|
||||
} |
|
||||
func (this *Context) BindXML(obj interface{}) error { |
|
||||
return this.MustBindWith(obj, binding.XML) |
|
||||
} |
|
||||
func (this *Context) BindQuery(obj interface{}) error { |
|
||||
return this.MustBindWith(obj, binding.Query) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) BindYAML(obj interface{}) error { |
|
||||
return this.MustBindWith(obj, binding.YAML) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) BindHeader(obj interface{}) error { |
|
||||
return this.MustBindWith(obj, binding.Header) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) BindUri(obj interface{}) error { |
|
||||
if err := this.ShouldBindUri(obj); err != nil { |
|
||||
this.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) // nolint: errcheck
|
|
||||
return err |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
// 输出-----------------------------------------------------------------------------------------
|
|
||||
func (this *Context) HTML(code int, name string, obj interface{}) { |
|
||||
instance := this.engine.HTMLRender.Instance(name, obj) |
|
||||
this.Render(code, instance) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) IndentedJSON(code int, obj interface{}) { |
|
||||
this.Render(code, render.IndentedJSON{Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) SecureJSON(code int, obj interface{}) { |
|
||||
this.Render(code, render.SecureJSON{Prefix: this.engine.secureJSONPrefix, Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) JSONP(code int, obj interface{}) { |
|
||||
callback := this.DefaultQuery("callback", "") |
|
||||
if callback == "" { |
|
||||
this.Render(code, render.JSON{Data: obj}) |
|
||||
return |
|
||||
} |
|
||||
this.Render(code, render.JsonpJSON{Callback: callback, Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) JSON(code int, obj interface{}) { |
|
||||
this.Render(code, render.JSON{Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) AsciiJSON(code int, obj interface{}) { |
|
||||
this.Render(code, render.AsciiJSON{Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) PureJSON(code int, obj interface{}) { |
|
||||
this.Render(code, render.PureJSON{Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) XML(code int, obj interface{}) { |
|
||||
this.Render(code, render.XML{Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) YAML(code int, obj interface{}) { |
|
||||
this.Render(code, render.YAML{Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) ProtoBuf(code int, obj interface{}) { |
|
||||
this.Render(code, render.ProtoBuf{Data: obj}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) String(code int, format string, values ...interface{}) { |
|
||||
this.Render(code, render.String{Format: format, Data: values}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Redirect(code int, location string) { |
|
||||
this.Render(-1, render.Redirect{ |
|
||||
Code: code, |
|
||||
Location: location, |
|
||||
Request: this.Request, |
|
||||
}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Data(code int, contentType string, data []byte) { |
|
||||
this.Render(code, render.Data{ |
|
||||
ContentType: contentType, |
|
||||
Data: data, |
|
||||
}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) DataFromReader(code int, contentLength int64, contentType string, reader io.Reader, extraHeaders map[string]string) { |
|
||||
this.Render(code, render.Reader{ |
|
||||
Headers: extraHeaders, |
|
||||
ContentType: contentType, |
|
||||
ContentLength: contentLength, |
|
||||
Reader: reader, |
|
||||
}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) File(filepath string) { |
|
||||
http.ServeFile(this.Writer, this.Request, filepath) |
|
||||
} |
|
||||
|
|
||||
/*渲染页面接口*/ |
|
||||
func (this *Context) Render(code int, r render.Render) { |
|
||||
this.Status(code) |
|
||||
|
|
||||
if !bodyAllowedForStatus(code) { |
|
||||
r.WriteContentType(this.Writer) |
|
||||
this.Writer.WriteHeaderNow() |
|
||||
return |
|
||||
} |
|
||||
if err := r.Render(this.Writer); err != nil { |
|
||||
panic(err) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/*渲染页面接口*/ |
|
||||
func (this *Context) RenderForBytes(code int, contentType string, body []byte) { |
|
||||
this.Status(code) |
|
||||
this.Header("ContentType", contentType) |
|
||||
if _, err := this.writermem.Write(body); err != nil { |
|
||||
panic(err) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *Context) FileFromFS(filepath string, fs http.FileSystem) { |
|
||||
defer func(old string) { |
|
||||
this.Request.URL.Path = old |
|
||||
}(this.Request.URL.Path) |
|
||||
this.Request.URL.Path = filepath |
|
||||
http.FileServer(fs).ServeHTTP(this.Writer, this.Request) |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
以高效的方式将指定的文件写入正文流 |
|
||||
在客户端，通常会使用给定的文件名下载文件 |
|
||||
*/ |
|
||||
func (this *Context) FileAttachment(filepath, filename string) { |
|
||||
if isASCII(filename) { |
|
||||
this.Writer.Header().Set("Content-Disposition", `attachment; filename="`+filename+`"`) |
|
||||
} else { |
|
||||
this.Writer.Header().Set("Content-Disposition", `attachment; filename*=UTF-8''`+url.QueryEscape(filename)) |
|
||||
} |
|
||||
http.ServeFile(this.Writer, this.Request, filepath) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Stream(step func(w io.Writer) bool) bool { |
|
||||
w := this.Writer |
|
||||
clientGone := w.CloseNotify() |
|
||||
for { |
|
||||
select { |
|
||||
case <-clientGone: |
|
||||
return true |
|
||||
default: |
|
||||
keepOpen := step(w) |
|
||||
w.Flush() |
|
||||
if !keepOpen { |
|
||||
return false |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
type Negotiate struct { |
|
||||
Offered []string |
|
||||
HTMLName string |
|
||||
HTMLData interface{} |
|
||||
JSONData interface{} |
|
||||
XMLData interface{} |
|
||||
YAMLData interface{} |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Negotiate(code int, config Negotiate) { |
|
||||
switch this.NegotiateFormat(config.Offered...) { |
|
||||
case binding.MIMEJSON: |
|
||||
data := chooseData(config.JSONData, config.Data) |
|
||||
this.JSON(code, data) |
|
||||
|
|
||||
case binding.MIMEHTML: |
|
||||
data := chooseData(config.HTMLData, config.Data) |
|
||||
this.HTML(code, config.HTMLName, data) |
|
||||
|
|
||||
case binding.MIMEXML: |
|
||||
data := chooseData(config.XMLData, config.Data) |
|
||||
this.XML(code, data) |
|
||||
|
|
||||
case binding.MIMEYAML: |
|
||||
data := chooseData(config.YAMLData, config.Data) |
|
||||
this.YAML(code, data) |
|
||||
|
|
||||
default: |
|
||||
this.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server")) // nolint: errcheck
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *Context) NegotiateFormat(offered ...string) string { |
|
||||
assert1(len(offered) > 0, "you must provide at least one offer") |
|
||||
|
|
||||
if this.Accepted == nil { |
|
||||
this.Accepted = parseAccept(this.requestHeader("Accept")) |
|
||||
} |
|
||||
if len(this.Accepted) == 0 { |
|
||||
return offered[0] |
|
||||
} |
|
||||
for _, accepted := range this.Accepted { |
|
||||
for _, offer := range offered { |
|
||||
// According to RFC 2616 and RFC 2396, non-ASCII characters are not allowed in headers,
|
|
||||
// therefore we can just iterate over the string without casting it into []rune
|
|
||||
i := 0 |
|
||||
for ; i < len(accepted); i++ { |
|
||||
if accepted[i] == '*' || offer[i] == '*' { |
|
||||
return offer |
|
||||
} |
|
||||
if accepted[i] != offer[i] { |
|
||||
break |
|
||||
} |
|
||||
} |
|
||||
if i == len(accepted) { |
|
||||
return offer |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
return "" |
|
||||
} |
|
||||
|
|
||||
func (this *Context) SetAccepted(formats ...string) { |
|
||||
this.Accepted = formats |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Deadline() (deadline time.Time, ok bool) { |
|
||||
if this.Request == nil || this.Request.Context() == nil { |
|
||||
return |
|
||||
} |
|
||||
return this.Request.Context().Deadline() |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Done() <-chan struct{} { |
|
||||
if this.Request == nil || this.Request.Context() == nil { |
|
||||
return nil |
|
||||
} |
|
||||
return this.Request.Context().Done() |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Err() error { |
|
||||
if this.Request == nil || this.Request.Context() == nil { |
|
||||
return nil |
|
||||
} |
|
||||
return this.Request.Context().Err() |
|
||||
} |
|
||||
|
|
||||
func (c *Context) Value(key interface{}) interface{} { |
|
||||
if key == 0 { |
|
||||
return c.Request |
|
||||
} |
|
||||
if keyAsString, ok := key.(string); ok { |
|
||||
if val, exists := c.Get(keyAsString); exists { |
|
||||
return val |
|
||||
} |
|
||||
} |
|
||||
if c.Request == nil || c.Request.Context() == nil { |
|
||||
return nil |
|
||||
} |
|
||||
return c.Request.Context().Value(key) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) ContentType() string { |
|
||||
return filterFlags(this.requestHeader("Content-Type")) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) RemoteIP() string { |
|
||||
ip, _, err := net.SplitHostPort(strings.TrimSpace(this.Request.RemoteAddr)) |
|
||||
if err != nil { |
|
||||
return "" |
|
||||
} |
|
||||
return ip |
|
||||
} |
|
||||
|
|
||||
func (this *Context) ClientIP() string { |
|
||||
// 检查我们是否在受信任的平台上运行，如果出错则继续向后运行
|
|
||||
if this.engine.TrustedPlatform != "" { |
|
||||
// Developers can define their own header of Trusted Platform or use predefined constants
|
|
||||
if addr := this.requestHeader(this.engine.TrustedPlatform); addr != "" { |
|
||||
return addr |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
// 它还检查 remoteIP 是否是受信任的代理。
|
|
||||
// 为了执行此验证，它将查看 IP 是否包含在至少一个 CIDR 块中
|
|
||||
// 由 Engine.SetTrustedProxies() 定义
|
|
||||
*/ |
|
||||
remoteIP := net.ParseIP(this.RemoteIP()) |
|
||||
if remoteIP == nil { |
|
||||
return "" |
|
||||
} |
|
||||
trusted := this.engine.isTrustedProxy(remoteIP) |
|
||||
|
|
||||
if trusted && this.engine.ForwardedByClientIP && this.engine.RemoteIPHeaders != nil { |
|
||||
for _, headerName := range this.engine.RemoteIPHeaders { |
|
||||
ip, valid := this.engine.validateHeader(this.requestHeader(headerName)) |
|
||||
if valid { |
|
||||
return ip |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
return remoteIP.String() |
|
||||
} |
|
||||
|
|
||||
func (this *Context) IsWebsocket() bool { |
|
||||
if strings.Contains(strings.ToLower(this.requestHeader("Connection")), "upgrade") && |
|
||||
strings.EqualFold(this.requestHeader("Upgrade"), "websocket") { |
|
||||
return true |
|
||||
} |
|
||||
return false |
|
||||
} |
|
||||
|
|
||||
func (this *Context) SetSameSite(samesite http.SameSite) { |
|
||||
this.sameSite = samesite |
|
||||
} |
|
||||
|
|
||||
func (this *Context) SetCookie(name, value string, maxAge int, path, domain string, secure, httpOnly bool) { |
|
||||
if path == "" { |
|
||||
path = "/" |
|
||||
} |
|
||||
http.SetCookie(this.Writer, &http.Cookie{ |
|
||||
Name: name, |
|
||||
Value: url.QueryEscape(value), |
|
||||
MaxAge: maxAge, |
|
||||
Path: path, |
|
||||
Domain: domain, |
|
||||
SameSite: this.sameSite, |
|
||||
Secure: secure, |
|
||||
HttpOnly: httpOnly, |
|
||||
}) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Cookie(name string) (string, error) { |
|
||||
cookie, err := this.Request.Cookie(name) |
|
||||
if err != nil { |
|
||||
return "", err |
|
||||
} |
|
||||
val, _ := url.QueryUnescape(cookie.Value) |
|
||||
return val, nil |
|
||||
} |
|
||||
|
|
||||
func (this *Context) Error(err error) *Error { |
|
||||
if err == nil { |
|
||||
panic("err is nil") |
|
||||
} |
|
||||
|
|
||||
var parsedError *Error |
|
||||
ok := errors.As(err, &parsedError) |
|
||||
if !ok { |
|
||||
parsedError = &Error{ |
|
||||
Err: err, |
|
||||
Type: ErrorTypePrivate, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
this.Errors = append(this.Errors, parsedError) |
|
||||
return parsedError |
|
||||
} |
|
||||
|
|
||||
func (this *Context) get(m map[string][]string, key string) (map[string]string, bool) { |
|
||||
dicts := make(map[string]string) |
|
||||
exist := false |
|
||||
for k, v := range m { |
|
||||
if i := strings.IndexByte(k, '['); i >= 1 && k[0:i] == key { |
|
||||
if j := strings.IndexByte(k[i+1:], ']'); j >= 1 { |
|
||||
exist = true |
|
||||
dicts[k[i+1:][:j]] = v[0] |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
return dicts, exist |
|
||||
} |
|
||||
|
|
||||
func (this *Context) requestHeader(key string) string { |
|
||||
return this.Request.Header.Get(key) |
|
||||
} |
|
||||
|
|
||||
func (this *Context) reset() { |
|
||||
this.Writer = &this.writermem |
|
||||
this.Params = this.Params[:0] |
|
||||
this.handlers = nil |
|
||||
this.index = -1 |
|
||||
|
|
||||
this.fullPath = "" |
|
||||
this.Keys = nil |
|
||||
this.Errors = this.Errors[:0] |
|
||||
this.Accepted = nil |
|
||||
this.queryCache = nil |
|
||||
this.formCache = nil |
|
||||
this.sameSite = 0 |
|
||||
*this.params = (*this.params)[:0] |
|
||||
*this.skippedNodes = (*this.skippedNodes)[:0] |
|
||||
} |
|
||||
|
|
||||
func (this *Context) ShouldBindQuery(obj any) error { |
|
||||
return this.ShouldBindWith(obj, binding.Query) |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
bodyAllowedForStatus 是 http.bodyAllowedForStatus 非导出函数的副本。 |
|
||||
*/ |
|
||||
func bodyAllowedForStatus(status int) bool { |
|
||||
switch { |
|
||||
case status >= 100 && status <= 199: |
|
||||
return false |
|
||||
case status == http.StatusNoContent: |
|
||||
return false |
|
||||
case status == http.StatusNotModified: |
|
||||
return false |
|
||||
} |
|
||||
return true |
|
||||
} |
|
||||
@ -1,44 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
) |
|
||||
|
|
||||
type HandlerFunc func(*Context) |
|
||||
type HandlersChain []HandlerFunc |
|
||||
|
|
||||
func (c HandlersChain) Last() HandlerFunc { |
|
||||
if length := len(c); length > 0 { |
|
||||
return c[length-1] |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
type RouteInfo struct { |
|
||||
Method string |
|
||||
Path string |
|
||||
Handler string |
|
||||
HandlerFunc HandlerFunc |
|
||||
} |
|
||||
|
|
||||
type RoutesInfo []RouteInfo |
|
||||
|
|
||||
type IRoutes interface { |
|
||||
Register(rcvr interface{}) |
|
||||
NoRoute(handlers ...HandlerFunc) |
|
||||
Group(relativePath string, handlers ...HandlerFunc) IRoutes |
|
||||
Use(...HandlerFunc) IRoutes |
|
||||
Handle(string, string, ...HandlerFunc) IRoutes |
|
||||
Any(string, ...HandlerFunc) IRoutes |
|
||||
GET(string, ...HandlerFunc) IRoutes |
|
||||
POST(string, ...HandlerFunc) IRoutes |
|
||||
DELETE(string, ...HandlerFunc) IRoutes |
|
||||
PATCH(string, ...HandlerFunc) IRoutes |
|
||||
PUT(string, ...HandlerFunc) IRoutes |
|
||||
OPTIONS(string, ...HandlerFunc) IRoutes |
|
||||
HEAD(string, ...HandlerFunc) IRoutes |
|
||||
StaticFile(string, string) IRoutes |
|
||||
StaticFileFS(string, string, http.FileSystem) IRoutes |
|
||||
Static(string, string) IRoutes |
|
||||
StaticFS(string, http.FileSystem) IRoutes |
|
||||
} |
|
||||
@ -1,522 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"html/template" |
|
||||
"net" |
|
||||
"net/http" |
|
||||
"path" |
|
||||
"strings" |
|
||||
"sync" |
|
||||
|
|
||||
"yunyan/lego/sys/gin/render" |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils" |
|
||||
|
|
||||
"golang.org/x/net/http2" |
|
||||
"golang.org/x/net/http2/h2c" |
|
||||
) |
|
||||
|
|
||||
/* |
|
||||
默认文件上传的最大尺寸 |
|
||||
*/ |
|
||||
const defaultMultipartMemory = 32 << 20 // 32 MB
|
|
||||
/* |
|
||||
默认可信代理 |
|
||||
*/ |
|
||||
var defaultTrustedCIDRs = []*net.IPNet{ |
|
||||
{ // 0.0.0.0/0 (IPv4)
|
|
||||
IP: net.IP{0x0, 0x0, 0x0, 0x0}, |
|
||||
Mask: net.IPMask{0x0, 0x0, 0x0, 0x0}, |
|
||||
}, |
|
||||
{ // ::/0 (IPv6)
|
|
||||
IP: net.IP{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, |
|
||||
Mask: net.IPMask{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, |
|
||||
}, |
|
||||
} |
|
||||
|
|
||||
func NewEngine(opts ...Option) (engine *Engine) { |
|
||||
option, _ := newOptions(opts...) |
|
||||
|
|
||||
engine = &Engine{ |
|
||||
RouterGroup: RouterGroup{ |
|
||||
Handlers: nil, |
|
||||
basePath: "/", |
|
||||
root: true, |
|
||||
}, |
|
||||
log: option.Log, |
|
||||
FuncMap: template.FuncMap{}, |
|
||||
RedirectTrailingSlash: option.RedirectTrailingSlash, |
|
||||
RedirectFixedPath: false, |
|
||||
HandleMethodNotAllowed: false, |
|
||||
ForwardedByClientIP: true, |
|
||||
RemoteIPHeaders: []string{"X-Forwarded-For", "X-Real-IP"}, |
|
||||
UseRawPath: false, |
|
||||
RemoveExtraSlash: false, |
|
||||
UnescapePathValues: true, |
|
||||
MaxMultipartMemory: option.MultipartMemory, |
|
||||
trees: make(methodTrees, 0, 9), |
|
||||
delims: render.Delims{Left: "{{", Right: "}}"}, |
|
||||
secureJSONPrefix: "while(1);", |
|
||||
trustedProxies: []string{"0.0.0.0/0"}, |
|
||||
trustedCIDRs: defaultTrustedCIDRs, |
|
||||
} |
|
||||
engine.RouterGroup.engine = engine |
|
||||
engine.pool.New = func() interface{} { |
|
||||
return engine.allocateContext() |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
var ( |
|
||||
default404Body = []byte("404 page not found") |
|
||||
default405Body = []byte("405 method not allowed") |
|
||||
) |
|
||||
var mimePlain = []string{MIMEPlain} |
|
||||
|
|
||||
type Engine struct { |
|
||||
RouterGroup |
|
||||
log log.ILogger |
|
||||
UseRawPath bool |
|
||||
/* |
|
||||
如果启用，路由器尝试修复当前请求路径，如果没有 |
|
||||
如果没有 |
|
||||
已为其注册句柄。 |
|
||||
第一个多余的路径元素，如 ../ 或 // 被删除。
|
|
||||
之后路由器对清理后的路径进行不区分大小写的查找。 |
|
||||
如果可以找到该路由的句柄，则路由器进行重定向 |
|
||||
到正确的路径，GET 请求的状态码为 301，而 GET 请求的状态码为 307 |
|
||||
所有其他请求方法。 |
|
||||
例如 /FOO 和 /..//Foo 可以重定向到 /foo。
|
|
||||
RedirectTrailingSlash 与此选项无关。 |
|
||||
*/ |
|
||||
RedirectFixedPath bool |
|
||||
/* |
|
||||
如果为真，路径值将不转义 |
|
||||
*/ |
|
||||
UnescapePathValues bool |
|
||||
/* |
|
||||
如果当前路由无法匹配，但启用自动重定向 |
|
||||
带有（不带）尾部斜杠的路径的处理程序存在。 |
|
||||
例如，如果 /foo/ 被请求，但路由只存在于 /foo，则 |
|
||||
对于 GET 请求，客户端被重定向到 /foo，http 状态码为 301 |
|
||||
对于所有其他请求方法，则为 307。 |
|
||||
*/ |
|
||||
RedirectTrailingSlash bool //
|
|
||||
|
|
||||
/* |
|
||||
如果启用，路由器检查是否允许其他方法 |
|
||||
当前路由，如果当前请求无法路由。 |
|
||||
如果是这种情况，则使用“不允许的方法”回答请求 |
|
||||
和 HTTP 状态码 405。 |
|
||||
如果不允许其他方法，则将请求委托给 NotFound |
|
||||
处理程序。 |
|
||||
*/ |
|
||||
HandleMethodNotAllowed bool |
|
||||
/* |
|
||||
可以从 URL 中解析出一个参数，即使带有额外的斜杠。 |
|
||||
*/ |
|
||||
RemoveExtraSlash bool |
|
||||
/* |
|
||||
TrustedPlatform 如果设置为值 gin.Platform* 的常量，则信任由设置的标头 |
|
||||
那个平台，比如判断客户端IP |
|
||||
*/ |
|
||||
TrustedPlatform string |
|
||||
/* |
|
||||
ForwardedByClientIP 如果启用，客户端 IP 将从请求的标头中解析 |
|
||||
匹配存储在 `(*gin.Engine).RemoteIPHeaders` 中的那些。 如果没有 IP |
|
||||
fetched, 它回退到从获取的 IP |
|
||||
`(*gin.Context).Request.RemoteAddr`。 |
|
||||
ForwardedByClientIP 布尔值 |
|
||||
*/ |
|
||||
ForwardedByClientIP bool |
|
||||
/* |
|
||||
RemoteIPHeaders 用于获取客户端 IP 时的 headers 列表 |
|
||||
`(*gin.Engine).ForwardedByClientIP` 为 `true` 并且 |
|
||||
`(*gin.Context).Request.RemoteAddr` 被至少一个匹配 |
|
||||
由 `(*gin.Engine).SetTrustedProxies()` 定义的列表的网络来源。 |
|
||||
*/ |
|
||||
RemoteIPHeaders []string |
|
||||
/* |
|
||||
文件上传的最大尺寸 |
|
||||
*/ |
|
||||
MaxMultipartMemory int64 |
|
||||
/* |
|
||||
是否使用H2C |
|
||||
*/ |
|
||||
UseH2C bool |
|
||||
delims render.Delims |
|
||||
secureJSONPrefix string |
|
||||
HTMLRender render.HTMLRender |
|
||||
FuncMap template.FuncMap |
|
||||
noRoute HandlersChain |
|
||||
noMethod HandlersChain |
|
||||
allNoRoute HandlersChain |
|
||||
allNoMethod HandlersChain |
|
||||
pool sync.Pool |
|
||||
trees methodTrees |
|
||||
maxParams uint16 |
|
||||
maxSections uint16 |
|
||||
trustedProxies []string |
|
||||
trustedCIDRs []*net.IPNet |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) { |
|
||||
c := this.pool.Get().(*Context) |
|
||||
c.writermem.reset(w) |
|
||||
c.Request = req |
|
||||
c.reset() |
|
||||
this.handleHTTPRequest(c) |
|
||||
this.pool.Put(c) |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) Handler() http.Handler { |
|
||||
if !this.UseH2C { |
|
||||
return this |
|
||||
} |
|
||||
|
|
||||
h2s := &http2.Server{} |
|
||||
return h2c.NewHandler(this, h2s) |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
使用中间件 |
|
||||
*/ |
|
||||
func (this *Engine) Use(middleware ...HandlerFunc) IRoutes { |
|
||||
this.RouterGroup.Use(middleware...) |
|
||||
this.rebuild404Handlers() |
|
||||
this.rebuild405Handlers() |
|
||||
return this |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
LoadHTMLGlob 加载由 glob 模式标识的 HTML 文件 |
|
||||
并将结果与 HTML 渲染器相关联。 |
|
||||
*/ |
|
||||
func (this *Engine) LoadHTMLGlob(pattern string) { |
|
||||
left := this.delims.Left |
|
||||
right := this.delims.Right |
|
||||
templ := template.Must(template.New("").Delims(left, right).Funcs(this.FuncMap).ParseGlob(pattern)) |
|
||||
|
|
||||
if this.log.Enabled(log.DebugLevel) { |
|
||||
this.debugPrintLoadTemplate(templ) |
|
||||
this.HTMLRender = render.HTMLDebug{Glob: pattern, FuncMap: this.FuncMap, Delims: this.delims} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
this.SetHTMLTemplate(templ) |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
LoadHTMLFiles 加载一段 HTML 文件 |
|
||||
并将结果与 HTML 渲染器相关联。 |
|
||||
*/ |
|
||||
func (this *Engine) LoadHTMLFiles(files ...string) { |
|
||||
if this.log.Enabled(log.DebugLevel) { |
|
||||
this.HTMLRender = render.HTMLDebug{Files: files, FuncMap: this.FuncMap, Delims: this.delims} |
|
||||
return |
|
||||
} |
|
||||
templ := template.Must(template.New("").Delims(this.delims.Left, this.delims.Right).Funcs(this.FuncMap).ParseFiles(files...)) |
|
||||
this.SetHTMLTemplate(templ) |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) SetHTMLTemplate(templ *template.Template) { |
|
||||
if len(this.trees) > 0 { |
|
||||
this.log.Warnf(`Since SetHTMLTemplate() is NOT thread-safe. It should only be called |
|
||||
at initialization. ie. before any route is registered or the router is listening in a socket: |
|
||||
router := gin.Default() |
|
||||
router.SetHTMLTemplate(template) // << good place
|
|
||||
`) |
|
||||
|
|
||||
} |
|
||||
this.HTMLRender = render.HTMLProduction{Template: templ.Funcs(this.FuncMap)} |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
设置template FuncMap |
|
||||
*/ |
|
||||
func (engine *Engine) SetFuncMap(funcMap template.FuncMap) { |
|
||||
engine.FuncMap = funcMap |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
404 处理路由 |
|
||||
*/ |
|
||||
func (this *Engine) NoRoute(handlers ...HandlerFunc) { |
|
||||
this.noRoute = handlers |
|
||||
this.rebuild404Handlers() |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
没有找到对应的方法 |
|
||||
*/ |
|
||||
func (this *Engine) NoMethod(handlers ...HandlerFunc) { |
|
||||
this.noMethod = handlers |
|
||||
this.rebuild405Handlers() |
|
||||
} |
|
||||
|
|
||||
func (engine *Engine) Routes() (routes RoutesInfo) { |
|
||||
for _, tree := range engine.trees { |
|
||||
routes = iterate("", tree.method, routes, tree.root) |
|
||||
} |
|
||||
return routes |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
设置信任代理 |
|
||||
*/ |
|
||||
func (this *Engine) SetTrustedProxies(trustedProxies []string) error { |
|
||||
this.trustedProxies = trustedProxies |
|
||||
return this.parseTrustedProxies() |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) addRoute(method, path string, handlers HandlersChain) { |
|
||||
assert1(path[0] == '/', "path must begin with '/'") |
|
||||
assert1(method != "", "HTTP method can not be empty") |
|
||||
assert1(len(handlers) > 0, "there must be at least one handler") |
|
||||
if this.log.Enabled(log.DebugLevel) { |
|
||||
nuHandlers := len(handlers) |
|
||||
handlerName := nameOfFunction(handlers.Last()) |
|
||||
this.log.Debugf("%s:%s --> %s handlers:%d", method, path, handlerName, nuHandlers) |
|
||||
} |
|
||||
root := this.trees.get(method) |
|
||||
if root == nil { |
|
||||
root = new(node) |
|
||||
root.fullPath = "/" |
|
||||
this.trees = append(this.trees, methodTree{method: method, root: root}) |
|
||||
} |
|
||||
root.addRoute(path, handlers) |
|
||||
// Update maxParams
|
|
||||
if paramsCount := countParams(path); paramsCount > this.maxParams { |
|
||||
this.maxParams = paramsCount |
|
||||
} |
|
||||
|
|
||||
if sectionsCount := countSections(path); sectionsCount > this.maxSections { |
|
||||
this.maxSections = sectionsCount |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 重定向
|
|
||||
func (this *Engine) HandleContext(c *Context) { |
|
||||
oldIndexValue := c.index |
|
||||
c.reset() |
|
||||
this.handleHTTPRequest(c) |
|
||||
c.index = oldIndexValue |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) handleHTTPRequest(c *Context) { |
|
||||
httpMethod := c.Request.Method |
|
||||
rPath := c.Request.URL.Path |
|
||||
unescape := false |
|
||||
if this.UseRawPath && len(c.Request.URL.RawPath) > 0 { |
|
||||
rPath = c.Request.URL.RawPath |
|
||||
unescape = this.UnescapePathValues |
|
||||
} |
|
||||
if this.RemoveExtraSlash { |
|
||||
rPath = cleanPath(rPath) |
|
||||
} |
|
||||
t := this.trees |
|
||||
for i, tl := 0, len(t); i < tl; i++ { |
|
||||
if t[i].method != httpMethod { |
|
||||
continue |
|
||||
} |
|
||||
root := t[i].root |
|
||||
// Find route in tree
|
|
||||
value := root.getValue(rPath, c.params, c.skippedNodes, unescape) |
|
||||
if value.params != nil { |
|
||||
c.Params = *value.params |
|
||||
} |
|
||||
if value.handlers != nil { |
|
||||
c.handlers = value.handlers |
|
||||
c.fullPath = value.fullPath |
|
||||
c.Next() |
|
||||
c.writermem.WriteHeaderNow() |
|
||||
return |
|
||||
} |
|
||||
if httpMethod != http.MethodConnect && rPath != "/" { |
|
||||
if value.tsr && this.RedirectTrailingSlash { |
|
||||
this.redirectTrailingSlash(c) |
|
||||
return |
|
||||
} |
|
||||
if this.RedirectFixedPath && this.redirectFixedPath(c, root, this.RedirectFixedPath) { |
|
||||
return |
|
||||
} |
|
||||
} |
|
||||
break |
|
||||
} |
|
||||
|
|
||||
if this.HandleMethodNotAllowed { |
|
||||
for _, tree := range this.trees { |
|
||||
if tree.method == httpMethod { |
|
||||
continue |
|
||||
} |
|
||||
if value := tree.root.getValue(rPath, nil, c.skippedNodes, unescape); value.handlers != nil { |
|
||||
c.handlers = this.allNoMethod |
|
||||
this.serveError(c, http.StatusMethodNotAllowed, default405Body) |
|
||||
return |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
c.handlers = this.allNoRoute |
|
||||
this.serveError(c, http.StatusNotFound, default404Body) |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) rebuild404Handlers() { |
|
||||
this.allNoRoute = this.combineHandlers(this.noRoute) |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) rebuild405Handlers() { |
|
||||
this.allNoMethod = this.combineHandlers(this.noMethod) |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) IsUnsafeTrustedProxies() bool { |
|
||||
return this.isTrustedProxy(net.ParseIP("0.0.0.0")) || this.isTrustedProxy(net.ParseIP("::")) |
|
||||
} |
|
||||
|
|
||||
// validateHeader 将解析 X-Forwarded-For 标头并返回受信任的客户端 IP 地址
|
|
||||
func (this *Engine) validateHeader(header string) (clientIP string, valid bool) { |
|
||||
if header == "" { |
|
||||
return "", false |
|
||||
} |
|
||||
items := strings.Split(header, ",") |
|
||||
for i := len(items) - 1; i >= 0; i-- { |
|
||||
ipStr := strings.TrimSpace(items[i]) |
|
||||
ip := net.ParseIP(ipStr) |
|
||||
if ip == nil { |
|
||||
break |
|
||||
} |
|
||||
|
|
||||
// X-Forwarded-For is appended by proxy
|
|
||||
// Check IPs in reverse order and stop when find untrusted proxy
|
|
||||
if (i == 0) || (!this.isTrustedProxy(ip)) { |
|
||||
return ipStr, true |
|
||||
} |
|
||||
} |
|
||||
return "", false |
|
||||
} |
|
||||
|
|
||||
// /目标Ip是否是可信
|
|
||||
func (this *Engine) isTrustedProxy(ip net.IP) bool { |
|
||||
if this.trustedCIDRs == nil { |
|
||||
return false |
|
||||
} |
|
||||
for _, cidr := range this.trustedCIDRs { |
|
||||
if cidr.Contains(ip) { |
|
||||
return true |
|
||||
} |
|
||||
} |
|
||||
return false |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) serveError(c *Context, code int, defaultMessage []byte) { |
|
||||
c.writermem.status = code |
|
||||
c.Next() |
|
||||
if c.writermem.Written() { |
|
||||
return |
|
||||
} |
|
||||
if c.writermem.Status() == code { |
|
||||
c.writermem.Header()["Content-Type"] = mimePlain |
|
||||
_, err := c.Writer.Write(defaultMessage) |
|
||||
if err != nil { |
|
||||
this.log.Errorf("[SYS-Gin] cannot write message to writer during serve error: %v", err) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
c.writermem.WriteHeaderNow() |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) redirectFixedPath(c *Context, root *node, trailingSlash bool) bool { |
|
||||
req := c.Request |
|
||||
rPath := req.URL.Path |
|
||||
|
|
||||
if fixedPath, ok := root.findCaseInsensitivePath(cleanPath(rPath), trailingSlash); ok { |
|
||||
req.URL.Path = utils.BytesToString(fixedPath) |
|
||||
this.redirectRequest(c) |
|
||||
return true |
|
||||
} |
|
||||
return false |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) redirectTrailingSlash(c *Context) { |
|
||||
req := c.Request |
|
||||
p := req.URL.Path |
|
||||
if prefix := path.Clean(c.Request.Header.Get("X-Forwarded-Prefix")); prefix != "." { |
|
||||
p = prefix + "/" + req.URL.Path |
|
||||
} |
|
||||
req.URL.Path = p + "/" |
|
||||
if length := len(p); length > 1 && p[length-1] == '/' { |
|
||||
req.URL.Path = p[:length-1] |
|
||||
} |
|
||||
this.redirectRequest(c) |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) redirectRequest(c *Context) { |
|
||||
req := c.Request |
|
||||
rPath := req.URL.Path |
|
||||
rURL := req.URL.String() |
|
||||
|
|
||||
code := http.StatusMovedPermanently // Permanent redirect, request with GET method
|
|
||||
if req.Method != http.MethodGet { |
|
||||
code = http.StatusTemporaryRedirect |
|
||||
} |
|
||||
this.log.Debugf("redirecting request %d: %s --> %s", code, rPath, rURL) |
|
||||
http.Redirect(c.Writer, req, rURL, code) |
|
||||
c.writermem.WriteHeaderNow() |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) parseTrustedProxies() error { |
|
||||
trustedCIDRs, err := this.prepareTrustedCIDRs() |
|
||||
this.trustedCIDRs = trustedCIDRs |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) prepareTrustedCIDRs() ([]*net.IPNet, error) { |
|
||||
if this.trustedProxies == nil { |
|
||||
return nil, nil |
|
||||
} |
|
||||
|
|
||||
cidr := make([]*net.IPNet, 0, len(this.trustedProxies)) |
|
||||
for _, trustedProxy := range this.trustedProxies { |
|
||||
if !strings.Contains(trustedProxy, "/") { |
|
||||
ip := parseIP(trustedProxy) |
|
||||
if ip == nil { |
|
||||
return cidr, &net.ParseError{Type: "IP address", Text: trustedProxy} |
|
||||
} |
|
||||
|
|
||||
switch len(ip) { |
|
||||
case net.IPv4len: |
|
||||
trustedProxy += "/32" |
|
||||
case net.IPv6len: |
|
||||
trustedProxy += "/128" |
|
||||
} |
|
||||
} |
|
||||
_, cidrNet, err := net.ParseCIDR(trustedProxy) |
|
||||
if err != nil { |
|
||||
return cidr, err |
|
||||
} |
|
||||
cidr = append(cidr, cidrNet) |
|
||||
} |
|
||||
return cidr, nil |
|
||||
} |
|
||||
|
|
||||
func (this *Engine) allocateContext() *Context { |
|
||||
v := make(Params, 0, this.maxParams) |
|
||||
skippedNodes := make([]skippedNode, 0, this.maxSections) |
|
||||
// return &Context{Log: this.log, engine: this, params: &v, skippedNodes: &skippedNodes, writermem: ResponseWriter{log: this.log}}
|
|
||||
return newContext(this.log, this, &v, &skippedNodes) |
|
||||
} |
|
||||
|
|
||||
// 日志接口-------------------------------------------------------------
|
|
||||
func (this *Engine) debugPrintLoadTemplate(tmpl *template.Template) { |
|
||||
var buf strings.Builder |
|
||||
for _, tmpl := range tmpl.Templates() { |
|
||||
buf.WriteString("\t- ") |
|
||||
buf.WriteString(tmpl.Name()) |
|
||||
buf.WriteString("\n") |
|
||||
} |
|
||||
format := "Loaded HTML Templates (%d): \n%s\n" |
|
||||
if !strings.HasSuffix(format, "\n") { |
|
||||
format += "\n" |
|
||||
} |
|
||||
this.log.Debugf(format, len(tmpl.Templates()), buf.String()) |
|
||||
|
|
||||
} |
|
||||
@ -1,201 +0,0 @@ |
|||||
// Copyright 2014 Manu Martinez-Almeida. All rights reserved.
|
|
||||
// Use of this source code is governed by a MIT style
|
|
||||
// license that can be found in the LICENSE file.
|
|
||||
|
|
||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"encoding/xml" |
|
||||
"fmt" |
|
||||
"reflect" |
|
||||
"strings" |
|
||||
|
|
||||
json "github.com/json-iterator/go" |
|
||||
) |
|
||||
|
|
||||
// H is a shortcut for map[string]interface{}
|
|
||||
type H map[string]interface{} |
|
||||
|
|
||||
// MarshalXML allows type H to be used with xml.Marshal.
|
|
||||
func (h H) MarshalXML(e *xml.Encoder, start xml.StartElement) error { |
|
||||
start.Name = xml.Name{ |
|
||||
Space: "", |
|
||||
Local: "map", |
|
||||
} |
|
||||
if err := e.EncodeToken(start); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
for key, value := range h { |
|
||||
elem := xml.StartElement{ |
|
||||
Name: xml.Name{Space: "", Local: key}, |
|
||||
Attr: []xml.Attr{}, |
|
||||
} |
|
||||
if err := e.EncodeElement(value, elem); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return e.EncodeToken(xml.EndElement{Name: start.Name}) |
|
||||
} |
|
||||
|
|
||||
// ErrorType is an unsigned 64-bit error code as defined in the gin spec.
|
|
||||
type ErrorType uint64 |
|
||||
|
|
||||
const ( |
|
||||
// ErrorTypeBind is used when Context.Bind() fails.
|
|
||||
ErrorTypeBind ErrorType = 1 << 63 |
|
||||
// ErrorTypeRender is used when Context.Render() fails.
|
|
||||
ErrorTypeRender ErrorType = 1 << 62 |
|
||||
// ErrorTypePrivate indicates a private error.
|
|
||||
ErrorTypePrivate ErrorType = 1 << 0 |
|
||||
// ErrorTypePublic indicates a public error.
|
|
||||
ErrorTypePublic ErrorType = 1 << 1 |
|
||||
// ErrorTypeAny indicates any other error.
|
|
||||
ErrorTypeAny ErrorType = 1<<64 - 1 |
|
||||
// ErrorTypeNu indicates any other error.
|
|
||||
ErrorTypeNu = 2 |
|
||||
) |
|
||||
|
|
||||
// Error represents a error's specification.
|
|
||||
type Error struct { |
|
||||
Err error |
|
||||
Type ErrorType |
|
||||
Meta interface{} |
|
||||
} |
|
||||
|
|
||||
type errorMsgs []*Error |
|
||||
|
|
||||
var _ error = &Error{} |
|
||||
|
|
||||
// SetType sets the error's type.
|
|
||||
func (msg *Error) SetType(flags ErrorType) *Error { |
|
||||
msg.Type = flags |
|
||||
return msg |
|
||||
} |
|
||||
|
|
||||
// SetMeta sets the error's meta data.
|
|
||||
func (msg *Error) SetMeta(data interface{}) *Error { |
|
||||
msg.Meta = data |
|
||||
return msg |
|
||||
} |
|
||||
|
|
||||
// JSON creates a properly formatted JSON
|
|
||||
func (msg *Error) JSON() interface{} { |
|
||||
jsonData := H{} |
|
||||
if msg.Meta != nil { |
|
||||
value := reflect.ValueOf(msg.Meta) |
|
||||
switch value.Kind() { |
|
||||
case reflect.Struct: |
|
||||
return msg.Meta |
|
||||
case reflect.Map: |
|
||||
for _, key := range value.MapKeys() { |
|
||||
jsonData[key.String()] = value.MapIndex(key).Interface() |
|
||||
} |
|
||||
default: |
|
||||
jsonData["meta"] = msg.Meta |
|
||||
} |
|
||||
} |
|
||||
if _, ok := jsonData["error"]; !ok { |
|
||||
jsonData["error"] = msg.Error() |
|
||||
} |
|
||||
return jsonData |
|
||||
} |
|
||||
|
|
||||
// MarshalJSON implements the json.Marshaller interface.
|
|
||||
func (msg *Error) MarshalJSON() ([]byte, error) { |
|
||||
return json.Marshal(msg.JSON()) |
|
||||
} |
|
||||
|
|
||||
// Error implements the error interface.
|
|
||||
func (msg Error) Error() string { |
|
||||
return msg.Err.Error() |
|
||||
} |
|
||||
|
|
||||
// IsType judges one error.
|
|
||||
func (msg *Error) IsType(flags ErrorType) bool { |
|
||||
return (msg.Type & flags) > 0 |
|
||||
} |
|
||||
|
|
||||
// Unwrap returns the wrapped error, to allow interoperability with errors.Is(), errors.As() and errors.Unwrap()
|
|
||||
func (msg *Error) Unwrap() error { |
|
||||
return msg.Err |
|
||||
} |
|
||||
|
|
||||
// ByType returns a readonly copy filtered the byte.
|
|
||||
// ie ByType(gin.ErrorTypePublic) returns a slice of errors with type=ErrorTypePublic.
|
|
||||
func (a errorMsgs) ByType(typ ErrorType) errorMsgs { |
|
||||
if len(a) == 0 { |
|
||||
return nil |
|
||||
} |
|
||||
if typ == ErrorTypeAny { |
|
||||
return a |
|
||||
} |
|
||||
var result errorMsgs |
|
||||
for _, msg := range a { |
|
||||
if msg.IsType(typ) { |
|
||||
result = append(result, msg) |
|
||||
} |
|
||||
} |
|
||||
return result |
|
||||
} |
|
||||
|
|
||||
// Last returns the last error in the slice. It returns nil if the array is empty.
|
|
||||
// Shortcut for errors[len(errors)-1].
|
|
||||
func (a errorMsgs) Last() *Error { |
|
||||
if length := len(a); length > 0 { |
|
||||
return a[length-1] |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
// Errors returns an array with all the error messages.
|
|
||||
// Example:
|
|
||||
//
|
|
||||
// c.Error(errors.New("first"))
|
|
||||
// c.Error(errors.New("second"))
|
|
||||
// c.Error(errors.New("third"))
|
|
||||
// c.Errors.Errors() // == []string{"first", "second", "third"}
|
|
||||
func (a errorMsgs) Errors() []string { |
|
||||
if len(a) == 0 { |
|
||||
return nil |
|
||||
} |
|
||||
errorStrings := make([]string, len(a)) |
|
||||
for i, err := range a { |
|
||||
errorStrings[i] = err.Error() |
|
||||
} |
|
||||
return errorStrings |
|
||||
} |
|
||||
|
|
||||
func (a errorMsgs) JSON() interface{} { |
|
||||
switch length := len(a); length { |
|
||||
case 0: |
|
||||
return nil |
|
||||
case 1: |
|
||||
return a.Last().JSON() |
|
||||
default: |
|
||||
jsonData := make([]interface{}, length) |
|
||||
for i, err := range a { |
|
||||
jsonData[i] = err.JSON() |
|
||||
} |
|
||||
return jsonData |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// MarshalJSON implements the json.Marshaller interface.
|
|
||||
func (a errorMsgs) MarshalJSON() ([]byte, error) { |
|
||||
return json.Marshal(a.JSON()) |
|
||||
} |
|
||||
|
|
||||
func (a errorMsgs) String() string { |
|
||||
if len(a) == 0 { |
|
||||
return "" |
|
||||
} |
|
||||
var buffer strings.Builder |
|
||||
for i, msg := range a { |
|
||||
fmt.Fprintf(&buffer, "Error #%02d: %s\n", i+1, msg.Err) |
|
||||
if msg.Meta != nil { |
|
||||
fmt.Fprintf(&buffer, " Meta: %v\n", msg.Meta) |
|
||||
} |
|
||||
} |
|
||||
return buffer.String() |
|
||||
} |
|
||||
@ -1,26 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import "net/http" |
|
||||
|
|
||||
type onlyFilesFS struct { |
|
||||
fs http.FileSystem |
|
||||
} |
|
||||
type neuteredReaddirFile struct { |
|
||||
http.File |
|
||||
} |
|
||||
|
|
||||
func Dir(root string, listDirectory bool) http.FileSystem { |
|
||||
fs := http.Dir(root) |
|
||||
if listDirectory { |
|
||||
return fs |
|
||||
} |
|
||||
return &onlyFilesFS{fs} |
|
||||
} |
|
||||
|
|
||||
func (fs onlyFilesFS) Open(name string) (http.File, error) { |
|
||||
f, err := fs.fs.Open(name) |
|
||||
if err != nil { |
|
||||
return nil, err |
|
||||
} |
|
||||
return neuteredReaddirFile{f}, nil |
|
||||
} |
|
||||
@ -1,47 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
MultipartMemory int64 //文件上传最大尺寸
|
|
||||
RedirectTrailingSlash bool |
|
||||
Log log.ILogger |
|
||||
} |
|
||||
|
|
||||
func SetMultipartMemory(v int64) Option { |
|
||||
return func(o *Options) { |
|
||||
o.MultipartMemory = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
如果当前路由无法匹配，但启用自动重定向 |
|
||||
带有（不带）尾部斜杠的路径的处理程序存在。 |
|
||||
例如，如果 /foo/ 被请求，但路由只存在于 /foo，则 |
|
||||
对于 GET 请求，客户端被重定向到 /foo，http 状态码为 301 |
|
||||
对于所有其他请求方法，则为 307。 |
|
||||
*/ |
|
||||
func SetRedirectTrailingSlash(v bool) Option { |
|
||||
return func(o *Options) { |
|
||||
o.RedirectTrailingSlash = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetLog(log log.ILogger) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Log = log |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func newOptions(opts ...Option) (options *Options, err error) { |
|
||||
options = &Options{ |
|
||||
MultipartMemory: defaultMultipartMemory, |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(options) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,116 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"bufio" |
|
||||
"io" |
|
||||
"net" |
|
||||
"net/http" |
|
||||
|
|
||||
"yunyan/lego/sys/log" |
|
||||
) |
|
||||
|
|
||||
const ( |
|
||||
noWritten = -1 |
|
||||
defaultStatus = http.StatusOK |
|
||||
) |
|
||||
|
|
||||
type IResponseWriter interface { |
|
||||
http.ResponseWriter |
|
||||
http.Hijacker |
|
||||
http.Flusher |
|
||||
http.CloseNotifier |
|
||||
/* |
|
||||
返回当前请求的 HTTP 响应状态码。 |
|
||||
*/ |
|
||||
Status() int |
|
||||
/* |
|
||||
大小返回已经写入响应 http 正文的字节数 |
|
||||
*/ |
|
||||
Size() int |
|
||||
// WriteString writes the string into the response body.
|
|
||||
WriteString(string) (int, error) |
|
||||
// Written returns true if the response body was already written.
|
|
||||
Written() bool |
|
||||
/* |
|
||||
WriteHeaderNow 强制写入 http 标头（状态码 + 标头）。 |
|
||||
*/ |
|
||||
WriteHeaderNow() |
|
||||
// Pusher get the http.Pusher for server push
|
|
||||
Pusher() http.Pusher |
|
||||
} |
|
||||
type ResponseWriter struct { |
|
||||
http.ResponseWriter |
|
||||
log log.ILogger |
|
||||
size int |
|
||||
status int |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) reset(writer http.ResponseWriter) { |
|
||||
this.ResponseWriter = writer |
|
||||
this.size = noWritten |
|
||||
this.status = defaultStatus |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) WriteHeader(code int) { |
|
||||
if code > 0 && this.status != code { |
|
||||
if this.Written() { |
|
||||
this.log.Warnf("Headers were already written. Wanted to override status code %d with %d", this.status, code) |
|
||||
} |
|
||||
this.status = code |
|
||||
} |
|
||||
} |
|
||||
func (this *ResponseWriter) WriteHeaderNow() { |
|
||||
if !this.Written() { |
|
||||
this.size = 0 |
|
||||
this.ResponseWriter.WriteHeader(this.status) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) Write(data []byte) (n int, err error) { |
|
||||
this.WriteHeaderNow() |
|
||||
n, err = this.ResponseWriter.Write(data) |
|
||||
this.size += n |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) WriteString(s string) (n int, err error) { |
|
||||
this.WriteHeaderNow() |
|
||||
n, err = io.WriteString(this.ResponseWriter, s) |
|
||||
this.size += n |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) Status() int { |
|
||||
return this.status |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) Size() int { |
|
||||
return this.size |
|
||||
} |
|
||||
func (this *ResponseWriter) Written() bool { |
|
||||
return this.size != noWritten |
|
||||
} |
|
||||
|
|
||||
// Hijack implements the http.Hijacker interface.
|
|
||||
func (this *ResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { |
|
||||
if this.size < 0 { |
|
||||
this.size = 0 |
|
||||
} |
|
||||
return this.ResponseWriter.(http.Hijacker).Hijack() |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) CloseNotify() <-chan bool { |
|
||||
return this.ResponseWriter.(http.CloseNotifier).CloseNotify() |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) Flush() { |
|
||||
this.WriteHeaderNow() |
|
||||
this.ResponseWriter.(http.Flusher).Flush() |
|
||||
} |
|
||||
|
|
||||
func (this *ResponseWriter) Pusher() (pusher http.Pusher) { |
|
||||
if pusher, ok := this.ResponseWriter.(http.Pusher); ok { |
|
||||
return pusher |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
@ -1,196 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
"path" |
|
||||
"reflect" |
|
||||
"regexp" |
|
||||
"strings" |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
regEnLetter = regexp.MustCompile("^[A-Z]+$") |
|
||||
anyMethods = []string{ |
|
||||
http.MethodGet, http.MethodPost, http.MethodPut, http.MethodPatch, |
|
||||
http.MethodHead, http.MethodOptions, http.MethodDelete, http.MethodConnect, |
|
||||
http.MethodTrace, |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
type RouterGroup struct { |
|
||||
Handlers HandlersChain |
|
||||
basePath string |
|
||||
engine *Engine |
|
||||
root bool |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) BasePath() string { |
|
||||
return this.basePath |
|
||||
} |
|
||||
func (this *RouterGroup) NoRoute(handlers ...HandlerFunc) { |
|
||||
this.engine.NoRoute(handlers...) |
|
||||
} |
|
||||
func (this *RouterGroup) Use(middleware ...HandlerFunc) IRoutes { |
|
||||
this.Handlers = append(this.Handlers, middleware...) |
|
||||
return this.returnObj() |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return &RouterGroup{ |
|
||||
Handlers: this.combineHandlers(handlers), |
|
||||
basePath: this.calculateAbsolutePath(relativePath), |
|
||||
engine: this.engine, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) Handle(httpMethod, relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
if matched := regEnLetter.MatchString(httpMethod); !matched { |
|
||||
panic("http method " + httpMethod + " is not valid") |
|
||||
} |
|
||||
return this.handle(httpMethod, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return this.handle(http.MethodPost, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return this.handle(http.MethodGet, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return this.handle(http.MethodDelete, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return this.handle(http.MethodPatch, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return this.handle(http.MethodPut, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return this.handle(http.MethodOptions, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
return this.handle(http.MethodHead, relativePath, handlers) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) IRoutes { |
|
||||
for _, method := range anyMethods { |
|
||||
this.handle(method, relativePath, handlers) |
|
||||
} |
|
||||
return this.returnObj() |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) StaticFile(relativePath, filepath string) IRoutes { |
|
||||
return this.staticFileHandler(relativePath, func(c *Context) { |
|
||||
c.File(filepath) |
|
||||
}) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) StaticFileFS(relativePath, filepath string, fs http.FileSystem) IRoutes { |
|
||||
return this.staticFileHandler(relativePath, func(c *Context) { |
|
||||
c.FileFromFS(filepath, fs) |
|
||||
}) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) Static(relativePath, root string) IRoutes { |
|
||||
return this.StaticFS(relativePath, Dir(root, false)) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) StaticFS(relativePath string, fs http.FileSystem) IRoutes { |
|
||||
if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") { |
|
||||
panic("URL parameters can not be used when serving a static folder") |
|
||||
} |
|
||||
handler := this.createStaticHandler(relativePath, fs) |
|
||||
urlPattern := path.Join(relativePath, "/*filepath") |
|
||||
|
|
||||
// Register GET and HEAD handlers
|
|
||||
this.GET(urlPattern, handler) |
|
||||
this.HEAD(urlPattern, handler) |
|
||||
return this.returnObj() |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes { |
|
||||
absolutePath := this.calculateAbsolutePath(relativePath) |
|
||||
handlers = this.combineHandlers(handlers) |
|
||||
this.engine.addRoute(httpMethod, absolutePath, handlers) |
|
||||
return this.returnObj() |
|
||||
} |
|
||||
|
|
||||
func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc { |
|
||||
absolutePath := group.calculateAbsolutePath(relativePath) |
|
||||
fileServer := http.StripPrefix(absolutePath, http.FileServer(fs)) |
|
||||
return func(c *Context) { |
|
||||
if _, noListing := fs.(*onlyFilesFS); noListing { |
|
||||
c.Writer.WriteHeader(http.StatusNotFound) |
|
||||
} |
|
||||
file := c.Param("filepath") |
|
||||
f, err := fs.Open(file) |
|
||||
if err != nil { |
|
||||
c.Writer.WriteHeader(http.StatusNotFound) |
|
||||
c.handlers = group.engine.noRoute |
|
||||
c.index = -1 |
|
||||
return |
|
||||
} |
|
||||
f.Close() |
|
||||
|
|
||||
fileServer.ServeHTTP(c.Writer, c.Request) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain { |
|
||||
finalSize := len(this.Handlers) + len(handlers) |
|
||||
assert1(finalSize < int(abortIndex), "too many handlers") |
|
||||
mergedHandlers := make(HandlersChain, finalSize) |
|
||||
copy(mergedHandlers, this.Handlers) |
|
||||
copy(mergedHandlers[len(this.Handlers):], handlers) |
|
||||
return mergedHandlers |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) calculateAbsolutePath(relativePath string) string { |
|
||||
return joinPaths(this.basePath, relativePath) |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) staticFileHandler(relativePath string, handler HandlerFunc) IRoutes { |
|
||||
if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") { |
|
||||
panic("URL parameters can not be used when serving a static file") |
|
||||
} |
|
||||
this.GET(relativePath, handler) |
|
||||
this.HEAD(relativePath, handler) |
|
||||
return this.returnObj() |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) returnObj() IRoutes { |
|
||||
if this.root { |
|
||||
return this.engine |
|
||||
} |
|
||||
return this |
|
||||
} |
|
||||
|
|
||||
func (this *RouterGroup) Register(rcvr interface{}) { |
|
||||
typ := reflect.TypeOf(rcvr) |
|
||||
vof := reflect.ValueOf(rcvr) |
|
||||
for m := 0; m < typ.NumMethod(); m++ { |
|
||||
method := typ.Method(m) |
|
||||
mname := method.Name |
|
||||
mtype := method.Type |
|
||||
if method.PkgPath != "" { |
|
||||
continue |
|
||||
} |
|
||||
if mtype.NumIn() != 2 { |
|
||||
continue |
|
||||
} |
|
||||
context := mtype.In(1) |
|
||||
if context.String() != "*engine.Context" { |
|
||||
continue |
|
||||
} |
|
||||
if mtype.NumOut() != 0 { |
|
||||
continue |
|
||||
} |
|
||||
this.POST(strings.ToLower(mname), vof.MethodByName(mname).Interface().(func(*Context))) |
|
||||
} |
|
||||
} |
|
||||
@ -1,838 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"net/url" |
|
||||
"strings" |
|
||||
"unicode" |
|
||||
"unicode/utf8" |
|
||||
|
|
||||
"yunyan/lego/utils" |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
strColon = []byte(":") |
|
||||
strStar = []byte("*") |
|
||||
strSlash = []byte("/") |
|
||||
) |
|
||||
|
|
||||
type Param struct { |
|
||||
Key string |
|
||||
Value string |
|
||||
} |
|
||||
|
|
||||
type Params []Param |
|
||||
|
|
||||
func (ps Params) Get(name string) (string, bool) { |
|
||||
for _, entry := range ps { |
|
||||
if entry.Key == name { |
|
||||
return entry.Value, true |
|
||||
} |
|
||||
} |
|
||||
return "", false |
|
||||
} |
|
||||
|
|
||||
func (ps Params) ByName(name string) (va string) { |
|
||||
va, _ = ps.Get(name) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type nodeType uint8 |
|
||||
type nodeValue struct { |
|
||||
handlers HandlersChain |
|
||||
params *Params |
|
||||
tsr bool |
|
||||
fullPath string |
|
||||
} |
|
||||
type skippedNode struct { |
|
||||
path string |
|
||||
node *node |
|
||||
paramsCount int16 |
|
||||
} |
|
||||
|
|
||||
const ( |
|
||||
root nodeType = iota + 1 |
|
||||
param |
|
||||
catchAll |
|
||||
) |
|
||||
|
|
||||
type node struct { |
|
||||
path string |
|
||||
indices string |
|
||||
wildChild bool |
|
||||
nType nodeType |
|
||||
priority uint32 |
|
||||
children []*node // child nodes, at most 1 :param style node at the end of the array
|
|
||||
handlers HandlersChain |
|
||||
fullPath string |
|
||||
} |
|
||||
|
|
||||
func (n *node) addChild(child *node) { |
|
||||
if n.wildChild && len(n.children) > 0 { |
|
||||
wildcardChild := n.children[len(n.children)-1] |
|
||||
n.children = append(n.children[:len(n.children)-1], child, wildcardChild) |
|
||||
} else { |
|
||||
n.children = append(n.children, child) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (n *node) addRoute(path string, handlers HandlersChain) { |
|
||||
fullPath := path |
|
||||
n.priority++ |
|
||||
// Empty tree
|
|
||||
if len(n.path) == 0 && len(n.children) == 0 { |
|
||||
n.insertChild(path, fullPath, handlers) |
|
||||
n.nType = root |
|
||||
return |
|
||||
} |
|
||||
parentFullPathIndex := 0 |
|
||||
walk: |
|
||||
for { |
|
||||
// Find the longest common prefix.
|
|
||||
// This also implies that the common prefix contains no ':' or '*'
|
|
||||
// since the existing key can't contain those chars.
|
|
||||
i := longestCommonPrefix(path, n.path) |
|
||||
|
|
||||
// Split edge
|
|
||||
if i < len(n.path) { |
|
||||
child := node{ |
|
||||
path: n.path[i:], |
|
||||
wildChild: n.wildChild, |
|
||||
indices: n.indices, |
|
||||
children: n.children, |
|
||||
handlers: n.handlers, |
|
||||
priority: n.priority - 1, |
|
||||
fullPath: n.fullPath, |
|
||||
} |
|
||||
|
|
||||
n.children = []*node{&child} |
|
||||
// []byte for proper unicode char conversion, see #65
|
|
||||
n.indices = utils.BytesToString([]byte{n.path[i]}) |
|
||||
n.path = path[:i] |
|
||||
n.handlers = nil |
|
||||
n.wildChild = false |
|
||||
n.fullPath = fullPath[:parentFullPathIndex+i] |
|
||||
} |
|
||||
|
|
||||
// Make new node a child of this node
|
|
||||
if i < len(path) { |
|
||||
path = path[i:] |
|
||||
c := path[0] |
|
||||
|
|
||||
// '/' after param
|
|
||||
if n.nType == param && c == '/' && len(n.children) == 1 { |
|
||||
parentFullPathIndex += len(n.path) |
|
||||
n = n.children[0] |
|
||||
n.priority++ |
|
||||
continue walk |
|
||||
} |
|
||||
|
|
||||
// Check if a child with the next path byte exists
|
|
||||
for i, max := 0, len(n.indices); i < max; i++ { |
|
||||
if c == n.indices[i] { |
|
||||
parentFullPathIndex += len(n.path) |
|
||||
i = n.incrementChildPrio(i) |
|
||||
n = n.children[i] |
|
||||
continue walk |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Otherwise insert it
|
|
||||
if c != ':' && c != '*' && n.nType != catchAll { |
|
||||
// []byte for proper unicode char conversion, see #65
|
|
||||
n.indices += utils.BytesToString([]byte{c}) |
|
||||
child := &node{ |
|
||||
fullPath: fullPath, |
|
||||
} |
|
||||
n.addChild(child) |
|
||||
n.incrementChildPrio(len(n.indices) - 1) |
|
||||
n = child |
|
||||
} else if n.wildChild { |
|
||||
// inserting a wildcard node, need to check if it conflicts with the existing wildcard
|
|
||||
n = n.children[len(n.children)-1] |
|
||||
n.priority++ |
|
||||
|
|
||||
// Check if the wildcard matches
|
|
||||
if len(path) >= len(n.path) && n.path == path[:len(n.path)] && |
|
||||
// Adding a child to a catchAll is not possible
|
|
||||
n.nType != catchAll && |
|
||||
// Check for longer wildcard, e.g. :name and :names
|
|
||||
(len(n.path) >= len(path) || path[len(n.path)] == '/') { |
|
||||
continue walk |
|
||||
} |
|
||||
|
|
||||
// Wildcard conflict
|
|
||||
pathSeg := path |
|
||||
if n.nType != catchAll { |
|
||||
pathSeg = strings.SplitN(pathSeg, "/", 2)[0] |
|
||||
} |
|
||||
prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path |
|
||||
panic("'" + pathSeg + |
|
||||
"' in new path '" + fullPath + |
|
||||
"' conflicts with existing wildcard '" + n.path + |
|
||||
"' in existing prefix '" + prefix + |
|
||||
"'") |
|
||||
} |
|
||||
|
|
||||
n.insertChild(path, fullPath, handlers) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// Otherwise add handle to current node
|
|
||||
if n.handlers != nil { |
|
||||
panic("handlers are already registered for path '" + fullPath + "'") |
|
||||
} |
|
||||
n.handlers = handlers |
|
||||
n.fullPath = fullPath |
|
||||
return |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (n *node) insertChild(path string, fullPath string, handlers HandlersChain) { |
|
||||
for { |
|
||||
// Find prefix until first wildcard
|
|
||||
wildcard, i, valid := findWildcard(path) |
|
||||
if i < 0 { // No wildcard found
|
|
||||
break |
|
||||
} |
|
||||
|
|
||||
// The wildcard name must only contain one ':' or '*' character
|
|
||||
if !valid { |
|
||||
panic("only one wildcard per path segment is allowed, has: '" + |
|
||||
wildcard + "' in path '" + fullPath + "'") |
|
||||
} |
|
||||
|
|
||||
// check if the wildcard has a name
|
|
||||
if len(wildcard) < 2 { |
|
||||
panic("wildcards must be named with a non-empty name in path '" + fullPath + "'") |
|
||||
} |
|
||||
|
|
||||
if wildcard[0] == ':' { // param
|
|
||||
if i > 0 { |
|
||||
// Insert prefix before the current wildcard
|
|
||||
n.path = path[:i] |
|
||||
path = path[i:] |
|
||||
} |
|
||||
|
|
||||
child := &node{ |
|
||||
nType: param, |
|
||||
path: wildcard, |
|
||||
fullPath: fullPath, |
|
||||
} |
|
||||
n.addChild(child) |
|
||||
n.wildChild = true |
|
||||
n = child |
|
||||
n.priority++ |
|
||||
|
|
||||
// if the path doesn't end with the wildcard, then there
|
|
||||
// will be another subpath starting with '/'
|
|
||||
if len(wildcard) < len(path) { |
|
||||
path = path[len(wildcard):] |
|
||||
|
|
||||
child := &node{ |
|
||||
priority: 1, |
|
||||
fullPath: fullPath, |
|
||||
} |
|
||||
n.addChild(child) |
|
||||
n = child |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
// Otherwise we're done. Insert the handle in the new leaf
|
|
||||
n.handlers = handlers |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// catchAll
|
|
||||
if i+len(wildcard) != len(path) { |
|
||||
panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'") |
|
||||
} |
|
||||
|
|
||||
if len(n.path) > 0 && n.path[len(n.path)-1] == '/' { |
|
||||
pathSeg := strings.SplitN(n.children[0].path, "/", 2)[0] |
|
||||
panic("catch-all wildcard '" + path + |
|
||||
"' in new path '" + fullPath + |
|
||||
"' conflicts with existing path segment '" + pathSeg + |
|
||||
"' in existing prefix '" + n.path + pathSeg + |
|
||||
"'") |
|
||||
} |
|
||||
|
|
||||
// currently fixed width 1 for '/'
|
|
||||
i-- |
|
||||
if path[i] != '/' { |
|
||||
panic("no / before catch-all in path '" + fullPath + "'") |
|
||||
} |
|
||||
|
|
||||
n.path = path[:i] |
|
||||
|
|
||||
// First node: catchAll node with empty path
|
|
||||
child := &node{ |
|
||||
wildChild: true, |
|
||||
nType: catchAll, |
|
||||
fullPath: fullPath, |
|
||||
} |
|
||||
|
|
||||
n.addChild(child) |
|
||||
n.indices = string('/') |
|
||||
n = child |
|
||||
n.priority++ |
|
||||
|
|
||||
// second node: node holding the variable
|
|
||||
child = &node{ |
|
||||
path: path[i:], |
|
||||
nType: catchAll, |
|
||||
handlers: handlers, |
|
||||
priority: 1, |
|
||||
fullPath: fullPath, |
|
||||
} |
|
||||
n.children = []*node{child} |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// If no wildcard was found, simply insert the path and handle
|
|
||||
n.path = path |
|
||||
n.handlers = handlers |
|
||||
n.fullPath = fullPath |
|
||||
} |
|
||||
func (n *node) incrementChildPrio(pos int) int { |
|
||||
cs := n.children |
|
||||
cs[pos].priority++ |
|
||||
prio := cs[pos].priority |
|
||||
|
|
||||
// Adjust position (move to front)
|
|
||||
newPos := pos |
|
||||
for ; newPos > 0 && cs[newPos-1].priority < prio; newPos-- { |
|
||||
// Swap node positions
|
|
||||
cs[newPos-1], cs[newPos] = cs[newPos], cs[newPos-1] |
|
||||
} |
|
||||
|
|
||||
// Build new index char string
|
|
||||
if newPos != pos { |
|
||||
n.indices = n.indices[:newPos] + // Unchanged prefix, might be empty
|
|
||||
n.indices[pos:pos+1] + // The index char we move
|
|
||||
n.indices[newPos:pos] + n.indices[pos+1:] // Rest without char at 'pos'
|
|
||||
} |
|
||||
|
|
||||
return newPos |
|
||||
} |
|
||||
|
|
||||
func (n *node) getValue(path string, params *Params, skippedNodes *[]skippedNode, unescape bool) (value nodeValue) { |
|
||||
var globalParamsCount int16 |
|
||||
|
|
||||
walk: // Outer loop for walking the tree
|
|
||||
for { |
|
||||
prefix := n.path |
|
||||
if len(path) > len(prefix) { |
|
||||
if path[:len(prefix)] == prefix { |
|
||||
path = path[len(prefix):] |
|
||||
|
|
||||
// Try all the non-wildcard children first by matching the indices
|
|
||||
idxc := path[0] |
|
||||
for i, c := range []byte(n.indices) { |
|
||||
if c == idxc { |
|
||||
// strings.HasPrefix(n.children[len(n.children)-1].path, ":") == n.wildChild
|
|
||||
if n.wildChild { |
|
||||
index := len(*skippedNodes) |
|
||||
*skippedNodes = (*skippedNodes)[:index+1] |
|
||||
(*skippedNodes)[index] = skippedNode{ |
|
||||
path: prefix + path, |
|
||||
node: &node{ |
|
||||
path: n.path, |
|
||||
wildChild: n.wildChild, |
|
||||
nType: n.nType, |
|
||||
priority: n.priority, |
|
||||
children: n.children, |
|
||||
handlers: n.handlers, |
|
||||
fullPath: n.fullPath, |
|
||||
}, |
|
||||
paramsCount: globalParamsCount, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
n = n.children[i] |
|
||||
continue walk |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if !n.wildChild { |
|
||||
// If the path at the end of the loop is not equal to '/' and the current node has no child nodes
|
|
||||
// the current node needs to roll back to last vaild skippedNode
|
|
||||
if path != "/" { |
|
||||
for l := len(*skippedNodes); l > 0; { |
|
||||
skippedNode := (*skippedNodes)[l-1] |
|
||||
*skippedNodes = (*skippedNodes)[:l-1] |
|
||||
if strings.HasSuffix(skippedNode.path, path) { |
|
||||
path = skippedNode.path |
|
||||
n = skippedNode.node |
|
||||
if value.params != nil { |
|
||||
*value.params = (*value.params)[:skippedNode.paramsCount] |
|
||||
} |
|
||||
globalParamsCount = skippedNode.paramsCount |
|
||||
continue walk |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Nothing found.
|
|
||||
// We can recommend to redirect to the same URL without a
|
|
||||
// trailing slash if a leaf exists for that path.
|
|
||||
value.tsr = path == "/" && n.handlers != nil |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// Handle wildcard child, which is always at the end of the array
|
|
||||
n = n.children[len(n.children)-1] |
|
||||
globalParamsCount++ |
|
||||
|
|
||||
switch n.nType { |
|
||||
case param: |
|
||||
// fix truncate the parameter
|
|
||||
// tree_test.go line: 204
|
|
||||
|
|
||||
// Find param end (either '/' or path end)
|
|
||||
end := 0 |
|
||||
for end < len(path) && path[end] != '/' { |
|
||||
end++ |
|
||||
} |
|
||||
|
|
||||
// Save param value
|
|
||||
if params != nil && cap(*params) > 0 { |
|
||||
if value.params == nil { |
|
||||
value.params = params |
|
||||
} |
|
||||
// Expand slice within preallocated capacity
|
|
||||
i := len(*value.params) |
|
||||
*value.params = (*value.params)[:i+1] |
|
||||
val := path[:end] |
|
||||
if unescape { |
|
||||
if v, err := url.QueryUnescape(val); err == nil { |
|
||||
val = v |
|
||||
} |
|
||||
} |
|
||||
(*value.params)[i] = Param{ |
|
||||
Key: n.path[1:], |
|
||||
Value: val, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// we need to go deeper!
|
|
||||
if end < len(path) { |
|
||||
if len(n.children) > 0 { |
|
||||
path = path[end:] |
|
||||
n = n.children[0] |
|
||||
continue walk |
|
||||
} |
|
||||
|
|
||||
// ... but we can't
|
|
||||
value.tsr = len(path) == end+1 |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
if value.handlers = n.handlers; value.handlers != nil { |
|
||||
value.fullPath = n.fullPath |
|
||||
return |
|
||||
} |
|
||||
if len(n.children) == 1 { |
|
||||
// No handle found. Check if a handle for this path + a
|
|
||||
// trailing slash exists for TSR recommendation
|
|
||||
n = n.children[0] |
|
||||
value.tsr = (n.path == "/" && n.handlers != nil) || (n.path == "" && n.indices == "/") |
|
||||
} |
|
||||
return |
|
||||
|
|
||||
case catchAll: |
|
||||
// Save param value
|
|
||||
if params != nil { |
|
||||
if value.params == nil { |
|
||||
value.params = params |
|
||||
} |
|
||||
// Expand slice within preallocated capacity
|
|
||||
i := len(*value.params) |
|
||||
*value.params = (*value.params)[:i+1] |
|
||||
val := path |
|
||||
if unescape { |
|
||||
if v, err := url.QueryUnescape(path); err == nil { |
|
||||
val = v |
|
||||
} |
|
||||
} |
|
||||
(*value.params)[i] = Param{ |
|
||||
Key: n.path[2:], |
|
||||
Value: val, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
value.handlers = n.handlers |
|
||||
value.fullPath = n.fullPath |
|
||||
return |
|
||||
|
|
||||
default: |
|
||||
panic("invalid node type") |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if path == prefix { |
|
||||
// If the current path does not equal '/' and the node does not have a registered handle and the most recently matched node has a child node
|
|
||||
// the current node needs to roll back to last vaild skippedNode
|
|
||||
if n.handlers == nil && path != "/" { |
|
||||
for l := len(*skippedNodes); l > 0; { |
|
||||
skippedNode := (*skippedNodes)[l-1] |
|
||||
*skippedNodes = (*skippedNodes)[:l-1] |
|
||||
if strings.HasSuffix(skippedNode.path, path) { |
|
||||
path = skippedNode.path |
|
||||
n = skippedNode.node |
|
||||
if value.params != nil { |
|
||||
*value.params = (*value.params)[:skippedNode.paramsCount] |
|
||||
} |
|
||||
globalParamsCount = skippedNode.paramsCount |
|
||||
continue walk |
|
||||
} |
|
||||
} |
|
||||
// n = latestNode.children[len(latestNode.children)-1]
|
|
||||
} |
|
||||
// We should have reached the node containing the handle.
|
|
||||
// Check if this node has a handle registered.
|
|
||||
if value.handlers = n.handlers; value.handlers != nil { |
|
||||
value.fullPath = n.fullPath |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// If there is no handle for this route, but this route has a
|
|
||||
// wildcard child, there must be a handle for this path with an
|
|
||||
// additional trailing slash
|
|
||||
if path == "/" && n.wildChild && n.nType != root { |
|
||||
value.tsr = true |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// No handle found. Check if a handle for this path + a
|
|
||||
// trailing slash exists for trailing slash recommendation
|
|
||||
for i, c := range []byte(n.indices) { |
|
||||
if c == '/' { |
|
||||
n = n.children[i] |
|
||||
value.tsr = (len(n.path) == 1 && n.handlers != nil) || |
|
||||
(n.nType == catchAll && n.children[0].handlers != nil) |
|
||||
return |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// Nothing found. We can recommend to redirect to the same URL with an
|
|
||||
// extra trailing slash if a leaf exists for that path
|
|
||||
value.tsr = path == "/" || |
|
||||
(len(prefix) == len(path)+1 && prefix[len(path)] == '/' && |
|
||||
path == prefix[:len(prefix)-1] && n.handlers != nil) |
|
||||
|
|
||||
// roll back to last valid skippedNode
|
|
||||
if !value.tsr && path != "/" { |
|
||||
for l := len(*skippedNodes); l > 0; { |
|
||||
skippedNode := (*skippedNodes)[l-1] |
|
||||
*skippedNodes = (*skippedNodes)[:l-1] |
|
||||
if strings.HasSuffix(skippedNode.path, path) { |
|
||||
path = skippedNode.path |
|
||||
n = skippedNode.node |
|
||||
if value.params != nil { |
|
||||
*value.params = (*value.params)[:skippedNode.paramsCount] |
|
||||
} |
|
||||
globalParamsCount = skippedNode.paramsCount |
|
||||
continue walk |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) ([]byte, bool) { |
|
||||
const stackBufSize = 128 |
|
||||
|
|
||||
// Use a static sized buffer on the stack in the common case.
|
|
||||
// If the path is too long, allocate a buffer on the heap instead.
|
|
||||
buf := make([]byte, 0, stackBufSize) |
|
||||
if length := len(path) + 1; length > stackBufSize { |
|
||||
buf = make([]byte, 0, length) |
|
||||
} |
|
||||
|
|
||||
ciPath := n.findCaseInsensitivePathRec( |
|
||||
path, |
|
||||
buf, // Preallocate enough memory for new path
|
|
||||
[4]byte{}, // Empty rune buffer
|
|
||||
fixTrailingSlash, |
|
||||
) |
|
||||
|
|
||||
return ciPath, ciPath != nil |
|
||||
} |
|
||||
|
|
||||
// 使用的递归不区分大小写查找函数
|
|
||||
func (n *node) findCaseInsensitivePathRec(path string, ciPath []byte, rb [4]byte, fixTrailingSlash bool) []byte { |
|
||||
npLen := len(n.path) |
|
||||
|
|
||||
walk: // Outer loop for walking the tree
|
|
||||
for len(path) >= npLen && (npLen == 0 || strings.EqualFold(path[1:npLen], n.path[1:])) { |
|
||||
// Add common prefix to result
|
|
||||
oldPath := path |
|
||||
path = path[npLen:] |
|
||||
ciPath = append(ciPath, n.path...) |
|
||||
|
|
||||
if len(path) == 0 { |
|
||||
// We should have reached the node containing the handle.
|
|
||||
// Check if this node has a handle registered.
|
|
||||
if n.handlers != nil { |
|
||||
return ciPath |
|
||||
} |
|
||||
|
|
||||
// No handle found.
|
|
||||
// Try to fix the path by adding a trailing slash
|
|
||||
if fixTrailingSlash { |
|
||||
for i, c := range []byte(n.indices) { |
|
||||
if c == '/' { |
|
||||
n = n.children[i] |
|
||||
if (len(n.path) == 1 && n.handlers != nil) || |
|
||||
(n.nType == catchAll && n.children[0].handlers != nil) { |
|
||||
return append(ciPath, '/') |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
// If this node does not have a wildcard (param or catchAll) child,
|
|
||||
// we can just look up the next child node and continue to walk down
|
|
||||
// the tree
|
|
||||
if !n.wildChild { |
|
||||
// Skip rune bytes already processed
|
|
||||
rb = shiftNRuneBytes(rb, npLen) |
|
||||
|
|
||||
if rb[0] != 0 { |
|
||||
// Old rune not finished
|
|
||||
idxc := rb[0] |
|
||||
for i, c := range []byte(n.indices) { |
|
||||
if c == idxc { |
|
||||
// continue with child node
|
|
||||
n = n.children[i] |
|
||||
npLen = len(n.path) |
|
||||
continue walk |
|
||||
} |
|
||||
} |
|
||||
} else { |
|
||||
// Process a new rune
|
|
||||
var rv rune |
|
||||
|
|
||||
// Find rune start.
|
|
||||
// Runes are up to 4 byte long,
|
|
||||
// -4 would definitely be another rune.
|
|
||||
var off int |
|
||||
for max := min(npLen, 3); off < max; off++ { |
|
||||
if i := npLen - off; utf8.RuneStart(oldPath[i]) { |
|
||||
// read rune from cached path
|
|
||||
rv, _ = utf8.DecodeRuneInString(oldPath[i:]) |
|
||||
break |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Calculate lowercase bytes of current rune
|
|
||||
lo := unicode.ToLower(rv) |
|
||||
utf8.EncodeRune(rb[:], lo) |
|
||||
|
|
||||
// Skip already processed bytes
|
|
||||
rb = shiftNRuneBytes(rb, off) |
|
||||
|
|
||||
idxc := rb[0] |
|
||||
for i, c := range []byte(n.indices) { |
|
||||
// Lowercase matches
|
|
||||
if c == idxc { |
|
||||
// must use a recursive approach since both the
|
|
||||
// uppercase byte and the lowercase byte might exist
|
|
||||
// as an index
|
|
||||
if out := n.children[i].findCaseInsensitivePathRec( |
|
||||
path, ciPath, rb, fixTrailingSlash, |
|
||||
); out != nil { |
|
||||
return out |
|
||||
} |
|
||||
break |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// If we found no match, the same for the uppercase rune,
|
|
||||
// if it differs
|
|
||||
if up := unicode.ToUpper(rv); up != lo { |
|
||||
utf8.EncodeRune(rb[:], up) |
|
||||
rb = shiftNRuneBytes(rb, off) |
|
||||
|
|
||||
idxc := rb[0] |
|
||||
for i, c := range []byte(n.indices) { |
|
||||
// Uppercase matches
|
|
||||
if c == idxc { |
|
||||
// Continue with child node
|
|
||||
n = n.children[i] |
|
||||
npLen = len(n.path) |
|
||||
continue walk |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Nothing found. We can recommend to redirect to the same URL
|
|
||||
// without a trailing slash if a leaf exists for that path
|
|
||||
if fixTrailingSlash && path == "/" && n.handlers != nil { |
|
||||
return ciPath |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
n = n.children[0] |
|
||||
switch n.nType { |
|
||||
case param: |
|
||||
// Find param end (either '/' or path end)
|
|
||||
end := 0 |
|
||||
for end < len(path) && path[end] != '/' { |
|
||||
end++ |
|
||||
} |
|
||||
|
|
||||
// Add param value to case insensitive path
|
|
||||
ciPath = append(ciPath, path[:end]...) |
|
||||
|
|
||||
// We need to go deeper!
|
|
||||
if end < len(path) { |
|
||||
if len(n.children) > 0 { |
|
||||
// Continue with child node
|
|
||||
n = n.children[0] |
|
||||
npLen = len(n.path) |
|
||||
path = path[end:] |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
// ... but we can't
|
|
||||
if fixTrailingSlash && len(path) == end+1 { |
|
||||
return ciPath |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
if n.handlers != nil { |
|
||||
return ciPath |
|
||||
} |
|
||||
|
|
||||
if fixTrailingSlash && len(n.children) == 1 { |
|
||||
// No handle found. Check if a handle for this path + a
|
|
||||
// trailing slash exists
|
|
||||
n = n.children[0] |
|
||||
if n.path == "/" && n.handlers != nil { |
|
||||
return append(ciPath, '/') |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return nil |
|
||||
|
|
||||
case catchAll: |
|
||||
return append(ciPath, path...) |
|
||||
|
|
||||
default: |
|
||||
panic("invalid node type") |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Nothing found.
|
|
||||
// Try to fix the path by adding / removing a trailing slash
|
|
||||
if fixTrailingSlash { |
|
||||
if path == "/" { |
|
||||
return ciPath |
|
||||
} |
|
||||
if len(path)+1 == npLen && n.path[len(path)] == '/' && |
|
||||
strings.EqualFold(path[1:], n.path[1:len(path)]) && n.handlers != nil { |
|
||||
return append(ciPath, n.path...) |
|
||||
} |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
type methodTree struct { |
|
||||
method string |
|
||||
root *node |
|
||||
} |
|
||||
|
|
||||
type methodTrees []methodTree |
|
||||
|
|
||||
func (trees methodTrees) get(method string) *node { |
|
||||
for _, tree := range trees { |
|
||||
if tree.method == method { |
|
||||
return tree.root |
|
||||
} |
|
||||
} |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
将数组中的字节向左移动 n 个字节 |
|
||||
*/ |
|
||||
func shiftNRuneBytes(rb [4]byte, n int) [4]byte { |
|
||||
switch n { |
|
||||
case 0: |
|
||||
return rb |
|
||||
case 1: |
|
||||
return [4]byte{rb[1], rb[2], rb[3], 0} |
|
||||
case 2: |
|
||||
return [4]byte{rb[2], rb[3]} |
|
||||
case 3: |
|
||||
return [4]byte{rb[3]} |
|
||||
default: |
|
||||
return [4]byte{} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func longestCommonPrefix(a, b string) int { |
|
||||
i := 0 |
|
||||
max := min(len(a), len(b)) |
|
||||
for i < max && a[i] == b[i] { |
|
||||
i++ |
|
||||
} |
|
||||
return i |
|
||||
} |
|
||||
|
|
||||
func findWildcard(path string) (wildcard string, i int, valid bool) { |
|
||||
// Find start
|
|
||||
for start, c := range []byte(path) { |
|
||||
// A wildcard starts with ':' (param) or '*' (catch-all)
|
|
||||
if c != ':' && c != '*' { |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
// Find end and check for invalid characters
|
|
||||
valid = true |
|
||||
for end, c := range []byte(path[start+1:]) { |
|
||||
switch c { |
|
||||
case '/': |
|
||||
return path[start : start+1+end], start, valid |
|
||||
case ':', '*': |
|
||||
valid = false |
|
||||
} |
|
||||
} |
|
||||
return path[start:], start, valid |
|
||||
} |
|
||||
return "", -1, false |
|
||||
} |
|
||||
|
|
||||
func countParams(path string) uint16 { |
|
||||
var n uint16 |
|
||||
s := utils.StringToBytes(path) |
|
||||
n += uint16(bytes.Count(s, strColon)) |
|
||||
n += uint16(bytes.Count(s, strStar)) |
|
||||
return n |
|
||||
} |
|
||||
|
|
||||
func countSections(path string) uint16 { |
|
||||
s := utils.StringToBytes(path) |
|
||||
return uint16(bytes.Count(s, strSlash)) |
|
||||
} |
|
||||
func min(a, b int) int { |
|
||||
if a <= b { |
|
||||
return a |
|
||||
} |
|
||||
return b |
|
||||
} |
|
||||
@ -1,201 +0,0 @@ |
|||||
package engine |
|
||||
|
|
||||
import ( |
|
||||
"net" |
|
||||
"path" |
|
||||
"reflect" |
|
||||
"runtime" |
|
||||
"strings" |
|
||||
"unicode" |
|
||||
) |
|
||||
|
|
||||
/* |
|
||||
解析一个 IP 的字符串表示并返回一个 net.IP |
|
||||
最小字节表示，如果输入无效，则为零。 |
|
||||
*/ |
|
||||
func parseIP(ip string) net.IP { |
|
||||
parsedIP := net.ParseIP(ip) |
|
||||
if ipv4 := parsedIP.To4(); ipv4 != nil { |
|
||||
return ipv4 |
|
||||
} |
|
||||
return parsedIP |
|
||||
} |
|
||||
|
|
||||
func lastChar(str string) uint8 { |
|
||||
if str == "" { |
|
||||
panic("The length of the string can't be 0") |
|
||||
} |
|
||||
return str[len(str)-1] |
|
||||
} |
|
||||
|
|
||||
func assert1(guard bool, text string) { |
|
||||
if !guard { |
|
||||
panic(text) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func nameOfFunction(f interface{}) string { |
|
||||
return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name() |
|
||||
} |
|
||||
|
|
||||
func joinPaths(absolutePath, relativePath string) string { |
|
||||
if relativePath == "" { |
|
||||
return absolutePath |
|
||||
} |
|
||||
|
|
||||
finalPath := path.Join(absolutePath, relativePath) |
|
||||
if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' { |
|
||||
return finalPath + "/" |
|
||||
} |
|
||||
return finalPath |
|
||||
} |
|
||||
|
|
||||
func iterate(path, method string, routes RoutesInfo, root *node) RoutesInfo { |
|
||||
path += root.path |
|
||||
if len(root.handlers) > 0 { |
|
||||
handlerFunc := root.handlers.Last() |
|
||||
routes = append(routes, RouteInfo{ |
|
||||
Method: method, |
|
||||
Path: path, |
|
||||
Handler: nameOfFunction(handlerFunc), |
|
||||
HandlerFunc: handlerFunc, |
|
||||
}) |
|
||||
} |
|
||||
for _, child := range root.children { |
|
||||
routes = iterate(path, method, routes, child) |
|
||||
} |
|
||||
return routes |
|
||||
} |
|
||||
func filterFlags(content string) string { |
|
||||
for i, char := range content { |
|
||||
if char == ' ' || char == ';' { |
|
||||
return content[:i] |
|
||||
} |
|
||||
} |
|
||||
return content |
|
||||
} |
|
||||
|
|
||||
func cleanPath(p string) string { |
|
||||
const stackBufSize = 128 |
|
||||
if p == "" { |
|
||||
return "/" |
|
||||
} |
|
||||
buf := make([]byte, 0, stackBufSize) |
|
||||
n := len(p) |
|
||||
r := 1 |
|
||||
w := 1 |
|
||||
if p[0] != '/' { |
|
||||
r = 0 |
|
||||
if n+1 > stackBufSize { |
|
||||
buf = make([]byte, n+1) |
|
||||
} else { |
|
||||
buf = buf[:n+1] |
|
||||
} |
|
||||
buf[0] = '/' |
|
||||
} |
|
||||
|
|
||||
trailing := n > 1 && p[n-1] == '/' |
|
||||
|
|
||||
for r < n { |
|
||||
switch { |
|
||||
case p[r] == '/': |
|
||||
r++ |
|
||||
case p[r] == '.' && r+1 == n: |
|
||||
trailing = true |
|
||||
r++ |
|
||||
case p[r] == '.' && p[r+1] == '/': |
|
||||
r += 2 |
|
||||
|
|
||||
case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'): |
|
||||
r += 3 |
|
||||
if w > 1 { |
|
||||
w-- |
|
||||
if len(buf) == 0 { |
|
||||
for w > 1 && p[w] != '/' { |
|
||||
w-- |
|
||||
} |
|
||||
} else { |
|
||||
for w > 1 && buf[w] != '/' { |
|
||||
w-- |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
default: |
|
||||
if w > 1 { |
|
||||
bufApp(&buf, p, w, '/') |
|
||||
w++ |
|
||||
} |
|
||||
for r < n && p[r] != '/' { |
|
||||
bufApp(&buf, p, w, p[r]) |
|
||||
w++ |
|
||||
r++ |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
if trailing && w > 1 { |
|
||||
bufApp(&buf, p, w, '/') |
|
||||
w++ |
|
||||
} |
|
||||
if len(buf) == 0 { |
|
||||
return p[:w] |
|
||||
} |
|
||||
return string(buf[:w]) |
|
||||
} |
|
||||
|
|
||||
func bufApp(buf *[]byte, s string, w int, c byte) { |
|
||||
b := *buf |
|
||||
if len(b) == 0 { |
|
||||
// No modification of the original string so far.
|
|
||||
// If the next character is the same as in the original string, we do
|
|
||||
// not yet have to allocate a buffer.
|
|
||||
if s[w] == c { |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// Otherwise use either the stack buffer, if it is large enough, or
|
|
||||
// allocate a new buffer on the heap, and copy all previous characters.
|
|
||||
length := len(s) |
|
||||
if length > cap(b) { |
|
||||
*buf = make([]byte, length) |
|
||||
} else { |
|
||||
*buf = (*buf)[:length] |
|
||||
} |
|
||||
b = *buf |
|
||||
|
|
||||
copy(b, s[:w]) |
|
||||
} |
|
||||
b[w] = c |
|
||||
} |
|
||||
|
|
||||
func parseAccept(acceptHeader string) []string { |
|
||||
parts := strings.Split(acceptHeader, ",") |
|
||||
out := make([]string, 0, len(parts)) |
|
||||
for _, part := range parts { |
|
||||
if i := strings.IndexByte(part, ';'); i > 0 { |
|
||||
part = part[:i] |
|
||||
} |
|
||||
if part = strings.TrimSpace(part); part != "" { |
|
||||
out = append(out, part) |
|
||||
} |
|
||||
} |
|
||||
return out |
|
||||
} |
|
||||
|
|
||||
func chooseData(custom, wildcard interface{}) interface{} { |
|
||||
if custom != nil { |
|
||||
return custom |
|
||||
} |
|
||||
if wildcard != nil { |
|
||||
return wildcard |
|
||||
} |
|
||||
panic("negotiation config is invalid") |
|
||||
} |
|
||||
|
|
||||
func isASCII(s string) bool { |
|
||||
for i := 0; i < len(s); i++ { |
|
||||
if s[i] > unicode.MaxASCII { |
|
||||
return false |
|
||||
} |
|
||||
} |
|
||||
return true |
|
||||
} |
|
||||
@ -1,171 +0,0 @@ |
|||||
package gin |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"errors" |
|
||||
"fmt" |
|
||||
"net" |
|
||||
"net/http" |
|
||||
|
|
||||
"yunyan/lego/sys/gin/engine" |
|
||||
"yunyan/lego/sys/gin/middleware/logger" |
|
||||
"yunyan/lego/sys/gin/middleware/recovery" |
|
||||
|
|
||||
"github.com/gin-gonic/autotls" |
|
||||
) |
|
||||
|
|
||||
func newSys(options *Options) (sys *Gin, err error) { |
|
||||
sys = &Gin{ |
|
||||
options: options, |
|
||||
} |
|
||||
sys.engine = engine.NewEngine(engine.SetLog(options.Log), engine.SetMultipartMemory(options.MultipartMemory)) |
|
||||
///添加基础中间件
|
|
||||
sys.engine.Use(logger.Logger([]string{}), recovery.Recovery()) |
|
||||
if options.CertFile != "" && options.KeyFile != "" { |
|
||||
sys.RunTLS(options.ListenPort, options.CertFile, options.KeyFile) |
|
||||
} else if options.LetEncrypt { |
|
||||
sys.RunLetEncrypt(options.Domain...) |
|
||||
} else { |
|
||||
sys.Run(options.ListenPort) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type Gin struct { |
|
||||
options *Options |
|
||||
server *http.Server |
|
||||
engine *engine.Engine |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) Run(listenPort int) (err error) { |
|
||||
// if this.engine.IsUnsafeTrustedProxies() {
|
|
||||
// this.Warnf("You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
|
|
||||
// "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.")
|
|
||||
|
|
||||
// }
|
|
||||
this.options.Log.Debugf("Listening and serving HTTP on:%d", listenPort) |
|
||||
this.server = &http.Server{ |
|
||||
Addr: fmt.Sprintf(":%d", listenPort), |
|
||||
Handler: this.engine.Handler(), |
|
||||
} |
|
||||
go func() { |
|
||||
if err := this.server.ListenAndServe(); err != nil && errors.Is(err, http.ErrServerClosed) { |
|
||||
this.options.Log.Errorln(err) |
|
||||
} |
|
||||
}() |
|
||||
// err = http.ListenAndServe(fmt.Sprintf(":%d", this.options.ListenPort), this.Handler())
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) RunTLS(listenPort int, certFile, keyFile string) (err error) { |
|
||||
this.options.Log.Debugf("Listening and serving HTTPS on :%d", listenPort) |
|
||||
// if this.engine.IsUnsafeTrustedProxies() {
|
|
||||
// this.Warnf("You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
|
|
||||
// "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.")
|
|
||||
// }
|
|
||||
this.server = &http.Server{ |
|
||||
Addr: fmt.Sprintf(":%d", listenPort), |
|
||||
Handler: this.engine.Handler(), |
|
||||
} |
|
||||
go func() { |
|
||||
if err := this.server.ListenAndServeTLS(certFile, keyFile); err != nil && errors.Is(err, http.ErrServerClosed) { |
|
||||
this.options.Log.Errorln(err) |
|
||||
} |
|
||||
}() |
|
||||
// err = http.ListenAndServeTLS(addr, certFile, keyFile, this.Handler())
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) RunLetEncrypt(domain ...string) { |
|
||||
this.options.Log.Debugf("Listening and serving LetEncrypt on :%v", domain) |
|
||||
go func() { |
|
||||
if err := autotls.Run(this.engine, domain...); err != nil { |
|
||||
this.options.Log.Errorln(err) |
|
||||
} |
|
||||
}() |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) RunListener(listener net.Listener) (err error) { |
|
||||
this.options.Log.Debugf("Listening and serving HTTP on listener what's bind with address@%s", listener.Addr()) |
|
||||
defer func() { |
|
||||
if err != nil { |
|
||||
this.options.Log.Errorln(err) |
|
||||
} |
|
||||
}() |
|
||||
// if this.engine.IsUnsafeTrustedProxies() {
|
|
||||
// this.Warnf("You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
|
|
||||
// "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.")
|
|
||||
|
|
||||
// }
|
|
||||
err = http.Serve(listener, this.engine.Handler()) |
|
||||
return |
|
||||
} |
|
||||
func (this *Gin) HandleContext(c *engine.Context) { |
|
||||
this.HandleContext(c) |
|
||||
} |
|
||||
func (this *Gin) LoadHTMLGlob(pattern string) { |
|
||||
this.engine.LoadHTMLGlob(pattern) |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) Close() (err error) { |
|
||||
if err = this.server.Shutdown(context.Background()); err != nil { |
|
||||
this.options.Log.Errorln(err) |
|
||||
} |
|
||||
this.server.Close() |
|
||||
return |
|
||||
} |
|
||||
func (this *Gin) Register(rcvr interface{}) { |
|
||||
this.engine.Register(rcvr) |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) NoRoute(handlers ...engine.HandlerFunc) { |
|
||||
this.engine.NoRoute(handlers...) |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) Group(relativePath string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.Group(relativePath, handlers...) |
|
||||
} |
|
||||
func (this *Gin) Use(handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.Use(handlers...) |
|
||||
} |
|
||||
func (this *Gin) Handle(httpMethod string, relativePath string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.Handle(httpMethod, relativePath, handlers...) |
|
||||
} |
|
||||
func (this *Gin) Any(relativePath string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.Any(relativePath, handlers...) |
|
||||
} |
|
||||
func (this *Gin) GET(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.GET(httpMethod, handlers...) |
|
||||
} |
|
||||
func (this *Gin) POST(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.POST(httpMethod, handlers...) |
|
||||
} |
|
||||
func (this *Gin) DELETE(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.DELETE(httpMethod, handlers...) |
|
||||
} |
|
||||
func (this *Gin) PATCH(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return defsys.PATCH(httpMethod, handlers...) |
|
||||
} |
|
||||
func (this *Gin) PUT(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.PUT(httpMethod, handlers...) |
|
||||
} |
|
||||
func (this *Gin) OPTIONS(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.OPTIONS(httpMethod, handlers...) |
|
||||
} |
|
||||
func (this *Gin) HEAD(httpMethod string, handlers ...engine.HandlerFunc) engine.IRoutes { |
|
||||
return this.engine.HEAD(httpMethod, handlers...) |
|
||||
} |
|
||||
func (this *Gin) StaticFile(relativePath string, filepath string) engine.IRoutes { |
|
||||
return this.engine.StaticFile(relativePath, filepath) |
|
||||
} |
|
||||
func (this *Gin) StaticFileFS(relativePath string, filepath string, fs http.FileSystem) engine.IRoutes { |
|
||||
return this.engine.StaticFileFS(relativePath, filepath, fs) |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) Static(relativePath string, root string) engine.IRoutes { |
|
||||
return this.engine.Static(relativePath, root) |
|
||||
} |
|
||||
|
|
||||
func (this *Gin) StaticFS(relativePath string, fs http.FileSystem) engine.IRoutes { |
|
||||
return this.engine.StaticFS(relativePath, fs) |
|
||||
} |
|
||||
@ -1,28 +0,0 @@ |
|||||
/* |
|
||||
解决跨域 中间件 |
|
||||
*/ |
|
||||
package cross |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
|
|
||||
"yunyan/lego/sys/gin/engine" |
|
||||
) |
|
||||
|
|
||||
func handlerCors() engine.HandlerFunc { |
|
||||
return func(c *engine.Context) { |
|
||||
method := c.Request.Method |
|
||||
origin := c.Request.Header.Get("Origin") //请求头部
|
|
||||
if origin != "" { |
|
||||
c.Header("Access-Control-Allow-Origin", origin) |
|
||||
c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE") |
|
||||
c.Header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type,X-Token, Accept, Authorization") |
|
||||
c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Cache-Control, Content-Language, Content-Type") |
|
||||
c.Header("Access-Control-Allow-Credentials", "true") |
|
||||
} //允许类型校验
|
|
||||
if method == "OPTIONS" { |
|
||||
c.AbortWithStatus(http.StatusNoContent) |
|
||||
} |
|
||||
c.Next() |
|
||||
} |
|
||||
} |
|
||||
@ -1,88 +0,0 @@ |
|||||
package jwt |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
"strings" |
|
||||
"time" |
|
||||
|
|
||||
"yunyan/lego/core" |
|
||||
"yunyan/lego/sys/gin/engine" |
|
||||
|
|
||||
"github.com/golang-jwt/jwt" |
|
||||
) |
|
||||
|
|
||||
func NewJWT(key, tokenKey string) *JWT { |
|
||||
return &JWT{ |
|
||||
jwtkey: []byte(key), |
|
||||
tokenKey: tokenKey, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
type JWT struct { |
|
||||
jwtkey []byte |
|
||||
tokenKey string |
|
||||
} |
|
||||
|
|
||||
// CreateToken 生成token
|
|
||||
func CreateToken(key, Id string) (string, error) { |
|
||||
expireTime := time.Now().Add(2 * time.Hour) //过期时间
|
|
||||
nowTime := time.Now() //当前时间
|
|
||||
claims := jwt.StandardClaims{ |
|
||||
Id: Id, //用户Id
|
|
||||
ExpiresAt: expireTime.Unix(), //过期时间戳
|
|
||||
IssuedAt: nowTime.Unix(), //当前时间戳
|
|
||||
Issuer: "blogLeo", //颁发者签名
|
|
||||
Subject: "userToken", //签名主题
|
|
||||
|
|
||||
} |
|
||||
tokenStruct := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) |
|
||||
return tokenStruct.SignedString([]byte(key)) |
|
||||
} |
|
||||
|
|
||||
// CheckToken 验证token
|
|
||||
func (this *JWT) CheckToken(token string) (*jwt.StandardClaims, bool) { |
|
||||
tokenObj, _ := jwt.ParseWithClaims(token, &jwt.StandardClaims{}, func(token *jwt.Token) (interface{}, error) { |
|
||||
return this.jwtkey, nil |
|
||||
}) |
|
||||
if key, _ := tokenObj.Claims.(*jwt.StandardClaims); tokenObj.Valid { |
|
||||
return key, true |
|
||||
} else { |
|
||||
return key, false |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// JwtMiddleware jwt中间件
|
|
||||
func (this *JWT) JwtMiddleware() engine.HandlerFunc { |
|
||||
return func(c *engine.Context) { |
|
||||
//从请求头中获取token
|
|
||||
tokenStr := c.Request.Header.Get(this.tokenKey) |
|
||||
//用户不存在
|
|
||||
if tokenStr == "" { |
|
||||
c.JSON(http.StatusOK, engine.H{"code": core.ErrorCode_NoLogin, "msg": "用户不存在"}) |
|
||||
c.Abort() //阻止执行
|
|
||||
return |
|
||||
} |
|
||||
//token格式错误
|
|
||||
tokenSlice := strings.Split(tokenStr, ".") |
|
||||
if len(tokenSlice) != 3 { |
|
||||
c.JSON(http.StatusOK, engine.H{"code": core.ErrorCode_NoLogin, "msg": "token格式错误"}) |
|
||||
c.Abort() //阻止执行
|
|
||||
return |
|
||||
} |
|
||||
//验证token
|
|
||||
tokenStruck, ok := this.CheckToken(tokenStr) |
|
||||
if !ok { |
|
||||
c.JSON(http.StatusOK, engine.H{"code": core.ErrorCode_NoLogin, "msg": "token不正确"}) |
|
||||
c.Abort() //阻止执行
|
|
||||
return |
|
||||
} |
|
||||
//token超时
|
|
||||
if time.Now().Unix() > tokenStruck.ExpiresAt { |
|
||||
c.JSON(http.StatusOK, engine.H{"code": core.ErrorCode_NoLogin, "msg": "token过期"}) |
|
||||
c.Abort() //阻止执行
|
|
||||
return |
|
||||
} |
|
||||
c.SetUserId(tokenStruck.Id) |
|
||||
c.Next() |
|
||||
} |
|
||||
} |
|
||||
@ -1,24 +0,0 @@ |
|||||
package jwt |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"testing" |
|
||||
|
|
||||
"github.com/golang-jwt/jwt" |
|
||||
) |
|
||||
|
|
||||
func Test_ParamSign(t *testing.T) { |
|
||||
if token, err := CreateToken("mysces", "liwei1dao"); err != nil { |
|
||||
fmt.Printf("err:%v", err) |
|
||||
return |
|
||||
} else { |
|
||||
tokenObj, _ := jwt.ParseWithClaims(token, &jwt.StandardClaims{}, func(token *jwt.Token) (interface{}, error) { |
|
||||
return []byte("mysces"), nil |
|
||||
}) |
|
||||
if key, ok := tokenObj.Claims.(*jwt.StandardClaims); ok && tokenObj.Valid { |
|
||||
fmt.Printf("key:%v", key) |
|
||||
} else { |
|
||||
fmt.Printf("void") |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,85 +0,0 @@ |
|||||
package logger |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"net/http" |
|
||||
"time" |
|
||||
|
|
||||
"yunyan/lego/sys/gin/engine" |
|
||||
) |
|
||||
|
|
||||
type LogFormatterParams struct { |
|
||||
Request *http.Request |
|
||||
// TimeStamp shows the time after the server returns a response.
|
|
||||
TimeStamp time.Time |
|
||||
// StatusCode is HTTP response code.
|
|
||||
StatusCode int |
|
||||
// Latency is how much time the server cost to process a certain request.
|
|
||||
Latency time.Duration |
|
||||
// ClientIP equals Context's ClientIP method.
|
|
||||
ClientIP string |
|
||||
// Method is the HTTP method given to the request.
|
|
||||
Method string |
|
||||
// Path is a path the client requests.
|
|
||||
Path string |
|
||||
// ErrorMessage is set if error has occurred in processing the request.
|
|
||||
ErrorMessage string |
|
||||
// isTerm shows whether gin's output descriptor refers to a terminal.
|
|
||||
isTerm bool |
|
||||
// BodySize is the size of the Response Body
|
|
||||
BodySize int |
|
||||
// Keys are the keys set on the request's context.
|
|
||||
Keys map[string]interface{} |
|
||||
} |
|
||||
|
|
||||
func Logger(SkipPaths []string) engine.HandlerFunc { |
|
||||
var skip map[string]struct{} |
|
||||
if length := len(SkipPaths); length > 0 { |
|
||||
skip = make(map[string]struct{}, length) |
|
||||
|
|
||||
for _, path := range SkipPaths { |
|
||||
skip[path] = struct{}{} |
|
||||
} |
|
||||
} |
|
||||
return func(c *engine.Context) { |
|
||||
// Start timer
|
|
||||
start := time.Now() |
|
||||
path := c.Request.URL.Path |
|
||||
raw := c.Request.URL.RawQuery |
|
||||
|
|
||||
// Process request
|
|
||||
c.Next() |
|
||||
|
|
||||
// Log only when path is not being skipped
|
|
||||
if _, ok := skip[path]; !ok { |
|
||||
param := LogFormatterParams{ |
|
||||
Request: c.Request, |
|
||||
Keys: c.Keys, |
|
||||
} |
|
||||
// Stop timer
|
|
||||
param.TimeStamp = time.Now() |
|
||||
param.Latency = param.TimeStamp.Sub(start) |
|
||||
|
|
||||
param.ClientIP = c.ClientIP() |
|
||||
param.Method = c.Request.Method |
|
||||
param.StatusCode = c.Writer.Status() |
|
||||
param.ErrorMessage = c.Errors.ByType(engine.ErrorTypePrivate).String() |
|
||||
|
|
||||
param.BodySize = c.Writer.Size() |
|
||||
|
|
||||
if raw != "" { |
|
||||
path = path + "?" + raw |
|
||||
} |
|
||||
param.Path = path |
|
||||
c.Log.Debugf(fmt.Sprintf("[FORMATTER TEST] %v | %3d | %13v | %15s | %-7s %s\n%s", |
|
||||
param.TimeStamp.Format("2006/01/02 - 15:04:05"), |
|
||||
param.StatusCode, |
|
||||
param.Latency, |
|
||||
param.ClientIP, |
|
||||
param.Method, |
|
||||
param.Path, |
|
||||
param.ErrorMessage, |
|
||||
)) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,159 +0,0 @@ |
|||||
package recovery |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"errors" |
|
||||
"fmt" |
|
||||
"io/ioutil" |
|
||||
"net" |
|
||||
"net/http" |
|
||||
"net/http/httputil" |
|
||||
"os" |
|
||||
"runtime" |
|
||||
"strings" |
|
||||
"time" |
|
||||
|
|
||||
"yunyan/lego/sys/gin/engine" |
|
||||
) |
|
||||
|
|
||||
const ( |
|
||||
green = "\033[97;42m" |
|
||||
white = "\033[90;47m" |
|
||||
yellow = "\033[90;43m" |
|
||||
red = "\033[97;41m" |
|
||||
blue = "\033[97;44m" |
|
||||
magenta = "\033[97;45m" |
|
||||
cyan = "\033[97;46m" |
|
||||
reset = "\033[0m" |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
dunno = []byte("???") |
|
||||
centerDot = []byte("·") |
|
||||
dot = []byte(".") |
|
||||
slash = []byte("/") |
|
||||
) |
|
||||
|
|
||||
// RecoveryFunc defines the function passable to CustomRecovery.
|
|
||||
type RecoveryFunc func(c *engine.Context, err interface{}) |
|
||||
|
|
||||
func Recovery() engine.HandlerFunc { |
|
||||
return CustomRecoveryWithWriter(defaultHandleRecovery) |
|
||||
} |
|
||||
|
|
||||
func defaultHandleRecovery(c *engine.Context, err interface{}) { |
|
||||
c.AbortWithStatus(http.StatusInternalServerError) |
|
||||
} |
|
||||
|
|
||||
// CustomRecoveryWithWriter returns a middleware for a given writer that recovers from any panics and calls the provided handle func to handle it.
|
|
||||
func CustomRecoveryWithWriter(handle RecoveryFunc) engine.HandlerFunc { |
|
||||
return func(c *engine.Context) { |
|
||||
defer func() { |
|
||||
if err := recover(); err != nil { |
|
||||
// Check for a broken connection, as it is not really a
|
|
||||
// condition that warrants a panic stack trace.
|
|
||||
var brokenPipe bool |
|
||||
if ne, ok := err.(*net.OpError); ok { |
|
||||
var se *os.SyscallError |
|
||||
if errors.As(ne, &se) { |
|
||||
if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") { |
|
||||
brokenPipe = true |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
stack := stack(3) |
|
||||
httpRequest, _ := httputil.DumpRequest(c.Request, false) |
|
||||
headers := strings.Split(string(httpRequest), "\r\n") |
|
||||
for idx, header := range headers { |
|
||||
current := strings.Split(header, ":") |
|
||||
if current[0] == "Authorization" { |
|
||||
headers[idx] = current[0] + ": *" |
|
||||
} |
|
||||
} |
|
||||
headersToStr := strings.Join(headers, "\r\n") |
|
||||
if brokenPipe { |
|
||||
c.Log.Errorf("%s\n%s%s", err, headersToStr, reset) |
|
||||
} else { |
|
||||
c.Log.Errorf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s", |
|
||||
timeFormat(time.Now()), headersToStr, err, stack, reset) |
|
||||
} |
|
||||
|
|
||||
if brokenPipe { |
|
||||
// If the connection is dead, we can't write a status to it.
|
|
||||
c.Error(err.(error)) // nolint: errcheck
|
|
||||
c.Abort() |
|
||||
} else { |
|
||||
handle(c, err) |
|
||||
} |
|
||||
} |
|
||||
}() |
|
||||
c.Next() |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// stack returns a nicely formatted stack frame, skipping skip frames.
|
|
||||
func stack(skip int) []byte { |
|
||||
buf := new(bytes.Buffer) // the returned data
|
|
||||
// As we loop, we open files and read them. These variables record the currently
|
|
||||
// loaded file.
|
|
||||
var lines [][]byte |
|
||||
var lastFile string |
|
||||
for i := skip; ; i++ { // Skip the expected number of frames
|
|
||||
pc, file, line, ok := runtime.Caller(i) |
|
||||
if !ok { |
|
||||
break |
|
||||
} |
|
||||
// Print this much at least. If we can't find the source, it won't show.
|
|
||||
fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc) |
|
||||
if file != lastFile { |
|
||||
data, err := ioutil.ReadFile(file) |
|
||||
if err != nil { |
|
||||
continue |
|
||||
} |
|
||||
lines = bytes.Split(data, []byte{'\n'}) |
|
||||
lastFile = file |
|
||||
} |
|
||||
fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line)) |
|
||||
} |
|
||||
return buf.Bytes() |
|
||||
} |
|
||||
|
|
||||
// source returns a space-trimmed slice of the n'th line.
|
|
||||
func source(lines [][]byte, n int) []byte { |
|
||||
n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
|
|
||||
if n < 0 || n >= len(lines) { |
|
||||
return dunno |
|
||||
} |
|
||||
return bytes.TrimSpace(lines[n]) |
|
||||
} |
|
||||
|
|
||||
// function returns, if possible, the name of the function containing the PC.
|
|
||||
func function(pc uintptr) []byte { |
|
||||
fn := runtime.FuncForPC(pc) |
|
||||
if fn == nil { |
|
||||
return dunno |
|
||||
} |
|
||||
name := []byte(fn.Name()) |
|
||||
// The name includes the path name to the package, which is unnecessary
|
|
||||
// since the file name is already included. Plus, it has center dots.
|
|
||||
// That is, we see
|
|
||||
// runtime/debug.*T·ptrmethod
|
|
||||
// and want
|
|
||||
// *T.ptrmethod
|
|
||||
// Also the package path might contain dot (e.g. code.google.com/...),
|
|
||||
// so first eliminate the path prefix
|
|
||||
if lastSlash := bytes.LastIndex(name, slash); lastSlash >= 0 { |
|
||||
name = name[lastSlash+1:] |
|
||||
} |
|
||||
if period := bytes.Index(name, dot); period >= 0 { |
|
||||
name = name[period+1:] |
|
||||
} |
|
||||
name = bytes.Replace(name, centerDot, dot, -1) |
|
||||
return name |
|
||||
} |
|
||||
|
|
||||
// timeFormat returns a customized time string for logger.
|
|
||||
func timeFormat(t time.Time) string { |
|
||||
return t.Format("2006/01/02 - 15:04:05") |
|
||||
} |
|
||||
@ -1,101 +0,0 @@ |
|||||
package gin |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
ListenPort int //监听端口
|
|
||||
CertFile string //tls文件
|
|
||||
KeyFile string //tls文件
|
|
||||
LetEncrypt bool //Let's Encrypt 证书模式
|
|
||||
Domain []string //域名
|
|
||||
MultipartMemory int64 //文件上传最大尺寸
|
|
||||
Debug bool //日志是否开启
|
|
||||
Log log.ILogger |
|
||||
} |
|
||||
|
|
||||
func SetListenPort(v int) Option { |
|
||||
return func(o *Options) { |
|
||||
o.ListenPort = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetCertFile(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.CertFile = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetKeyFile(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.KeyFile = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetLetEncrypt(v bool) Option { |
|
||||
return func(o *Options) { |
|
||||
o.LetEncrypt = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetDomain(v []string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Domain = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetMultipartMemory(v int64) Option { |
|
||||
return func(o *Options) { |
|
||||
o.MultipartMemory = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetDebug(v bool) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Debug = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetLog(v log.ILogger) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Log = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) (options *Options, err error) { |
|
||||
options = &Options{ |
|
||||
ListenPort: 8080, |
|
||||
CertFile: "", |
|
||||
KeyFile: "", |
|
||||
Debug: true, |
|
||||
} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.gin", 3)) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) (options *Options, err error) { |
|
||||
options = &Options{ |
|
||||
ListenPort: 8080, |
|
||||
CertFile: "", |
|
||||
KeyFile: "", |
|
||||
Debug: false, |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.gin", 3)) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,21 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import "net/http" |
|
||||
|
|
||||
// Data contains ContentType and bytes data.
|
|
||||
type Data struct { |
|
||||
ContentType string |
|
||||
Data []byte |
|
||||
} |
|
||||
|
|
||||
// Render (Data) writes data with custom ContentType.
|
|
||||
func (r Data) Render(w http.ResponseWriter) (err error) { |
|
||||
r.WriteContentType(w) |
|
||||
_, err = w.Write(r.Data) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (Data) writes custom ContentType.
|
|
||||
func (r Data) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, []string{r.ContentType}) |
|
||||
} |
|
||||
@ -1,84 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"html/template" |
|
||||
"net/http" |
|
||||
) |
|
||||
|
|
||||
var htmlContentType = []string{"text/html; charset=utf-8"} |
|
||||
|
|
||||
/* |
|
||||
Delims 表示一组用于 HTML 模板渲染的左右分隔符。 |
|
||||
*/ |
|
||||
type Delims struct { |
|
||||
// Left delimiter, defaults to {{.
|
|
||||
Left string |
|
||||
// Right delimiter, defaults to }}.
|
|
||||
Right string |
|
||||
} |
|
||||
|
|
||||
/* |
|
||||
包含模板引用及其分隔符 |
|
||||
*/ |
|
||||
type HTMLRender interface { |
|
||||
Instance(string, interface{}) Render |
|
||||
} |
|
||||
type HTMLProduction struct { |
|
||||
Template *template.Template |
|
||||
Delims Delims |
|
||||
} |
|
||||
|
|
||||
func (r HTMLProduction) Instance(name string, data interface{}) Render { |
|
||||
return HTML{ |
|
||||
Template: r.Template, |
|
||||
Name: name, |
|
||||
Data: data, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
type HTMLDebug struct { |
|
||||
Files []string |
|
||||
Glob string |
|
||||
Delims Delims |
|
||||
FuncMap template.FuncMap |
|
||||
} |
|
||||
|
|
||||
// 返回一个实现Render接口的HTML实例。
|
|
||||
func (r HTMLDebug) Instance(name string, data interface{}) Render { |
|
||||
return HTML{ |
|
||||
Template: r.loadTemplate(), |
|
||||
Name: name, |
|
||||
Data: data, |
|
||||
} |
|
||||
} |
|
||||
func (r HTMLDebug) loadTemplate() *template.Template { |
|
||||
if r.FuncMap == nil { |
|
||||
r.FuncMap = template.FuncMap{} |
|
||||
} |
|
||||
if len(r.Files) > 0 { |
|
||||
return template.Must(template.New("").Delims(r.Delims.Left, r.Delims.Right).Funcs(r.FuncMap).ParseFiles(r.Files...)) |
|
||||
} |
|
||||
if r.Glob != "" { |
|
||||
return template.Must(template.New("").Delims(r.Delims.Left, r.Delims.Right).Funcs(r.FuncMap).ParseGlob(r.Glob)) |
|
||||
} |
|
||||
panic("the HTML debug render was created without files or glob pattern") |
|
||||
} |
|
||||
|
|
||||
type HTML struct { |
|
||||
Template *template.Template |
|
||||
Name string |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
func (r HTML) Render(w http.ResponseWriter) error { |
|
||||
r.WriteContentType(w) |
|
||||
|
|
||||
if r.Name == "" { |
|
||||
return r.Template.Execute(w, r.Data) |
|
||||
} |
|
||||
return r.Template.ExecuteTemplate(w, r.Name, r.Data) |
|
||||
} |
|
||||
|
|
||||
func (r HTML) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, htmlContentType) |
|
||||
} |
|
||||
@ -1,190 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"fmt" |
|
||||
"html/template" |
|
||||
"net/http" |
|
||||
|
|
||||
json "github.com/json-iterator/go" |
|
||||
|
|
||||
"yunyan/lego/utils" |
|
||||
) |
|
||||
|
|
||||
// JSON contains the given interface object.
|
|
||||
type JSON struct { |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
// IndentedJSON contains the given interface object.
|
|
||||
type IndentedJSON struct { |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
// SecureJSON contains the given interface object and its prefix.
|
|
||||
type SecureJSON struct { |
|
||||
Prefix string |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
// JsonpJSON contains the given interface object its callback.
|
|
||||
type JsonpJSON struct { |
|
||||
Callback string |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
// AsciiJSON contains the given interface object.
|
|
||||
type AsciiJSON struct { |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
// PureJSON contains the given interface object.
|
|
||||
type PureJSON struct { |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
var ( |
|
||||
jsonContentType = []string{"application/json; charset=utf-8"} |
|
||||
jsonpContentType = []string{"application/javascript; charset=utf-8"} |
|
||||
jsonASCIIContentType = []string{"application/json"} |
|
||||
) |
|
||||
|
|
||||
// Render (JSON) writes data with custom ContentType.
|
|
||||
func (r JSON) Render(w http.ResponseWriter) (err error) { |
|
||||
if err = WriteJSON(w, r.Data); err != nil { |
|
||||
panic(err) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (JSON) writes JSON ContentType.
|
|
||||
func (r JSON) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, jsonContentType) |
|
||||
} |
|
||||
|
|
||||
// WriteJSON marshals the given interface object and writes it with custom ContentType.
|
|
||||
func WriteJSON(w http.ResponseWriter, obj interface{}) error { |
|
||||
writeContentType(w, jsonContentType) |
|
||||
jsonBytes, err := json.Marshal(obj) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
_, err = w.Write(jsonBytes) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
// Render (IndentedJSON) marshals the given interface object and writes it with custom ContentType.
|
|
||||
func (r IndentedJSON) Render(w http.ResponseWriter) error { |
|
||||
r.WriteContentType(w) |
|
||||
jsonBytes, err := json.MarshalIndent(r.Data, "", " ") |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
_, err = w.Write(jsonBytes) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (IndentedJSON) writes JSON ContentType.
|
|
||||
func (r IndentedJSON) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, jsonContentType) |
|
||||
} |
|
||||
|
|
||||
// Render (SecureJSON) marshals the given interface object and writes it with custom ContentType.
|
|
||||
func (r SecureJSON) Render(w http.ResponseWriter) error { |
|
||||
r.WriteContentType(w) |
|
||||
jsonBytes, err := json.Marshal(r.Data) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
// if the jsonBytes is array values
|
|
||||
if bytes.HasPrefix(jsonBytes, utils.StringToBytes("[")) && bytes.HasSuffix(jsonBytes, |
|
||||
utils.StringToBytes("]")) { |
|
||||
if _, err = w.Write(utils.StringToBytes(r.Prefix)); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
} |
|
||||
_, err = w.Write(jsonBytes) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (SecureJSON) writes JSON ContentType.
|
|
||||
func (r SecureJSON) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, jsonContentType) |
|
||||
} |
|
||||
|
|
||||
// Render (JsonpJSON) marshals the given interface object and writes it and its callback with custom ContentType.
|
|
||||
func (r JsonpJSON) Render(w http.ResponseWriter) (err error) { |
|
||||
r.WriteContentType(w) |
|
||||
ret, err := json.Marshal(r.Data) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
if r.Callback == "" { |
|
||||
_, err = w.Write(ret) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
callback := template.JSEscapeString(r.Callback) |
|
||||
if _, err = w.Write(utils.StringToBytes(callback)); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
if _, err = w.Write(utils.StringToBytes("(")); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
if _, err = w.Write(ret); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
if _, err = w.Write(utils.StringToBytes(");")); err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (JsonpJSON) writes Javascript ContentType.
|
|
||||
func (r JsonpJSON) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, jsonpContentType) |
|
||||
} |
|
||||
|
|
||||
// Render (AsciiJSON) marshals the given interface object and writes it with custom ContentType.
|
|
||||
func (r AsciiJSON) Render(w http.ResponseWriter) (err error) { |
|
||||
r.WriteContentType(w) |
|
||||
ret, err := json.Marshal(r.Data) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
var buffer bytes.Buffer |
|
||||
for _, r := range utils.BytesToString(ret) { |
|
||||
cvt := string(r) |
|
||||
if r >= 128 { |
|
||||
cvt = fmt.Sprintf("\\u%04x", int64(r)) |
|
||||
} |
|
||||
buffer.WriteString(cvt) |
|
||||
} |
|
||||
|
|
||||
_, err = w.Write(buffer.Bytes()) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (AsciiJSON) writes JSON ContentType.
|
|
||||
func (r AsciiJSON) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, jsonASCIIContentType) |
|
||||
} |
|
||||
|
|
||||
// Render (PureJSON) writes custom ContentType and encodes the given interface object.
|
|
||||
func (r PureJSON) Render(w http.ResponseWriter) error { |
|
||||
r.WriteContentType(w) |
|
||||
encoder := json.NewEncoder(w) |
|
||||
encoder.SetEscapeHTML(false) |
|
||||
return encoder.Encode(r.Data) |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (PureJSON) writes custom ContentType.
|
|
||||
func (r PureJSON) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, jsonContentType) |
|
||||
} |
|
||||
@ -1,32 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
|
|
||||
"google.golang.org/protobuf/proto" |
|
||||
) |
|
||||
|
|
||||
// ProtoBuf contains the given interface object.
|
|
||||
type ProtoBuf struct { |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
var protobufContentType = []string{"application/x-protobuf"} |
|
||||
|
|
||||
// Render (ProtoBuf) marshals the given interface object and writes data with custom ContentType.
|
|
||||
func (r ProtoBuf) Render(w http.ResponseWriter) error { |
|
||||
r.WriteContentType(w) |
|
||||
|
|
||||
bytes, err := proto.Marshal(r.Data.(proto.Message)) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
_, err = w.Write(bytes) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (ProtoBuf) writes ProtoBuf ContentType.
|
|
||||
func (r ProtoBuf) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, protobufContentType) |
|
||||
} |
|
||||
@ -1,44 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"io" |
|
||||
"net/http" |
|
||||
"strconv" |
|
||||
) |
|
||||
|
|
||||
// Reader contains the IO reader and its length, and custom ContentType and other headers.
|
|
||||
type Reader struct { |
|
||||
ContentType string |
|
||||
ContentLength int64 |
|
||||
Reader io.Reader |
|
||||
Headers map[string]string |
|
||||
} |
|
||||
|
|
||||
// Render (Reader) writes data with custom ContentType and headers.
|
|
||||
func (r Reader) Render(w http.ResponseWriter) (err error) { |
|
||||
r.WriteContentType(w) |
|
||||
if r.ContentLength >= 0 { |
|
||||
if r.Headers == nil { |
|
||||
r.Headers = map[string]string{} |
|
||||
} |
|
||||
r.Headers["Content-Length"] = strconv.FormatInt(r.ContentLength, 10) |
|
||||
} |
|
||||
r.writeHeaders(w, r.Headers) |
|
||||
_, err = io.Copy(w, r.Reader) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (Reader) writes custom ContentType.
|
|
||||
func (r Reader) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, []string{r.ContentType}) |
|
||||
} |
|
||||
|
|
||||
// writeHeaders writes custom Header.
|
|
||||
func (r Reader) writeHeaders(w http.ResponseWriter, headers map[string]string) { |
|
||||
header := w.Header() |
|
||||
for k, v := range headers { |
|
||||
if header.Get(k) == "" { |
|
||||
header.Set(k, v) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,25 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"net/http" |
|
||||
) |
|
||||
|
|
||||
// Redirect contains the http request reference and redirects status code and location.
|
|
||||
type Redirect struct { |
|
||||
Code int |
|
||||
Request *http.Request |
|
||||
Location string |
|
||||
} |
|
||||
|
|
||||
// Render (Redirect) redirects the http request to new location and writes redirect response.
|
|
||||
func (r Redirect) Render(w http.ResponseWriter) error { |
|
||||
if (r.Code < http.StatusMultipleChoices || r.Code > http.StatusPermanentRedirect) && r.Code != http.StatusCreated { |
|
||||
panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code)) |
|
||||
} |
|
||||
http.Redirect(w, r.Request, r.Location, r.Code) |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (Redirect) don't write any ContentType.
|
|
||||
func (r Redirect) WriteContentType(http.ResponseWriter) {} |
|
||||
@ -1,19 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
) |
|
||||
|
|
||||
type Render interface { |
|
||||
// Render 使用自定义 ContentType 写入数据。
|
|
||||
Render(http.ResponseWriter) error |
|
||||
// WriteContentType 写入自定义 ContentType。
|
|
||||
WriteContentType(w http.ResponseWriter) |
|
||||
} |
|
||||
|
|
||||
func writeContentType(w http.ResponseWriter, value []string) { |
|
||||
header := w.Header() |
|
||||
if val := header["Content-Type"]; len(val) == 0 { |
|
||||
header["Content-Type"] = value |
|
||||
} |
|
||||
} |
|
||||
@ -1,37 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"net/http" |
|
||||
|
|
||||
"yunyan/lego/utils" |
|
||||
) |
|
||||
|
|
||||
// String contains the given interface object slice and its format.
|
|
||||
type String struct { |
|
||||
Format string |
|
||||
Data []interface{} |
|
||||
} |
|
||||
|
|
||||
var plainContentType = []string{"text/plain; charset=utf-8"} |
|
||||
|
|
||||
// Render (String) writes data with custom ContentType.
|
|
||||
func (r String) Render(w http.ResponseWriter) error { |
|
||||
return WriteString(w, r.Format, r.Data) |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (String) writes Plain ContentType.
|
|
||||
func (r String) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, plainContentType) |
|
||||
} |
|
||||
|
|
||||
// WriteString writes data according to its format and write custom ContentType.
|
|
||||
func WriteString(w http.ResponseWriter, format string, data []interface{}) (err error) { |
|
||||
writeContentType(w, plainContentType) |
|
||||
if len(data) > 0 { |
|
||||
_, err = fmt.Fprintf(w, format, data...) |
|
||||
return |
|
||||
} |
|
||||
_, err = w.Write(utils.StringToBytes(format)) |
|
||||
return |
|
||||
} |
|
||||
@ -1,24 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"encoding/xml" |
|
||||
"net/http" |
|
||||
) |
|
||||
|
|
||||
// XML contains the given interface object.
|
|
||||
type XML struct { |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
var xmlContentType = []string{"application/xml; charset=utf-8"} |
|
||||
|
|
||||
// Render (XML) encodes the given interface object and writes data with custom ContentType.
|
|
||||
func (r XML) Render(w http.ResponseWriter) error { |
|
||||
r.WriteContentType(w) |
|
||||
return xml.NewEncoder(w).Encode(r.Data) |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (XML) writes XML ContentType for response.
|
|
||||
func (r XML) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, xmlContentType) |
|
||||
} |
|
||||
@ -1,32 +0,0 @@ |
|||||
package render |
|
||||
|
|
||||
import ( |
|
||||
"net/http" |
|
||||
|
|
||||
"gopkg.in/yaml.v2" |
|
||||
) |
|
||||
|
|
||||
// YAML contains the given interface object.
|
|
||||
type YAML struct { |
|
||||
Data interface{} |
|
||||
} |
|
||||
|
|
||||
var yamlContentType = []string{"application/x-yaml; charset=utf-8"} |
|
||||
|
|
||||
// Render (YAML) marshals the given interface object and writes data with custom ContentType.
|
|
||||
func (r YAML) Render(w http.ResponseWriter) error { |
|
||||
r.WriteContentType(w) |
|
||||
|
|
||||
bytes, err := yaml.Marshal(r.Data) |
|
||||
if err != nil { |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
_, err = w.Write(bytes) |
|
||||
return err |
|
||||
} |
|
||||
|
|
||||
// WriteContentType (YAML) writes YAML ContentType for response.
|
|
||||
func (r YAML) WriteContentType(w http.ResponseWriter) { |
|
||||
writeContentType(w, yamlContentType) |
|
||||
} |
|
||||
@ -1,52 +0,0 @@ |
|||||
package gin_test |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"net/http" |
|
||||
"os" |
|
||||
"os/signal" |
|
||||
"syscall" |
|
||||
"testing" |
|
||||
|
|
||||
"yunyan/lego/sys/gin" |
|
||||
"yunyan/lego/sys/gin/engine" |
|
||||
"yunyan/lego/sys/log" |
|
||||
) |
|
||||
|
|
||||
func Test_sys(t *testing.T) { |
|
||||
if err := log.OnInit(nil, |
|
||||
log.SetFileName("log.log"), |
|
||||
log.SetIsDebug(false), |
|
||||
log.SetEncoder(log.TextEncoder), |
|
||||
); err != nil { |
|
||||
fmt.Printf("log init err:%v", err) |
|
||||
return |
|
||||
} |
|
||||
if sys, err := gin.NewSys(); err != nil { |
|
||||
fmt.Printf("gin init err:%v", err) |
|
||||
} else { |
|
||||
sys.GET("/test", func(c *engine.Context) { |
|
||||
c.JSON(http.StatusOK, "hello") |
|
||||
}) |
|
||||
} |
|
||||
|
|
||||
//监听外部关闭服务信号
|
|
||||
c := make(chan os.Signal, 1) |
|
||||
//添加进程结束信号
|
|
||||
signal.Notify(c, |
|
||||
os.Interrupt, //退出信号 ctrl+c退出
|
|
||||
syscall.SIGHUP, //终端控制进程结束(终端连接断开)
|
|
||||
syscall.SIGINT, //用户发送INTR字符(Ctrl+C)触发
|
|
||||
syscall.SIGTERM, //结束程序(可以被捕获、阻塞或忽略)
|
|
||||
syscall.SIGQUIT) //用户发送QUIT字符(Ctrl+/)触发
|
|
||||
select { |
|
||||
case sig := <-c: |
|
||||
fmt.Println("关闭 signal\n", sig) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// /测试签名
|
|
||||
func Test_ParamSign(t *testing.T) { |
|
||||
origin, sgin := gin.ParamSign("@234%67g12q4*67m12#4l67!", map[string]interface{}{"images": []string{"测试资源.png", "11.jpg"}}) |
|
||||
fmt.Println(origin, sgin) |
|
||||
} |
|
||||
@ -1,31 +0,0 @@ |
|||||
package lghttp |
|
||||
|
|
||||
import "context" |
|
||||
|
|
||||
/* |
|
||||
系统描述:mgo数据库驱动系统 |
|
||||
*/ |
|
||||
type ( |
|
||||
ISys interface { |
|
||||
RequestForJson(ctx context.Context, method string, url string, args, result interface{}) (err error) |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
defsys ISys |
|
||||
) |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
defsys, err = newSys(newOptions(config, option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
sys, err = newSys(newOptionsByOption(option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
//请求http
|
|
||||
func RequestForJson(ctx context.Context, method string, url string, args, result interface{}) (err error) { |
|
||||
return defsys.RequestForJson(ctx, method, url, args, result) |
|
||||
} |
|
||||
@ -1,59 +0,0 @@ |
|||||
package lghttp |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"context" |
|
||||
"yunyan/lego/sys/log" |
|
||||
"encoding/json" |
|
||||
"fmt" |
|
||||
"io" |
|
||||
"net/http" |
|
||||
"time" |
|
||||
) |
|
||||
|
|
||||
func newSys(options Options) (sys *Fasthttp, err error) { |
|
||||
sys = &Fasthttp{options: options} |
|
||||
sys.client = &http.Client{ |
|
||||
Transport: &http.Transport{ |
|
||||
MaxIdleConns: 10, |
|
||||
MaxIdleConnsPerHost: 10, |
|
||||
IdleConnTimeout: 30 * time.Second, |
|
||||
}, |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type Fasthttp struct { |
|
||||
options Options |
|
||||
client *http.Client |
|
||||
} |
|
||||
|
|
||||
func (this *Fasthttp) RequestForJson(ctx context.Context, method string, url string, args, result interface{}) (err error) { |
|
||||
var ( |
|
||||
req *http.Request |
|
||||
resp *http.Response |
|
||||
reqbody []byte |
|
||||
respbody []byte |
|
||||
) |
|
||||
this.options.Log.Debug("RequestForJson", log.Field{Key: "method", Value: method}, log.Field{Key: "url", Value: url}, log.Field{Key: "args", Value: args}) |
|
||||
if reqbody, err = json.Marshal(args); err != nil { |
|
||||
return |
|
||||
} |
|
||||
if req, err = http.NewRequestWithContext(ctx, method, url, bytes.NewBuffer(reqbody)); err != nil { |
|
||||
return |
|
||||
} |
|
||||
req.Header.Set("Content-Type", "application/json") |
|
||||
if resp, err = this.client.Do(req); err != nil { |
|
||||
return |
|
||||
} |
|
||||
defer resp.Body.Close() |
|
||||
if resp.StatusCode != 200 { |
|
||||
err = fmt.Errorf("req fail StatusCode:%d", resp.StatusCode) |
|
||||
} else { |
|
||||
if respbody, err = io.ReadAll(resp.Body); err != nil { |
|
||||
return |
|
||||
} |
|
||||
err = json.Unmarshal(respbody, result) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,45 +0,0 @@ |
|||||
package lghttp |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
Debug bool //日志是否开启
|
|
||||
Log log.ILogger |
|
||||
MaxConnsPerHost int // 控制每个主机的最大连接数
|
|
||||
ReqTimeOut int // 请求超时时间 单位秒
|
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{ |
|
||||
MaxConnsPerHost: 100, |
|
||||
ReqTimeOut: 3, |
|
||||
} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.fasthttp", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{ |
|
||||
MaxConnsPerHost: 100, |
|
||||
ReqTimeOut: 3, |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.fasthttp", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1 +0,0 @@ |
|||||
package lghttp_test |
|
||||
@ -1,34 +0,0 @@ |
|||||
package tos |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"io" |
|
||||
|
|
||||
"github.com/volcengine/ve-tos-golang-sdk/v2/tos" |
|
||||
) |
|
||||
|
|
||||
type ( |
|
||||
ISys interface { |
|
||||
Get(ctx context.Context, name string, listener tos.DataTransferListener) (resp *tos.GetObjectV2Output, err error) |
|
||||
Put(ctx context.Context, name string, r io.Reader) (err error) |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var defsys ISys |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
defsys, err = newSys(newOptions(config, option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
sys, err = newSys(newOptionsByOption(option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func Get(ctx context.Context, name string, listener tos.DataTransferListener) (resp *tos.GetObjectV2Output, err error) { |
|
||||
return defsys.Get(ctx, name, listener) |
|
||||
} |
|
||||
func Put(ctx context.Context, name string, r io.Reader) (err error) { |
|
||||
return defsys.Put(ctx, name, r) |
|
||||
} |
|
||||
@ -1,64 +0,0 @@ |
|||||
package tos |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
Debug bool //日志是否开启
|
|
||||
Log log.ILogger |
|
||||
AsccessKey string |
|
||||
SecretKey string |
|
||||
Endpoint string |
|
||||
Region string |
|
||||
BucketName string |
|
||||
} |
|
||||
|
|
||||
func SetAsccessKey(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.AsccessKey = v |
|
||||
} |
|
||||
} |
|
||||
func SetSecretKey(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.SecretKey = v |
|
||||
} |
|
||||
} |
|
||||
func SetRegion(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Region = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetBucketName(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.BucketName = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.tavily", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.tavily", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1,29 +0,0 @@ |
|||||
package tos_test |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"yunyan/lego/sys/sdk/bytedance/tos" |
|
||||
"fmt" |
|
||||
"os" |
|
||||
"testing" |
|
||||
) |
|
||||
|
|
||||
func Test_Sys(t *testing.T) { |
|
||||
if err := tos.OnInit(nil, |
|
||||
tos.SetAsccessKey("AKLTYjQ4NTVjZjkyMGQ1NGRhNWIwODA4YmNmZmU0ZmYwYTg"), |
|
||||
tos.SetSecretKey("TXprNFpEQTFZV1JpTTJGbE5HRTFZemcwWXpFNVptSTBOVGN6TVRnM05XTQ=="), |
|
||||
tos.SetRegion("cn-shanghai"), |
|
||||
tos.SetBucketName("insightcube"), |
|
||||
); err != nil { |
|
||||
return |
|
||||
} else { |
|
||||
var file *os.File |
|
||||
defer file.Close() |
|
||||
if file, err = os.Open("./liwei.text"); err != nil { |
|
||||
fmt.Println("打开文件失败!", err) |
|
||||
return |
|
||||
} |
|
||||
err = tos.Put(context.Background(), "./liwei.text", file) |
|
||||
fmt.Printf("results:%v", err) |
|
||||
} |
|
||||
} |
|
||||
@ -1,46 +0,0 @@ |
|||||
package tos |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"io" |
|
||||
|
|
||||
"github.com/volcengine/ve-tos-golang-sdk/v2/tos" |
|
||||
) |
|
||||
|
|
||||
func newSys(options Options) (sys *TOS, err error) { |
|
||||
sys = &TOS{ |
|
||||
options: options, |
|
||||
} |
|
||||
sys.client, err = tos.NewClientV2(options.Endpoint, tos.WithRegion(options.Region), |
|
||||
tos.WithCredentials(tos.NewStaticCredentials(options.AsccessKey, options.SecretKey))) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type TOS struct { |
|
||||
options Options |
|
||||
client *tos.ClientV2 |
|
||||
} |
|
||||
|
|
||||
func (this *TOS) Get(ctx context.Context, name string, listener tos.DataTransferListener) (resp *tos.GetObjectV2Output, err error) { |
|
||||
// 下载数据到内存
|
|
||||
resp, err = this.client.GetObjectV2(ctx, &tos.GetObjectV2Input{ |
|
||||
Bucket: this.options.BucketName, |
|
||||
Key: name, |
|
||||
// 获取当前下载进度
|
|
||||
DataTransferListener: listener, |
|
||||
// 下载时重写响应头
|
|
||||
ResponseContentType: "application/json", |
|
||||
}) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *TOS) Put(ctx context.Context, name string, r io.Reader) (err error) { |
|
||||
_, err = this.client.PutObjectV2(ctx, &tos.PutObjectV2Input{ |
|
||||
PutObjectBasicInput: tos.PutObjectBasicInput{ |
|
||||
Bucket: this.options.BucketName, |
|
||||
Key: name, |
|
||||
}, |
|
||||
Content: r, |
|
||||
}) |
|
||||
return |
|
||||
} |
|
||||
@ -1,70 +0,0 @@ |
|||||
package timewheel |
|
||||
|
|
||||
import ( |
|
||||
"time" |
|
||||
) |
|
||||
|
|
||||
type ( |
|
||||
ISys interface { |
|
||||
Start() |
|
||||
Stop() |
|
||||
Add(delay time.Duration, handler func(*Task, ...interface{}), args ...interface{}) *Task |
|
||||
AddCron(delay time.Duration, handler func(*Task, ...interface{}), args ...interface{}) *Task |
|
||||
Remove(task *Task) error |
|
||||
NewTimer(delay time.Duration) *Timer |
|
||||
NewTicker(delay time.Duration) *Ticker |
|
||||
AfterFunc(delay time.Duration, callback func()) *Timer |
|
||||
After(delay time.Duration) <-chan time.Time |
|
||||
Sleep(delay time.Duration) |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
defsys ISys |
|
||||
) |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
if defsys, err = newsys(newOptions(config, option...)); err == nil { |
|
||||
defsys.Start() |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
if sys, err = newsys(newOptionsByOption(option...)); err == nil { |
|
||||
sys.Start() |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func Add(delay time.Duration, handler func(*Task, ...interface{}), args ...interface{}) *Task { |
|
||||
return defsys.Add(delay, handler, args...) |
|
||||
} |
|
||||
|
|
||||
func AddCron(delay time.Duration, handler func(*Task, ...interface{}), args ...interface{}) *Task { |
|
||||
return defsys.AddCron(delay, handler, args...) |
|
||||
} |
|
||||
|
|
||||
func Remove(task *Task) error { |
|
||||
return defsys.Remove(task) |
|
||||
} |
|
||||
|
|
||||
func NewTimer(delay time.Duration) *Timer { |
|
||||
return defsys.NewTimer(delay) |
|
||||
} |
|
||||
|
|
||||
func NewTicker(delay time.Duration) *Ticker { |
|
||||
return defsys.NewTicker(delay) |
|
||||
} |
|
||||
|
|
||||
func AfterFunc(delay time.Duration, callback func()) *Timer { |
|
||||
return defsys.AfterFunc(delay, callback) |
|
||||
} |
|
||||
|
|
||||
func After(delay time.Duration) <-chan time.Time { |
|
||||
return defsys.After(delay) |
|
||||
} |
|
||||
|
|
||||
func Sleep(delay time.Duration) { |
|
||||
defsys.Sleep(delay) |
|
||||
} |
|
||||
@ -1,66 +0,0 @@ |
|||||
package timewheel |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
"time" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
Tick time.Duration //不小于 10毫秒
|
|
||||
BucketsNum int |
|
||||
} |
|
||||
|
|
||||
func SetTick(v time.Duration) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Tick = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func SetBucketsNum(v int) Option { |
|
||||
return func(o *Options) { |
|
||||
o.BucketsNum = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{ |
|
||||
Tick: time.Second, |
|
||||
BucketsNum: 1024, |
|
||||
} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Tick < 100*time.Millisecond { |
|
||||
log.Errorf("创建时间轮参数异常 Tick 必须大于 100 ms ") |
|
||||
options.Tick = 100 * time.Millisecond |
|
||||
} |
|
||||
if options.BucketsNum < 0 { |
|
||||
log.Errorf("创建时间轮参数异常 BucketsNum 必须大于 0 ") |
|
||||
options.BucketsNum = 1 |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{ |
|
||||
Tick: 1000, |
|
||||
BucketsNum: 1024, |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Tick < 100*time.Millisecond { |
|
||||
log.Warnf("创建时间轮参数异常 Tick 必须大于 100 ms ") |
|
||||
options.Tick = 100 * time.Millisecond |
|
||||
} |
|
||||
if options.BucketsNum < 0 { |
|
||||
log.Warnf("创建时间轮参数异常 BucketsNum 必须大于 0 ") |
|
||||
options.BucketsNum = 1 |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1,34 +0,0 @@ |
|||||
package timewheel |
|
||||
|
|
||||
import ( |
|
||||
"sync" |
|
||||
) |
|
||||
|
|
||||
var incr = 0 |
|
||||
|
|
||||
var ( |
|
||||
defaultTaskPool = newTaskPool() |
|
||||
) |
|
||||
|
|
||||
type taskPool struct { |
|
||||
bp *sync.Pool |
|
||||
} |
|
||||
|
|
||||
func newTaskPool() *taskPool { |
|
||||
return &taskPool{ |
|
||||
bp: &sync.Pool{ |
|
||||
New: func() interface{} { |
|
||||
return &Task{} |
|
||||
}, |
|
||||
}, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (pool *taskPool) get() *Task { |
|
||||
return pool.bp.Get().(*Task) |
|
||||
} |
|
||||
|
|
||||
func (pool *taskPool) put(obj *Task) { |
|
||||
obj.Reset() |
|
||||
pool.bp.Put(obj) |
|
||||
} |
|
||||
@ -1,457 +0,0 @@ |
|||||
package timewheel |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"yunyan/lego" |
|
||||
"yunyan/lego/sys/log" |
|
||||
"fmt" |
|
||||
"runtime" |
|
||||
"sync" |
|
||||
"sync/atomic" |
|
||||
"time" |
|
||||
) |
|
||||
|
|
||||
// 创建一个时间轮
|
|
||||
func newsys(options Options) (sys *TimeWheel, err error) { |
|
||||
sys = &TimeWheel{ |
|
||||
// tick
|
|
||||
tick: options.Tick, |
|
||||
tickQueue: make(chan time.Time, 10), |
|
||||
|
|
||||
// store
|
|
||||
bucketsNum: options.BucketsNum, |
|
||||
bucketIndexes: make(map[taskID]int, 1024*100), |
|
||||
buckets: make([]map[taskID]*Task, options.BucketsNum), |
|
||||
currentIndex: 0, |
|
||||
|
|
||||
// signal
|
|
||||
addC: make(chan *Task, 1024*5), |
|
||||
removeC: make(chan *Task, 1024*2), |
|
||||
stopC: make(chan struct{}), |
|
||||
} |
|
||||
|
|
||||
for i := 0; i < options.BucketsNum; i++ { |
|
||||
sys.buckets[i] = make(map[taskID]*Task, 16) |
|
||||
} |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
const ( |
|
||||
typeTimer taskType = iota |
|
||||
typeTicker |
|
||||
|
|
||||
modeIsCircle = true |
|
||||
modeNotCircle = false |
|
||||
|
|
||||
modeIsAsync = true |
|
||||
modeNotAsync = false |
|
||||
) |
|
||||
|
|
||||
type ( |
|
||||
taskType int64 |
|
||||
taskID int64 |
|
||||
Task struct { |
|
||||
delay time.Duration |
|
||||
id taskID |
|
||||
round int |
|
||||
args []interface{} |
|
||||
callback func(*Task, ...interface{}) |
|
||||
async bool //异步执行
|
|
||||
stop bool //是否停止
|
|
||||
circle bool //是否循环
|
|
||||
} |
|
||||
TimeWheel struct { |
|
||||
randomID int64 |
|
||||
tick time.Duration |
|
||||
ticker *time.Ticker |
|
||||
tickQueue chan time.Time |
|
||||
bucketsNum int |
|
||||
buckets []map[taskID]*Task // key: added item, value: *Task
|
|
||||
bucketIndexes map[taskID]int // key: added item, value: bucket position
|
|
||||
currentIndex int |
|
||||
onceStart sync.Once |
|
||||
addC chan *Task |
|
||||
removeC chan *Task |
|
||||
stopC chan struct{} |
|
||||
exited bool |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
// for sync.Pool
|
|
||||
func (t *Task) Reset() { |
|
||||
t.round = 0 |
|
||||
t.callback = nil |
|
||||
|
|
||||
t.async = false |
|
||||
t.stop = false |
|
||||
t.circle = false |
|
||||
} |
|
||||
|
|
||||
// 启动时间轮
|
|
||||
func (this *TimeWheel) Start() { |
|
||||
// onlye once start
|
|
||||
this.onceStart.Do( |
|
||||
func() { |
|
||||
this.ticker = time.NewTicker(this.tick) |
|
||||
go this.schduler() |
|
||||
go this.tickGenerator() |
|
||||
}, |
|
||||
) |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) Add(delay time.Duration, handler func(*Task, ...interface{}), args ...interface{}) *Task { |
|
||||
return this.addAny(delay, modeNotCircle, modeIsAsync, handler, args...) |
|
||||
} |
|
||||
|
|
||||
// AddCron add interval task
|
|
||||
func (this *TimeWheel) AddCron(delay time.Duration, handler func(*Task, ...interface{}), args ...interface{}) *Task { |
|
||||
return this.addAny(delay, true, modeIsAsync, handler, args...) |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) Remove(task *Task) error { |
|
||||
this.removeC <- task |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
// 停止时间轮
|
|
||||
func (this *TimeWheel) Stop() { |
|
||||
this.stopC <- struct{}{} |
|
||||
} |
|
||||
|
|
||||
// 此处写法 为监控时间轮是否正常执行
|
|
||||
func (this *TimeWheel) tickGenerator() { |
|
||||
if this.tickQueue == nil { |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
for !this.exited { |
|
||||
select { |
|
||||
case <-this.ticker.C: |
|
||||
select { |
|
||||
case this.tickQueue <- time.Now(): |
|
||||
default: |
|
||||
panic("raise long time blocking") |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 调度器
|
|
||||
func (this *TimeWheel) schduler() { |
|
||||
queue := this.ticker.C |
|
||||
if this.tickQueue != nil { |
|
||||
queue = this.tickQueue |
|
||||
} |
|
||||
|
|
||||
for { |
|
||||
select { |
|
||||
case <-queue: |
|
||||
this.handleTick() |
|
||||
case task := <-this.addC: |
|
||||
this.put(task) |
|
||||
case key := <-this.removeC: |
|
||||
this.remove(key) |
|
||||
case <-this.stopC: |
|
||||
this.exited = true |
|
||||
this.ticker.Stop() |
|
||||
return |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 清理
|
|
||||
func (this *TimeWheel) collectTask(task *Task) { |
|
||||
if index, ok := this.bucketIndexes[task.id]; ok { |
|
||||
delete(this.bucketIndexes, task.id) |
|
||||
delete(this.buckets[index], task.id) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) recoverTask(task *Task) { |
|
||||
defaultTaskPool.put(task) |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) handleTick() { |
|
||||
bucket := this.buckets[this.currentIndex] |
|
||||
for k, task := range bucket { |
|
||||
if task.stop { |
|
||||
this.collectTask(task) |
|
||||
this.recoverTask(task) |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
if bucket[k].round > 0 { |
|
||||
bucket[k].round-- |
|
||||
continue |
|
||||
} |
|
||||
this.collectTask(task) |
|
||||
if task.async { |
|
||||
go func(_task *Task) { |
|
||||
defer func() { //程序异常 收集异常信息传递给前端显示
|
|
||||
if r := recover(); r != nil { |
|
||||
buf := make([]byte, 4096) |
|
||||
l := runtime.Stack(buf, false) |
|
||||
err := fmt.Errorf("%v: %s", r, buf[:l]) |
|
||||
log.Errorf("[timewheel] calltask err:%s", err.Error()) |
|
||||
} |
|
||||
}() |
|
||||
this.calltask(_task, _task.args...) |
|
||||
if _task.circle { //重新进入队列中
|
|
||||
// this.putCircle(_task, true)
|
|
||||
this.addC <- _task |
|
||||
} else { |
|
||||
this.recoverTask(_task) |
|
||||
} |
|
||||
}(task) |
|
||||
} else { |
|
||||
this.calltask(task, task.args...) |
|
||||
//循环执行
|
|
||||
if task.circle { |
|
||||
this.putCircle(task, true) |
|
||||
} else { |
|
||||
this.recoverTask(task) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if this.currentIndex == this.bucketsNum-1 { |
|
||||
this.currentIndex = 0 |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
this.currentIndex++ |
|
||||
} |
|
||||
|
|
||||
// 执行时间轮事件 捕捉异常错误 防止程序崩溃
|
|
||||
func (this *TimeWheel) calltask(task *Task, args ...interface{}) { |
|
||||
defer lego.Recover("TimeWheel") |
|
||||
if task.callback == nil { |
|
||||
log.Error("sys.timeWheel task callback err!", log.Field{Key: "task", Value: task}) |
|
||||
return |
|
||||
} |
|
||||
task.callback(task, task.args...) |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) addAny(delay time.Duration, circle, async bool, callback func(*Task, ...interface{}), agr ...interface{}) *Task { |
|
||||
if delay <= 0 { |
|
||||
delay = this.tick |
|
||||
} |
|
||||
|
|
||||
id := this.genUniqueID() |
|
||||
|
|
||||
var task *Task |
|
||||
task = defaultTaskPool.get() |
|
||||
task.delay = delay |
|
||||
task.id = id |
|
||||
task.args = agr |
|
||||
task.callback = callback |
|
||||
task.circle = circle |
|
||||
task.async = async // refer to src/runtime/time.go
|
|
||||
|
|
||||
this.addC <- task |
|
||||
return task |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) put(task *Task) { |
|
||||
this.store(task, false) |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) putCircle(task *Task, circleMode bool) { |
|
||||
this.store(task, circleMode) |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) store(task *Task, circleMode bool) { |
|
||||
round := this.calculateRound(task.delay) |
|
||||
index := this.calculateIndex(task.delay) |
|
||||
|
|
||||
if round > 0 && circleMode { |
|
||||
task.round = round - 1 |
|
||||
} else { |
|
||||
task.round = round |
|
||||
} |
|
||||
|
|
||||
this.bucketIndexes[task.id] = index |
|
||||
this.buckets[index][task.id] = task |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) calculateRound(delay time.Duration) (round int) { |
|
||||
delaySeconds := delay.Seconds() |
|
||||
tickSeconds := this.tick.Seconds() |
|
||||
round = int(delaySeconds / tickSeconds / float64(this.bucketsNum)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) calculateIndex(delay time.Duration) (index int) { |
|
||||
delaySeconds := delay.Seconds() |
|
||||
tickSeconds := this.tick.Seconds() |
|
||||
index = (int(float64(this.currentIndex) + delaySeconds/tickSeconds)) % this.bucketsNum |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) remove(task *Task) { |
|
||||
this.collectTask(task) |
|
||||
this.recoverTask(task) |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) NewTimer(delay time.Duration) *Timer { |
|
||||
queue := make(chan bool, 1) // buf = 1, refer to src/time/sleep.go
|
|
||||
task := this.addAny(delay, |
|
||||
modeNotCircle, |
|
||||
modeNotAsync, |
|
||||
func(*Task, ...interface{}) { |
|
||||
notfiyChannel(queue) |
|
||||
}, |
|
||||
) |
|
||||
|
|
||||
// init timer
|
|
||||
ctx, cancel := context.WithCancel(context.Background()) |
|
||||
timer := &Timer{ |
|
||||
this: this, |
|
||||
C: queue, // faster
|
|
||||
task: task, |
|
||||
Ctx: ctx, |
|
||||
cancel: cancel, |
|
||||
} |
|
||||
|
|
||||
return timer |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) AfterFunc(delay time.Duration, callback func()) *Timer { |
|
||||
queue := make(chan bool, 1) |
|
||||
task := this.addAny(delay, |
|
||||
modeNotCircle, modeIsAsync, |
|
||||
func(*Task, ...interface{}) { |
|
||||
callback() |
|
||||
notfiyChannel(queue) |
|
||||
}, |
|
||||
) |
|
||||
|
|
||||
// init timer
|
|
||||
ctx, cancel := context.WithCancel(context.Background()) |
|
||||
timer := &Timer{ |
|
||||
this: this, |
|
||||
C: queue, // faster
|
|
||||
task: task, |
|
||||
Ctx: ctx, |
|
||||
cancel: cancel, |
|
||||
fn: callback, |
|
||||
} |
|
||||
|
|
||||
return timer |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) NewTicker(delay time.Duration) *Ticker { |
|
||||
queue := make(chan bool, 1) |
|
||||
task := this.addAny(delay, |
|
||||
modeIsCircle, |
|
||||
modeNotAsync, |
|
||||
func(*Task, ...interface{}) { |
|
||||
notfiyChannel(queue) |
|
||||
}, |
|
||||
) |
|
||||
|
|
||||
// init ticker
|
|
||||
ctx, cancel := context.WithCancel(context.Background()) |
|
||||
ticker := &Ticker{ |
|
||||
task: task, |
|
||||
this: this, |
|
||||
C: queue, |
|
||||
Ctx: ctx, |
|
||||
cancel: cancel, |
|
||||
} |
|
||||
|
|
||||
return ticker |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) After(delay time.Duration) <-chan time.Time { |
|
||||
queue := make(chan time.Time, 1) |
|
||||
this.addAny(delay, |
|
||||
modeNotCircle, modeNotAsync, |
|
||||
func(*Task, ...interface{}) { |
|
||||
queue <- time.Now() |
|
||||
}, |
|
||||
) |
|
||||
return queue |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) Sleep(delay time.Duration) { |
|
||||
queue := make(chan bool, 1) |
|
||||
this.addAny(delay, |
|
||||
modeNotCircle, modeNotAsync, |
|
||||
func(*Task, ...interface{}) { |
|
||||
queue <- true |
|
||||
}, |
|
||||
) |
|
||||
<-queue |
|
||||
} |
|
||||
|
|
||||
// similar to golang std timer
|
|
||||
type Timer struct { |
|
||||
task *Task |
|
||||
this *TimeWheel |
|
||||
fn func() // external custom func
|
|
||||
C chan bool |
|
||||
|
|
||||
cancel context.CancelFunc |
|
||||
Ctx context.Context |
|
||||
} |
|
||||
|
|
||||
func (t *Timer) Reset(delay time.Duration) { |
|
||||
var task *Task |
|
||||
if t.fn != nil { // use AfterFunc
|
|
||||
task = t.this.addAny(delay, |
|
||||
modeNotCircle, modeIsAsync, // must async mode
|
|
||||
func(*Task, ...interface{}) { |
|
||||
t.fn() |
|
||||
notfiyChannel(t.C) |
|
||||
}, |
|
||||
) |
|
||||
} else { |
|
||||
task = t.this.addAny(delay, |
|
||||
modeNotCircle, modeNotAsync, |
|
||||
func(*Task, ...interface{}) { |
|
||||
notfiyChannel(t.C) |
|
||||
}, |
|
||||
) |
|
||||
} |
|
||||
|
|
||||
t.task = task |
|
||||
} |
|
||||
|
|
||||
func (t *Timer) Stop() { |
|
||||
t.task.stop = true |
|
||||
t.cancel() |
|
||||
t.this.Remove(t.task) |
|
||||
} |
|
||||
|
|
||||
func (t *Timer) StopFunc(callback func()) { |
|
||||
t.fn = callback |
|
||||
} |
|
||||
|
|
||||
type Ticker struct { |
|
||||
this *TimeWheel |
|
||||
task *Task |
|
||||
cancel context.CancelFunc |
|
||||
|
|
||||
C chan bool |
|
||||
Ctx context.Context |
|
||||
} |
|
||||
|
|
||||
func (t *Ticker) Stop() { |
|
||||
t.task.stop = true |
|
||||
t.cancel() |
|
||||
t.this.Remove(t.task) |
|
||||
} |
|
||||
|
|
||||
func notfiyChannel(q chan bool) { |
|
||||
select { |
|
||||
case q <- true: |
|
||||
default: |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (this *TimeWheel) genUniqueID() taskID { |
|
||||
id := atomic.AddInt64(&this.randomID, 1) |
|
||||
return taskID(id) |
|
||||
} |
|
||||
@ -1,57 +0,0 @@ |
|||||
package timewheel_test |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"testing" |
|
||||
"time" |
|
||||
|
|
||||
"yunyan/lego/sys/timewheel" |
|
||||
) |
|
||||
|
|
||||
func checkTimeCost(t *testing.T, start, end time.Time, before int, after int) bool { |
|
||||
due := end.Sub(start) |
|
||||
if due > time.Duration(after)*time.Millisecond { |
|
||||
t.Error("delay run") |
|
||||
return false |
|
||||
} |
|
||||
|
|
||||
if due < time.Duration(before)*time.Millisecond { |
|
||||
t.Error("run ahead") |
|
||||
return false |
|
||||
} |
|
||||
|
|
||||
return true |
|
||||
} |
|
||||
|
|
||||
func TestAddFunc(t *testing.T) { |
|
||||
tw, _ := timewheel.NewSys(timewheel.SetTick(100), timewheel.SetBucketsNum(10)) |
|
||||
tw.Start() |
|
||||
defer tw.Stop() |
|
||||
|
|
||||
for index := 1; index < 6; index++ { |
|
||||
queue := make(chan bool, 0) |
|
||||
start := time.Now() |
|
||||
tw.Add(time.Duration(index)*time.Second, func(*timewheel.Task, ...interface{}) { |
|
||||
queue <- true |
|
||||
}) |
|
||||
|
|
||||
<-queue |
|
||||
|
|
||||
before := index*1000 - 200 |
|
||||
after := index*1000 + 200 |
|
||||
checkTimeCost(t, start, time.Now(), before, after) |
|
||||
fmt.Println("time since: ", time.Since(start).String()) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func Test_AddFunc(t *testing.T) { |
|
||||
tw, _ := timewheel.NewSys(timewheel.SetTick(100*time.Millisecond), timewheel.SetBucketsNum(10)) |
|
||||
tw.Start() |
|
||||
defer tw.Stop() |
|
||||
start := time.Now() |
|
||||
tw.AddCron(time.Second, func(*timewheel.Task, ...interface{}) { |
|
||||
fmt.Println("time since: ", time.Since(start).String()) |
|
||||
}) |
|
||||
|
|
||||
time.Sleep(10 * time.Second) |
|
||||
} |
|
||||
@ -1,84 +0,0 @@ |
|||||
package container |
|
||||
|
|
||||
import "sync" |
|
||||
|
|
||||
// BeeMap is a map with lock
|
|
||||
|
|
||||
type BeeMap struct { |
|
||||
lock *sync.RWMutex |
|
||||
bm map[interface{}]interface{} |
|
||||
} |
|
||||
|
|
||||
// NewBeeMap return new safemap
|
|
||||
func NewBeeMap() *BeeMap { |
|
||||
return &BeeMap{ |
|
||||
lock: new(sync.RWMutex), |
|
||||
bm: make(map[interface{}]interface{}), |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Get from maps return the k's value
|
|
||||
func (m *BeeMap) Get(k interface{}) interface{} { |
|
||||
m.lock.RLock() |
|
||||
if val, ok := m.bm[k]; ok { |
|
||||
m.lock.RUnlock() |
|
||||
return val |
|
||||
} |
|
||||
m.lock.RUnlock() |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
// Set Maps the given key and value. Returns false
|
|
||||
// if the key is already in the map and changes nothing.
|
|
||||
func (m *BeeMap) Set(k interface{}, v interface{}) bool { |
|
||||
m.lock.Lock() |
|
||||
if val, ok := m.bm[k]; !ok { |
|
||||
m.bm[k] = v |
|
||||
m.lock.Unlock() |
|
||||
} else if val != v { |
|
||||
m.bm[k] = v |
|
||||
m.lock.Unlock() |
|
||||
} else { |
|
||||
m.lock.Unlock() |
|
||||
return false |
|
||||
} |
|
||||
return true |
|
||||
} |
|
||||
|
|
||||
// Check Returns true if k is exist in the map.
|
|
||||
func (m *BeeMap) Check(k interface{}) bool { |
|
||||
m.lock.RLock() |
|
||||
if _, ok := m.bm[k]; !ok { |
|
||||
m.lock.RUnlock() |
|
||||
return false |
|
||||
} |
|
||||
m.lock.RUnlock() |
|
||||
return true |
|
||||
} |
|
||||
|
|
||||
// Delete the given key and value.
|
|
||||
func (m *BeeMap) Delete(k interface{}) { |
|
||||
m.lock.Lock() |
|
||||
delete(m.bm, k) |
|
||||
m.lock.Unlock() |
|
||||
} |
|
||||
|
|
||||
func (m *BeeMap) DeleteAll() { |
|
||||
m.lock.Lock() |
|
||||
for k, _ := range m.bm { |
|
||||
delete(m.bm, k) |
|
||||
} |
|
||||
|
|
||||
m.lock.Unlock() |
|
||||
} |
|
||||
|
|
||||
// Items returns all items in safemap.
|
|
||||
func (m *BeeMap) Items() map[interface{}]interface{} { |
|
||||
m.lock.RLock() |
|
||||
r := make(map[interface{}]interface{}) |
|
||||
for k, v := range m.bm { |
|
||||
r[k] = v |
|
||||
} |
|
||||
m.lock.RUnlock() |
|
||||
return r |
|
||||
} |
|
||||
@ -1,250 +0,0 @@ |
|||||
package container |
|
||||
|
|
||||
import ( |
|
||||
"sync" |
|
||||
|
|
||||
json "github.com/json-iterator/go" |
|
||||
) |
|
||||
|
|
||||
var SHARD_COUNT = 32 |
|
||||
|
|
||||
type ConcurrentMap []*ConcurrentMapShared |
|
||||
|
|
||||
type ConcurrentMapShared struct { |
|
||||
items map[string]interface{} |
|
||||
sync.RWMutex |
|
||||
} |
|
||||
|
|
||||
func NewConcurrentMap() ConcurrentMap { |
|
||||
m := make(ConcurrentMap, SHARD_COUNT) |
|
||||
for i := 0; i < SHARD_COUNT; i++ { |
|
||||
m[i] = &ConcurrentMapShared{items: make(map[string]interface{})} |
|
||||
} |
|
||||
return m |
|
||||
} |
|
||||
|
|
||||
func (m ConcurrentMap) GetShard(key string) *ConcurrentMapShared { |
|
||||
return m[uint(fnv32(key))%uint(SHARD_COUNT)] |
|
||||
} |
|
||||
func (m ConcurrentMap) MSet(data map[string]interface{}) { |
|
||||
for key, value := range data { |
|
||||
shard := m.GetShard(key) |
|
||||
shard.Lock() |
|
||||
shard.items[key] = value |
|
||||
shard.Unlock() |
|
||||
} |
|
||||
} |
|
||||
func (m ConcurrentMap) Set(key string, value interface{}) { |
|
||||
// Get map shard.
|
|
||||
shard := m.GetShard(key) |
|
||||
shard.Lock() |
|
||||
shard.items[key] = value |
|
||||
shard.Unlock() |
|
||||
} |
|
||||
func (m ConcurrentMap) Upsert(key string, value interface{}, cb UpsertCb) (res interface{}) { |
|
||||
shard := m.GetShard(key) |
|
||||
shard.Lock() |
|
||||
v, ok := shard.items[key] |
|
||||
res = cb(ok, v, value) |
|
||||
shard.items[key] = res |
|
||||
shard.Unlock() |
|
||||
return res |
|
||||
} |
|
||||
func (m ConcurrentMap) SetIfAbsent(key string, value interface{}) bool { |
|
||||
// Get map shard.
|
|
||||
shard := m.GetShard(key) |
|
||||
shard.Lock() |
|
||||
_, ok := shard.items[key] |
|
||||
if !ok { |
|
||||
shard.items[key] = value |
|
||||
} |
|
||||
shard.Unlock() |
|
||||
return !ok |
|
||||
} |
|
||||
func (m ConcurrentMap) Get(key string) (interface{}, bool) { |
|
||||
shard := m.GetShard(key) |
|
||||
shard.RLock() |
|
||||
val, ok := shard.items[key] |
|
||||
shard.RUnlock() |
|
||||
return val, ok |
|
||||
} |
|
||||
func (m ConcurrentMap) Count() int { |
|
||||
count := 0 |
|
||||
for i := 0; i < SHARD_COUNT; i++ { |
|
||||
shard := m[i] |
|
||||
shard.RLock() |
|
||||
count += len(shard.items) |
|
||||
shard.RUnlock() |
|
||||
} |
|
||||
return count |
|
||||
} |
|
||||
func (m ConcurrentMap) Has(key string) bool { |
|
||||
// Get shard
|
|
||||
shard := m.GetShard(key) |
|
||||
shard.RLock() |
|
||||
// See if element is within shard.
|
|
||||
_, ok := shard.items[key] |
|
||||
shard.RUnlock() |
|
||||
return ok |
|
||||
} |
|
||||
func (m ConcurrentMap) Remove(key string) { |
|
||||
// Try to get shard.
|
|
||||
shard := m.GetShard(key) |
|
||||
shard.Lock() |
|
||||
delete(shard.items, key) |
|
||||
shard.Unlock() |
|
||||
} |
|
||||
func (m ConcurrentMap) RemoveCb(key string, cb RemoveCb) bool { |
|
||||
// Try to get shard.
|
|
||||
shard := m.GetShard(key) |
|
||||
shard.Lock() |
|
||||
v, ok := shard.items[key] |
|
||||
remove := cb(key, v, ok) |
|
||||
if remove && ok { |
|
||||
delete(shard.items, key) |
|
||||
} |
|
||||
shard.Unlock() |
|
||||
return remove |
|
||||
} |
|
||||
func (m ConcurrentMap) Pop(key string) (v interface{}, exists bool) { |
|
||||
// Try to get shard.
|
|
||||
shard := m.GetShard(key) |
|
||||
shard.Lock() |
|
||||
v, exists = shard.items[key] |
|
||||
delete(shard.items, key) |
|
||||
shard.Unlock() |
|
||||
return v, exists |
|
||||
} |
|
||||
func (m ConcurrentMap) IsEmpty() bool { |
|
||||
return m.Count() == 0 |
|
||||
} |
|
||||
func (m ConcurrentMap) Iter() <-chan Tuple { |
|
||||
chans := snapshot(m) |
|
||||
ch := make(chan Tuple) |
|
||||
go fanIn(chans, ch) |
|
||||
return ch |
|
||||
} |
|
||||
func (m ConcurrentMap) IterBuffered() <-chan Tuple { |
|
||||
chans := snapshot(m) |
|
||||
total := 0 |
|
||||
for _, c := range chans { |
|
||||
total += cap(c) |
|
||||
} |
|
||||
ch := make(chan Tuple, total) |
|
||||
go fanIn(chans, ch) |
|
||||
return ch |
|
||||
} |
|
||||
func (m ConcurrentMap) Items() map[string]interface{} { |
|
||||
tmp := make(map[string]interface{}) |
|
||||
|
|
||||
// Insert items to temporary map.
|
|
||||
for item := range m.IterBuffered() { |
|
||||
tmp[item.Key] = item.Val |
|
||||
} |
|
||||
|
|
||||
return tmp |
|
||||
} |
|
||||
func (m ConcurrentMap) IterCb(fn IterCb) { |
|
||||
for idx := range m { |
|
||||
shard := (m)[idx] |
|
||||
shard.RLock() |
|
||||
for key, value := range shard.items { |
|
||||
fn(key, value) |
|
||||
} |
|
||||
shard.RUnlock() |
|
||||
} |
|
||||
} |
|
||||
func (m ConcurrentMap) Keys() []string { |
|
||||
count := m.Count() |
|
||||
ch := make(chan string, count) |
|
||||
go func() { |
|
||||
// Foreach shard.
|
|
||||
wg := sync.WaitGroup{} |
|
||||
wg.Add(SHARD_COUNT) |
|
||||
for _, shard := range m { |
|
||||
go func(shard *ConcurrentMapShared) { |
|
||||
// Foreach key, value pair.
|
|
||||
shard.RLock() |
|
||||
for key := range shard.items { |
|
||||
ch <- key |
|
||||
} |
|
||||
shard.RUnlock() |
|
||||
wg.Done() |
|
||||
}(shard) |
|
||||
} |
|
||||
wg.Wait() |
|
||||
close(ch) |
|
||||
}() |
|
||||
|
|
||||
// Generate keys
|
|
||||
keys := make([]string, 0, count) |
|
||||
for k := range ch { |
|
||||
keys = append(keys, k) |
|
||||
} |
|
||||
return keys |
|
||||
} |
|
||||
func (m ConcurrentMap) MarshalJSON() ([]byte, error) { |
|
||||
// Create a temporary map, which will hold all item spread across shards.
|
|
||||
tmp := make(map[string]interface{}) |
|
||||
|
|
||||
// Insert items to temporary map.
|
|
||||
for item := range m.IterBuffered() { |
|
||||
tmp[item.Key] = item.Val |
|
||||
} |
|
||||
return json.Marshal(tmp) |
|
||||
} |
|
||||
|
|
||||
type UpsertCb func(exist bool, valueInMap interface{}, newValue interface{}) interface{} |
|
||||
type RemoveCb func(key string, v interface{}, exists bool) bool |
|
||||
type Tuple struct { |
|
||||
Key string |
|
||||
Val interface{} |
|
||||
} |
|
||||
|
|
||||
func snapshot(m ConcurrentMap) (chans []chan Tuple) { |
|
||||
chans = make([]chan Tuple, SHARD_COUNT) |
|
||||
wg := sync.WaitGroup{} |
|
||||
wg.Add(SHARD_COUNT) |
|
||||
// Foreach shard.
|
|
||||
for index, shard := range m { |
|
||||
go func(index int, shard *ConcurrentMapShared) { |
|
||||
// Foreach key, value pair.
|
|
||||
shard.RLock() |
|
||||
chans[index] = make(chan Tuple, len(shard.items)) |
|
||||
wg.Done() |
|
||||
for key, val := range shard.items { |
|
||||
chans[index] <- Tuple{key, val} |
|
||||
} |
|
||||
shard.RUnlock() |
|
||||
close(chans[index]) |
|
||||
}(index, shard) |
|
||||
} |
|
||||
wg.Wait() |
|
||||
return chans |
|
||||
} |
|
||||
|
|
||||
type IterCb func(key string, v interface{}) |
|
||||
|
|
||||
func fanIn(chans []chan Tuple, out chan Tuple) { |
|
||||
wg := sync.WaitGroup{} |
|
||||
wg.Add(len(chans)) |
|
||||
for _, ch := range chans { |
|
||||
go func(ch chan Tuple) { |
|
||||
for t := range ch { |
|
||||
out <- t |
|
||||
} |
|
||||
wg.Done() |
|
||||
}(ch) |
|
||||
} |
|
||||
wg.Wait() |
|
||||
close(out) |
|
||||
} |
|
||||
func fnv32(key string) uint32 { |
|
||||
hash := uint32(2166136261) |
|
||||
const prime32 = uint32(16777619) |
|
||||
for i := 0; i < len(key); i++ { |
|
||||
hash *= prime32 |
|
||||
hash ^= uint32(key[i]) |
|
||||
} |
|
||||
return hash |
|
||||
} |
|
||||
@ -1,243 +0,0 @@ |
|||||
package container |
|
||||
|
|
||||
// minCapacity is the smallest capacity that deque may have.
|
|
||||
// Must be power of 2 for bitwise modulus: x % n == x & (n - 1).
|
|
||||
const minCapacity = 16 |
|
||||
|
|
||||
// Deque represents a single instance of the deque data structure.
|
|
||||
type Deque struct { |
|
||||
buf []interface{} |
|
||||
head int |
|
||||
tail int |
|
||||
count int |
|
||||
minCap int |
|
||||
} |
|
||||
|
|
||||
// Len returns the number of elements currently stored in the queue.
|
|
||||
func (q *Deque) Len() int { |
|
||||
return q.count |
|
||||
} |
|
||||
|
|
||||
// PushBack appends an element to the back of the queue. Implements FIFO when
|
|
||||
// elements are removed with PopFront(), and LIFO when elements are removed
|
|
||||
// with PopBack().
|
|
||||
func (q *Deque) PushBack(elem interface{}) { |
|
||||
q.growIfFull() |
|
||||
|
|
||||
q.buf[q.tail] = elem |
|
||||
// Calculate new tail position.
|
|
||||
q.tail = q.next(q.tail) |
|
||||
q.count++ |
|
||||
} |
|
||||
|
|
||||
// PushFront prepends an element to the front of the queue.
|
|
||||
func (q *Deque) PushFront(elem interface{}) { |
|
||||
q.growIfFull() |
|
||||
|
|
||||
// Calculate new head position.
|
|
||||
q.head = q.prev(q.head) |
|
||||
q.buf[q.head] = elem |
|
||||
q.count++ |
|
||||
} |
|
||||
|
|
||||
// PopFront removes and returns the element from the front of the queue.
|
|
||||
// Implements FIFO when used with PushBack(). If the queue is empty, the call
|
|
||||
// panics.
|
|
||||
func (q *Deque) PopFront() interface{} { |
|
||||
if q.count <= 0 { |
|
||||
panic("deque: PopFront() called on empty queue") |
|
||||
} |
|
||||
ret := q.buf[q.head] |
|
||||
q.buf[q.head] = nil |
|
||||
// Calculate new head position.
|
|
||||
q.head = q.next(q.head) |
|
||||
q.count-- |
|
||||
|
|
||||
q.shrinkIfExcess() |
|
||||
return ret |
|
||||
} |
|
||||
|
|
||||
// PopBack removes and returns the element from the back of the queue.
|
|
||||
// Implements LIFO when used with PushBack(). If the queue is empty, the call
|
|
||||
// panics.
|
|
||||
func (q *Deque) PopBack() interface{} { |
|
||||
if q.count <= 0 { |
|
||||
panic("deque: PopBack() called on empty queue") |
|
||||
} |
|
||||
|
|
||||
// Calculate new tail position
|
|
||||
q.tail = q.prev(q.tail) |
|
||||
|
|
||||
// Remove value at tail.
|
|
||||
ret := q.buf[q.tail] |
|
||||
q.buf[q.tail] = nil |
|
||||
q.count-- |
|
||||
|
|
||||
q.shrinkIfExcess() |
|
||||
return ret |
|
||||
} |
|
||||
|
|
||||
// Front returns the element at the front of the queue. This is the element
|
|
||||
// that would be returned by PopFront(). This call panics if the queue is
|
|
||||
// empty.
|
|
||||
func (q *Deque) Front() interface{} { |
|
||||
if q.count <= 0 { |
|
||||
panic("deque: Front() called when empty") |
|
||||
} |
|
||||
return q.buf[q.head] |
|
||||
} |
|
||||
|
|
||||
// Back returns the element at the back of the queue. This is the element
|
|
||||
// that would be returned by PopBack(). This call panics if the queue is
|
|
||||
// empty.
|
|
||||
func (q *Deque) Back() interface{} { |
|
||||
if q.count <= 0 { |
|
||||
panic("deque: Back() called when empty") |
|
||||
} |
|
||||
return q.buf[q.prev(q.tail)] |
|
||||
} |
|
||||
|
|
||||
// At returns the element at index i in the queue without removing the element
|
|
||||
// from the queue. This method accepts only non-negative index values. At(0)
|
|
||||
// refers to the first element and is the same as Front(). At(Len()-1) refers
|
|
||||
// to the last element and is the same as Back(). If the index is invalid, the
|
|
||||
// call panics.
|
|
||||
//
|
|
||||
// The purpose of At is to allow Deque to serve as a more general purpose
|
|
||||
// circular buffer, where items are only added to and removed from the ends of
|
|
||||
// the deque, but may be read from any place within the deque. Consider the
|
|
||||
// case of a fixed-size circular log buffer: A new entry is pushed onto one end
|
|
||||
// and when full the oldest is popped from the other end. All the log entries
|
|
||||
// in the buffer must be readable without altering the buffer contents.
|
|
||||
func (q *Deque) At(i int) interface{} { |
|
||||
if i < 0 || i >= q.count { |
|
||||
panic("deque: At() called with index out of range") |
|
||||
} |
|
||||
// bitwise modulus
|
|
||||
return q.buf[(q.head+i)&(len(q.buf)-1)] |
|
||||
} |
|
||||
|
|
||||
// Clear removes all elements from the queue, but retains the current capacity.
|
|
||||
// This is useful when repeatedly reusing the queue at high frequency to avoid
|
|
||||
// GC during reuse. The queue will not be resized smaller as long as items are
|
|
||||
// only added. Only when items are removed is the queue subject to getting
|
|
||||
// resized smaller.
|
|
||||
func (q *Deque) Clear() { |
|
||||
// bitwise modulus
|
|
||||
modBits := len(q.buf) - 1 |
|
||||
for h := q.head; h != q.tail; h = (h + 1) & modBits { |
|
||||
q.buf[h] = nil |
|
||||
} |
|
||||
q.head = 0 |
|
||||
q.tail = 0 |
|
||||
q.count = 0 |
|
||||
} |
|
||||
|
|
||||
// Rotate rotates the deque n steps front-to-back. If n is negative, rotates
|
|
||||
// back-to-front. Having Deque provide Rotate() avoids resizing that could
|
|
||||
// happen if implementing rotation using only Pop and Push methods.
|
|
||||
func (q *Deque) Rotate(n int) { |
|
||||
if q.count <= 1 { |
|
||||
return |
|
||||
} |
|
||||
// Rotating a multiple of q.count is same as no rotation.
|
|
||||
n %= q.count |
|
||||
if n == 0 { |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
modBits := len(q.buf) - 1 |
|
||||
// If no empty space in buffer, only move head and tail indexes.
|
|
||||
if q.head == q.tail { |
|
||||
// Calculate new head and tail using bitwise modulus.
|
|
||||
q.head = (q.head + n) & modBits |
|
||||
q.tail = (q.tail + n) & modBits |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
if n < 0 { |
|
||||
// Rotate back to front.
|
|
||||
for ; n < 0; n++ { |
|
||||
// Calculate new head and tail using bitwise modulus.
|
|
||||
q.head = (q.head - 1) & modBits |
|
||||
q.tail = (q.tail - 1) & modBits |
|
||||
// Put tail value at head and remove value at tail.
|
|
||||
q.buf[q.head] = q.buf[q.tail] |
|
||||
q.buf[q.tail] = nil |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// Rotate front to back.
|
|
||||
for ; n > 0; n-- { |
|
||||
// Put head value at tail and remove value at head.
|
|
||||
q.buf[q.tail] = q.buf[q.head] |
|
||||
q.buf[q.head] = nil |
|
||||
// Calculate new head and tail using bitwise modulus.
|
|
||||
q.head = (q.head + 1) & modBits |
|
||||
q.tail = (q.tail + 1) & modBits |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// SetMinCapacity sets a minimum capacity of 2^minCapacityExp. If the value of
|
|
||||
// the minimum capacity is less than or equal to the minimum allowed, then
|
|
||||
// capacity is set to the minimum allowed. This may be called at anytime to
|
|
||||
// set a new minimum capacity.
|
|
||||
//
|
|
||||
// Setting a larger minimum capacity may be used to prevent resizing when the
|
|
||||
// number of stored items changes frequently across a wide range.
|
|
||||
func (q *Deque) SetMinCapacity(minCapacityExp uint) { |
|
||||
if 1<<minCapacityExp > minCapacity { |
|
||||
q.minCap = 1 << minCapacityExp |
|
||||
} else { |
|
||||
q.minCap = minCapacity |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// prev returns the previous buffer position wrapping around buffer.
|
|
||||
func (q *Deque) prev(i int) int { |
|
||||
return (i - 1) & (len(q.buf) - 1) // bitwise modulus
|
|
||||
} |
|
||||
|
|
||||
// next returns the next buffer position wrapping around buffer.
|
|
||||
func (q *Deque) next(i int) int { |
|
||||
return (i + 1) & (len(q.buf) - 1) // bitwise modulus
|
|
||||
} |
|
||||
|
|
||||
// growIfFull resizes up if the buffer is full.
|
|
||||
func (q *Deque) growIfFull() { |
|
||||
if len(q.buf) == 0 { |
|
||||
if q.minCap == 0 { |
|
||||
q.minCap = minCapacity |
|
||||
} |
|
||||
q.buf = make([]interface{}, q.minCap) |
|
||||
return |
|
||||
} |
|
||||
if q.count == len(q.buf) { |
|
||||
q.resize() |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// shrinkIfExcess resize down if the buffer 1/4 full.
|
|
||||
func (q *Deque) shrinkIfExcess() { |
|
||||
if len(q.buf) > q.minCap && (q.count<<2) == len(q.buf) { |
|
||||
q.resize() |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// resize resizes the deque to fit exactly twice its current contents. This is
|
|
||||
// used to grow the queue when it is full, and also to shrink it when it is
|
|
||||
// only a quarter full.
|
|
||||
func (q *Deque) resize() { |
|
||||
newBuf := make([]interface{}, q.count<<1) |
|
||||
if q.tail > q.head { |
|
||||
copy(newBuf, q.buf[q.head:q.tail]) |
|
||||
} else { |
|
||||
n := copy(newBuf, q.buf[q.head:]) |
|
||||
copy(newBuf[n:], q.buf[:q.tail]) |
|
||||
} |
|
||||
|
|
||||
q.head = 0 |
|
||||
q.tail = q.count |
|
||||
q.buf = newBuf |
|
||||
} |
|
||||
@ -1,51 +0,0 @@ |
|||||
package container |
|
||||
|
|
||||
// LimitedQueue 是一个具有有限容量的泛型队列
|
|
||||
type LimitedQueue[T any] struct { |
|
||||
capacity int |
|
||||
queue []T |
|
||||
} |
|
||||
|
|
||||
// NewLimitedQueue 创建一个新的 LimitedQueue
|
|
||||
func NewLimitedQueue[T any](capacity int) *LimitedQueue[T] { |
|
||||
return &LimitedQueue[T]{ |
|
||||
capacity: capacity, |
|
||||
queue: make([]T, 0, capacity), |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Enqueue 向队列中添加一个元素
|
|
||||
func (lq *LimitedQueue[T]) Enqueue(value T) { |
|
||||
if len(lq.queue) >= lq.capacity { |
|
||||
lq.queue = lq.queue[1:] |
|
||||
} |
|
||||
lq.queue = append(lq.queue, value) |
|
||||
} |
|
||||
|
|
||||
// Dequeue 从队列中移除最早添加的元素
|
|
||||
func (lq *LimitedQueue[T]) Dequeue() *T { |
|
||||
if len(lq.queue) == 0 { |
|
||||
return nil |
|
||||
} |
|
||||
elem := lq.queue[0] |
|
||||
lq.queue = lq.queue[1:] |
|
||||
return &elem |
|
||||
} |
|
||||
|
|
||||
// Len 返回队列的长度
|
|
||||
func (lq *LimitedQueue[T]) Len() int { |
|
||||
return len(lq.queue) |
|
||||
} |
|
||||
|
|
||||
// Peek 返回队列的第一个元素但不移除它
|
|
||||
func (lq *LimitedQueue[T]) Peek() *T { |
|
||||
if len(lq.queue) == 0 { |
|
||||
return nil |
|
||||
} |
|
||||
return &lq.queue[0] |
|
||||
} |
|
||||
|
|
||||
// ToSlice 返回队列中所有元素的切片
|
|
||||
func (lq *LimitedQueue[T]) ToSlice() []T { |
|
||||
return append([]T(nil), lq.queue...) |
|
||||
} |
|
||||
@ -1,46 +0,0 @@ |
|||||
package container |
|
||||
|
|
||||
import ( |
|
||||
"container/list" |
|
||||
"fmt" |
|
||||
"sync" |
|
||||
) |
|
||||
|
|
||||
type Queue struct { |
|
||||
sync.Mutex |
|
||||
data *list.List |
|
||||
} |
|
||||
|
|
||||
func NewQueue() *Queue { |
|
||||
q := new(Queue) |
|
||||
q.data = list.New() |
|
||||
return q |
|
||||
} |
|
||||
|
|
||||
func (q *Queue) Len() int { |
|
||||
return q.data.Len() |
|
||||
} |
|
||||
|
|
||||
func (q *Queue) Push(v interface{}) { |
|
||||
defer q.Unlock() |
|
||||
q.Lock() |
|
||||
q.data.PushFront(v) |
|
||||
} |
|
||||
|
|
||||
func (q *Queue) Pop() interface{} { |
|
||||
defer q.Unlock() |
|
||||
q.Lock() |
|
||||
iter := q.data.Back() |
|
||||
if iter == nil { |
|
||||
return nil |
|
||||
} |
|
||||
v := iter.Value |
|
||||
q.data.Remove(iter) |
|
||||
return v |
|
||||
} |
|
||||
|
|
||||
func (q *Queue) Dump() { |
|
||||
for iter := q.data.Back(); iter != nil; iter = iter.Prev() { |
|
||||
fmt.Println("item:", iter.Value) |
|
||||
} |
|
||||
} |
|
||||
@ -1,112 +0,0 @@ |
|||||
package addr |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"net" |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
privateBlocks []*net.IPNet |
|
||||
) |
|
||||
|
|
||||
func init() { |
|
||||
for _, b := range []string{"10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "100.64.0.0/10"} { |
|
||||
if _, block, err := net.ParseCIDR(b); err == nil { |
|
||||
privateBlocks = append(privateBlocks, block) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func isPrivateIP(ipAddr string) bool { |
|
||||
ip := net.ParseIP(ipAddr) |
|
||||
for _, priv := range privateBlocks { |
|
||||
if priv.Contains(ip) { |
|
||||
return true |
|
||||
} |
|
||||
} |
|
||||
return false |
|
||||
} |
|
||||
|
|
||||
// Extract returns a real ip
|
|
||||
func Extract(addr string) (string, error) { |
|
||||
// if addr specified then its returned
|
|
||||
if len(addr) > 0 && (addr != "0.0.0.0" && addr != "[::]") { |
|
||||
return addr, nil |
|
||||
} |
|
||||
|
|
||||
addrs, err := net.InterfaceAddrs() |
|
||||
if err != nil { |
|
||||
return "", fmt.Errorf("Failed to get interface addresses! Err: %v", err) |
|
||||
} |
|
||||
|
|
||||
var ipAddr []byte |
|
||||
|
|
||||
for _, rawAddr := range addrs { |
|
||||
var ip net.IP |
|
||||
switch addr := rawAddr.(type) { |
|
||||
case *net.IPAddr: |
|
||||
ip = addr.IP |
|
||||
case *net.IPNet: |
|
||||
ip = addr.IP |
|
||||
default: |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
if ip.To4() == nil { |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
if !isPrivateIP(ip.String()) { |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
ipAddr = ip |
|
||||
break |
|
||||
} |
|
||||
|
|
||||
if ipAddr == nil { |
|
||||
return "", fmt.Errorf("No private IP address found, and explicit IP not provided") |
|
||||
} |
|
||||
|
|
||||
return net.IP(ipAddr).String(), nil |
|
||||
} |
|
||||
|
|
||||
// IPs returns all known ips
|
|
||||
func IPs() []string { |
|
||||
ifaces, err := net.Interfaces() |
|
||||
if err != nil { |
|
||||
return nil |
|
||||
} |
|
||||
|
|
||||
var ipAddrs []string |
|
||||
|
|
||||
for _, i := range ifaces { |
|
||||
addrs, err := i.Addrs() |
|
||||
if err != nil { |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
for _, addr := range addrs { |
|
||||
var ip net.IP |
|
||||
switch v := addr.(type) { |
|
||||
case *net.IPNet: |
|
||||
ip = v.IP |
|
||||
case *net.IPAddr: |
|
||||
ip = v.IP |
|
||||
} |
|
||||
|
|
||||
if ip == nil { |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
ip = ip.To4() |
|
||||
if ip == nil { |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
ipAddrs = append(ipAddrs, ip.String()) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
return ipAddrs |
|
||||
} |
|
||||
@ -1,38 +0,0 @@ |
|||||
package addr |
|
||||
|
|
||||
import ( |
|
||||
"net" |
|
||||
"testing" |
|
||||
) |
|
||||
|
|
||||
func TestExtractor(t *testing.T) { |
|
||||
testData := []struct { |
|
||||
addr string |
|
||||
expect string |
|
||||
parse bool |
|
||||
}{ |
|
||||
{"127.0.0.1", "127.0.0.1", false}, |
|
||||
{"10.0.0.1", "10.0.0.1", false}, |
|
||||
{"", "", true}, |
|
||||
{"0.0.0.0", "", true}, |
|
||||
{"[::]", "", true}, |
|
||||
} |
|
||||
|
|
||||
for _, d := range testData { |
|
||||
addr, err := Extract(d.addr) |
|
||||
if err != nil { |
|
||||
t.Errorf("Unexpected error %v", err) |
|
||||
} |
|
||||
|
|
||||
if d.parse { |
|
||||
ip := net.ParseIP(addr) |
|
||||
if ip == nil { |
|
||||
t.Error("Unexpected nil IP") |
|
||||
} |
|
||||
|
|
||||
} else if addr != d.expect { |
|
||||
t.Errorf("Expected %s got %s", d.expect, addr) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
@ -1,55 +0,0 @@ |
|||||
package ip |
|
||||
|
|
||||
import ( |
|
||||
"io/ioutil" |
|
||||
"net" |
|
||||
"net/http" |
|
||||
|
|
||||
json "github.com/json-iterator/go" |
|
||||
|
|
||||
"github.com/axgle/mahonia" |
|
||||
) |
|
||||
|
|
||||
type IPInfo struct { |
|
||||
IP string `json:"ip"` |
|
||||
Pro string `json:"pro"` |
|
||||
ProCode string `json:"proCode"` |
|
||||
City string `json:"city"` |
|
||||
CityCode string `json:"cityCode"` |
|
||||
Region string `json:"region"` |
|
||||
RegionCode string `json:"regionCode"` |
|
||||
Addr string `json:"addr"` |
|
||||
RegionNames string `json:"regionNames"` |
|
||||
Err string `json:"err"` |
|
||||
} |
|
||||
|
|
||||
// 获取以太网IP
|
|
||||
func GetEthernetInfo() *IPInfo { |
|
||||
url := "http://whois.pconline.com.cn/ipJson.jsp?json=true" |
|
||||
resp, err := http.Get(url) |
|
||||
if err != nil { |
|
||||
return nil |
|
||||
} |
|
||||
defer resp.Body.Close() |
|
||||
body, err := ioutil.ReadAll(resp.Body) |
|
||||
if err != nil { |
|
||||
return nil |
|
||||
} |
|
||||
bodystr := mahonia.NewDecoder("gbk").ConvertString(string(body)) |
|
||||
var result IPInfo |
|
||||
if err := json.Unmarshal([]byte(bodystr), &result); err != nil { |
|
||||
return nil |
|
||||
} |
|
||||
return &result |
|
||||
} |
|
||||
|
|
||||
// 获取本地Ip
|
|
||||
func GetOutboundIP() string { |
|
||||
conn, err := net.Dial("udp", "8.8.8.8:80") |
|
||||
if err != nil { |
|
||||
return "" |
|
||||
} |
|
||||
defer conn.Close() |
|
||||
localAddr := conn.LocalAddr().(*net.UDPAddr) |
|
||||
return localAddr.IP.String() |
|
||||
} |
|
||||
@ -1,83 +0,0 @@ |
|||||
package container |
|
||||
|
|
||||
import ( |
|
||||
"sync/atomic" |
|
||||
"unsafe" |
|
||||
) |
|
||||
|
|
||||
// LKQueue is a lock-free unbounded queue.
|
|
||||
type LKQueue struct { |
|
||||
head unsafe.Pointer |
|
||||
tail unsafe.Pointer |
|
||||
size int32 |
|
||||
} |
|
||||
type node struct { |
|
||||
value interface{} |
|
||||
next unsafe.Pointer |
|
||||
} |
|
||||
|
|
||||
// NewLKQueue returns an empty queue.
|
|
||||
func NewLKQueue() *LKQueue { |
|
||||
n := unsafe.Pointer(&node{}) |
|
||||
return &LKQueue{head: n, tail: n, size: 0} |
|
||||
} |
|
||||
|
|
||||
// Enqueue puts the given value v at the tail of the queue.
|
|
||||
func (q *LKQueue) Enqueue(v interface{}) { |
|
||||
n := &node{value: v} |
|
||||
for { |
|
||||
tail := load(&q.tail) |
|
||||
next := load(&tail.next) |
|
||||
if tail == load(&q.tail) { // are tail and next consistent?
|
|
||||
if next == nil { |
|
||||
if cas(&tail.next, next, n) { |
|
||||
cas(&q.tail, tail, n) // Enqueue is done. try to swing tail to the inserted node
|
|
||||
atomic.AddInt32(&q.size, 1) |
|
||||
return |
|
||||
} |
|
||||
} else { // tail was not pointing to the last node
|
|
||||
// try to swing Tail to the next node
|
|
||||
cas(&q.tail, tail, next) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// Dequeue removes and returns the value at the head of the queue.
|
|
||||
// It returns nil if the queue is empty.
|
|
||||
func (q *LKQueue) Dequeue() interface{} { |
|
||||
for { |
|
||||
head := load(&q.head) |
|
||||
tail := load(&q.tail) |
|
||||
next := load(&head.next) |
|
||||
if head == load(&q.head) { // are head, tail, and next consistent?
|
|
||||
if head == tail { // is queue empty or tail falling behind?
|
|
||||
if next == nil { // is queue empty?
|
|
||||
return nil |
|
||||
} |
|
||||
// tail is falling behind. try to advance it
|
|
||||
cas(&q.tail, tail, next) |
|
||||
} else { |
|
||||
// read value before CAS otherwise another dequeue might free the next node
|
|
||||
v := next.value |
|
||||
if cas(&q.head, head, next) { |
|
||||
atomic.AddInt32(&q.size, -1) |
|
||||
return v // Dequeue is done. return
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func (q *LKQueue) Size() int32 { |
|
||||
return atomic.LoadInt32(&q.size) |
|
||||
} |
|
||||
|
|
||||
func load(p *unsafe.Pointer) (n *node) { |
|
||||
return (*node)(atomic.LoadPointer(p)) |
|
||||
} |
|
||||
|
|
||||
func cas(p *unsafe.Pointer, old, new *node) (ok bool) { |
|
||||
return atomic.CompareAndSwapPointer( |
|
||||
p, unsafe.Pointer(old), unsafe.Pointer(new)) |
|
||||
} |
|
||||
@ -1,35 +0,0 @@ |
|||||
package sortslice |
|
||||
|
|
||||
//排序工具
|
|
||||
func quickSort(arr []interface{}, start, end int, compete func(a interface{}, b interface{}) int8) { |
|
||||
if start < end { |
|
||||
i, j := start, end |
|
||||
key := arr[(start+end)/2] |
|
||||
for i <= j { |
|
||||
for compete(arr[i], key) == -1 { |
|
||||
i++ |
|
||||
} |
|
||||
for compete(arr[j], key) == 1 { |
|
||||
j-- |
|
||||
} |
|
||||
if i <= j { |
|
||||
arr[i], arr[j] = arr[j], arr[i] |
|
||||
i++ |
|
||||
j-- |
|
||||
} |
|
||||
} |
|
||||
if start < j { |
|
||||
quickSort(arr, start, j, compete) |
|
||||
} |
|
||||
if end > i { |
|
||||
quickSort(arr, i, end, compete) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func Sort(a []interface{}, compete func(a interface{}, b interface{}) int8) { |
|
||||
if len(a) < 2 { |
|
||||
return |
|
||||
} |
|
||||
quickSort(a, 0, len(a)-1, compete) |
|
||||
} |
|
||||
@ -1,27 +0,0 @@ |
|||||
package sortslice |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"hash/crc32" |
|
||||
"sort" |
|
||||
) |
|
||||
|
|
||||
type uInt32Slice []uint32 |
|
||||
|
|
||||
func (p uInt32Slice) Len() int { return len(p) } |
|
||||
func (p uInt32Slice) Less(i, j int) bool { return p[i] < p[j] } |
|
||||
func (p uInt32Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } |
|
||||
|
|
||||
// Sort is a convenience method.
|
|
||||
func (p uInt32Slice) Sort() { sort.Sort(p) } |
|
||||
|
|
||||
func GetSessionId(session []uint32) (Id uint32) { |
|
||||
s := uInt32Slice(session) |
|
||||
s.Sort() |
|
||||
Session := "" |
|
||||
for _, v := range s { |
|
||||
Session = Session + fmt.Sprintf("%d", v) |
|
||||
} |
|
||||
Id = crc32.ChecksumIEEE([]byte(Session)) |
|
||||
return |
|
||||
} |
|
||||
@ -1,15 +0,0 @@ |
|||||
package version |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"testing" |
|
||||
"time" |
|
||||
) |
|
||||
|
|
||||
func Test_Version(t *testing.T) { |
|
||||
versionA := "1.2.3a " |
|
||||
versionB := "1.2.3b " |
|
||||
fmt.Println(CompareStrVer(versionA, versionB)) |
|
||||
time.LoadLocation("Local ") |
|
||||
fmt.Println(time.Now()) |
|
||||
} |
|
||||
@ -1,66 +0,0 @@ |
|||||
package version |
|
||||
|
|
||||
import ( |
|
||||
"strings" |
|
||||
) |
|
||||
|
|
||||
func CompareStrVer(verA, verB string) int8 { |
|
||||
verStrArrA := spliteStrByNet(verA) |
|
||||
verStrArrB := spliteStrByNet(verB) |
|
||||
lenStrA := len(verStrArrA) |
|
||||
lenStrB := len(verStrArrB) |
|
||||
if lenStrA > lenStrB { |
|
||||
return 1 |
|
||||
} |
|
||||
if lenStrA < lenStrB { |
|
||||
return -1 |
|
||||
} |
|
||||
return compareArrStrVers(verStrArrA, verStrArrB) |
|
||||
} |
|
||||
|
|
||||
// 比较版本号字符串数组
|
|
||||
func compareArrStrVers(verA, verB []string) int8 { |
|
||||
for index, _ := range verA { |
|
||||
littleResult := compareLittleVer(verA[index], verB[index]) |
|
||||
if littleResult != 0 { |
|
||||
return littleResult |
|
||||
} |
|
||||
} |
|
||||
return 0 |
|
||||
} |
|
||||
|
|
||||
//
|
|
||||
// 比较小版本号字符串
|
|
||||
//
|
|
||||
func compareLittleVer(verA, verB string) int8 { |
|
||||
bytesA := []byte(verA) |
|
||||
bytesB := []byte(verB) |
|
||||
lenA := len(bytesA) |
|
||||
lenB := len(bytesB) |
|
||||
if lenA > lenB { |
|
||||
return 1 |
|
||||
} |
|
||||
if lenA < lenB { |
|
||||
return -1 |
|
||||
} |
|
||||
//如果长度相等则按byte位进行比较
|
|
||||
return compareByBytes(bytesA, bytesB) |
|
||||
} |
|
||||
|
|
||||
// 按byte位进行比较小版本号
|
|
||||
func compareByBytes(verA, verB []byte) int8 { |
|
||||
for index, _ := range verA { |
|
||||
if verA[index] > verB[index] { |
|
||||
return 1 |
|
||||
} |
|
||||
if verA[index] < verB[index] { |
|
||||
return -1 |
|
||||
} |
|
||||
} |
|
||||
return 0 |
|
||||
} |
|
||||
|
|
||||
// 按“.”分割版本号为小版本号的字符串数组
|
|
||||
func spliteStrByNet(strV string) []string { |
|
||||
return strings.Split(strV, ". ") |
|
||||
} |
|
||||
@ -1,13 +0,0 @@ |
|||||
package base64 |
|
||||
|
|
||||
import "encoding/base64" |
|
||||
|
|
||||
///编码
|
|
||||
func EncodeToString(src []byte) string { |
|
||||
return base64.StdEncoding.EncodeToString(src) |
|
||||
} |
|
||||
|
|
||||
///解码
|
|
||||
func DecodeString(s string) ([]byte, error) { |
|
||||
return base64.StdEncoding.DecodeString(s) |
|
||||
} |
|
||||
@ -1,116 +0,0 @@ |
|||||
package crypto |
|
||||
|
|
||||
/* |
|
||||
国密算法库 github.com/tjfoc/gmsm/ 封装 |
|
||||
*/ |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"crypto/rand" |
|
||||
|
|
||||
"github.com/tjfoc/gmsm/sm2" |
|
||||
"github.com/tjfoc/gmsm/sm3" |
|
||||
"github.com/tjfoc/gmsm/sm4" |
|
||||
"github.com/tjfoc/gmsm/x509" |
|
||||
) |
|
||||
|
|
||||
///生成密钥对
|
|
||||
func GenerateKey(key string) (*sm2.PrivateKey, error) { |
|
||||
return sm2.GenerateKey(bytes.NewBufferString(key)) |
|
||||
} |
|
||||
|
|
||||
///读取私钥
|
|
||||
func ReadPrivateKeyFromPem(privateKeyPem []byte, pwd []byte) (*sm2.PrivateKey, error) { |
|
||||
return x509.ReadPrivateKeyFromPem(privateKeyPem, pwd) |
|
||||
} |
|
||||
|
|
||||
///读取私钥
|
|
||||
func ReadPublicKeyFromPem(privateKeyPem []byte) (*sm2.PublicKey, error) { |
|
||||
return x509.ReadPublicKeyFromPem(privateKeyPem) |
|
||||
} |
|
||||
|
|
||||
///国密—SM2-加密
|
|
||||
func GM_SM2_Encry(origData []byte, pub *sm2.PublicKey) (ciphertext []byte, err error) { |
|
||||
ciphertext, err = pub.EncryptAsn1(origData, rand.Reader) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
///国密—SM2-解密
|
|
||||
func GM_SM2_Decry(ciphertext []byte, priv *sm2.PrivateKey) (origData []byte, err error) { |
|
||||
origData, err = priv.DecryptAsn1(ciphertext) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
///国密—SM2-签名
|
|
||||
func GM_SM2_Sign(origData, key string) (sign string, err error) { |
|
||||
var ( |
|
||||
priv *sm2.PrivateKey |
|
||||
msg []byte |
|
||||
signdata []byte |
|
||||
) |
|
||||
if priv, err = sm2.GenerateKey(bytes.NewBufferString(key)); err != nil { |
|
||||
return |
|
||||
} |
|
||||
msg = []byte(origData) |
|
||||
if signdata, err = priv.Sign(rand.Reader, msg, nil); err != nil { |
|
||||
return |
|
||||
} |
|
||||
sign = string(signdata) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
///国密—SM2-验签
|
|
||||
func GM_SM2_Verify(origData, sign, key string) (isok bool, err error) { |
|
||||
var ( |
|
||||
priv *sm2.PrivateKey |
|
||||
pub *sm2.PublicKey |
|
||||
) |
|
||||
if priv, err = sm2.GenerateKey(bytes.NewBufferString(key)); err != nil { |
|
||||
return |
|
||||
} |
|
||||
pub = &priv.PublicKey |
|
||||
isok = pub.Verify([]byte(origData), []byte(sign)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
///国密—SM3-哈希
|
|
||||
func GM_SM3_Hash(origData string) (hash string) { |
|
||||
h := sm3.New() |
|
||||
h.Write([]byte(origData)) |
|
||||
hash = string(h.Sum(nil)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
///国密-SM4-sm4Ecb模式pksc7填充加密
|
|
||||
func GM_SM4_Ecb(origData string, key string) (ciphertext string, err error) { |
|
||||
var ( |
|
||||
iv []byte |
|
||||
ecbdata []byte |
|
||||
) |
|
||||
iv = []byte("0000000000000000") |
|
||||
if err = sm4.SetIV(iv); err != nil { //设置SM4算法实现的IV值,不设置则使用默认值
|
|
||||
return |
|
||||
} |
|
||||
if ecbdata, err = sm4.Sm4Ecb([]byte(key), []byte(origData), true); err != nil { //sm4Ecb模式pksc7填充加密
|
|
||||
return |
|
||||
} |
|
||||
ciphertext = string(ecbdata) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
///国密-SM4-sm4Ecb模式pksc7填充加密
|
|
||||
func GM_SM4_Dec(ciphertext string, key string) (origData string, err error) { |
|
||||
var ( |
|
||||
iv []byte |
|
||||
ecbdata []byte |
|
||||
) |
|
||||
iv = []byte("0000000000000000") |
|
||||
if err = sm4.SetIV(iv); err != nil { //设置SM4算法实现的IV值,不设置则使用默认值
|
|
||||
return |
|
||||
} |
|
||||
if ecbdata, err = sm4.Sm4Ecb([]byte(key), []byte(ciphertext), false); err != nil { //sm4Ecb模式pksc7填充加密
|
|
||||
return |
|
||||
} |
|
||||
origData = string(ecbdata) |
|
||||
return |
|
||||
} |
|
||||
@ -1,87 +0,0 @@ |
|||||
package crypto |
|
||||
|
|
||||
import ( |
|
||||
"crypto/rand" |
|
||||
"fmt" |
|
||||
"testing" |
|
||||
|
|
||||
"github.com/tjfoc/gmsm/sm2" |
|
||||
"github.com/tjfoc/gmsm/x509" |
|
||||
) |
|
||||
|
|
||||
func Test_GM_SM2_Encry(t *testing.T) { |
|
||||
priv, err := sm2.GenerateKey(nil) // 生成密钥对
|
|
||||
if err != nil { |
|
||||
t.Fatal(err) |
|
||||
} |
|
||||
privPem, err := x509.WritePrivateKeyToPem(priv, nil) // 生成密钥文件
|
|
||||
if err != nil { |
|
||||
t.Fatal(err) |
|
||||
} else { |
|
||||
fmt.Printf("privPem:%s\n", string(privPem)) |
|
||||
} |
|
||||
pubKey, _ := priv.Public().(*sm2.PublicKey) |
|
||||
pubkeyPem, err := x509.WritePublicKeyToPem(pubKey) // 生成公钥文件
|
|
||||
_, err = x509.ReadPrivateKeyFromPem(privPem, nil) // 读取密钥
|
|
||||
if err != nil { |
|
||||
t.Fatal(err) |
|
||||
} else { |
|
||||
fmt.Printf("pubkeyPem:%s\n", string(pubkeyPem)) |
|
||||
} |
|
||||
pubKey, err = x509.ReadPublicKeyFromPem(pubkeyPem) // 读取公钥
|
|
||||
if err != nil { |
|
||||
t.Fatal(err) |
|
||||
} |
|
||||
cipher, err := pubKey.EncryptAsn1([]byte( |
|
||||
`liwei1dao |
|
||||
liwei2dao |
|
||||
liwei3dao |
|
||||
liwei4dao`), rand.Reader) |
|
||||
if err != nil { |
|
||||
t.Fatal(err) |
|
||||
} else { |
|
||||
fmt.Printf("cipher:%s\n", string(cipher)) |
|
||||
} |
|
||||
|
|
||||
origData, err := priv.DecryptAsn1(cipher) |
|
||||
if err != nil { |
|
||||
t.Fatal(err) |
|
||||
} else { |
|
||||
fmt.Printf("origData:%s\n", string(origData)) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func Test_GM_SM2_Decry(t *testing.T) { |
|
||||
|
|
||||
} |
|
||||
|
|
||||
func Test_GM_SM2_Sign(t *testing.T) { |
|
||||
origData, err := GM_SM2_Sign("token", "123456781234567812345678") |
|
||||
fmt.Printf("origData:%s err:%v", origData, err) |
|
||||
} |
|
||||
|
|
||||
func Test_GM_SM2_Verify(t *testing.T) { |
|
||||
isok, err := GM_SM2_Verify("token", "123456781234567812345678", "") |
|
||||
fmt.Printf("isok:%v rr:%v", isok, err) |
|
||||
} |
|
||||
|
|
||||
func Test_GM_SM3_Hash(t *testing.T) { |
|
||||
hash := GM_SM3_Hash("123456781234567812345678") |
|
||||
fmt.Printf("hash:%v", hash) |
|
||||
} |
|
||||
|
|
||||
func Test_GM_SM4_Ecb(t *testing.T) { |
|
||||
ciphertext, err := GM_SM4_Ecb("123456781234567812345678", "") |
|
||||
fmt.Printf("ciphertext:%v err:%v", ciphertext, err) |
|
||||
} |
|
||||
|
|
||||
func Test_GM_SM4_Dec(t *testing.T) { |
|
||||
ciphertext, err := GM_SM4_Dec("123456781234567812345678", "") |
|
||||
fmt.Printf("ciphertext:%v err:%v", ciphertext, err) |
|
||||
} |
|
||||
|
|
||||
func Test_GM_SM2_Hex(t *testing.T) { |
|
||||
// if priv, err := x509.ReadPrivateKeyFromHex(""); err != nil {
|
|
||||
|
|
||||
// }
|
|
||||
} |
|
||||
@ -1,49 +0,0 @@ |
|||||
package gm_java |
|
||||
|
|
||||
/* |
|
||||
国密算法库 github.com/ZZMarquis/gm/sm2 封装 |
|
||||
主要处理Java 版本国密算法 |
|
||||
*/ |
|
||||
|
|
||||
import ( |
|
||||
"encoding/base64" |
|
||||
"fmt" |
|
||||
|
|
||||
"github.com/ZZMarquis/gm/sm2" |
|
||||
) |
|
||||
|
|
||||
//样例 base64Key:FXlrn8jX61JDcBtOOh59yy/sM2r1hBT5XODayZKRDVE=
|
|
||||
func ReadPrivateKeyFormBase64(base64Key string) (privKey *sm2.PrivateKey, err error) { |
|
||||
var ( |
|
||||
key []byte |
|
||||
) |
|
||||
if key, err = base64.StdEncoding.DecodeString(base64Key); err != nil { |
|
||||
err = fmt.Errorf("ReadPrivateKeyFormBase64 Base64 DecodeString err:%v", err) |
|
||||
return |
|
||||
} |
|
||||
privKey, err = sm2.RawBytesToPrivateKey(key) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
//样例 base64Key:BHa3F+W4YhmWoqa7glAURrU7vijUSNtg+9ZnQREuq/8+6MsGAc7
|
|
||||
func ReadPublicKeyFormBase64(base64Key string) (pubKey *sm2.PublicKey, err error) { |
|
||||
var ( |
|
||||
key []byte |
|
||||
) |
|
||||
if key, err = base64.StdEncoding.DecodeString(base64Key); err != nil { |
|
||||
err = fmt.Errorf("ReadPublicKeyFormBase64 Base64 DecodeString err:%v", err) |
|
||||
return |
|
||||
} |
|
||||
pubKey, err = sm2.RawBytesToPublicKey(key) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
///SM2 加密
|
|
||||
func SM2_Encrypt(pubKey *sm2.PublicKey, in []byte) ([]byte, error) { |
|
||||
return sm2.Encrypt(pubKey, in, sm2.C1C3C2) |
|
||||
} |
|
||||
|
|
||||
///SM2 解密
|
|
||||
func SM2_Decrypt(privKey *sm2.PrivateKey, in []byte) ([]byte, error) { |
|
||||
return sm2.Decrypt(privKey, in, sm2.C1C3C2) |
|
||||
} |
|
||||
@ -1,21 +0,0 @@ |
|||||
package gm_java |
|
||||
|
|
||||
import ( |
|
||||
"encoding/base64" |
|
||||
"fmt" |
|
||||
"io/ioutil" |
|
||||
"testing" |
|
||||
|
|
||||
"github.com/ZZMarquis/gm/sm2" |
|
||||
) |
|
||||
|
|
||||
func Test_RSA_Decrypt(t *testing.T) { |
|
||||
data, _ := base64.StdEncoding.DecodeString("FXlrn8jX61JDcBtOOh59yy/sM2r1hBT5XODayZKRDVE=") |
|
||||
privKey, err := sm2.RawBytesToPrivateKey(data) |
|
||||
fmt.Printf("privKey:%v err:%v\n", privKey, err) |
|
||||
content, err := ioutil.ReadFile("encode.txt") |
|
||||
fmt.Printf("content:%s err:%v\n", string(content), err) |
|
||||
mdata, _ := base64.StdEncoding.DecodeString(string(content)) |
|
||||
orgdata, err := sm2.Decrypt(privKey, mdata, sm2.C1C3C2) |
|
||||
fmt.Printf("orgdata:%s err:%v\n", string(orgdata), err) |
|
||||
} |
|
||||
@ -1,133 +0,0 @@ |
|||||
package sra |
|
||||
|
|
||||
/* |
|
||||
RSA 非对称加密算法封装 |
|
||||
*/ |
|
||||
|
|
||||
import ( |
|
||||
"crypto" |
|
||||
"crypto/rand" |
|
||||
"crypto/rsa" |
|
||||
"crypto/sha256" |
|
||||
"crypto/x509" |
|
||||
"encoding/pem" |
|
||||
"errors" |
|
||||
"fmt" |
|
||||
) |
|
||||
|
|
||||
//RSA公钥私钥产生
|
|
||||
func GenRsaKey(bits int) (prvkey, pubkey []byte, err error) { |
|
||||
// 生成私钥文件
|
|
||||
privateKey, err := rsa.GenerateKey(rand.Reader, bits) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
derStream := x509.MarshalPKCS1PrivateKey(privateKey) |
|
||||
block := &pem.Block{ |
|
||||
Type: "RSA PRIVATE KEY", |
|
||||
Bytes: derStream, |
|
||||
} |
|
||||
prvkey = pem.EncodeToMemory(block) |
|
||||
publicKey := &privateKey.PublicKey |
|
||||
derPkix, err := x509.MarshalPKIXPublicKey(publicKey) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
block = &pem.Block{ |
|
||||
Type: "PUBLIC KEY", |
|
||||
Bytes: derPkix, |
|
||||
} |
|
||||
pubkey = pem.EncodeToMemory(block) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
//签名
|
|
||||
func RsaSignWithSha256(data []byte, keyBytes []byte) (sgin []byte, err error) { |
|
||||
var ( |
|
||||
privateKey *rsa.PrivateKey |
|
||||
) |
|
||||
h := sha256.New() |
|
||||
h.Write(data) |
|
||||
hashed := h.Sum(nil) |
|
||||
block, _ := pem.Decode(keyBytes) |
|
||||
if block == nil { |
|
||||
err = errors.New("private key error") |
|
||||
return |
|
||||
} |
|
||||
privateKey, err = x509.ParsePKCS1PrivateKey(block.Bytes) |
|
||||
if err != nil { |
|
||||
err = fmt.Errorf("ParsePKCS8PrivateKey err:%v", err) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
sgin, err = rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, hashed) |
|
||||
if err != nil { |
|
||||
err = fmt.Errorf("Error from signing err:%v", err) |
|
||||
return |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
//验证
|
|
||||
func RsaVerySignWithSha256(data, signData, keyBytes []byte) (issucc bool, err error) { |
|
||||
var ( |
|
||||
pubKey interface{} |
|
||||
) |
|
||||
block, _ := pem.Decode(keyBytes) |
|
||||
if block == nil { |
|
||||
err = errors.New("public key error") |
|
||||
return |
|
||||
} |
|
||||
pubKey, err = x509.ParsePKIXPublicKey(block.Bytes) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
hashed := sha256.Sum256(data) |
|
||||
err = rsa.VerifyPKCS1v15(pubKey.(*rsa.PublicKey), crypto.SHA256, hashed[:], signData) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
return true, nil |
|
||||
} |
|
||||
|
|
||||
// 公钥加密
|
|
||||
func RsaEncrypt(data, keyBytes []byte) ([]byte, error) { |
|
||||
//解密pem格式的公钥
|
|
||||
block, _ := pem.Decode(keyBytes) |
|
||||
if block == nil { |
|
||||
return nil, errors.New("public key error") |
|
||||
} |
|
||||
// 解析公钥
|
|
||||
pubInterface, err := x509.ParsePKIXPublicKey(block.Bytes) |
|
||||
if err != nil { |
|
||||
return nil, err |
|
||||
} |
|
||||
// 类型断言
|
|
||||
pub := pubInterface.(*rsa.PublicKey) |
|
||||
//加密
|
|
||||
ciphertext, err := rsa.EncryptPKCS1v15(rand.Reader, pub, data) |
|
||||
if err != nil { |
|
||||
return nil, err |
|
||||
} |
|
||||
return ciphertext, nil |
|
||||
} |
|
||||
|
|
||||
// 私钥解密
|
|
||||
func RsaDecrypt(ciphertext, keyBytes []byte) ([]byte, error) { |
|
||||
//获取私钥
|
|
||||
block, _ := pem.Decode(keyBytes) |
|
||||
if block == nil { |
|
||||
return nil, errors.New("private key error!") |
|
||||
} |
|
||||
//解析PKCS1格式的私钥
|
|
||||
priv, err := x509.ParsePKCS1PrivateKey(block.Bytes) |
|
||||
if err != nil { |
|
||||
return nil, err |
|
||||
} |
|
||||
// 解密
|
|
||||
data, err := rsa.DecryptPKCS1v15(rand.Reader, priv, ciphertext) |
|
||||
if err != nil { |
|
||||
return nil, err |
|
||||
} |
|
||||
return data, nil |
|
||||
} |
|
||||
@ -1,31 +0,0 @@ |
|||||
package sra |
|
||||
|
|
||||
import ( |
|
||||
"encoding/hex" |
|
||||
"fmt" |
|
||||
"testing" |
|
||||
) |
|
||||
|
|
||||
func Test_RSA(t *testing.T) { |
|
||||
//rsa 密钥文件产生
|
|
||||
fmt.Println("-------------------------------获取RSA公私钥-----------------------------------------") |
|
||||
prvKey, pubKey, _ := GenRsaKey(1204) |
|
||||
fmt.Println(string(prvKey)) |
|
||||
fmt.Println(string(pubKey)) |
|
||||
|
|
||||
fmt.Println("-------------------------------进行签名与验证操作-----------------------------------------") |
|
||||
var data = "卧了个槽，这么神奇的吗？？！！！ ԅ(¯﹃¯ԅ) ！！！！！！）" |
|
||||
fmt.Println("对消息进行签名操作...") |
|
||||
signData, _ := RsaSignWithSha256([]byte(data), prvKey) |
|
||||
fmt.Println("消息的签名信息： ", hex.EncodeToString(signData)) |
|
||||
fmt.Println("\n对签名信息进行验证...") |
|
||||
if ok, _ := RsaVerySignWithSha256([]byte(data), signData, pubKey); ok { |
|
||||
fmt.Println("签名信息验证成功，确定是正确私钥签名！！") |
|
||||
} |
|
||||
|
|
||||
fmt.Println("-------------------------------进行加密解密操作-----------------------------------------") |
|
||||
ciphertext, _ := RsaEncrypt([]byte(data), pubKey) |
|
||||
fmt.Println("公钥加密后的数据：", hex.EncodeToString(ciphertext)) |
|
||||
sourceData, _ := RsaDecrypt(ciphertext, prvKey) |
|
||||
fmt.Println("私钥解密后的数据：", string(sourceData)) |
|
||||
} |
|
||||
@ -1,113 +0,0 @@ |
|||||
package mcp |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"yunyan/lego/core" |
|
||||
"yunyan/lego/core/cbase" |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/sys/juhe" |
|
||||
"fmt" |
|
||||
|
|
||||
"github.com/mark3labs/mcp-go/mcp" |
|
||||
) |
|
||||
|
|
||||
// 股票信息卡片
|
|
||||
type FinanceCard struct { |
|
||||
CompanyName string `json:"companyName"` |
|
||||
CurrPrice string `json:"currPrice"` |
|
||||
OpenPrice string `json:"openPrice"` |
|
||||
TodayLow string `json:"todayLow"` |
|
||||
TodayHigh string `json:"todayHigh"` |
|
||||
Volume string `json:"volume"` |
|
||||
} |
|
||||
|
|
||||
// 股票查询
|
|
||||
type tool_finance struct { |
|
||||
cbase.ModuleCompBase |
|
||||
module *Mcp |
|
||||
} |
|
||||
|
|
||||
// 组件初始化接口
|
|
||||
func (this *tool_finance) Init(service core.IService, module core.IModule, comp core.IModuleComp, opt core.IModuleOptions) (err error) { |
|
||||
this.ModuleCompBase.Init(service, module, comp, opt) |
|
||||
this.module = module.(*Mcp) |
|
||||
return |
|
||||
} |
|
||||
func (this *tool_finance) Start() (err error) { |
|
||||
err = this.ModuleCompBase.Start() |
|
||||
if this.module.AddTool(ToolGroup_CHINA, this.Tool(), this.Handl) { |
|
||||
if err := juhe.OnInit(this.module.service.GetSettings().Sys["juhe"]); err != nil { |
|
||||
panic(fmt.Sprintf("init sys.juhe err: %s", err.Error())) |
|
||||
} else { |
|
||||
log.Infof("init sys.juhe success!") |
|
||||
} |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
func (this *tool_finance) Tool() (tool mcp.Tool) { |
|
||||
return mcp.NewTool("finance_query", |
|
||||
mcp.WithDescription("根据提供的股票代码查询股票信息"), |
|
||||
mcp.WithString("code", |
|
||||
mcp.Description("股票代码"), |
|
||||
mcp.Required(), |
|
||||
), |
|
||||
) |
|
||||
} |
|
||||
|
|
||||
// Handl 工具处理接口
|
|
||||
// 参数:
|
|
||||
// - ctx: 上下文
|
|
||||
// - request: MCP 工具调用请求
|
|
||||
//
|
|
||||
// 返回值:
|
|
||||
// - result: MCP 工具调用结果
|
|
||||
// - err: 处理过程中的错误
|
|
||||
//
|
|
||||
// 异常:
|
|
||||
// - 无（不主动 panic）
|
|
||||
func (this *tool_finance) Handl(ctx context.Context, request mcp.CallToolRequest) (result *mcp.CallToolResult, err error) { |
|
||||
var ( |
|
||||
code string |
|
||||
data *juhe.StockResponse |
|
||||
card *FinanceCard |
|
||||
context string |
|
||||
) |
|
||||
if code, err = request.RequireString("code"); err != nil { |
|
||||
return |
|
||||
} |
|
||||
if data, err = juhe.Financebygid(code); err != nil { |
|
||||
context = "获取天气信息失败" |
|
||||
} else { |
|
||||
context = fmt.Sprintf("当前%s股票情况:今日开盘价:%s,昨日收盘价:%s,当前价格:%s,今日最高价:%s,今日最低价:%s,成交量:%s,成交金额:%s", |
|
||||
data.FinanceResult[0].Data.Name, |
|
||||
data.FinanceResult[0].Data.TodayStartPri, |
|
||||
data.FinanceResult[0].Data.YestodEndPri, |
|
||||
data.FinanceResult[0].Data.NowPri, |
|
||||
data.FinanceResult[0].Data.TodayMax, |
|
||||
data.FinanceResult[0].Data.TodayMin, |
|
||||
data.FinanceResult[0].Data.TraNumber, |
|
||||
data.FinanceResult[0].Data.TraAmount, |
|
||||
) |
|
||||
card = &FinanceCard{ |
|
||||
CompanyName: code, |
|
||||
CurrPrice: data.FinanceResult[0].Data.NowPri, |
|
||||
OpenPrice: data.FinanceResult[0].Data.TodayStartPri, |
|
||||
TodayLow: data.FinanceResult[0].Data.TodayMin, |
|
||||
TodayHigh: data.FinanceResult[0].Data.TodayMax, |
|
||||
Volume: data.FinanceResult[0].Data.TraNumber, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
result = &mcp.CallToolResult{ |
|
||||
Content: []mcp.Content{ |
|
||||
mcp.TextContent{ |
|
||||
Type: "text", |
|
||||
Text: context, |
|
||||
}, |
|
||||
}, |
|
||||
} |
|
||||
result.Meta = map[string]interface{}{ |
|
||||
"tool_finance": card, |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,122 +0,0 @@ |
|||||
package mcp |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"yunyan/lego/core" |
|
||||
"yunyan/lego/core/cbase" |
|
||||
"yunyan/lego/sys/log" |
|
||||
lgspotify "yunyan/sys/spotify" |
|
||||
"yunyan/utils" |
|
||||
"fmt" |
|
||||
|
|
||||
"github.com/mark3labs/mcp-go/mcp" |
|
||||
"github.com/zmb3/spotify/v2" |
|
||||
) |
|
||||
|
|
||||
// 音乐卡片 结构统一化输出
|
|
||||
type SpotifyMusicCard struct { |
|
||||
Name string `json:"name"` |
|
||||
Images string `json:"image"` |
|
||||
Url string `json:"url"` |
|
||||
Sgener string `json:"sgener"` |
|
||||
} |
|
||||
|
|
||||
// 天气查询
|
|
||||
type tool_spotify_music_play struct { |
|
||||
cbase.ModuleCompBase |
|
||||
module *Mcp |
|
||||
} |
|
||||
|
|
||||
// 组件初始化接口
|
|
||||
func (this *tool_spotify_music_play) Init(service core.IService, module core.IModule, comp core.IModuleComp, opt core.IModuleOptions) (err error) { |
|
||||
this.ModuleCompBase.Init(service, module, comp, opt) |
|
||||
this.module = module.(*Mcp) |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *tool_spotify_music_play) Start() (err error) { |
|
||||
err = this.ModuleCompBase.Start() |
|
||||
if this.module.AddTool(ToolGroup_GLOBAL, this.Tool(), this.Handl) { |
|
||||
if err := lgspotify.OnInit(this.module.service.GetSettings().Sys["spotify"]); err != nil { |
|
||||
panic(fmt.Sprintf("init sys.spotify err: %s", err.Error())) |
|
||||
} else { |
|
||||
log.Infof("init sys.spotify success!") |
|
||||
} |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *tool_spotify_music_play) Tool() (tool mcp.Tool) { |
|
||||
return mcp.NewTool("spotify_music_play", |
|
||||
mcp.WithDescription("为用户提供音乐播放服务"), |
|
||||
mcp.WithString("query", |
|
||||
mcp.Description("Music keyword information"), |
|
||||
mcp.Required(), |
|
||||
), |
|
||||
mcp.WithString("offset", |
|
||||
mcp.Description("music offset (max 9, default 0)"), |
|
||||
mcp.DefaultNumber(0), |
|
||||
), |
|
||||
) |
|
||||
} |
|
||||
|
|
||||
// Handl 工具处理接口
|
|
||||
// 参数:
|
|
||||
// - ctx: 上下文
|
|
||||
// - request: MCP 工具调用请求
|
|
||||
//
|
|
||||
// 返回值:
|
|
||||
// - result: MCP 工具调用结果
|
|
||||
// - err: 处理过程中的错误
|
|
||||
//
|
|
||||
// 异常:
|
|
||||
// - 无（不主动 panic）
|
|
||||
func (this *tool_spotify_music_play) Handl(ctx context.Context, request mcp.CallToolRequest) (result *mcp.CallToolResult, err error) { |
|
||||
var ( |
|
||||
offset int |
|
||||
query string |
|
||||
data []spotify.FullTrack |
|
||||
card *SpotifyMusicCard |
|
||||
context string |
|
||||
) |
|
||||
offset = request.GetInt("offset", 0) |
|
||||
if query, err = request.RequireString("query"); err != nil { |
|
||||
return |
|
||||
} |
|
||||
data, err = lgspotify.SearchMusic(ctx, query, 1, offset) |
|
||||
|
|
||||
if err != nil { |
|
||||
context = "播放音乐失败" |
|
||||
log.Errorf("获取天气信息失败:%v", err) |
|
||||
return |
|
||||
} else { |
|
||||
card = &SpotifyMusicCard{ |
|
||||
Name: data[0].Name, |
|
||||
Images: data[0].Album.Images[0].URL, |
|
||||
Url: string(data[0].URI), |
|
||||
Sgener: data[0].Album.Name, |
|
||||
} |
|
||||
context = utils.ToString(map[string]interface{}{ |
|
||||
"card_music": card, |
|
||||
"result": fmt.Sprintf("正在为你播放音乐:%s", data[0].Name), |
|
||||
}) |
|
||||
log.Debug("播放音乐成功", |
|
||||
log.Field{Key: "query", Value: query}, |
|
||||
log.Field{Key: "card", Value: card}, |
|
||||
) |
|
||||
} |
|
||||
|
|
||||
result = &mcp.CallToolResult{ |
|
||||
Content: []mcp.Content{ |
|
||||
mcp.TextContent{ |
|
||||
Type: "text", |
|
||||
Text: context, |
|
||||
}, |
|
||||
}, |
|
||||
} |
|
||||
// result.Meta = map[string]interface{}{
|
|
||||
// "card_spotify": card,
|
|
||||
// }
|
|
||||
return |
|
||||
} |
|
||||
@ -1,134 +0,0 @@ |
|||||
package mcp |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"yunyan/lego/core" |
|
||||
"yunyan/lego/core/cbase" |
|
||||
"yunyan/lego/sys/log" |
|
||||
lgspotify "yunyan/sys/spotify" |
|
||||
"yunyan/utils" |
|
||||
"fmt" |
|
||||
|
|
||||
"github.com/mark3labs/mcp-go/mcp" |
|
||||
"github.com/zmb3/spotify/v2" |
|
||||
) |
|
||||
|
|
||||
// 音乐卡片 结构统一化输出
|
|
||||
type SpotifyMusicListCard struct { |
|
||||
Musics []SpotifyMusicCard `json:"musics"` |
|
||||
} |
|
||||
|
|
||||
// 天气查询
|
|
||||
type tool_spotify_music_playlist struct { |
|
||||
cbase.ModuleCompBase |
|
||||
module *Mcp |
|
||||
} |
|
||||
|
|
||||
// 组件初始化接口
|
|
||||
func (this *tool_spotify_music_playlist) Init(service core.IService, module core.IModule, comp core.IModuleComp, opt core.IModuleOptions) (err error) { |
|
||||
this.ModuleCompBase.Init(service, module, comp, opt) |
|
||||
this.module = module.(*Mcp) |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *tool_spotify_music_playlist) Start() (err error) { |
|
||||
err = this.ModuleCompBase.Start() |
|
||||
if this.module.AddTool(ToolGroup_GLOBAL, this.Tool(), this.Handl) { |
|
||||
if err := lgspotify.OnInit(this.module.service.GetSettings().Sys["spotify"]); err != nil { |
|
||||
panic(fmt.Sprintf("init sys.spotify err: %s", err.Error())) |
|
||||
} else { |
|
||||
log.Infof("init sys.spotify success!") |
|
||||
} |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *tool_spotify_music_playlist) Tool() (tool mcp.Tool) { |
|
||||
return mcp.NewTool("spotify_music_play", |
|
||||
mcp.WithDescription("Recommend the desired song list to users to realize the music playing experience"), |
|
||||
mcp.WithString("query", |
|
||||
mcp.Description("Music keyword information"), |
|
||||
mcp.Required(), |
|
||||
), |
|
||||
mcp.WithNumber("count", |
|
||||
mcp.Description("music of results (1-20, default 10)"), |
|
||||
mcp.DefaultNumber(10), |
|
||||
mcp.Min(1), |
|
||||
mcp.Max(20), |
|
||||
), |
|
||||
mcp.WithString("offset", |
|
||||
mcp.Description("music offset (max 9, default 0)"), |
|
||||
mcp.DefaultNumber(0), |
|
||||
), |
|
||||
) |
|
||||
} |
|
||||
|
|
||||
// Handl 工具处理接口
|
|
||||
// 参数:
|
|
||||
// - ctx: 上下文
|
|
||||
// - request: MCP 工具调用请求
|
|
||||
//
|
|
||||
// 返回值:
|
|
||||
// - result: MCP 工具调用结果
|
|
||||
// - err: 处理过程中的错误
|
|
||||
//
|
|
||||
// 异常:
|
|
||||
// - 无（不主动 panic）
|
|
||||
func (this *tool_spotify_music_playlist) Handl(ctx context.Context, request mcp.CallToolRequest) (result *mcp.CallToolResult, err error) { |
|
||||
var ( |
|
||||
offset, limit int |
|
||||
query string |
|
||||
data []spotify.SimplePlaylist |
|
||||
musics []spotify.PlaylistItem |
|
||||
card *SpotifyMusicListCard |
|
||||
context string |
|
||||
) |
|
||||
limit = request.GetInt("count", 10) |
|
||||
offset = request.GetInt("offset", 0) |
|
||||
if query, err = request.RequireString("query"); err != nil { |
|
||||
return |
|
||||
} |
|
||||
if data, err = lgspotify.SearchMusicList(ctx, query, 1, offset); err == nil { |
|
||||
musics, err = lgspotify.SearchMusicListDetails(ctx, data[0].ID, limit, 0) |
|
||||
} |
|
||||
|
|
||||
if err != nil { |
|
||||
context = "播放音乐失败" |
|
||||
log.Errorf("获取天气信息失败:%v", err) |
|
||||
return |
|
||||
} else { |
|
||||
card = &SpotifyMusicListCard{Musics: make([]SpotifyMusicCard, 0)} |
|
||||
for _, v := range musics { |
|
||||
item := SpotifyMusicCard{ |
|
||||
Name: v.Track.Track.Name, |
|
||||
Images: v.Track.Track.Album.Images[0].URL, |
|
||||
Url: string(v.Track.Track.URI), |
|
||||
Sgener: v.Track.Track.Album.Name, |
|
||||
} |
|
||||
card.Musics = append(card.Musics, item) |
|
||||
} |
|
||||
|
|
||||
context = utils.ToString(map[string]interface{}{ |
|
||||
"card_musiclist": card, |
|
||||
"result": fmt.Sprintf("正在为你播放音乐列表:%s", data[0].Name), |
|
||||
}) |
|
||||
log.Debug("播放音乐成功", |
|
||||
log.Field{Key: "query", Value: query}, |
|
||||
log.Field{Key: "card", Value: card}, |
|
||||
) |
|
||||
} |
|
||||
|
|
||||
result = &mcp.CallToolResult{ |
|
||||
Content: []mcp.Content{ |
|
||||
mcp.TextContent{ |
|
||||
Type: "text", |
|
||||
Text: context, |
|
||||
}, |
|
||||
}, |
|
||||
} |
|
||||
// result.Meta = map[string]interface{}{
|
|
||||
// "card_spotifylist": card,
|
|
||||
// }
|
|
||||
return |
|
||||
} |
|
||||
@ -1,79 +0,0 @@ |
|||||
package timer |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"yunyan/comm" |
|
||||
redissys "yunyan/lego/sys/redis" |
|
||||
"yunyan/modules" |
|
||||
"fmt" |
|
||||
"time" |
|
||||
|
|
||||
"yunyan/lego/base" |
|
||||
"yunyan/lego/core" |
|
||||
"yunyan/lego/sys/cron" |
|
||||
) |
|
||||
|
|
||||
type uselogTimer struct { |
|
||||
modules.MCompHttpGate |
|
||||
service base.IRPCXService |
|
||||
module *Timer |
|
||||
options *Options |
|
||||
} |
|
||||
|
|
||||
func (this *uselogTimer) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) { |
|
||||
this.MCompHttpGate.Init(service, module, comp, options) |
|
||||
this.service = service.(base.IRPCXService) |
|
||||
this.module = module.(*Timer) |
|
||||
this.options = options.(*Options) |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *uselogTimer) Start() (err error) { |
|
||||
err = this.MCompHttpGate.Start() |
|
||||
//凌晨1分1秒执行
|
|
||||
cron.AddFunc("1 1 0 * * ?", this.timer) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *uselogTimer) timer() { |
|
||||
fmt.Println("开始读取 log:* 数据...", time.Now().Format("15:04:05")) |
|
||||
ctx := context.Background() |
|
||||
// 使用 SCAN 而非 KEYS（更安全）
|
|
||||
var ( |
|
||||
cursor uint64 |
|
||||
datas []map[string]string = make([]map[string]string, 0) |
|
||||
) |
|
||||
for { |
|
||||
keys, newCursor, err := redissys.Conn().Scan(ctx, cursor, redissys.RKey(fmt.Sprintf("%s:*", comm.TableUseRecordLog)), 100).Result() |
|
||||
if err != nil { |
|
||||
fmt.Println("Scan error:", err) |
|
||||
break |
|
||||
} |
|
||||
|
|
||||
for _, key := range keys { |
|
||||
data, err := redissys.Conn().HGetAll(ctx, key).Result() |
|
||||
if err != nil { |
|
||||
fmt.Println("HGETALL error:", err) |
|
||||
continue |
|
||||
} |
|
||||
datas = append(datas, data) |
|
||||
// ✅ 这里处理数据，比如打印 / 存储到 DB
|
|
||||
fmt.Printf("处理 %s: %+v\n", key, data) |
|
||||
|
|
||||
// 删除日志 key
|
|
||||
if err := redissys.Conn().Del(ctx, key).Err(); err != nil { |
|
||||
fmt.Println("DEL error:", err) |
|
||||
} else { |
|
||||
fmt.Printf("已删除 %s\n", key) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if newCursor == 0 { |
|
||||
break |
|
||||
} |
|
||||
cursor = newCursor |
|
||||
} |
|
||||
|
|
||||
fmt.Println("日志处理完成。") |
|
||||
} |
|
||||
@ -1,32 +0,0 @@ |
|||||
package sts |
|
||||
|
|
||||
type ( |
|
||||
Authorization struct { |
|
||||
Expiration string |
|
||||
AccessKeyId string |
|
||||
AccessKeySecret string |
|
||||
SecurityToken string |
|
||||
} |
|
||||
ISys interface { |
|
||||
//roleArn:角色ARN。
|
|
||||
AssumeRole(roleArn, roleSessionName string) (auth *Authorization, err error) |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
defsys ISys |
|
||||
) |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
defsys, err = newSys(newOptions(config, option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
sys, err = newSys(newOptionsByOption(option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func AssumeRole(roleArn, roleSessionName string) (auth *Authorization, err error) { |
|
||||
return defsys.AssumeRole(roleArn, roleSessionName) |
|
||||
} |
|
||||
@ -1,52 +0,0 @@ |
|||||
package sts |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
RegionId string |
|
||||
AccessKeyId string |
|
||||
AccessKeySecret string |
|
||||
} |
|
||||
|
|
||||
// 注册点 cn-shenzhen
|
|
||||
func SetRegionId(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.RegionId = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 头像->访问控制->用户->用户 AccessKey
|
|
||||
func SetAccessKeyId(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.AccessKeyId = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 头像->访问控制->用户->用户 AccessKeySecret
|
|
||||
func SetAccessKeySecret(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.AccessKeySecret = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1,49 +0,0 @@ |
|||||
package sts |
|
||||
|
|
||||
import ( |
|
||||
"github.com/aliyun/alibaba-cloud-sdk-go/services/sts" |
|
||||
) |
|
||||
|
|
||||
func newSys(options Options) (sys *STS, err error) { |
|
||||
sys = &STS{options: options} |
|
||||
err = sys.init() |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type STS struct { |
|
||||
options Options |
|
||||
client *sts.Client |
|
||||
} |
|
||||
|
|
||||
func (this *STS) init() (err error) { |
|
||||
if this.client, err = sts.NewClientWithAccessKey(this.options.RegionId, this.options.AccessKeyId, this.options.AccessKeySecret); err != nil { |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *STS) AssumeRole(roleArn, roleSessionName string) (auth *Authorization, err error) { |
|
||||
var ( |
|
||||
request *sts.AssumeRoleRequest |
|
||||
response *sts.AssumeRoleResponse |
|
||||
) |
|
||||
//构建请求对象。
|
|
||||
request = sts.CreateAssumeRoleRequest() |
|
||||
request.Scheme = "https" |
|
||||
//设置参数。关于参数含义和设置方法，请参见《API参考》。
|
|
||||
request.RoleArn = roleArn |
|
||||
request.RoleSessionName = roleSessionName |
|
||||
//发起请求，并得到响应。
|
|
||||
response, err = this.client.AssumeRole(request) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
auth = &Authorization{ |
|
||||
Expiration: response.Credentials.Expiration, |
|
||||
AccessKeyId: response.Credentials.AccessKeyId, |
|
||||
AccessKeySecret: response.Credentials.AccessKeySecret, |
|
||||
SecurityToken: response.Credentials.SecurityToken, |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,30 +0,0 @@ |
|||||
package sts_test |
|
||||
|
|
||||
import ( |
|
||||
"fmt" |
|
||||
"testing" |
|
||||
|
|
||||
"yunyan/sys/aliyun/sts" |
|
||||
) |
|
||||
|
|
||||
// oss: #对象存储
|
|
||||
// Endpoint: https://oss-ap-southeast-1.aliyuncs.com
|
|
||||
// AccessKeyId: xxxxxxxxxxxxx
|
|
||||
// AccessKeySecret: xxxxxxxxxxxxxxxxxxx
|
|
||||
// BucketName: dpmobj
|
|
||||
|
|
||||
func Test_STS(t *testing.T) { |
|
||||
sys, err := sts.NewSys( |
|
||||
sts.SetRegionId("cn-shenzhen"), |
|
||||
sts.SetAccessKeyId("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"), |
|
||||
sts.SetAccessKeySecret("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"), |
|
||||
) |
|
||||
if err != nil { |
|
||||
fmt.Printf("初始化OSS 系统失败 err:%v", err) |
|
||||
return |
|
||||
} else { |
|
||||
fmt.Printf("初始化OSS 系统成功") |
|
||||
auth, err := sys.AssumeRole("xxxxxxxxxxxxxxxxxxxxxxxxxxx", "SessionTest") |
|
||||
fmt.Printf("初始化OSS AssumeRole auth:%+v err:%v", auth, err) |
|
||||
} |
|
||||
} |
|
||||
@ -1,84 +0,0 @@ |
|||||
package axml |
|
||||
|
|
||||
import ( |
|
||||
"regexp" |
|
||||
"strings" |
|
||||
) |
|
||||
|
|
||||
func newSys(options Options) (sys ISys, err error) { |
|
||||
sys = &AXml{} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// XMLItem 表示一个通用的 XML 数据项
|
|
||||
type XMLItem struct { |
|
||||
TagName string // 标签名
|
|
||||
Attributes map[string]string // 属性键值对
|
|
||||
Content string // 标签内容
|
|
||||
} |
|
||||
type AXml struct { |
|
||||
source string |
|
||||
buffer string |
|
||||
items []*XMLItem |
|
||||
} |
|
||||
|
|
||||
func (this *AXml) Add(data string) (err error) { |
|
||||
this.source += data |
|
||||
this.buffer += data |
|
||||
this.processData() |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *AXml) Get(name string) (items []*XMLItem) { |
|
||||
items = make([]*XMLItem, 0) |
|
||||
for _, v := range this.items { |
|
||||
if v.TagName == name { |
|
||||
items = append(items, v) |
|
||||
} |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// 解析数据
|
|
||||
func (this *AXml) processData() { |
|
||||
// 匹配完整的 <tag attr="value">content</tag> 模式
|
|
||||
// 捕获标签名、属性和内容
|
|
||||
re := regexp.MustCompile(`<([a-zA-Z][^>]*)>((?:[^<]|<[^/])*?)</([a-zA-Z][^>]*)>`) |
|
||||
matches := re.FindAllStringSubmatch(this.buffer, -1) |
|
||||
|
|
||||
// var items []XMLItem
|
|
||||
for _, match := range matches { |
|
||||
if len(match) != 4 { |
|
||||
continue |
|
||||
} |
|
||||
// match[0] 是完整匹配，match[1] 是标签和属性部分，match[2] 是内容
|
|
||||
tagAndAttrs := match[1] |
|
||||
content := match[2] |
|
||||
|
|
||||
// 解析标签名和属性
|
|
||||
attrRe := regexp.MustCompile(`([a-zA-Z]+)(?: *= *"([^"]*)")?`) |
|
||||
attrMatches := attrRe.FindAllStringSubmatch(tagAndAttrs, -1) |
|
||||
|
|
||||
item := &XMLItem{ |
|
||||
Attributes: make(map[string]string), |
|
||||
} |
|
||||
for _, attrMatch := range attrMatches { |
|
||||
if len(attrMatch) >= 2 { |
|
||||
if item.TagName == "" { |
|
||||
item.TagName = attrMatch[1] // 第一个捕获组是标签名
|
|
||||
} |
|
||||
if len(attrMatch) == 3 && attrMatch[2] != "" { |
|
||||
item.Attributes[attrMatch[1]] = attrMatch[2] // 属性名和值
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
item.Content = strings.TrimSpace(content) |
|
||||
|
|
||||
if item.TagName != "" { |
|
||||
this.items = append(this.items, item) |
|
||||
// 从缓冲区移除已解析的部分
|
|
||||
this.buffer = this.buffer[strings.Index(this.buffer, match[0])+len(match[0]):] |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
@ -1,30 +0,0 @@ |
|||||
package axml |
|
||||
|
|
||||
type ( |
|
||||
ISys interface { |
|
||||
Add(data string) (err error) |
|
||||
Get(name string) (items []*XMLItem) |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var ( |
|
||||
defsys ISys |
|
||||
) |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
defsys, err = newSys(newOptions(config, option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
sys, err = newSys(newOptionsByOption(option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func Add(data string) error { |
|
||||
return defsys.Add(data) |
|
||||
} |
|
||||
|
|
||||
func Get(name string) (items []*XMLItem) { |
|
||||
return defsys.Get(name) |
|
||||
} |
|
||||
@ -1,37 +0,0 @@ |
|||||
package axml |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
Debug bool //日志是否开启
|
|
||||
Log log.ILogger |
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.deepseek", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.deepseek", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1,56 +0,0 @@ |
|||||
package coze |
|
||||
|
|
||||
import "context" |
|
||||
|
|
||||
type ( |
|
||||
Message struct { |
|
||||
Role string `json:"role"` |
|
||||
Content string `json:"content"` |
|
||||
} |
|
||||
//回应流式切片
|
|
||||
ChatResponseChoice struct { |
|
||||
Role string `json:"role"` |
|
||||
Content string `json:"content,omitempty"` |
|
||||
Meta map[string]interface{} `json:"meta,omitempty"` |
|
||||
} |
|
||||
// ToolResponseCard 通用卡片结构（不解析底层元素细节）
|
|
||||
CardContent struct { |
|
||||
CardType int `json:"card_type"` |
|
||||
TemplateURL string `json:"template_url"` |
|
||||
TemplateID int64 `json:"template_id"` |
|
||||
ResponseForModel string `json:"response_for_model"` |
|
||||
ContentType int `json:"content_type"` |
|
||||
Data string `json:"data"` // 卡片结构JSON字符串
|
|
||||
Variables map[string]any `json:"variables"` // 变量数据
|
|
||||
InfoInCard string `json:"info_in_card"` // 备用数据
|
|
||||
ResponseType string `json:"response_type"` |
|
||||
XProperties map[string]any `json:"x_properties"` |
|
||||
} |
|
||||
CardContentData struct { |
|
||||
Variables map[string]CardData `json:"variables"` //卡片数据
|
|
||||
} |
|
||||
CardData struct { |
|
||||
ID string `json:"ID"` |
|
||||
Name string `json:"name"` |
|
||||
DefaultValue interface{} `json:"defaultValue"` |
|
||||
} |
|
||||
ISys interface { |
|
||||
ChatForSteams(ctx context.Context, uid string, customVariables map[string]string, messages []Message, choiceChan chan *ChatResponseChoice) (err error) |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var defsys ISys |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
defsys, err = newSys(newOptions(config, option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
sys, err = newSys(newOptionsByOption(option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func ChatForSteams(ctx context.Context, uid string, customVariables map[string]string, messages []Message, choiceChan chan *ChatResponseChoice) (err error) { |
|
||||
return defsys.ChatForSteams(ctx, uid, customVariables, messages, choiceChan) |
|
||||
} |
|
||||
@ -1,132 +0,0 @@ |
|||||
package coze |
|
||||
|
|
||||
import ( |
|
||||
"context" |
|
||||
"encoding/json" |
|
||||
"errors" |
|
||||
"fmt" |
|
||||
"io" |
|
||||
"net/http" |
|
||||
"time" |
|
||||
|
|
||||
"github.com/coze-dev/coze-go" |
|
||||
) |
|
||||
|
|
||||
func newSys(options Options) (sys *Coze, err error) { |
|
||||
sys = &Coze{ |
|
||||
options: options, |
|
||||
} |
|
||||
// sys.Init()
|
|
||||
authCli := coze.NewTokenAuth(options.Token) |
|
||||
sys.api = coze.NewCozeAPI(authCli, coze.WithBaseURL(coze.CnBaseURL)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type Coze struct { |
|
||||
options Options |
|
||||
api coze.CozeAPI |
|
||||
} |
|
||||
|
|
||||
func (this *Coze) Init() { |
|
||||
// Get an access_token through personal access token or oauth.
|
|
||||
// token := os.Getenv("COZE_API_TOKEN")
|
|
||||
authCli := coze.NewTokenAuth(this.options.Token) |
|
||||
|
|
||||
// 1. Initialize with default configuration
|
|
||||
cozeCli1 := coze.NewCozeAPI(authCli) |
|
||||
fmt.Println("client 1:", cozeCli1) |
|
||||
|
|
||||
// 2. Initialize with custom base URL
|
|
||||
// cozeAPIBase := os.Getenv("COZE_API_BASE")
|
|
||||
cozeCli2 := coze.NewCozeAPI(authCli, coze.WithBaseURL(coze.ComBaseURL)) |
|
||||
fmt.Println("client 2:", cozeCli2) |
|
||||
|
|
||||
// 3. Initialize with custom HTTP client
|
|
||||
customClient := &http.Client{ |
|
||||
Timeout: 30 * time.Second, |
|
||||
Transport: &http.Transport{ |
|
||||
MaxIdleConns: 100, |
|
||||
MaxIdleConnsPerHost: 100, |
|
||||
IdleConnTimeout: 90 * time.Second, |
|
||||
}, |
|
||||
} |
|
||||
cozeCli3 := coze.NewCozeAPI(authCli, |
|
||||
coze.WithBaseURL(coze.ComBaseURL), |
|
||||
coze.WithHttpClient(customClient), |
|
||||
) |
|
||||
fmt.Println("client 3:", cozeCli3) |
|
||||
} |
|
||||
|
|
||||
func (this *Coze) ChatForSteams(ctx context.Context, uid string, customVariables map[string]string, messages []Message, choiceChan chan *ChatResponseChoice) (err error) { |
|
||||
var ( |
|
||||
msgs []*coze.Message = make([]*coze.Message, len(messages)) |
|
||||
resp coze.Stream[coze.ChatEvent] |
|
||||
) |
|
||||
|
|
||||
for i, v := range messages { |
|
||||
msgs[i] = &coze.Message{ |
|
||||
Role: coze.MessageRoleUser, |
|
||||
Content: v.Content, |
|
||||
} |
|
||||
} |
|
||||
req := &coze.CreateChatsReq{ |
|
||||
BotID: this.options.BotID, |
|
||||
UserID: uid, |
|
||||
Messages: msgs, |
|
||||
CustomVariables: customVariables, |
|
||||
} |
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) |
|
||||
defer cancel() |
|
||||
defer close(choiceChan) |
|
||||
if resp, err = this.api.Chat.Stream(ctx, req); err != nil { |
|
||||
this.options.Log.Errorln(err) |
|
||||
return |
|
||||
} |
|
||||
defer resp.Close() |
|
||||
for { |
|
||||
event, err := resp.Recv() |
|
||||
if errors.Is(err, io.EOF) { |
|
||||
break |
|
||||
} |
|
||||
if err != nil { |
|
||||
this.options.Log.Errorln(err) |
|
||||
break |
|
||||
} |
|
||||
// fmt.Printf("结果:Event: %s Message:%+v \n", event.Event, event.Message)
|
|
||||
if event.Event == coze.ChatEventConversationMessageDelta { |
|
||||
choiceChan <- &ChatResponseChoice{ |
|
||||
Role: "ai", |
|
||||
Content: event.Message.Content, |
|
||||
} |
|
||||
} else if event.Event == coze.ChatEventConversationMessageCompleted { |
|
||||
if event.Message.Type == coze.MessageTypeToolResponse { |
|
||||
// fmt.Printf("结果:Event: %s Message:%+v \n\n\n", event.Event, event.Message)
|
|
||||
card := CardContent{} |
|
||||
if err = json.Unmarshal([]byte(event.Message.Content), &card); err != nil { |
|
||||
this.options.Log.Errorln(err) |
|
||||
} else { |
|
||||
data := CardContentData{} |
|
||||
if card.Data != "" { |
|
||||
if err = json.Unmarshal([]byte(card.Data), &data); err != nil { |
|
||||
fmt.Println(card.Data) |
|
||||
this.options.Log.Errorln(card.Data, err) |
|
||||
} else { |
|
||||
if len(data.Variables) > 0 { |
|
||||
for _, v := range data.Variables { |
|
||||
choiceChan <- &ChatResponseChoice{ |
|
||||
Role: "card", |
|
||||
Meta: map[string]interface{}{ |
|
||||
v.Name: v.DefaultValue, |
|
||||
}, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,49 +0,0 @@ |
|||||
package coze |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
Debug bool //日志是否开启
|
|
||||
Log log.ILogger |
|
||||
Token string |
|
||||
BotID string |
|
||||
} |
|
||||
|
|
||||
func SetToken(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Token = v |
|
||||
} |
|
||||
} |
|
||||
func SetBotID(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.BotID = v |
|
||||
} |
|
||||
} |
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.coze", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.coze", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1,38 +0,0 @@ |
|||||
package coze_test |
|
||||
|
|
||||
import ( |
|
||||
|
|
||||
//"lego_bighealth/sys/coze"
|
|
||||
|
|
||||
"context" |
|
||||
"yunyan/sys/coze" |
|
||||
"fmt" |
|
||||
"testing" |
|
||||
) |
|
||||
|
|
||||
func Test_Sys_Chat(t *testing.T) { |
|
||||
if sys, err := coze.NewSys( |
|
||||
coze.SetToken("pat_wOdiIjLLWuqHxIla03qr81FqWmestCGe1WIfTGUALQhuPbtm3vmntQbtfds9SikP"), |
|
||||
coze.SetBotID("7486826364478898226"), |
|
||||
); err != nil { |
|
||||
fmt.Printf("Sys Init err:%v", err) |
|
||||
} else { |
|
||||
result := make(chan *coze.ChatResponseChoice, 10) |
|
||||
go func() { |
|
||||
err := sys.ChatForSteams(context.Background(), "liwei1dao", map[string]string{"sys_lon_lat": "116.321669,39.985266"}, []coze.Message{ |
|
||||
{ |
|
||||
Role: "user", |
|
||||
Content: "给我导航到大新地铁站", |
|
||||
}, |
|
||||
}, result) |
|
||||
if err != nil { |
|
||||
fmt.Printf(" err:%v", err) |
|
||||
return |
|
||||
} |
|
||||
}() |
|
||||
|
|
||||
for v := range result { |
|
||||
fmt.Printf("result:%v\n", v) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,119 +0,0 @@ |
|||||
package deepseek |
|
||||
|
|
||||
type ( |
|
||||
ISys interface { |
|
||||
Chat(msgs []Message) (result []string, err error) |
|
||||
} |
|
||||
//消息
|
|
||||
Message struct { |
|
||||
//发起消息的角色
|
|
||||
//Possible values: [system,user,assistant,tool];
|
|
||||
Role string `json:"role"` |
|
||||
//消息的内容
|
|
||||
Content string `json:"content"` |
|
||||
//是否访问网络
|
|
||||
Web bool `json:"web"` |
|
||||
//可以选填的参与者的名称，为模型提供信息以区分相同角色的参与者。
|
|
||||
Name string `json:"name"` |
|
||||
//(Beta) 设置此参数为 true，来强制模型在其回答中以此 assistant 消息中提供的前缀内容开始。
|
|
||||
//您必须设置 base_url="https://api.deepseek.com/beta" 来使用此功能
|
|
||||
Prefix bool `json:"prefix"` |
|
||||
//(Beta) 用于 deepseek-reasoner 模型在对话前缀续写功能下，作为最后一条 assistant 思维链内容的输入。使用此功能时，prefix 参数必须设置为 true。
|
|
||||
ReasoningContent string `json:"reasoning_content"` |
|
||||
//此消息所响应的 tool call 的 ID。
|
|
||||
ToolCallId string `json:"tool_call_id"` |
|
||||
} |
|
||||
//回应控制
|
|
||||
ResponesFormat struct { |
|
||||
Type string `json:"type"` |
|
||||
} |
|
||||
//流式参数
|
|
||||
StreaOptions struct { |
|
||||
//如果设置为 true，在流式消息最后的 data: [DONE] 之前将会传输一个额外的块。此块上的 usage 字段显示整个请求的 token 使用统计信息，而 choices 字段将始终是一个空数组。所有其他块也将包含一个 usage 字段，但其值为 null。
|
|
||||
IncludeUsage bool `json:"include_usage"` |
|
||||
} |
|
||||
//工具
|
|
||||
Tool struct { |
|
||||
Type string `json:"type"` //工具名称
|
|
||||
Function Function `json:"function"` //工具名称
|
|
||||
} |
|
||||
//工具
|
|
||||
Function struct { |
|
||||
Name string `json:"name"` //方法名称
|
|
||||
Description string `json:"description"` //方法描述
|
|
||||
Parameters Parameters `json:"parameters"` //参数列表
|
|
||||
} |
|
||||
//方法调用 参数列表
|
|
||||
Parameters struct { |
|
||||
Type string `json:"type"` //传参勒烯
|
|
||||
Properties map[string]Propertie `json:"properties"` //参数列表
|
|
||||
Required []string `json:"required"` //必传参数列表
|
|
||||
} |
|
||||
//参数
|
|
||||
Propertie struct { |
|
||||
Type string `json:"type"` //参数类型
|
|
||||
Description string `json:"description"` //参数描述
|
|
||||
} |
|
||||
ChatRequest struct { |
|
||||
//对话的消息列表。
|
|
||||
Messages []Message `json:"messages"` |
|
||||
//Possible values: [deepseek-chat, deepseek-reasoner];
|
|
||||
//使用的模型的 ID。您可以使用 deepseek-chat。
|
|
||||
Model string `json:"model"` |
|
||||
//Possible values: >= -2 and <= 2;
|
|
||||
//Default value: 0;
|
|
||||
//介于 -2.0 和 2.0 之间的数字。如果该值为正，那么新 token 会根据其在已有文本中的出现频率受到相应的惩罚，降低模型重复相同内容的可能性。
|
|
||||
FrequencyPenalty string `json:"frequency_penalty"` |
|
||||
//Possible values: > 1;
|
|
||||
//介于 1 到 8192 间的整数，限制一次请求中模型生成 completion 的最大 token 数。输入 token 和输出 token 的总长度受模型的上下文长度的限制。
|
|
||||
//如未指定 max_tokens参数，默认使用 4096。
|
|
||||
MaxTokens int `json:"max_tokens"` |
|
||||
//Possible values: >= -2 and <= 2
|
|
||||
//Default value: 0
|
|
||||
//介于 -2.0 和 2.0 之间的数字。如果该值为正，那么新 token 会根据其是否已在已有文本中出现受到相应的惩罚，从而增加模型谈论新主题的可能性。
|
|
||||
PresencePenalty int `json:"presence_penalty"` |
|
||||
//一个 object，指定模型必须输出的格式。设置为 { "type": "json_object" } 以启用 JSON 模式，该模式保证模型生成的消息是有效的 JSON。
|
|
||||
//注意: 使用 JSON 模式时，你还必须通过系统或用户消息指示模型生成 JSON。否则，模型可能会生成不断的空白字符，直到生成达到令牌限制，从而导致请求长时间运行并显得“卡住”。此外，如果 finish_reason="length"，这表示生成超过了 max_tokens 或对话超过了最大上下文长度，消息内容可能会被部分截断
|
|
||||
ResponesFormat ResponesFormat `json:"response_format"` |
|
||||
//一个 string 或最多包含 16 个 string 的 list，在遇到这些词时，API 将停止生成更多的 token。
|
|
||||
Stop []string `json:"stop"` |
|
||||
//如果设置为 True，将会以 SSE（server-sent events）的形式以流式发送消息增量。消息流以
|
|
||||
Stream bool `json:"stream"` |
|
||||
//流式输出相关选项。只有在 stream 参数为 true 时，才可设置此参数
|
|
||||
StreaOptions *StreaOptions `json:"stream_options"` |
|
||||
//Possible values: <= 2
|
|
||||
//Default value: 1
|
|
||||
//采样温度，介于 0 和 2 之间。更高的值，如 0.8，会使输出更随机，而更低的值，如 0.2，会使其更加集中和确定。 我们通常建议可以更改这个值或者更改 top_p，但不建议同时对两者进行修改。
|
|
||||
Temperature int `json:"temperature"` |
|
||||
//Possible values: <= 1
|
|
||||
//Default value: 1
|
|
||||
//作为调节采样温度的替代方案，模型会考虑前 top_p 概率的 token 的结果。所以 0.1 就意味着只有包括在最高 10% 概率中的 token 会被考虑。 我们通常建议修改这个值或者更改 temperature，但不建议同时对两者进行修改
|
|
||||
TopP int `json:"top_p"` |
|
||||
//模型可能会调用的 tool 的列表。目前，仅支持 function 作为工具。使用此参数来提供以 JSON 作为输入参数的 function 列表。最多支持 128 个 function。
|
|
||||
Tools []Tool |
|
||||
} |
|
||||
|
|
||||
ChatResponse struct { |
|
||||
// 根据实际的API响应定义结构体字段
|
|
||||
// 例如：
|
|
||||
Choices []struct { |
|
||||
Message Message `json:"message"` |
|
||||
} `json:"choices"` |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var defsys ISys |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
defsys, err = newSys(newOptions(config, option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
sys, err = newSys(newOptionsByOption(option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func Chat(msgs []Message) (result []string, err error) { |
|
||||
return defsys.Chat(msgs) |
|
||||
} |
|
||||
@ -1,86 +0,0 @@ |
|||||
package deepseek |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"encoding/json" |
|
||||
"fmt" |
|
||||
"io" |
|
||||
"net/http" |
|
||||
"sync" |
|
||||
) |
|
||||
|
|
||||
func newSys(options Options) (sys *Deepseek, err error) { |
|
||||
sys = &Deepseek{ |
|
||||
options: options, |
|
||||
pool: sync.Pool{ |
|
||||
New: func() interface{} { |
|
||||
return &http.Client{} |
|
||||
}, |
|
||||
}} |
|
||||
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type Deepseek struct { |
|
||||
options Options |
|
||||
pool sync.Pool |
|
||||
} |
|
||||
|
|
||||
func (this *Deepseek) Chat(msgs []Message) (result []string, err error) { |
|
||||
var ( |
|
||||
jsonData []byte |
|
||||
body []byte |
|
||||
resp *http.Response |
|
||||
) |
|
||||
|
|
||||
url := "https://api.deepseek.com/v1/chat/completions" |
|
||||
chatRequest := ChatRequest{ |
|
||||
Model: "deepseek-chat", |
|
||||
Messages: msgs, |
|
||||
Stream: false, |
|
||||
} |
|
||||
|
|
||||
jsonData, err = json.Marshal(chatRequest) |
|
||||
if err != nil { |
|
||||
fmt.Println("Error marshalling JSON:", err) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData)) |
|
||||
if err != nil { |
|
||||
fmt.Println("Error creating request:", err) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
req.Header.Set("Content-Type", "application/json") |
|
||||
req.Header.Set("Authorization", "Bearer "+this.options.Appkey) |
|
||||
|
|
||||
client := this.pool.Get().(*http.Client) |
|
||||
defer this.pool.Put(client) |
|
||||
resp, err = client.Do(req) |
|
||||
if err != nil { |
|
||||
this.options.Log.Errorln("Error making request:", err) |
|
||||
return |
|
||||
} |
|
||||
defer resp.Body.Close() |
|
||||
|
|
||||
body, err = io.ReadAll(resp.Body) |
|
||||
if err != nil { |
|
||||
fmt.Println("Error reading response body:", err) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
var chatResponse ChatResponse |
|
||||
err = json.Unmarshal(body, &chatResponse) |
|
||||
if err != nil { |
|
||||
fmt.Println("Error unmarshalling response:", err) |
|
||||
return |
|
||||
} |
|
||||
result = make([]string, len(chatResponse.Choices)) |
|
||||
// 输出响应结果
|
|
||||
for _, choice := range chatResponse.Choices { |
|
||||
// fmt.Println("Response:", choice.Message.Content)
|
|
||||
result = append(result, choice.Message.Content) |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,44 +0,0 @@ |
|||||
package deepseek |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
Debug bool //日志是否开启
|
|
||||
Log log.ILogger |
|
||||
Appkey string |
|
||||
} |
|
||||
|
|
||||
func SetAppkey(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.Appkey = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.deepseek", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.deepseek", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1,157 +0,0 @@ |
|||||
package deepseek_test |
|
||||
|
|
||||
import ( |
|
||||
"bytes" |
|
||||
"context" |
|
||||
"yunyan/sys/deepseek" |
|
||||
"encoding/json" |
|
||||
"fmt" |
|
||||
"net/http" |
|
||||
"testing" |
|
||||
"time" |
|
||||
) |
|
||||
|
|
||||
const ( |
|
||||
deepseekAPIURL = "https://api.deepseek.com/v1/chat/completions" |
|
||||
) |
|
||||
|
|
||||
type DeepSeekClient struct { |
|
||||
apiKey string |
|
||||
httpClient *http.Client |
|
||||
} |
|
||||
|
|
||||
func NewDeepSeekClient(apiKey string) *DeepSeekClient { |
|
||||
return &DeepSeekClient{ |
|
||||
apiKey: apiKey, |
|
||||
httpClient: &http.Client{Timeout: 30 * time.Second}, |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 增强版请求结构（假设支持搜索参数）
|
|
||||
type ChatRequest struct { |
|
||||
Model string `json:"model"` // 指定支持搜索的模型
|
|
||||
Messages []Message `json:"messages"` // 对话历史
|
|
||||
SearchConfig *SearchConfig `json:"search_config"` // 搜索配置
|
|
||||
Temperature float64 `json:"temperature,omitempty"` |
|
||||
} |
|
||||
|
|
||||
type SearchConfig struct { |
|
||||
Enable bool `json:"enable"` // 启用搜索
|
|
||||
SearchDepth int `json:"search_depth"` // 搜索深度
|
|
||||
RealTimeSearch bool `json:"real_time_search"` // 实时搜索
|
|
||||
ResultMaxTokens int `json:"result_max_tokens"` // 结果最大长度
|
|
||||
} |
|
||||
|
|
||||
type Message struct { |
|
||||
Role string `json:"role"` |
|
||||
Content string `json:"content"` |
|
||||
} |
|
||||
|
|
||||
type ChatResponse struct { |
|
||||
Choices []struct { |
|
||||
Message Message `json:"message"` |
|
||||
SearchResult []struct { // 假设返回包含搜索结果
|
|
||||
Title string `json:"title"` |
|
||||
Snippet string `json:"snippet"` |
|
||||
URL string `json:"url"` |
|
||||
} `json:"search_results,omitempty"` |
|
||||
} `json:"choices"` |
|
||||
} |
|
||||
|
|
||||
func (c *DeepSeekClient) ChatWithSearch(ctx context.Context, req ChatRequest) (*ChatResponse, error) { |
|
||||
reqBody, _ := json.Marshal(req) |
|
||||
|
|
||||
httpReq, _ := http.NewRequestWithContext(ctx, "POST", deepseekAPIURL, bytes.NewReader(reqBody)) |
|
||||
httpReq.Header.Set("Authorization", "Bearer "+c.apiKey) |
|
||||
httpReq.Header.Set("Content-Type", "application/json") |
|
||||
httpReq.Header.Set("Accept", "application/json") |
|
||||
|
|
||||
resp, err := c.httpClient.Do(httpReq) |
|
||||
if err != nil { |
|
||||
return nil, fmt.Errorf("API请求失败: %w", err) |
|
||||
} |
|
||||
defer resp.Body.Close() |
|
||||
|
|
||||
if resp.StatusCode != http.StatusOK { |
|
||||
return nil, fmt.Errorf("API返回异常状态码: %d", resp.StatusCode) |
|
||||
} |
|
||||
|
|
||||
var response ChatResponse |
|
||||
if err := json.NewDecoder(resp.Body).Decode(&response); err != nil { |
|
||||
return nil, fmt.Errorf("响应解析失败: %w", err) |
|
||||
} |
|
||||
|
|
||||
return &response, nil |
|
||||
} |
|
||||
|
|
||||
func Test_DeepSeek(t *testing.T) { |
|
||||
apiKey := "sk-3adfd188a3134e718bbf704f525aff17" |
|
||||
|
|
||||
client := NewDeepSeekClient(apiKey) |
|
||||
|
|
||||
// 构造包含搜索功能的请求
|
|
||||
request := ChatRequest{ |
|
||||
Model: "deepseek-chat", // 假设支持搜索的模型名称
|
|
||||
Messages: []Message{ |
|
||||
{ |
|
||||
Role: "user", |
|
||||
Content: "深圳今天的天气如何?", |
|
||||
}, |
|
||||
}, |
|
||||
SearchConfig: &SearchConfig{ |
|
||||
Enable: true, |
|
||||
SearchDepth: 3, |
|
||||
RealTimeSearch: true, |
|
||||
ResultMaxTokens: 500, |
|
||||
}, |
|
||||
Temperature: 0.5, |
|
||||
} |
|
||||
|
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second) |
|
||||
defer cancel() |
|
||||
|
|
||||
response, err := client.ChatWithSearch(ctx, request) |
|
||||
if err != nil { |
|
||||
fmt.Printf("AI回答错误：%v", err) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// 处理响应
|
|
||||
if len(response.Choices) > 0 { |
|
||||
choice := response.Choices[0] |
|
||||
fmt.Println("AI回答：", choice.Message.Content) |
|
||||
|
|
||||
if len(choice.SearchResult) > 0 { |
|
||||
fmt.Println("\n引用的搜索结果：") |
|
||||
for _, result := range choice.SearchResult { |
|
||||
fmt.Printf("标题: %s\n摘要: %s\n链接: %s\n\n", |
|
||||
result.Title, |
|
||||
ellipsis(result.Snippet, 100), |
|
||||
result.URL) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 辅助函数：截断长文本
|
|
||||
func ellipsis(s string, maxLen int) string { |
|
||||
if len(s) <= maxLen { |
|
||||
return s |
|
||||
} |
|
||||
return s[:maxLen] + "..." |
|
||||
} |
|
||||
|
|
||||
func Test_Sys(t *testing.T) { |
|
||||
if sys, err := deepseek.NewSys( |
|
||||
deepseek.SetAppkey("sk-3adfd188a3134e718bbf704f525aff17"), |
|
||||
); err != nil { |
|
||||
fmt.Printf("Sys Init err:%v", err) |
|
||||
} else { |
|
||||
result, err := sys.Chat([]deepseek.Message{{ |
|
||||
Role: "user", |
|
||||
Content: "茅台今日股价分析需包含技术指标", |
|
||||
Web: true, |
|
||||
}}) |
|
||||
fmt.Printf(" result:%v err:%v", result, err) |
|
||||
} |
|
||||
} |
|
||||
@ -1,196 +0,0 @@ |
|||||
package dify |
|
||||
|
|
||||
import "encoding/json" |
|
||||
|
|
||||
const ( |
|
||||
baseurl = "https://api.dify.ai/v1/chat-messages" |
|
||||
workflowsurl = "https://api.dify.ai/v1/workflows/run" |
|
||||
) |
|
||||
|
|
||||
type ( |
|
||||
ISys interface { |
|
||||
ChatForChan(msg string, result chan string) (err error) |
|
||||
Workflows(msg string, result chan string) (err error) |
|
||||
} |
|
||||
|
|
||||
File struct { |
|
||||
Type string `json:"type"` |
|
||||
TransferMethod string `json:"transfer_method"` |
|
||||
URL string `json:"url"` |
|
||||
} |
|
||||
|
|
||||
ChatMessageRequest struct { |
|
||||
Inputs map[string]interface{} `json:"inputs"` |
|
||||
Query string `json:"query"` |
|
||||
ResponseMode string `json:"response_mode"` |
|
||||
ConversationID string `json:"conversation_id"` |
|
||||
User string `json:"user"` |
|
||||
Files []File `json:"files"` |
|
||||
} |
|
||||
|
|
||||
BaseEvent struct { |
|
||||
Event string `json:"event"` |
|
||||
ConversationID string `json:"conversation_id"` |
|
||||
MessageID string `json:"message_id,omitempty"` |
|
||||
CreatedAt int64 `json:"created_at"` |
|
||||
TaskID string `json:"task_id,omitempty"` // 仅 TTS 相关事件存在
|
|
||||
} |
|
||||
|
|
||||
MessageEvent struct { |
|
||||
BaseEvent |
|
||||
Answer string `json:"answer"` |
|
||||
} |
|
||||
|
|
||||
Usage struct { |
|
||||
PromptTokens int `json:"prompt_tokens"` |
|
||||
PromptUnitPrice string `json:"prompt_unit_price"` |
|
||||
PromptPrice string `json:"prompt_price"` |
|
||||
CompletionTokens int `json:"completion_tokens"` |
|
||||
CompletionUnitPrice string `json:"completion_unit_price"` |
|
||||
CompletionPrice string `json:"completion_price"` |
|
||||
TotalTokens int `json:"total_tokens"` |
|
||||
TotalPrice string `json:"total_price"` |
|
||||
Currency string `json:"currency"` |
|
||||
Latency float64 `json:"latency"` |
|
||||
} |
|
||||
|
|
||||
RetrieverResource struct { |
|
||||
Position int `json:"position"` |
|
||||
DatasetID string `json:"dataset_id"` |
|
||||
DatasetName string `json:"dataset_name"` |
|
||||
DocumentID string `json:"document_id"` |
|
||||
DocumentName string `json:"document_name"` |
|
||||
SegmentID string `json:"segment_id"` |
|
||||
Score float64 `json:"score"` |
|
||||
Content string `json:"content"` |
|
||||
} |
|
||||
|
|
||||
MessageEndEvent struct { |
|
||||
BaseEvent |
|
||||
ID string `json:"id"` |
|
||||
Metadata struct { |
|
||||
Usage Usage `json:"usage"` |
|
||||
RetrieverResources []RetrieverResource `json:"retriever_resources"` |
|
||||
} `json:"metadata"` |
|
||||
} |
|
||||
|
|
||||
TTSMessageEvent struct { |
|
||||
BaseEvent |
|
||||
Audio string `json:"audio"` // Base64 编码的音频数据
|
|
||||
} |
|
||||
|
|
||||
TTSMessageEndEvent struct { |
|
||||
BaseEvent |
|
||||
Audio string `json:"audio"` // 可能为空或包含最终音频
|
|
||||
} |
|
||||
|
|
||||
WorkflowResponse struct { |
|
||||
TaskID string `json:"task_id"` |
|
||||
WorkflowRunID string `json:"workflow_run_id"` |
|
||||
Data struct { |
|
||||
ID string `json:"id"` |
|
||||
WorkflowID string `json:"workflow_id"` |
|
||||
Status string `json:"status"` |
|
||||
Outputs struct { |
|
||||
Text string `json:"text"` |
|
||||
} `json:"outputs"` |
|
||||
Error interface{} `json:"error"` // 使用 interface{} 因为可能是 null 或其他类型
|
|
||||
ElapsedTime float64 `json:"elapsed_time"` |
|
||||
TotalTokens int `json:"total_tokens"` |
|
||||
TotalSteps int `json:"total_steps"` |
|
||||
CreatedAt int64 `json:"created_at"` |
|
||||
FinishedAt int64 `json:"finished_at"` |
|
||||
} `json:"data"` |
|
||||
} |
|
||||
|
|
||||
// 通用事件结构
|
|
||||
EventData struct { |
|
||||
Event string `json:"event"` |
|
||||
TaskID string `json:"task_id"` |
|
||||
Data json.RawMessage `json:"data"` // 这里使用 RawMessage 延迟解析
|
|
||||
} |
|
||||
|
|
||||
// workflow_started 事件结构
|
|
||||
WorkflowStartedData struct { |
|
||||
WorkflowRunID string `json:"workflow_run_id"` |
|
||||
ID string `json:"id"` |
|
||||
WorkflowID string `json:"workflow_id"` |
|
||||
SequenceNum int `json:"sequence_number"` |
|
||||
CreatedAt int64 `json:"created_at"` |
|
||||
} |
|
||||
|
|
||||
// node_started 事件结构
|
|
||||
NodeStartedData struct { |
|
||||
WorkflowRunID string `json:"workflow_run_id"` |
|
||||
ID string `json:"id"` |
|
||||
NodeID string `json:"node_id"` |
|
||||
NodeType string `json:"node_type"` |
|
||||
Title string `json:"title"` |
|
||||
Index int `json:"index"` |
|
||||
Inputs map[string]interface{} `json:"inputs"` |
|
||||
CreatedAt int64 `json:"created_at"` |
|
||||
} |
|
||||
|
|
||||
// node_finished 事件结构
|
|
||||
NodeFinishedData struct { |
|
||||
WorkflowRunID string `json:"workflow_run_id"` |
|
||||
ID string `json:"id"` |
|
||||
NodeID string `json:"node_id"` |
|
||||
NodeType string `json:"node_type"` |
|
||||
Title string `json:"title"` |
|
||||
Index int `json:"index"` |
|
||||
Inputs map[string]interface{} `json:"inputs"` |
|
||||
Outputs map[string]interface{} `json:"outputs"` |
|
||||
Status string `json:"status"` |
|
||||
ElapsedTime float64 `json:"elapsed_time"` |
|
||||
ExecutionMeta struct { |
|
||||
TotalTokens int `json:"total_tokens"` |
|
||||
TotalPrice float64 `json:"total_price"` |
|
||||
Currency string `json:"currency"` |
|
||||
} `json:"execution_metadata"` |
|
||||
CreatedAt int64 `json:"created_at"` |
|
||||
} |
|
||||
|
|
||||
// workflow_finished 事件结构
|
|
||||
WorkflowFinishedData struct { |
|
||||
WorkflowRunID string `json:"workflow_run_id"` |
|
||||
ID string `json:"id"` |
|
||||
WorkflowID string `json:"workflow_id"` |
|
||||
Outputs map[string]interface{} `json:"outputs"` |
|
||||
Status string `json:"status"` |
|
||||
ElapsedTime float64 `json:"elapsed_time"` |
|
||||
TotalTokens int `json:"total_tokens"` |
|
||||
TotalSteps string `json:"total_steps"` |
|
||||
CreatedAt int64 `json:"created_at"` |
|
||||
FinishedAt int64 `json:"finished_at"` |
|
||||
} |
|
||||
|
|
||||
// tts_message 事件结构
|
|
||||
TTSMessageData struct { |
|
||||
ConversationID string `json:"conversation_id"` |
|
||||
MessageID string `json:"message_id"` |
|
||||
CreatedAt int64 `json:"created_at"` |
|
||||
TaskID string `json:"task_id"` |
|
||||
Audio string `json:"audio"` |
|
||||
} |
|
||||
) |
|
||||
|
|
||||
var defsys ISys |
|
||||
|
|
||||
func OnInit(config map[string]interface{}, option ...Option) (err error) { |
|
||||
defsys, err = newSys(newOptions(config, option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func NewSys(option ...Option) (sys ISys, err error) { |
|
||||
sys, err = newSys(newOptionsByOption(option...)) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func ChatForChan(message string, result chan string) (err error) { |
|
||||
return defsys.ChatForChan(message, result) |
|
||||
} |
|
||||
|
|
||||
func Workflows(msg string, result chan string) (err error) { |
|
||||
return defsys.Workflows(msg, result) |
|
||||
} |
|
||||
@ -1,203 +0,0 @@ |
|||||
package dify |
|
||||
|
|
||||
import ( |
|
||||
"bufio" |
|
||||
"bytes" |
|
||||
"context" |
|
||||
"encoding/json" |
|
||||
"fmt" |
|
||||
"log" |
|
||||
"net/http" |
|
||||
"strings" |
|
||||
"time" |
|
||||
) |
|
||||
|
|
||||
func newSys(options Options) (sys *Dify, err error) { |
|
||||
sys = &Dify{ |
|
||||
options: options, |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
type Dify struct { |
|
||||
options Options |
|
||||
} |
|
||||
|
|
||||
func (this *Dify) ChatForChan(msg string, result chan string) (err error) { |
|
||||
var ( |
|
||||
body []byte |
|
||||
line []byte |
|
||||
value string |
|
||||
) |
|
||||
// 创建带超时的 context（建议 5-10 分钟，根据实际需求调整）
|
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute) |
|
||||
defer cancel() |
|
||||
|
|
||||
requestBody := ChatMessageRequest{ |
|
||||
Inputs: make(map[string]interface{}), |
|
||||
Query: msg, |
|
||||
ResponseMode: "streaming", |
|
||||
ConversationID: "", |
|
||||
User: "abc-123", |
|
||||
// Files: []File{
|
|
||||
// {
|
|
||||
// Type: "image",
|
|
||||
// TransferMethod: "remote_url",
|
|
||||
// URL: "https://cloud.dify.ai/logo/logo-site.png",
|
|
||||
// },
|
|
||||
// },
|
|
||||
} |
|
||||
|
|
||||
body, err = json.Marshal(requestBody) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
req, _ := http.NewRequestWithContext(ctx, "POST", baseurl, bytes.NewReader(body)) |
|
||||
req.Header.Set("Authorization", "Bearer "+this.options.ApiKey) |
|
||||
req.Header.Set("Content-Type", "application/json") |
|
||||
|
|
||||
client := &http.Client{ |
|
||||
Timeout: 0, // 禁用客户端超时，使用 context 控制
|
|
||||
} |
|
||||
|
|
||||
resp, err := client.Do(req) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
defer resp.Body.Close() |
|
||||
|
|
||||
if resp.StatusCode != http.StatusOK { |
|
||||
err = fmt.Errorf("code == %d", resp.StatusCode) |
|
||||
} |
|
||||
|
|
||||
// 流式读取核心逻辑
|
|
||||
reader := bufio.NewReader(resp.Body) |
|
||||
for { |
|
||||
select { |
|
||||
case <-ctx.Done(): |
|
||||
log.Println("上下文超时或取消") |
|
||||
return |
|
||||
default: |
|
||||
// 读取直到遇到 \n\n（SSE 事件分隔符）
|
|
||||
line, err = reader.ReadBytes('\n') |
|
||||
if err != nil { |
|
||||
if err.Error() == "EOF" { |
|
||||
close(result) |
|
||||
return |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// 清理数据行
|
|
||||
line = bytes.TrimSpace(line) |
|
||||
if len(line) == 0 { |
|
||||
continue |
|
||||
} |
|
||||
|
|
||||
// 处理 SSE 格式
|
|
||||
if bytes.HasPrefix(line, []byte("data: ")) { |
|
||||
data := bytes.TrimPrefix(line, []byte("data: ")) |
|
||||
if value, err = handleEvent(data); err == nil { |
|
||||
result <- value |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func handleEvent(data []byte) (result string, err error) { |
|
||||
var base BaseEvent |
|
||||
if err = json.Unmarshal(data, &base); err != nil { |
|
||||
// fmt.Printf("Error parsing base event: %v", err)
|
|
||||
return |
|
||||
} |
|
||||
|
|
||||
switch base.Event { |
|
||||
case "message": |
|
||||
var msg MessageEvent |
|
||||
if err = json.Unmarshal(data, &msg); err != nil { |
|
||||
// fmt.Printf("Error parsing message event: %v", err)
|
|
||||
return |
|
||||
} |
|
||||
result = msg.Answer |
|
||||
// fmt.Printf("[MSG] %s", msg.Answer)
|
|
||||
case "message_end": |
|
||||
var end MessageEndEvent |
|
||||
if err = json.Unmarshal(data, &end); err != nil { |
|
||||
// fmt.Printf("Error parsing message_end event: %v", err)
|
|
||||
return |
|
||||
} |
|
||||
// fmt.Printf("\n[END] Usage: %+v", end.Metadata.Usage)
|
|
||||
|
|
||||
case "tts_message": |
|
||||
var tts TTSMessageEvent |
|
||||
if err = json.Unmarshal(data, &tts); err != nil { |
|
||||
// fmt.Printf("Error parsing tts_message event: %v", err)
|
|
||||
return |
|
||||
} |
|
||||
// 处理音频数据（base64 解码等）
|
|
||||
// fmt.Printf("[TTS] Received audio chunk (%d bytes)\n", len(tts.Audio))
|
|
||||
|
|
||||
case "tts_message_end": |
|
||||
var ttsEnd TTSMessageEndEvent |
|
||||
if err = json.Unmarshal(data, &ttsEnd); err != nil { |
|
||||
// fmt.Printf("Error parsing tts_message_end event: %v", err)
|
|
||||
return |
|
||||
} |
|
||||
// fmt.Println("[TTS END] Audio stream completed")
|
|
||||
default: |
|
||||
// fmt.Printf("Unknown event type: %s", base.Event)
|
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
func (this *Dify) Workflows(msg string, result chan string) (err error) { |
|
||||
var ( |
|
||||
jsonData []byte |
|
||||
req *http.Request |
|
||||
) |
|
||||
defer close(result) |
|
||||
// 请求数据
|
|
||||
requestData := map[string]interface{}{ |
|
||||
"inputs": map[string]interface{}{ |
|
||||
"user_input": msg, |
|
||||
}, // 工作流输入参数
|
|
||||
"response_mode": "streaming", // 响应模式
|
|
||||
"user": "abc-123", // 用户标识
|
|
||||
} |
|
||||
|
|
||||
// 将请求数据转换为 JSON
|
|
||||
jsonData, err = json.Marshal(requestData) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// 创建 HTTP 请求
|
|
||||
req, err = http.NewRequest("POST", workflowsurl, strings.NewReader(string(jsonData))) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
req.Header.Set("Authorization", "Bearer app-Dh6RBY4u4G8Kfk4l9sle1UPl") |
|
||||
req.Header.Set("Content-Type", "application/json") |
|
||||
|
|
||||
// 发送请求
|
|
||||
client := &http.Client{} |
|
||||
resp, err := client.Do(req) |
|
||||
if err != nil { |
|
||||
return |
|
||||
} |
|
||||
defer resp.Body.Close() |
|
||||
scanner := bufio.NewScanner(resp.Body) |
|
||||
for scanner.Scan() { |
|
||||
line := scanner.Text() |
|
||||
if strings.HasPrefix(line, "data: ") { |
|
||||
line = strings.TrimPrefix(line, "data: ") |
|
||||
result <- line |
|
||||
} |
|
||||
} |
|
||||
if err = scanner.Err(); err != nil { |
|
||||
return |
|
||||
} |
|
||||
return |
|
||||
} |
|
||||
@ -1,44 +0,0 @@ |
|||||
package dify |
|
||||
|
|
||||
import ( |
|
||||
"yunyan/lego/sys/log" |
|
||||
"yunyan/lego/utils/mapstructure" |
|
||||
) |
|
||||
|
|
||||
type Option func(*Options) |
|
||||
type Options struct { |
|
||||
Debug bool //日志是否开启
|
|
||||
Log log.ILogger |
|
||||
ApiKey string |
|
||||
} |
|
||||
|
|
||||
func SetApiKey(v string) Option { |
|
||||
return func(o *Options) { |
|
||||
o.ApiKey = v |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func newOptions(config map[string]interface{}, opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
if config != nil { |
|
||||
mapstructure.Decode(config, &options) |
|
||||
} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.dify", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
|
|
||||
func newOptionsByOption(opts ...Option) Options { |
|
||||
options := Options{} |
|
||||
for _, o := range opts { |
|
||||
o(&options) |
|
||||
} |
|
||||
if options.Log == nil { |
|
||||
options.Log = log.NewTurnlog(options.Debug, log.Clone("sys.dify", 3)) |
|
||||
} |
|
||||
return options |
|
||||
} |
|
||||
@ -1,160 +0,0 @@ |
|||||
package dify_test |
|
||||
|
|
||||
import ( |
|
||||
"bufio" |
|
||||
"yunyan/sys/dify" |
|
||||
"encoding/json" |
|
||||
"fmt" |
|
||||
"net/http" |
|
||||
"strings" |
|
||||
"testing" |
|
||||
|
|
||||
"github.com/go-resty/resty/v2" |
|
||||
) |
|
||||
|
|
||||
func Test_Sys_Chat(t *testing.T) { |
|
||||
if sys, err := dify.NewSys( |
|
||||
dify.SetApiKey("app-7wHwovYZsZBveMPpi1k1ZN8c"), |
|
||||
); err != nil { |
|
||||
fmt.Printf("Sys Init err:%v", err) |
|
||||
} else { |
|
||||
result := make(chan string) |
|
||||
go func() { |
|
||||
err := sys.ChatForChan("你好! 你的名字？", result) |
|
||||
if err != nil { |
|
||||
fmt.Printf(" err:%v", err) |
|
||||
return |
|
||||
} |
|
||||
}() |
|
||||
|
|
||||
for v := range result { |
|
||||
fmt.Printf(" result:%v", v) |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
func Test_Sys_Workflows(t *testing.T) { |
|
||||
|
|
||||
client := resty.New() |
|
||||
// Dify API 端点
|
|
||||
url := "https://api.dify.ai/v1/workflows/run" |
|
||||
// 请求数据
|
|
||||
requestData := map[string]interface{}{ |
|
||||
"inputs": map[string]interface{}{ |
|
||||
"user_input": "武汉的天气如何？", |
|
||||
}, // 工作流输入参数
|
|
||||
"response_mode": "blocking", // 响应模式
|
|
||||
"user": "abc-123", // 用户标识
|
|
||||
} |
|
||||
|
|
||||
// 发送 POST 请求
|
|
||||
resp, err := client.R(). |
|
||||
SetHeader("Authorization", "Bearer app-Dh6RBY4u4G8Kfk4l9sle1UPl"). |
|
||||
SetHeader("Content-Type", "application/json"). |
|
||||
SetBody(requestData). |
|
||||
Post(url) |
|
||||
|
|
||||
if err != nil { |
|
||||
fmt.Println("Error sending request:", err) |
|
||||
return |
|
||||
} |
|
||||
|
|
||||
// 打印响应
|
|
||||
fmt.Println("Response Status:", resp.Status()) |
|
||||
// fmt.Println("Response Body:", resp.String())
|
|
||||
wresp := &dify.WorkflowResponse{} |
|
||||
err = json.Unmarshal(resp.Body(), wresp) |
|
||||
fmt.Printf("Response:%+v", wresp) |
|
||||
} |
|
||||
|
|
||||
func Test_Sys_WorkflowsForSatem(t *testing.T) { |
|
||||
// Dify API 端点
|
|
||||
url := "https://api.dify.ai/v1/workflows/run" |
|
||||
// 请求数据
|
|
||||
requestData := map[string]interface{}{ |
|
||||
"inputs": map[string]interface{}{ |
|
||||
"user_input": "武汉的天气如何？", |
|
||||
}, // 工作流输入参数
|
|
||||
"response_mode": "streaming", // 响应模式
|
|
||||
"user": "abc-123", // 用户标识
|
|
||||
} |
|
||||
|
|
||||
// 将请求数据转换为 JSON
|
|
||||
jsonData, err := json.Marshal(requestData) |
|
||||
if err != nil { |
|
||||
t.Fatalf("Error marshalling JSON: %v", err) |
|
||||
} |
|
||||
|
|
||||
// 创建 HTTP 请求
|
|
||||
req, err := http.NewRequest("POST", url, strings.NewReader(string(jsonData))) |
|
||||
if err != nil { |
|
||||
t.Fatalf("Error creating request: %v", err) |
|
||||
} |
|
||||
req.Header.Set("Authorization", "Bearer app-Dh6RBY4u4G8Kfk4l9sle1UPl") |
|
||||
req.Header.Set("Content-Type", "application/json") |
|
||||
|
|
||||
// 发送请求
|
|
||||
client := &http.Client{} |
|
||||
resp, err := client.Do(req) |
|
||||
if err != nil { |
|
||||
t.Fatalf("Error sending request: %v", err) |
|
||||
} |
|
||||
defer resp.Body.Close() |
|
||||
|
|
||||
defer resp.Body.Close() |
|
||||
|
|
||||
scanner := bufio.NewScanner(resp.Body) |
|
||||
for scanner.Scan() { |
|
||||
line := scanner.Text() |
|
||||
if strings.HasPrefix(line, "data: ") { |
|
||||
line = strings.TrimPrefix(line, "data: ") |
|
||||
var event dify.EventData |
|
||||
if err := json.Unmarshal([]byte(line), &event); err != nil { |
|
||||
fmt.Printf("Error parsing JSON: %v\n", err) |
|
||||
continue |
|
||||
} |
|
||||
parseEvent(event) // 解析不同类型的事件
|
|
||||
} |
|
||||
} |
|
||||
|
|
||||
if err := scanner.Err(); err != nil { |
|
||||
t.Fatalf("Error reading stream response: %v", err) |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// 解析数据
|
|
||||
func parseEvent(event dify.EventData) { |
|
||||
switch event.Event { |
|
||||
case "workflow_started": |
|
||||
var data dify.WorkflowStartedData |
|
||||
if err := json.Unmarshal(event.Data, &data); err == nil { |
|
||||
fmt.Printf("Workflow started: %+v\n", data) |
|
||||
} |
|
||||
|
|
||||
case "node_started": |
|
||||
var data dify.NodeStartedData |
|
||||
if err := json.Unmarshal(event.Data, &data); err == nil { |
|
||||
fmt.Printf("Node started: %+v\n", data) |
|
||||
} |
|
||||
|
|
||||
case "node_finished": |
|
||||
var data dify.NodeFinishedData |
|
||||
if err := json.Unmarshal(event.Data, &data); err == nil { |
|
||||
fmt.Printf("Node finished: %+v\n", data) |
|
||||
} |
|
||||
|
|
||||
case "workflow_finished": |
|
||||
var data dify.WorkflowFinishedData |
|
||||
if err := json.Unmarshal(event.Data, &data); err == nil { |
|
||||
fmt.Printf("Workflow finished: %+v\n", data) |
|
||||
} |
|
||||
|
|
||||
case "tts_message": |
|
||||
var data dify.TTSMessageData |
|
||||
if err := json.Unmarshal(event.Data, &data); err == nil { |
|
||||
fmt.Printf("TTS message: %+v\n", data) |
|
||||
} |
|
||||
default: |
|
||||
fmt.Printf("Unknown event: %s\n", event.Event) |
|
||||
} |
|
||||
} |
|
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue