gojs/service
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: gojs:main
Branches Tags
gojs:main
gojs:v0.0.18
gojs:v0.0.17
gojs:v0.0.16
gojs:v0.0.15
gojs:v0.0.14
gojs:v0.0.13
gojs:v0.0.12
gojs:v0.0.11
gojs:v0.0.10
gojs:v0.0.9
gojs:v0.0.8
gojs:v0.0.7
gojs:v0.0.6
gojs:v0.0.5
gojs:v0.0.4
gojs:v0.0.3
gojs:v0.0.2
gojs:v0.0.1
..
compare: gojs:v0.0.7
Branches Tags
gojs:main
gojs:v0.0.18
gojs:v0.0.17
gojs:v0.0.16
gojs:v0.0.15
gojs:v0.0.14
gojs:v0.0.13
gojs:v0.0.12
gojs:v0.0.11
gojs:v0.0.10
gojs:v0.0.9
gojs:v0.0.8
gojs:v0.0.7
gojs:v0.0.6
gojs:v0.0.5
gojs:v0.0.4
gojs:v0.0.3
gojs:v0.0.2
gojs:v0.0.1

No commits in common. "main" and "v0.0.7" have entirely different histories.
main ... v0.0.7

20 changed files with 671 additions and 1112 deletions
Show Stats Expand all files Collapse all files

5
caller.go
View File

@ -22,10 +22,7 @@ func NewCaller(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
func makeResult(r *httpclient.Result, vm *goja.Runtime) goja.Value {
if r.Error != nil {
// panic(vm.NewGoError(r.Error))
vm.SetData("_lastError", r.Error)
gojs.GetLogger(vm).Error(r.Error.Error())
return nil
panic(vm.NewGoError(r.Error))
}
headers := map[string]string{}
for k, v := range r.Response.Header {

56
go.mod
View File

@ -1,54 +1,44 @@
module apigo.cc/gojs/service
go 1.24.0
go 1.18
require (
apigo.cc/gojs v0.0.32
apigo.cc/gojs/console v0.0.4
apigo.cc/gojs/file v0.0.7
apigo.cc/gojs/http v0.0.8
apigo.cc/gojs/runtime v0.0.4
apigo.cc/gojs/task v0.0.8
apigo.cc/gojs/util v0.0.16
apigo.cc/gojs v0.0.9
apigo.cc/gojs/console v0.0.2
apigo.cc/gojs/http v0.0.3
apigo.cc/gojs/util v0.0.8
github.com/gorilla/websocket v1.5.3
github.com/ssgo/config v1.7.10
github.com/ssgo/discover v1.7.10
github.com/ssgo/config v1.7.9
github.com/ssgo/discover v1.7.9
github.com/ssgo/httpclient v1.7.8
github.com/ssgo/log v1.7.10
github.com/ssgo/redis v1.7.8
github.com/ssgo/s v1.7.25
github.com/ssgo/log v1.7.7
github.com/ssgo/redis v1.7.7
github.com/ssgo/s v1.7.22
github.com/ssgo/standard v1.7.7
github.com/ssgo/u v1.7.23
github.com/ssgo/u v1.7.13
)
require (
github.com/ZZMarquis/gm v1.3.2 // indirect
github.com/dlclark/regexp2 v1.11.5 // indirect
github.com/emmansun/gmsm v0.40.0 // indirect
github.com/fsnotify/fsnotify v1.9.0 // indirect
github.com/dlclark/regexp2 v1.11.4 // indirect
github.com/emmansun/gmsm v0.29.6 // indirect
github.com/fsnotify/fsnotify v1.8.0 // indirect
github.com/go-ole/go-ole v1.3.0 // indirect
github.com/go-rod/rod v0.116.2 // indirect
github.com/go-sourcemap/sourcemap v2.1.4+incompatible // indirect
github.com/gomodule/redigo v1.9.2 // indirect
github.com/google/pprof v0.0.0-20250903194437-c28834ac2320 // indirect
github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect
github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
github.com/lufia/plan9stats v0.0.0-20240909124753-873cd0166683 // indirect
github.com/obscuren/ecies v0.0.0-20150213224233-7c0f4a9b18d9 // indirect
github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
github.com/robfig/cron/v3 v3.0.1 // indirect
github.com/shirou/gopsutil/v3 v3.24.5 // indirect
github.com/shoenig/go-m1cpu v0.1.6 // indirect
github.com/ssgo/tool v0.4.29 // indirect
github.com/tklauser/go-sysconf v0.3.15 // indirect
github.com/tklauser/numcpus v0.10.0 // indirect
github.com/ysmood/fetchup v0.2.3 // indirect
github.com/ysmood/goob v0.4.0 // indirect
github.com/ysmood/got v0.40.0 // indirect
github.com/ysmood/gson v0.7.3 // indirect
github.com/ysmood/leakless v0.9.0 // indirect
github.com/ssgo/tool v0.4.27 // indirect
github.com/tklauser/go-sysconf v0.3.14 // indirect
github.com/tklauser/numcpus v0.9.0 // indirect
github.com/yusufpapurcu/wmi v1.2.4 // indirect
golang.org/x/crypto v0.46.0 // indirect
golang.org/x/net v0.48.0 // indirect
golang.org/x/sys v0.39.0 // indirect
golang.org/x/text v0.32.0 // indirect
golang.org/x/crypto v0.31.0 // indirect
golang.org/x/net v0.32.0 // indirect
golang.org/x/sys v0.28.0 // indirect
golang.org/x/text v0.21.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)

15
request.go
View File

@ -91,10 +91,7 @@ func (r *Request) MakeURL(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value
func (r *Request) ReadAll(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
data, err := io.ReadAll(r.req.Body)
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return nil
panic(vm.NewGoError(err))
}
return vm.ToValue(data)
}
@ -105,10 +102,7 @@ func (r *Request) Read(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
data := make([]byte, size)
n, err := r.req.Body.Read(data)
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return nil
panic(vm.NewGoError(err))
}
return vm.ToValue(data[0:n])
}
@ -116,10 +110,7 @@ func (r *Request) Read(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
func (r *Request) Close(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
err := r.req.Body.Close()
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return nil
panic(vm.NewGoError(err))
}
return nil
}

5
response.go
View File

@ -93,10 +93,7 @@ func (r *Response) Write(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value
args := gojs.MakeArgs(&argsIn, vm).Check(1)
n, err := r.resp.Write(args.Bytes(0))
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return vm.ToValue(false)
panic(vm.NewGoError(err))
}
return vm.ToValue(n)
}

669
service.go
View File

@ -37,8 +37,6 @@ var serviceMD string
var server *s.AsyncServer
var pools = map[string]*gojs.Pool{}
var poolsMTime = map[string]int64{}
var poolsConfig = map[string]gojs.PoolConfig{}
var poolExists = map[string]bool{}
var poolActionRegistered = map[string]bool{}
@ -50,11 +48,10 @@ type TplCache struct {
Tpl *template.Template
}
// var tplFunc = map[string]any{}
var tplReplaces = map[string]string{}
var tplLock = sync.RWMutex{}
// var tplCache = map[string]*TplCache{}
var tplFunc = map[string]any{}
var tplFuncLock = sync.RWMutex{}
var tplCache = map[string]*TplCache{}
var tplCacheLock = sync.RWMutex{}
type LimiterConfig struct {
From string
@ -74,8 +71,6 @@ type Config struct {
LimitedMessage string
Limiters map[string]*LimiterConfig
LimiterRedis string
HotLoad int
TplSafePaths []string
Proxy map[string]string
Rewrite map[string]string
@ -91,16 +86,13 @@ var configed = false
func initConfig(opt *gojs.Obj, logger *log.Logger, vm *goja.Runtime) {
configed = true
s.InitConfig()
if startPath := vm.GetData("startPath"); startPath != nil {
if startPath, ok := vm.GoData["startPath"]; ok {
s.SetWorkPath(u.String(startPath))
}
// 处理配置
serviceConfig = Config{"Session", "Device", "Client", "id", "", 3600, "auth failed", "verify failed", "too many requests", nil, "", 0, []string{}, map[string]string{}, map[string]string{}, map[string]string{}}
if errs := config.LoadConfig("service", &serviceConfig); len(errs) > 0 {
// panic(vm.NewGoError(errs[0]))
vm.SetData("_lastError", errs[0])
gojs.GetLogger(vm).Error(errs[0].Error())
return
serviceConfig = Config{"Session", "Device", "Client", "userId", "", 3600, "auth failed", "verify failed", "too many requests", nil, "", map[string]string{}, map[string]string{}, map[string]string{}}
if errs := config.LoadConfig("service", &serviceConfig); errs != nil && len(errs) > 0 {
panic(vm.NewGoError(errs[0]))
}
config.LoadConfig("service", &discover.Config)
// var auth goja.Callable
@ -143,38 +135,24 @@ func initConfig(opt *gojs.Obj, logger *log.Logger, vm *goja.Runtime) {
}
}
}
// 如果没有session中的authLevel验证失败，则使用Access-Token中的authLevel（服务间调用）
if authAccessToken && setAuthLevel < authLevel {
setAuthLevel = s.GetAuthTokenLevel(request.Header.Get("Access-Token"))
}
authOk := false
if setAuthLevel >= authLevel {
authOk = true // 默认通过
if options != nil && options.Ext != nil && options.Ext["funcs"] != nil {
if needFuncs, ok := options.Ext["funcs"].([]string); ok && len(needFuncs) > 0 {
// 指定了细化的权限验证要求
request.Set("funcs", needFuncs)
authOk = session.authFuncs(needFuncs)
}
}
}
if authOk {
return true, session
}
msg := serviceConfig.AuthFieldMessage
if strings.Contains(msg, "{{") {
msg = strings.ReplaceAll(msg, "{{TARGET_AUTHLEVEL}}", u.String(authLevel))
msg = strings.ReplaceAll(msg, "{{USER_AUTHLEVEL}}", u.String(setAuthLevel))
}
var obj any
if json.Unmarshal([]byte(msg), &obj) == nil {
return false, obj
} else {
return false, msg
msg := serviceConfig.AuthFieldMessage
if strings.Contains(msg, "{{") {
msg = strings.ReplaceAll(msg, "{{TARGET_AUTHLEVEL}}", u.String(authLevel))
msg = strings.ReplaceAll(msg, "{{USER_AUTHLEVEL}}", u.String(setAuthLevel))
}
var obj any
if json.Unmarshal([]byte(msg), &obj) == nil {
return false, obj
} else {
return false, msg
}
}
})
s.Init()
@ -202,49 +180,10 @@ func initConfig(opt *gojs.Obj, logger *log.Logger, vm *goja.Runtime) {
}
}
}
if serviceConfig.HotLoad > 0 {
s.NewTimerServer("hotload", time.Duration(serviceConfig.HotLoad)*time.Second, func(b *bool) {
tmpPoolsMTimes := map[string]int64{}
poolsLock.RLock()
for actionFile, mtime := range poolsMTime {
tmpPoolsMTimes[actionFile] = mtime
}
poolsLock.RUnlock()
for actionFile, mtime := range tmpPoolsMTimes {
fi := u.GetFileInfo(actionFile)
if fi == nil {
continue
}
newMtime := fi.ModTime.Unix()
if newMtime > mtime {
// 重新加载文件
actionCode := u.ReadFileN(actionFile)
if !strings.Contains(actionCode, "function main(") { // || !strings.Contains(actionCode, ".register(")
logger.Error("hotload file %s failed, must be a js file with main function", actionFile)
continue
}
poolsLock.RLock()
oldOpt := poolsConfig[actionFile]
poolsLock.RUnlock()
p := gojs.NewPoolByCode(actionCode, actionFile, oldOpt, logger)
poolsLock.Lock()
pools[actionFile] = p
poolsMTime[actionFile] = newMtime
poolsLock.Unlock()
logger.Info("hotload file %s success", actionFile, "mtime", fi.ModTime)
}
}
}, nil, nil)
}
}
func init() {
s.Config.KeepKeyCase = true
s.DontStartLogAuto = true
obj := map[string]any{
"config": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm)
@ -257,10 +196,7 @@ func init() {
// panic(vm.NewGoError(errors.New("must run service.config frist")))
}
if server != nil {
// panic(vm.NewGoError(errors.New("server already started")))
vm.SetData("_lastError", errors.New("server already started"))
gojs.GetLogger(vm).Error("server already started")
return vm.ToValue(false)
panic(vm.NewGoError(errors.New("server already started")))
}
// 处理静态文件
if len(serviceConfig.Static) > 0 {
@ -276,10 +212,10 @@ func init() {
}
// 处理Watch
if inWatch := vm.GetData("inWatch"); inWatch != nil && inWatch.(bool) {
if vm.GoData["inWatch"] == true {
onWatchConn := map[string]*websocket.Conn{}
onWatchLock := sync.Mutex{}
vm.SetData("onWatch", func(filename string) {
vm.GoData["onWatch"] = func(filename string) {
onWatchLock.Lock()
defer onWatchLock.Unlock()
for id, conn := range onWatchConn {
@ -287,7 +223,7 @@ func init() {
delete(onWatchConn, id)
}
}
})
}
s.AddShutdownHook(func() {
for _, conn := range onWatchConn {
conn.Close()
@ -299,12 +235,8 @@ func init() {
onWatchLock.Unlock()
}, "")
s.SetOutFilter(func(in map[string]any, request *s.Request, response *s.Response, out any, logger *log.Logger) (newOut any, isOver bool) {
contentType := response.Header().Get("Content-Type")
outStr := u.String(out)
if strings.HasPrefix(contentType, "text/html") || (contentType == "" && strings.Contains(outStr, "<html")) {
if strings.Contains(outStr, "let _watchWS = null") {
return nil, false
}
if strings.HasPrefix(response.Header().Get("Content-Type"), "text/html") {
outStr := u.String(out)
// 注入自动刷新的代码
outStr = strings.ReplaceAll(outStr, "</html>", `<script>
let _watchWS = null
@ -352,7 +284,6 @@ func init() {
server = s.AsyncStart()
waitChan = make(chan bool, 1)
server.OnStop(func() {
configed = false
if onStop != nil {
onStop(nil)
}
@ -371,131 +302,83 @@ func init() {
},
"stop": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
if server == nil {
// panic(vm.NewGoError(errors.New("server not started")))
vm.SetData("_lastError", errors.New("server not started"))
gojs.GetLogger(vm).Error("server not started")
return vm.ToValue(false)
panic(vm.NewGoError(errors.New("server not started")))
}
server.Stop()
s.ResetAllSets()
return vm.ToValue(true)
return nil
},
"uniqueId": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm)
size := args.Int(0)
var id string
if size >= 20 {
id = s.UniqueId20()
} else if size >= 16 {
id = s.UniqueId16()
} else if size >= 14 {
id = s.UniqueId14()
} else if size >= 12 {
id = s.UniqueId14()[0:12]
} else {
id = s.UniqueId()
}
return vm.ToValue(id)
},
"uniqueIdL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm)
size := args.Int(0)
var id string
if size >= 20 {
id = s.UniqueId20()
} else if size >= 16 {
id = s.UniqueId16()
} else if size >= 14 {
id = s.UniqueId14()
} else if size >= 12 {
id = s.UniqueId14()[0:12]
} else {
id = s.UniqueId()
}
return vm.ToValue(strings.ToLower(id))
},
// "uniqueId": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm)
// size := args.Int(0)
// var id string
// if size >= 20 {
// id = s.UniqueId20()
// } else if size >= 16 {
// id = s.UniqueId16()
// } else if size >= 14 {
// id = s.UniqueId14()
// } else if size >= 12 {
// id = s.UniqueId14()[0:12]
// } else {
// id = s.UniqueId()
// }
// return vm.ToValue(id)
// },
// "uniqueIdL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm)
// size := args.Int(0)
// var id string
// if size >= 20 {
// id = s.UniqueId20()
// } else if size >= 16 {
// id = s.UniqueId16()
// } else if size >= 14 {
// id = s.UniqueId14()
// } else if size >= 12 {
// id = s.UniqueId14()[0:12]
// } else {
// id = s.UniqueId()
// }
// return vm.ToValue(strings.ToLower(id))
// },
"id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
size := args.Int(0)
if size == 0 {
size = 12
space := args.Str(0)
size := args.Int(1)
var id string
if size >= 12 {
id = s.Id12(space)
} else if size >= 10 {
id = s.Id10(space)
} else if size >= 8 {
id = s.Id8(space)
} else {
id = s.Id6(space)
}
if size > 20 {
size = 20
}
rd := sessionRedis
if rd == nil {
// 使用u.Id
return vm.ToValue(u.UniqueId()[0:size])
}
tm := time.Now()
// 计算从2000年开始到现在的索引值（2000年时间戳：946656000）（5位62进制最小值：14776336）（可以表示901356495个，即142.9年至2142年）
secIndex := (tm.Unix()-946656000)/5 + 14776336
secTag := int(tm.UnixMicro() % 5)
uid := u.AppendInt(nil, uint64(secIndex))
secIndexKey := fmt.Sprintf("_SecIdx_%d", secIndex)
inSecIndex := rd.INCR(secIndexKey)
if inSecIndex == 1 {
rd.EXPIRE(secIndexKey, 6)
}
inSecIndexBytes := u.EncodeInt(uint64(inSecIndex))
uid = u.AppendInt(uid, uint64(secTag*12+len(inSecIndexBytes))) // 长度位，防止不同长度+随机值发生碰撞（用毫秒的%4*12位基础+位数可以随机表示12位长度，看起来有变化）
uid = append(uid, inSecIndexBytes...)
// 用随机数填充
uid = u.FillInt(uid, size)
// 交叉乱序
uid = u.ExchangeInt(uid)
// 散列乱序
uid = u.HashInt(uid)
return vm.ToValue(string(uid))
return vm.ToValue(id)
},
"idL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
space := args.Str(0)
size := args.Int(1)
var id string
if size >= 12 {
id = s.Id12(space)
} else if size >= 10 {
id = s.Id10(space)
} else if size >= 8 {
id = s.Id8(space)
} else {
id = s.Id6(space)
}
return vm.ToValue(strings.ToLower(id))
},
// "id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// space := args.Str(0)
// size := args.Int(1)
// var id string
// if size >= 12 {
// id = s.Id12(space)
// } else if size >= 10 {
// id = s.Id10(space)
// } else if size >= 8 {
// id = s.Id8(space)
// } else {
// id = s.Id6(space)
// }
// return vm.ToValue(id)
// },
// "idL": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// space := args.Str(0)
// size := args.Int(1)
// var id string
// if size >= 12 {
// id = s.Id12(space)
// } else if size >= 10 {
// id = s.Id10(space)
// } else if size >= 8 {
// id = s.Id8(space)
// } else {
// id = s.Id6(space)
// }
// return vm.ToValue(strings.ToLower(id))
// },
"register": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(2)
o := args.Obj(0)
action := args.Func(1)
if action == nil {
// panic(vm.NewGoError(errors.New("action must be a callback function")))
vm.SetData("_lastError", errors.New("action must be a callback function"))
gojs.GetLogger(vm).Error("action must be a callback function")
return vm.ToValue(false)
panic(vm.NewGoError(errors.New("action must be a callback function")))
}
authLevel := o.Int("authLevel")
@ -514,7 +397,7 @@ func init() {
for i, require := range requiresObj {
requires[i] = u.String(require)
}
vm.SetData(fmt.Sprint("REQUIRE_"+host, method, path), requires)
vm.GoData[fmt.Sprint("REQUIRE_"+host, method, path)] = requires
}
if verifiesObj := o.Obj("verifies"); verifiesObj != nil {
verifiesSet := map[string]func(any, *goja.Runtime) bool{}
@ -548,29 +431,29 @@ func init() {
}
}
}
vm.SetData(fmt.Sprint("VERIFY_"+host, method, path), verifiesSet)
vm.GoData[fmt.Sprint("VERIFY_"+host, method, path)] = verifiesSet
}
opt := s.WebServiceOptions{
NoBody: o.Bool("noBody"),
NoLog200: o.Bool("noLog200"),
Host: host,
Ext: o.Map("ext"),
//Ext: nil,
Limiters: usedLimiters,
}
startFile := u.String(vm.GetData("startFile"))
startFile := u.String(vm.GoData["startFile"])
poolsLock.RLock()
poolExist := poolExists[startFile]
poolsLock.RUnlock()
if poolExist {
// 从对象调用（支持并发）
actionKey := "REGISTER_" + host + method + path
vm.SetData(actionKey, action)
vm.SetData(actionKey+"This", args.This)
vm.GoData[actionKey] = action
vm.GoData[actionKey+"This"] = args.This
if method == "WS" {
vm.SetData(actionKey+"onMessage", o.Func("onMessage"))
vm.SetData(actionKey+"onClose", o.Func("onClose"))
vm.GoData[actionKey+"onMessage"] = o.Func("onMessage")
vm.GoData[actionKey+"onClose"] = o.Func("onClose")
}
poolsLock.Lock()
actionRegistered := poolActionRegistered[actionKey]
@ -589,7 +472,7 @@ func init() {
// 无对象池，直接调用（单线程）
s.RestfulWithOptions(authLevel, method, path, makeInnerAction(action, vm, args.This), memo, opt)
}
return vm.ToValue(true)
return nil
},
"load": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
@ -609,146 +492,104 @@ func init() {
mainArgs = mainArgs1
}
}
fi := u.GetFileInfo(actionFile)
if fi == nil {
if !u.FileExists(actionFile) {
fullActionFile, _ := filepath.Abs(actionFile)
// panic(vm.NewGoError(errors.New("actionFile must be a js file path: " + fullActionFile)))
vm.SetData("_lastError", errors.New("actionFile must be a js file path: "+fullActionFile))
gojs.GetLogger(vm).Error("actionFile must be a js file path: " + fullActionFile)
return vm.ToValue(false)
panic(vm.NewGoError(errors.New("actionFile must be a js file path: " + fullActionFile)))
}
actionCode := u.ReadFileN(actionFile)
if !strings.Contains(actionCode, "function main(") { // || !strings.Contains(actionCode, ".register(")
// panic(vm.NewGoError(errors.New("actionFile must be a js file with main function")))
vm.SetData("_lastError", errors.New("actionFile must be a js file with main function"))
gojs.GetLogger(vm).Error("actionFile must be a js file with main function")
return vm.ToValue(false)
if !strings.Contains(actionCode, "function main(") || !strings.Contains(actionCode, ".register(") {
panic(vm.NewGoError(errors.New("actionFile must be a js file with main function and call service.register")))
}
poolsLock.Lock()
poolExists[actionFile] = true
poolsLock.Unlock()
poolOpt := gojs.PoolConfig{
p := gojs.NewPoolByCode(actionCode, actionFile, gojs.PoolConfig{
Min: mi,
Max: ma,
Idle: idle,
Debug: debug,
Args: mainArgs,
}
p := gojs.NewPoolByCode(actionCode, actionFile, poolOpt, args.Logger)
}, args.Logger)
//p := gojs.NewLBByCode(actionCode, actionFile, gojs.LBConfig{
// Num: num,
// Debug: debug,
// Args: mainArgs,
//}, args.Logger)
mtime := fi.ModTime.Unix()
poolsLock.Lock()
pools[actionFile] = p
poolsMTime[actionFile] = mtime
poolsConfig[actionFile] = poolOpt
poolsLock.Unlock()
return vm.ToValue(true)
return nil
},
// "task": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// taskFile := args.Path(0)
// interval := args.Int(1)
// if interval == 0 {
// interval = 1000
// }
// if interval < 100 {
// interval = 100
// }
// if !u.FileExists(taskFile) {
// panic(vm.NewGoError(errors.New("taskFile must be a js file path")))
// }
// rt := gojs.New()
// _, err := rt.RunFile(taskFile)
// if err != nil {
// panic(vm.NewGoError(err))
// }
// s.NewTimerServer(taskFile, time.Duration(interval)*time.Millisecond, func(isRunning *bool) {
// rt.RunCode("if(onRun)onRun()")
// }, func() {
// rt.RunCode("if(onStart)onStart()")
// }, func() {
// rt.RunCode("if(onStop)onStop()")
// })
// return nil
// },
// "setTplFunc": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// fnObj := args.Obj(0)
// if fnObj != nil {
// fnList := map[string]any{}
// for _, k := range fnObj.O.Keys() {
// if jsFunc := fnObj.Func(k); jsFunc != nil {
// fn := func(args ...any) any {
// jsArgs := make([]goja.Value, len(args))
// for i := 0; i < len(args); i++ {
// jsArgs[i] = vm.ToValue(args[i])
// }
// // vm.CallbackLocker.Lock()
// r, err := jsFunc(argsIn.This, jsArgs...)
// // vm.CallbackLocker.Unlock()
// if err == nil {
// return r.Export()
// } else {
// panic(vm.NewGoError(err))
// }
// }
// fnList[k] = fn
// }
// }
// if len(fnList) > 0 {
// tplLock.Lock()
// for k, v := range fnList {
// tplFunc[k] = v
// }
// tplLock.Unlock()
// }
// }
// return nil
// },
"setTplReplaces": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
"task": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
replaces := args.Map(0)
tplLock.Lock()
for k, v := range replaces {
tplReplaces[k] = u.String(v)
taskFile := args.Path(0)
interval := args.Int(1)
if interval == 0 {
interval = 1000
}
if interval < 100 {
interval = 100
}
if !u.FileExists(taskFile) {
panic(vm.NewGoError(errors.New("taskFile must be a js file path")))
}
rt := gojs.New()
_, err := rt.RunFile(taskFile)
if err != nil {
panic(vm.NewGoError(err))
}
s.NewTimerServer(taskFile, time.Duration(interval)*time.Millisecond, func(isRunning *bool) {
rt.RunCode("if(onRun)onRun()")
}, func() {
rt.RunCode("if(onStart)onStart()")
}, func() {
rt.RunCode("if(onStop)onStop()")
})
return nil
},
"setTplFunc": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
fnObj := args.Obj(0)
if fnObj != nil {
fnList := map[string]any{}
for _, k := range fnObj.O.Keys() {
if jsFunc := fnObj.Func(k); jsFunc != nil {
fn := func(args ...any) any {
jsArgs := make([]goja.Value, len(args))
for i := 0; i < len(args); i++ {
jsArgs[i] = vm.ToValue(args[i])
}
if r, err := jsFunc(argsIn.This, jsArgs...); err == nil {
return r.Export()
} else {
panic(vm.NewGoError(err))
}
}
fnList[k] = fn
}
}
if len(fnList) > 0 {
tplFuncLock.Lock()
for k, v := range fnList {
tplFunc[k] = v
}
tplFuncLock.Unlock()
}
}
tplLock.Unlock()
return nil
},
"tpl": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(2)
filename := args.Path(0)
if !tplIsSafe(filename) {
// panic(vm.NewGoError(errors.New("tpl file " + filename + " not in safe paths")))
vm.SetData("_lastError", errors.New("tpl file "+filename+" not in safe paths"))
gojs.GetLogger(vm).Error("tpl file " + filename + " not in safe paths")
return nil
}
basepath := filepath.Dir(filename)
info := u.GetFileInfo(filename)
if info == nil {
// panic(vm.NewGoError(errors.New("tpl file " + filename + " not exists")))
vm.SetData("_lastError", errors.New("tpl file "+filename+" not exists"))
gojs.GetLogger(vm).Error("tpl file " + filename + " not exists")
return nil
panic(vm.NewGoError(errors.New("tpl file " + filename + " not exists")))
}
data := args.Any(1)
// tplLock.RLock()
// t := tplCache[filename]
var t *TplCache
if t1 := vm.GetData("TPL_" + filename); t1 != nil {
if t2, ok := t1.(*TplCache); ok {
t = t2
}
}
// t := vm.GetData("TPL_" + filename).(*TplCache)
// tplLock.RUnlock()
tplCacheLock.RLock()
t := tplCache[filename]
tplCacheLock.RUnlock()
if t != nil {
for f, tm := range t.FileModTime {
info := u.GetFileInfo(f)
@ -759,124 +600,58 @@ func init() {
}
}
if t == nil {
tpl := template.New(filename)
fnList := map[string]any{}
if fnObj := args.Obj(2); fnObj != nil {
for _, k := range fnObj.O.Keys() {
if jsFunc := fnObj.Func(k); jsFunc != nil {
fn := func(args ...any) any {
jsArgs := make([]goja.Value, len(args))
for i := 0; i < len(args); i++ {
jsArgs[i] = vm.ToValue(args[i])
}
r, err := jsFunc(argsIn.This, jsArgs...)
if err == nil {
return r.Export()
} else {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return nil
}
}
fnList[k] = fn
}
}
}
if len(fnList) > 0 {
tpl = tpl.Funcs(fnList)
tpl := template.New("main")
if len(tplFunc) > 0 {
tpl = tpl.Funcs(tplFunc)
}
fileModTime := map[string]int64{
filename: info.ModTime.UnixMilli(),
}
var err error
code := tplReplace(u.ReadFileN(filename))
for _, m := range tplIncludeMatcher.FindAllStringSubmatch(code, -1) {
a := strings.SplitN(m[1], ":", 2)
includeFilename := a[0]
includeFilepath := filepath.Join(basepath, includeFilename)
if !tplIsSafe(includeFilepath) {
// panic(vm.NewGoError(errors.New("tpl file " + includeFilepath + " not in safe paths")))
vm.SetData("_lastError", errors.New("tpl file "+includeFilepath+" not in safe paths"))
gojs.GetLogger(vm).Error("tpl file " + includeFilepath + " not in safe paths")
return nil
for _, m := range tplIncludeMatcher.FindAllStringSubmatch(u.ReadFileN(filename), -1) {
includeFilename := m[1]
info2 := u.GetFileInfo(includeFilename)
if info2 == nil {
includeFilename = filepath.Join(filepath.Dir(filename), m[1])
info2 = u.GetFileInfo(includeFilename)
}
// 每个被包含的文件只解析一次（统一修正）
if fileModTime[includeFilepath] == 0 {
info2 := u.GetFileInfo(includeFilepath)
if info2 != nil {
includeCode := tplReplace(u.ReadFileN(includeFilepath))
foundBlock := false
includeCode = tplDefineMatcher.ReplaceAllStringFunc(includeCode, func(str string) string {
if m := tplDefineMatcher.FindStringSubmatch(str); len(m) > 1 {
foundBlock = true
if m[1] == "main" {
return `{{ define "` + includeFilename + `" }}`
}
return `{{ define "` + includeFilename + ":" + m[1] + `" }}`
}
return str
})
if !foundBlock {
includeCode = `{{ define "` + includeFilename + `" }}` + includeCode + `{{ end }}`
}
tpl, err = tpl.Parse(includeCode)
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return nil
}
fileModTime[includeFilepath] = info2.ModTime.UnixMilli()
} else {
// panic(vm.NewGoError(errors.New("tpl file " + includeFilepath + " not exists")))
vm.SetData("_lastError", errors.New("tpl file "+includeFilepath+" not exists"))
gojs.GetLogger(vm).Error("tpl file " + includeFilepath + " not exists")
return nil
if info2 != nil {
tpl, err = tpl.Parse(`{{ define "` + m[1] + `" }}` + u.ReadFileN(includeFilename) + `{{ end }}`)
if err != nil {
panic(vm.NewGoError(err))
}
fileModTime[includeFilename] = info2.ModTime.UnixMilli()
}
}
tpl, err = tpl.Parse(code)
tpl, err = tpl.ParseFiles(filename)
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return nil
panic(vm.NewGoError(err))
}
t = &TplCache{
Tpl: tpl,
FileModTime: fileModTime,
}
// tplLock.Lock()
// tplCache[filename] = t
// tplLock.Unlock()
vm.SetData("TPL_"+filename, t)
}
buf := bytes.NewBuffer(make([]byte, 0))
err := t.Tpl.ExecuteTemplate(buf, filename, data)
err := t.Tpl.ExecuteTemplate(buf, filepath.Base(filename), data)
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return nil
panic(vm.NewGoError(err))
}
return vm.ToValue(buf.String())
},
// "dataSet": DataSet,
// "dataGet": DataGet,
// "dataKeys": DataKeys,
// "dataCount": DataCount,
// "dataFetch": DataFetch,
// "dataRemove": DataRemove,
// "listPop": ListPop,
// "listPush": ListPush,
// "listCount": ListCount,
// "listRemove": ListRemove,
"newCaller": NewCaller,
"dataSet": DataSet,
"dataGet": DataGet,
"dataKeys": DataKeys,
"dataCount": DataCount,
"dataFetch": DataFetch,
"dataRemove": DataRemove,
"listPop": ListPop,
"listPush": ListPush,
"listCount": ListCount,
"listRemove": ListRemove,
"newCaller": NewCaller,
}
gojs.Register("apigo.cc/gojs/service", gojs.Module{
@ -902,53 +677,10 @@ func init() {
})
}
var regexpCache = map[string]*regexp.Regexp{}
var regexpLock = sync.RWMutex{}
func getRegexp(regexpStr string) (*regexp.Regexp, error) {
regexpLock.RLock()
rx, ok := regexpCache[regexpStr]
regexpLock.RUnlock()
if ok {
return rx, nil
}
rx, err := regexp.Compile(regexpStr)
if err == nil {
regexpLock.Lock()
defer regexpLock.Unlock()
regexpCache[regexpStr] = rx
}
return rx, err
}
func tplReplace(code string) string {
for k, v := range tplReplaces {
if rx, err := getRegexp(k); err == nil {
code = rx.ReplaceAllString(code, v)
}
}
return code
}
func tplIsSafe(filename string) bool {
if len(serviceConfig.TplSafePaths) > 0 {
isSafe := false
for _, safePath := range serviceConfig.TplSafePaths {
if strings.HasPrefix(filename, safePath) {
isSafe = true
break
}
}
return isSafe
}
return true
}
var tplIncludeMatcher = regexp.MustCompile(`{{\s*template\s+"([^"]+)"`)
var tplDefineMatcher = regexp.MustCompile(`{{\s*define\s+"([^"]+)"\s*}}`)
func verifyRegexp(regexpStr string) func(any, *goja.Runtime) bool {
if rx, err := getRegexp(regexpStr); err != nil {
if rx, err := regexp.Compile(regexpStr); err != nil {
return func(value any, vm *goja.Runtime) bool {
return rx.MatchString(u.String(value))
}
@ -1034,10 +766,10 @@ func runAction(action goja.Callable, vm *goja.Runtime, thisArg goja.Value, args
defer vm.CallbackLocker.Unlock()
// 验证请求参数的有效性
if verifies, ok := vm.GetData("VERIFY_" + u.String(request.Get("registerTag"))).(map[string]func(any, *goja.Runtime) bool); ok {
if verifies, ok := vm.GoData["VERIFY_"+u.String(request.Get("registerTag"))].(map[string]func(any, *goja.Runtime) bool); ok {
failedFields := make([]string, 0)
// 检查必填字段
if requires, ok := vm.GetData("REQUIRE_" + u.String(request.Get("registerTag"))).([]string); ok {
if requires, ok := vm.GoData["REQUIRE_"+u.String(request.Get("registerTag"))].([]string); ok {
for _, requireField := range requires {
if _, ok := args[requireField]; !ok {
failedFields = append(failedFields, requireField)
@ -1068,15 +800,6 @@ func runAction(action goja.Callable, vm *goja.Runtime, thisArg goja.Value, args
}
}
// force set userId to vm
vmUserId := "_guest"
if session != nil {
if userId, ok := session.data[serviceConfig.UserIdKey]; ok {
vmUserId = u.String(userId)
}
}
vm.SetData("userId", vmUserId)
requestParams, resp := makeRequestParams(args, headers, request, response, client, caller, session, logger)
var r any

482
service.ts
View File

@ -1,30 +1,29 @@
// just for develop
export default {
config,
start,
stop,
register,
load,
// task,
newCaller,
// dataSet,
// dataGet,
// dataKeys,
// dataCount,
// dataFetch,
// dataRemove,
// listPush,
// listPop,
// listCount,
// listRemove,
id,
// idL,
// uniqueId,
// uniqueIdL,
// setTplFunc,
setTplReplaces,
tpl,
config,
start,
stop,
register,
load,
task,
newCaller,
dataSet,
dataGet,
dataKeys,
dataCount,
dataFetch,
dataRemove,
listPush,
listPop,
listCount,
listRemove,
id,
idL,
uniqueId,
uniqueIdL,
setTplFunc,
tpl,
}
function config(config?: Config): void { }
@ -33,264 +32,259 @@ function stop(): void { }
function register(option: RegisterOption, callback: (params: RequestParams) => void): any { return null }
function load(serviceFile: string, poolConfig?: PoolConfig): void { }
// function task(taskFile: string, interval: number = 1000): void { }
function task(taskFile: string, interval: number = 1000): void { }
function newCaller(): Caller { return null as any }
// function dataSet(scope: string, key: string, value: any): void { }
// function dataGet(scope: string, key: string): any { return null }
// function dataKeys(scope: string): string[] { return [] }
// function dataCount(scope: string): number { return 0 }
// function dataFetch(scope: string): Map<string, any> { return null as any }
// function dataRemove(scope: string, key?: string): void { }
function dataSet(scope: string, key: string, value: any): void { }
function dataGet(scope: string, key: string): any { return null }
function dataKeys(scope: string): string[] { return [] }
function dataCount(scope: string): number { return 0 }
function dataFetch(scope: string): Map<string, any> { return null as any }
function dataRemove(scope: string, key?: string): void { }
// function listPush(scope: string, key: string, value: any): void { }
// function listPop(scope: string, key: string): any { return null }
// function listCount(scope: string): number { return 0 }
// function listRemove(scope: string): void { }
function id(size?: number): string { return '' }
// function id(space: string, size?: number): string { return '' }
// function idL(space: string, size?: number): string { return '' }
// function uniqueId(size?: number): string { return '' }
// function uniqueIdL(size?: number): string { return '' }
// function setTplFunc(fnList: Object): void { }
function setTplReplaces(replaces: Object): void { }
function tpl(file: string, data: Object, fnList?: Object): string { return '' }
function listPush(scope: string, key: string, value: any): void { }
function listPop(scope: string, key: string): any { return null }
function listCount(scope: string): number { return 0 }
function listRemove(scope: string): void { }
function id(space: string, size?: number): string { return '' }
function idL(space: string, size?: number): string { return '' }
function uniqueId(size?: number): string { return '' }
function uniqueIdL(size?: number): string { return '' }
function setTplFunc(fnList: Object): void { }
function tpl(file: string, data: Object): string { return '' }
export interface Config {
// github.com/ssgo/s 的配置参数
listen: string // 监听端口（|隔开多个监听）（,隔开多个选项）（如果不指定IP则监听在0.0.0.0，如果不指定端口则使用h2c协议监听在随机端口，80端口默认使用http协议，443端口默认使用https协议），例如 80,http|443|443:h2|127.0.0.1:8080,h2c
ssl: Map<string, CertSet> // SSL证书配置，key为域名，value为cert和key的文件路径
noLogGets: boolean // 不记录GET请求的日志
noLogHeaders: string // 不记录请求头中包含的这些字段，多个字段用逗号分隔，默认不记录：Accept,Accept-Encoding,Cache-Control,Pragma,Connection,Upgrade-Insecure-Requests
logInputArrayNum: number // 请求字段中容器类型（数组、Map）在日志打印个数限制 默认为10个，多余的数据将不再日志中记录
logInputFieldSize: number // 请求字段中单个字段在日志打印长度限制 默认为500个字符，多余的数据将不再日志中记录
noLogOutputFields: string // 不记录响应字段中包含的这些字段（key名），多个字段用逗号分隔
logOutputArrayNum: number // 响应字段中容器类型（数组、Map）在日志打印个数限制 默认为3个，多余的数据将不再日志中记录
logOutputFieldSize: number // 响应字段中单个字段在日志打印长度限制 默认为100个字符，多余的数据将不再日志中记录
logWebsocketAction: boolean // 记录Websocket中每个Action的请求日志，默认不记录
compress: boolean // 是否启用压缩，默认不启用
compressMinSize: number // 小于设定值的应答内容将不进行压缩，默认值：1024
compressMaxSize: number // 大于设定值的应答内容将不进行压缩，默认值：4096000
checkDomain: string // 心跳检测时使用域名，，默认使用IP地址，心跳检测使用 HEAD /__CHECK__ 请求，应答 299 表示正常，593 表示异常
redirectTimeout: number // proxy和discover发起请求时的超时时间，单位ms，默认值：10000
acceptXRealIpWithoutRequestId: boolean // 是否允许头部没有携带请求ID的X-Real-IP信息，默认不允许（防止伪造客户端IP）
statisticTime: boolean // 是否开启请求时间统计，默认不开启
statisticTimeInterval: number // 统计时间间隔，单位ms，默认值：10000
fast: boolean // 是否启用快速模式（为了追求性能牺牲一部分特性），默认不启用
maxUploadSize: number // 最大上传文件大小（multipart/form-data请求的总空间），单位字节，默认值：104857600
cpu: number // CPU占用的核数，默认为0，即不做限制
memory: number // 内存（单位M），默认为0，即不做限制
cpuMonitor: boolean // 在日志中记录CPU使用情况，默认不开启
memoryMonitor: boolean // 在日志中记录内存使用情况，默认不开启
cpuLimitValue: number // CPU超过最高占用值（10-100）超过次数将自动重启（如果CpuMonitor开启的话），默认100
memoryLimitValue: number // 内存超过最高占用值（10-100）超过次数将自动重启（如果MemoryMonitor开启的话），默认95
cpuLimitTimes: number // CPU超过最高占用值超过次数（1-100）将报警（如果CpuMonitor开启的话），默认6（即30秒内连续6次）
memoryLimitTimes: number // 内存超过最高占用值超过次数（1-100）将报警（如果MemoryMonitor开启的话），默认6（即30秒内连续6次）
cookieScope: string // 启用Session时Cookie的有效范围，host|domain|topDomain，默认值为host
sessionWithoutCookie: boolean // Session禁用Cookie保持，默认使用Cookie
deviceWithoutCookie: boolean // 设备ID禁用Cookie保持，默认使用Cookie
idServer: string // 用s.UniqueId、s.Id来生成唯一ID（雪花算法）时所需的redis服务器连接，如果不指定将不能实现跨服务的全局唯一
keepKeyCase: boolean // 是否保持Key的首字母大小写？默认保持，设置为false则自动将首字母转为小写
indexFiles: string[] // 访问静态文件时的索引文件，默认为 index.html
indexDir: boolean // 访问目录时显示文件列表
readTimeout: number // 读取请求的超时时间，单位ms
readHeaderTimeout: number // 读取请求头的超时时间，单位ms
writeTimeout: number // 响应写入的超时时间，单位ms
idleTimeout: number // 连接空闲超时时间，单位ms
maxHeaderBytes: number // 请求头的最大字节数
maxHandlers: number // 每个连接的最大处理程序数量
maxConcurrentStreams: number // 每个连接的最大并发流数量
maxDecoderHeaderTableSize: number // 解码器头表的最大大小
maxEncoderHeaderTableSize: number // 编码器头表的最大大小
maxReadFrameSize: number // 单个帧的最大读取大小
maxUploadBufferPerConnection: number // 每个连接的最大上传缓冲区大小
maxUploadBufferPerStream: number // 每个流的最大上传缓冲区大小
interface Config {
// github.com/ssgo/s 的配置参数
listen: string // 监听端口（|隔开多个监听）（,隔开多个选项）（如果不指定IP则监听在0.0.0.0，如果不指定端口则使用h2c协议监听在随机端口，80端口默认使用http协议，443端口默认使用https协议），例如 80,http|443|443:h2|127.0.0.1:8080,h2c
ssl: Map<string, CertSet> // SSL证书配置，key为域名，value为cert和key的文件路径
noLogGets: boolean // 不记录GET请求的日志
noLogHeaders: string // 不记录请求头中包含的这些字段，多个字段用逗号分隔，默认不记录：Accept,Accept-Encoding,Cache-Control,Pragma,Connection,Upgrade-Insecure-Requests
logInputArrayNum: number // 请求字段中容器类型（数组、Map）在日志打印个数限制 默认为10个，多余的数据将不再日志中记录
logInputFieldSize: number // 请求字段中单个字段在日志打印长度限制 默认为500个字符，多余的数据将不再日志中记录
noLogOutputFields: string // 不记录响应字段中包含的这些字段（key名），多个字段用逗号分隔
logOutputArrayNum: number // 响应字段中容器类型（数组、Map）在日志打印个数限制 默认为3个，多余的数据将不再日志中记录
logOutputFieldSize: number // 响应字段中单个字段在日志打印长度限制 默认为100个字符，多余的数据将不再日志中记录
logWebsocketAction: boolean // 记录Websocket中每个Action的请求日志，默认不记录
compress: boolean // 是否启用压缩，默认不启用
compressMinSize: number // 小于设定值的应答内容将不进行压缩，默认值：1024
compressMaxSize: number // 大于设定值的应答内容将不进行压缩，默认值：4096000
checkDomain: string // 心跳检测时使用域名，，默认使用IP地址，心跳检测使用 HEAD /__CHECK__ 请求，应答 299 表示正常，593 表示异常
redirectTimeout: number // proxy和discover发起请求时的超时时间，单位ms，默认值：10000
acceptXRealIpWithoutRequestId: boolean // 是否允许头部没有携带请求ID的X-Real-IP信息，默认不允许（防止伪造客户端IP）
statisticTime: boolean // 是否开启请求时间统计，默认不开启
statisticTimeInterval: number // 统计时间间隔，单位ms，默认值：10000
fast: boolean // 是否启用快速模式（为了追求性能牺牲一部分特性），默认不启用
maxUploadSize: number // 最大上传文件大小（multipart/form-data请求的总空间），单位字节，默认值：104857600
cpu: number // CPU占用的核数，默认为0，即不做限制
memory: number // 内存（单位M），默认为0，即不做限制
cpuMonitor: boolean // 在日志中记录CPU使用情况，默认不开启
memoryMonitor: boolean // 在日志中记录内存使用情况，默认不开启
cpuLimitValue: number // CPU超过最高占用值（10-100）超过次数将自动重启（如果CpuMonitor开启的话），默认100
memoryLimitValue: number // 内存超过最高占用值（10-100）超过次数将自动重启（如果MemoryMonitor开启的话），默认95
cpuLimitTimes: number // CPU超过最高占用值超过次数（1-100）将报警（如果CpuMonitor开启的话），默认6（即30秒内连续6次）
memoryLimitTimes: number // 内存超过最高占用值超过次数（1-100）将报警（如果MemoryMonitor开启的话），默认6（即30秒内连续6次）
cookieScope: string // 启用Session时Cookie的有效范围，host|domain|topDomain，默认值为host
sessionWithoutCookie: boolean // Session禁用Cookie保持，默认使用Cookie
deviceWithoutCookie: boolean // 设备ID禁用Cookie保持，默认使用Cookie
idServer: string // 用s.UniqueId、s.Id来生成唯一ID（雪花算法）时所需的redis服务器连接，如果不指定将不能实现跨服务的全局唯一
keepKeyCase: boolean // 是否保持Key的首字母大小写？默认保持，设置为false则自动将首字母转为小写
indexFiles: string[] // 访问静态文件时的索引文件，默认为 index.html
indexDir: boolean // 访问目录时显示文件列表
readTimeout: number // 读取请求的超时时间，单位ms
readHeaderTimeout: number // 读取请求头的超时时间，单位ms
writeTimeout: number // 响应写入的超时时间，单位ms
idleTimeout: number // 连接空闲超时时间，单位ms
maxHeaderBytes: number // 请求头的最大字节数
maxHandlers: number // 每个连接的最大处理程序数量
maxConcurrentStreams: number // 每个连接的最大并发流数量
maxDecoderHeaderTableSize: number // 解码器头表的最大大小
maxEncoderHeaderTableSize: number // 编码器头表的最大大小
maxReadFrameSize: number // 单个帧的最大读取大小
maxUploadBufferPerConnection: number // 每个连接的最大上传缓冲区大小
maxUploadBufferPerStream: number // 每个流的最大上传缓冲区大小
// 其他配置
sessionKey: string // HTTP头和Cookie中SessionID的Key，客户端没有传递时服务端自动生成，Header的优先级高于Cookie，默认为 Session, 设置为空时表示不使用
deviceKey: string // 标识设备ID的Key，客户端没有传递时服务端自动生成，Header的优先级高于Cookie，默认为 Device， 设置为空时表示不使用
clientKey: string // 标识客户端的Key，默认为 Client，对应的Header头为 ClientName 和 ClientVersion
userIdKey: string // session中userID的Key，用于在日志中记录用户ID信息，默认为 id
sessionProvider: string // 指定一个redis连接（例如：redis://:sskey加密的密码@127.0.0.1:6379/15），默认使用内存存储
sessionTimeout: number // session过期时间，单位 秒，默认为 3600秒
authFieldMessage: string | Object // 身份验证失败时的消息，默认为 auth failed，可以设置对象来返回JSON，可以使用模版 {{TARGET_AUTHLEVEL}}、{{USER_AUTHLEVEL}}
verifyFieldMessage: string | Object // 参数验证失败时的消息，默认为 verify failed，可以设置对象来返回JSON，可以使用模版 {{FAILED_FIELDS}}
limitedMessage: string | Object // 访问受限时的消息，默认为 too many requests，可以设置对象来返回JSON，可以使用模版 {{LIMITED_FROM}}、{{LIMITED_VALUE}}
limiterRedis: string // 限流器使用的Redis连接，默认使用内存存储
limiters: Map<string, LimiterConfig> // 限流器配置，from 为数据来源，例如：ip、user、device、header.User-Agent、in.phone 等（in表示从请求参数中获取），time为时间间隔，单位ms，times为 时间间隔内允许访问的次数
hotLoad: number // 热加载配置，单位s，默认值：0，0表示不检测热加载
tplSafePaths: string[] // 模板文件的安全路径，默认不开启安全检查
// 其他配置
sessionKey: string // HTTP头和Cookie中SessionID的Key，客户端没有传递时服务端自动生成，Header的优先级高于Cookie，默认为 Session, 设置为空时表示不使用
deviceKey: string // 标识设备ID的Key，客户端没有传递时服务端自动生成，Header的优先级高于Cookie，默认为 Device， 设置为空时表示不使用
clientKey: string // 标识客户端的Key，默认为 Client，对应的Header头为 ClientName 和 ClientVersion
userIdKey: string // session中userID的Key，用于在日志中记录userId信息，默认为 userId
sessionProvider: string // 指定一个redis连接（例如：redis://:sskey加密的密码@127.0.0.1:6379/15），默认使用内存存储
sessionTimeout: number // session过期时间，单位 秒，默认为 3600秒
authFieldMessage: string | Object // 身份验证失败时的消息，默认为 auth failed，可以设置对象来返回JSON，可以使用模版 {{TARGET_AUTHLEVEL}}、{{USER_AUTHLEVEL}}
verifyFieldMessage: string | Object // 参数验证失败时的消息，默认为 verify failed，可以设置对象来返回JSON，可以使用模版 {{FAILED_FIELDS}}
limitedMessage: string | Object // 访问受限时的消息，默认为 too many requests，可以设置对象来返回JSON，可以使用模版 {{LIMITED_FROM}}、{{LIMITED_VALUE}}
limiterRedis: string // 限流器使用的Redis连接，默认使用内存存储
limiters: Map<string, LimiterConfig> // 限流器配置，from 为数据来源，例如：ip、user、device、header.User-Agent、in.phone 等（in表示从请求参数中获取），time为时间间隔，单位ms，times为 时间间隔内允许访问的次数
// gateway 的配置参数
proxy: Map<string, string> // 代理配置，key为[host][path]，value为代理的目标应用或URL
rewrite: Map<string, string> // 重写请求路径，key为[host][path]，value为重写后的路径
static: Map<string, string> // 静态文件目录，key为[host][path]，value为目录路径
// gateway 的配置参数
proxy: Map<string, string> // 代理配置，key为[host][path]，value为代理的目标应用或URL
rewrite: Map<string, string> // 重写请求路径，key为[host][path]，value为重写后的路径
static: Map<string, string> // 静态文件目录，key为[host][path]，value为目录路径
// github.com/ssgo/discover 的配置参数
registry: string // 服务注册中心，请配置一个有效的RedisURL，默认值 redis://:@127.0.0.1:6379/15
app: string // 设置该值将会自动将服务注册到 discover
weight: number // 节点的权重，默认值 100
accessTokens: Map<string, number> // 请求接口时使用指定的Access-Token进行验证，值为Token对应的authLevel（允许访问大于等于指定对应authLevel的接口）
calls: Map<string, string> // 配置将会调用的服务，格式：[1|2]:[http|https|h2c]:[AccessToken]，默认协议为：h2c，如使用h2c协议可只提供 AccessToken
callRetryTimes: number // 调用其他服务时最大重试次数，默认值 10
ipPrefix: string // discover服务发现时指定使用的IP网段，默认排除 172.17.（Docker）
// github.com/ssgo/discover 的配置参数
registry: string // 服务注册中心，请配置一个有效的RedisURL，默认值 redis://:@127.0.0.1:6379/15
app: string // 设置该值将会自动将服务注册到 discover
weight: number // 节点的权重，默认值 100
accessTokens: Map<string, number> // 请求接口时使用指定的Access-Token进行验证，值为Token对应的authLevel（允许访问大于等于指定对应authLevel的接口）
calls: Map<string, string> // 配置将会调用的服务，格式：[1|2]:[http|https|h2c]:[AccessToken]，默认协议为：h2c，如使用h2c协议可只提供 AccessToken
callRetryTimes: number // 调用其他服务时最大重试次数，默认值 10
ipPrefix: string // discover服务发现时指定使用的IP网段，默认排除 172.17.（Docker）
}
export interface CertSet {
certFile: string
keyFile: string
interface CertSet {
certFile: string
keyFile: string
}
export interface PoolConfig {
min: number
max: string
idle: number
interface PoolConfig {
min: number
max: string
idle: number
}
export interface LimiterConfig {
from: string
time: number
times: number
interface LimiterConfig {
from: string
time: number
times: number
}
export interface RegisterOption {
authLevel: number
host: string
method: string
path: string
memo: string
noBody: boolean
noLog200: boolean
limiters: string[]
verifies: Object
requires: string[]
ext: Object
onMessage: (params: OnMessageParams) => void
onClose: (params: RequestParams) => void
interface RegisterOption {
authLevel: number
host: string
method: string
path: string
memo: string
noBody: boolean
noLog200: boolean
limiters: string[]
verifies: Object
requires: string[]
onMessage: (params: OnMessageParams) => void
onClose: (params: RequestParams) => void
}
export interface RequestParams {
args: Object
headers: Object
request: Request
client: WSClient
caller: Caller
session: Session
response: Response
logger: Logger
interface RequestParams {
args: Object
headers: Object
request: Request
client: WSClient
caller: Caller
session: Session
response: Response
logger: Logger
}
export interface OnMessageParams {
type: string
data: string | Object
client: WSClient
session: Session
logger: Logger
interface OnMessageParams {
type: string
data: string | Object
client: WSClient
session: Session
logger: Logger
}
export interface WSClient {
id: string
read: () => WSMessage
write: (data: any) => void
writeMessage: (type: string, data: any) => void
ping: () => void
close: () => void
interface WSClient {
id: string
read: () => WSMessage
write: (data: any) => void
writeMessage: (type: string, data: any) => void
ping: () => void
close: () => void
}
export interface WSMessage {
type: string
data: string | Object
interface WSMessage {
type: string
data: string | Object
}
export interface Session {
set: (key: string | Object, value?: any) => void
get: (...keys: string[]) => any | Object
remove: (...keys: string[]) => void
setAuthLevel: (authLevel: number) => void
save: () => void
interface Session {
set: (key: string | Object, value?: any) => void
get: (...keys: string[]) => any | Object
remove: (...keys: string[]) => void
setAuthLevel: (authLevel: number) => void
save: () => void
}
export interface Caller {
get(url: string, headers?: Object): Result
head(url: string, headers?: Object): Result
post(url: string, data: any, headers?: Object): Result
put(url: string, data: any, headers?: Object): Result
delete(url: string, data: any, headers?: Object): Result
do(method: string, url: string, data: any, callback?: (data: string) => void, headers?: Object): Result
interface Caller {
get(url: string, headers?: Object): Result
head(url: string, headers?: Object): Result
post(url: string, data: any, headers?: Object): Result
put(url: string, data: any, headers?: Object): Result
delete(url: string, data: any, headers?: Object): Result
do(method: string, url: string, data: any, callback?: (data: string) => void, headers?: Object): Result
}
export interface Result {
status: string
statusCode: number
headers: Object
bytes(): Uint8Array
string(): string
object(): Object
interface Result {
status: string
statusCode: number
headers: Object
bytes(): Uint8Array
string(): string
object(): Object
}
export interface CookieOption {
path: string
domain: string
expires: any
maxAge: number
secure: boolean
httpOnly: boolean
interface CookieOption {
path: string
domain: string
expires: any
maxAge: number
secure: boolean
httpOnly: boolean
}
export interface Request {
id: string
proto: string
scheme: string
host: string
method: string
path: string
remoteAddr: string
realIP: string
referer: string
userAgent: string
url: string
contentLength: number
cookies: Object
headers: Object
args: Object
files: Map<string, UploadFile>
multiFiles: Map<string, UploadFile[]>
makeURL: (path: string) => string
readAll: () => any
read: (size: number) => any
close: () => void
get: (key: string) => any
set: (key: string, value: any) => void
getHeader: (key: string) => string
setHeader: (key: string, value: string) => void
setUserID: (id: string) => void
interface Request {
id: string
proto: string
scheme: string
host: string
method: string
path: string
remoteAddr: string
realIP: string
referer: string
userAgent: string
url: string
contentLength: number
cookies: Object
headers: Object
args: Object
files: Map<string, UploadFile>
multiFiles: Map<string, UploadFile[]>
makeURL: (path: string) => string
readAll: () => any
read: (size: number) => any
close: () => void
get: (key: string) => any
set: (key: string, value: any) => void
getHeader: (key: string) => string
setHeader: (key: string, value: string) => void
setUserID: (id: string) => void
}
export interface Response {
id: string
setStatus: (code: number) => void
setCookie: (name: string, value: string, option?: CookieOption) => void
setHeader: (name: string, value: string) => void
addHeader: (name: string, value: string) => void
getHeader: (name: string) => string
write: (data: any) => number
flush: () => void
sendFile: (contentType: string, filename: string) => void
downloadFile: (contentType: string, filename: string, data: any) => void
location: (url: string) => void
end: (data: any) => void
interface Response {
id: string
setStatus: (code: number) => void
setCookie: (name: string, value: string, option?: CookieOption) => void
setHeader: (name: string, value: string) => void
addHeader: (name: string, value: string) => void
getHeader: (name: string) => string
write: (data: any) => number
flush: () => void
sendFile: (contentType: string, filename: string) => void
downloadFile: (contentType: string, filename: string, data: any) => void
location: (url: string) => void
end: (data: any) => void
}
export interface Logger {
debug: (message: string, info?: Object) => void
info: (message: string, info?: Object) => void
warn: (message: string, info?: Object) => void
error: (message: string, info?: Object) => void
interface Logger {
debug: (message: string, info?: Object) => void
info: (message: string, info?: Object) => void
warn: (message: string, info?: Object) => void
error: (message: string, info?: Object) => void
}
export interface UploadFile {
name: string
size: number
data: any
interface UploadFile {
name: string
size: number
data: any
}

83
session.go
View File

@ -2,7 +2,6 @@ package service
import (
"reflect"
"strings"
"sync"
"time"
@ -10,14 +9,12 @@ import (
"apigo.cc/gojs/goja"
"github.com/ssgo/log"
"github.com/ssgo/redis"
"github.com/ssgo/u"
)
type Session struct {
id string
conn *redis.Redis
data map[string]any
funcAuthCache map[string]bool
id string
conn *redis.Redis
data map[string]any
}
var sessionRedis *redis.Redis
@ -43,10 +40,9 @@ func NewSession(id string, logger *log.Logger) *Session {
}
}
return &Session{
id: id,
conn: conn,
data: data,
funcAuthCache: map[string]bool{},
id: id,
conn: conn,
data: data,
}
}
@ -106,73 +102,6 @@ func (session *Session) SetAuthLevel(argsIn goja.FunctionCall, vm *goja.Runtime)
return nil
}
func (session *Session) authFuncs(needFuncs []string) bool {
cacheKey := strings.Join(needFuncs, "; ")
if cachedResult, ok := session.funcAuthCache[cacheKey]; ok {
return cachedResult
}
normalAuthOk := 0
requiredAuthTotal := 0
requiredAuthOk := 0
isOk := false
if userFuncs, ok := session.data["funcs"].([]string); ok && len(userFuncs) > 0 {
if u.StringIn(userFuncs, "system.superAdmin.") {
isOk = true
} else {
// 统计必须有几个权限
for _, needFunc := range needFuncs {
if needFunc[0] == '&' {
requiredAuthTotal++
}
}
// 检查是否有匹配的权限（左匹配）
for _, needFunc := range needFuncs {
isRequired := false
if needFunc[0] == '&' {
// 必须有此权限
isRequired = true
needFunc = needFunc[1:]
}
for _, userFunc := range userFuncs {
if strings.HasPrefix(userFunc, needFunc) {
// 匹配成功
if isRequired {
// 必须有此权限并且匹配成功
requiredAuthOk++
} else {
// 普通权限匹配成功
normalAuthOk++
}
break
}
}
if normalAuthOk > 0 && requiredAuthOk == requiredAuthTotal {
// 普通权限匹配成功，并且必须有权限也匹配成功，直接返回
isOk = true
break
}
}
}
}
session.funcAuthCache[cacheKey] = isOk
return isOk
}
func (session *Session) AuthFuncs(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
var needFuncs []string
if args.Arguments[0].ExportType().Kind() == reflect.Slice {
// 第一个参数是数组
needFuncs = args.Arr(0).StrArray(0)
} else {
// 平铺的参数
needFuncs = args.StrArray(0)
}
return vm.ToValue(session.authFuncs(needFuncs))
}
func (session *Session) Save(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
if session.conn == nil {
now := time.Now().Unix()

299
task.go
View File

@ -1,165 +1,162 @@
package service
// type Task struct {
// spec string
// file string
// vm *gojs.Runtime
// lock sync.RWMutex
// mtime time.Time
// // policy string
// }
// var tasks []Task
// var tasksLock = sync.RWMutex{}
import (
"container/list"
"sync"
// var taskData = map[string]map[string]any{}
// var taskDataLock = sync.RWMutex{}
"apigo.cc/gojs"
"apigo.cc/gojs/goja"
)
// var taskList = map[string]*list.List{}
// var taskListLock = sync.RWMutex{}
var taskData = map[string]map[string]any{}
var taskDataLock = sync.RWMutex{}
// func DataSet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(3)
// scope := args.Str(0)
// key := args.Str(1)
// value := args.Any(2)
// taskDataLock.Lock()
// defer taskDataLock.Unlock()
// if taskData[scope] == nil {
// taskData[scope] = map[string]any{}
// }
// taskData[scope][key] = value
// return nil
// }
var taskList = map[string]*list.List{}
var taskListLock = sync.RWMutex{}
// func DataGet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(2)
// scope := args.Str(0)
// key := args.Str(1)
// taskDataLock.RLock()
// defer taskDataLock.RUnlock()
// if taskData[scope] != nil {
// return vm.ToValue(taskData[scope][key])
// }
// return nil
// }
func DataSet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(3)
scope := args.Str(0)
key := args.Str(1)
value := args.Any(2)
taskDataLock.Lock()
defer taskDataLock.Unlock()
if taskData[scope] == nil {
taskData[scope] = map[string]any{}
}
taskData[scope][key] = value
return nil
}
// func DataKeys(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// scope := args.Str(0)
// taskDataLock.RLock()
// defer taskDataLock.RUnlock()
// if taskData[scope] != nil {
// keys := make([]string, len(taskData[scope]))
// i := 0
// for key := range taskData[scope] {
// keys[i] = key
// i++
// }
// return vm.ToValue(keys)
// }
// return nil
// }
func DataGet(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(2)
scope := args.Str(0)
key := args.Str(1)
taskDataLock.RLock()
defer taskDataLock.RUnlock()
if taskData[scope] != nil {
return vm.ToValue(taskData[scope][key])
}
return nil
}
// func DataCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// scope := args.Str(0)
// taskDataLock.RLock()
// defer taskDataLock.RUnlock()
// if taskData[scope] != nil {
// return vm.ToValue(len(taskData[scope]))
// }
// return vm.ToValue(0)
// }
func DataKeys(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
scope := args.Str(0)
taskDataLock.RLock()
defer taskDataLock.RUnlock()
if taskData[scope] != nil {
keys := make([]string, len(taskData[scope]))
i := 0
for key := range taskData[scope] {
keys[i] = key
i++
}
return vm.ToValue(keys)
}
return nil
}
// func DataFetch(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// scope := args.Str(0)
// taskDataLock.RLock()
// defer taskDataLock.RUnlock()
// if taskData[scope] != nil {
// all := make(map[string]any)
// for k, v := range taskData[scope] {
// all[k] = v
// }
// return vm.ToValue(all)
// }
// return nil
// }
func DataCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
scope := args.Str(0)
taskDataLock.RLock()
defer taskDataLock.RUnlock()
if taskData[scope] != nil {
return vm.ToValue(len(taskData[scope]))
}
return vm.ToValue(0)
}
// func DataRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// scope := args.Str(0)
// key := args.Str(1)
// taskDataLock.Lock()
// defer taskDataLock.Unlock()
// if taskData[scope] != nil {
// if key != "" {
// delete(taskData[scope], key)
// } else {
// delete(taskData, scope)
// }
// }
// return nil
// }
func DataFetch(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
scope := args.Str(0)
taskDataLock.RLock()
defer taskDataLock.RUnlock()
if taskData[scope] != nil {
all := make(map[string]any)
for k, v := range taskData[scope] {
all[k] = v
}
return vm.ToValue(all)
}
return nil
}
// func ListPush(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(2)
// scope := args.Str(0)
// value := args.Any(1)
// fromHead := args.Bool(2)
// taskListLock.Lock()
// defer taskListLock.Unlock()
// list1 := taskList[scope]
// if list1 == nil {
// list1 = list.New()
// taskList[scope] = list1
// }
// if fromHead {
// list1.PushFront(value)
// } else {
// list1.PushBack(value)
// }
// return nil
// }
func DataRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
scope := args.Str(0)
key := args.Str(1)
taskDataLock.Lock()
defer taskDataLock.Unlock()
if taskData[scope] != nil {
if key != "" {
delete(taskData[scope], key)
} else {
delete(taskData, scope)
}
}
return nil
}
// func ListPop(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// scope := args.Str(0)
// fromEnd := args.Bool(1)
// taskListLock.Lock()
// var item *list.Element
// defer taskListLock.Unlock()
// list1 := taskList[scope]
// if list1 != nil {
// if fromEnd {
// item = list1.Front()
// } else {
// item = list1.Back()
// }
// if item != nil {
// list1.Remove(item)
// return vm.ToValue(item.Value)
// }
// }
// return nil
// }
func ListPush(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(2)
scope := args.Str(0)
value := args.Any(1)
fromHead := args.Bool(2)
taskListLock.Lock()
defer taskListLock.Unlock()
list1 := taskList[scope]
if list1 == nil {
list1 = list.New()
taskList[scope] = list1
}
if fromHead {
list1.PushFront(value)
} else {
list1.PushBack(value)
}
return nil
}
// func ListCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// scope := args.Str(0)
// taskListLock.RLock()
// defer taskListLock.RUnlock()
// if taskList[scope] != nil {
// return vm.ToValue(taskList[scope].Len())
// }
// return vm.ToValue(0)
// }
func ListPop(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
scope := args.Str(0)
fromEnd := args.Bool(1)
taskListLock.Lock()
var item *list.Element
defer taskListLock.Unlock()
list1 := taskList[scope]
if list1 != nil {
if fromEnd {
item = list1.Front()
} else {
item = list1.Back()
}
if item != nil {
list1.Remove(item)
return vm.ToValue(item.Value)
}
}
return nil
}
// func ListRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
// args := gojs.MakeArgs(&argsIn, vm).Check(1)
// scope := args.Str(0)
// taskListLock.Lock()
// defer taskListLock.Unlock()
// delete(taskList, scope)
// return nil
// }
func ListCount(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
scope := args.Str(0)
taskListLock.RLock()
defer taskListLock.RUnlock()
if taskList[scope] != nil {
return vm.ToValue(taskList[scope].Len())
}
return vm.ToValue(0)
}
func ListRemove(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(1)
scope := args.Str(0)
taskListLock.Lock()
defer taskListLock.Unlock()
delete(taskList, scope)
return nil
}

5
tests/api/echo.js
View File

@ -1,12 +1,13 @@
import service from "apigo.cc/gojs/service"
import rt from "apigo.cc/gojs/runtime"
import co from "apigo.cc/gojs/console"
import u from "apigo.cc/gojs/util"
function main() {
service.register({ path: '/echo2', noLog200: true }, ({ args, response }) => {
// setTimeout(() => {
// response.end(args.name)
// }, 10)
rt.sleep(10)
u.sleep(10)
return args.name
})
}

7
tests/api/ws.js
View File

@ -1,6 +1,5 @@
import s from "apigo.cc/gojs/service"
import co from "apigo.cc/gojs/console"
import task from "apigo.cc/gojs/task"
function main() {
s.register({
@ -10,13 +9,11 @@ function main() {
},
onClose: ({ client }) => {
co.info('ws closed', client.id)
// s.dataRemove('wsTest', client.id)
task.remove('wsTest_' + client.id)
s.dataRemove('wsTest', client.id)
}
}, ({ client }) => {
co.info('ws connected', client.id)
// s.dataSet('wsTest', client.id, client)
task.set('wsTest_' + client.id, client)
s.dataSet('wsTest', client.id, client)
client.write('Hello, World!')
})
}

5
tests/service_pool_test.go
View File

@ -2,14 +2,12 @@ package service_test
import (
"fmt"
"os"
"sync"
"time"
"apigo.cc/gojs"
_ "apigo.cc/gojs/console"
_ "apigo.cc/gojs/http"
_ "apigo.cc/gojs/runtime"
"apigo.cc/gojs/service"
_ "apigo.cc/gojs/service"
_ "apigo.cc/gojs/util"
@ -40,7 +38,6 @@ func TestStartByPool(t *testing.T) {
gojs.ExportForDev()
rt2 = gojs.New()
u.CopyFile("api/echo.js", "api/echo_tmp.js")
err := rt2.StartFromFile("start.js")
if err != nil {
t.Fatal("start failed", err)
@ -219,7 +216,7 @@ func TestStopByPool(t *testing.T) {
t.Fatal("stop failed", err)
}
gojs.WaitAll()
os.Remove("api/echo_tmp.js")
runtime.GC()
ms3 := runtime.MemStats{}
runtime.ReadMemStats(&ms3)

32
tests/service_test.go
View File

@ -2,16 +2,12 @@ package service_test
import (
"fmt"
"os"
"strings"
"testing"
"time"
"apigo.cc/gojs"
_ "apigo.cc/gojs/console"
_ "apigo.cc/gojs/file"
_ "apigo.cc/gojs/http"
_ "apigo.cc/gojs/runtime"
_ "apigo.cc/gojs/service"
_ "apigo.cc/gojs/util"
"github.com/ssgo/httpclient"
@ -26,7 +22,6 @@ const runTimes = 100
func TestStart(t *testing.T) {
gojs.ExportForDev()
rt = gojs.New()
u.CopyFile("api/echo.js", "api/echo_tmp.js")
err := rt.StartFromFile("start.js")
if err != nil {
t.Fatal("start failed", err)
@ -60,19 +55,6 @@ func TestJsEcho(t *testing.T) {
}
}
func TestJsEcho2(t *testing.T) {
for i := 0; i < runTimes; i++ {
name := u.UniqueId()
r, err := rt.RunCode("test2('" + name + "')")
if err != nil {
t.Fatal("test2 js get failed, got error", err)
} else if r != name {
t.Fatal("test2 js get failed, name not match", r, name)
}
}
u.WriteFile("api/echo_tmp.js", strings.Replace(u.ReadFileN("api/echo.js"), "return args.name", "return args.name+'!!'", 1))
}
func TestGoEcho(t *testing.T) {
hc := httpclient.GetClientH2C(0)
for i := 0; i < runTimes; i++ {
@ -136,19 +118,6 @@ func TestGoAsyncEcho(t *testing.T) {
fmt.Println(u.BGreen("last name:"), lastName, lastResult)
}
func TestJsEcho2WithHotLoad(t *testing.T) {
time.Sleep(time.Second)
for i := 0; i < runTimes; i++ {
name := u.UniqueId()
r, err := rt.RunCode("test2('" + name + "')")
if err != nil {
t.Fatal("test2 js get failed, got error", err)
} else if r != name+"!!" {
t.Fatal("test2 js get failed, name not match", r, name)
}
}
}
func TestStop(t *testing.T) {
go func() {
time.Sleep(100 * time.Millisecond)
@ -156,7 +125,6 @@ func TestStop(t *testing.T) {
}()
gojs.WaitAll()
time.Sleep(100 * time.Millisecond)
os.Remove("api/echo_tmp.js")
// if err != nil {
// t.Fatal("stop failed", err)
// }

6
tests/service_ws_test.go
View File

@ -6,9 +6,7 @@ import (
"apigo.cc/gojs"
_ "apigo.cc/gojs/console"
_ "apigo.cc/gojs/http"
_ "apigo.cc/gojs/runtime"
_ "apigo.cc/gojs/service"
_ "apigo.cc/gojs/task"
_ "apigo.cc/gojs/util"
"github.com/ssgo/u"
@ -45,9 +43,7 @@ func TestWS(t *testing.T) {
}
func TestStopWSByPool(t *testing.T) {
fmt.Println(u.BGreen("stop ws"))
_, err := rt3.RunCode("s.stop();task.stop();")
fmt.Println(u.BGreen("stop ws ok"), err)
_, err := rt3.RunCode("s.stop()")
if err != nil {
t.Fatal("stop failed", err)
}

12
tests/start.js
View File

@ -1,8 +1,7 @@
import s from "apigo.cc/gojs/service"
import http from "apigo.cc/gojs/http"
import rt from "apigo.cc/gojs/runtime"
import u from "apigo.cc/gojs/util"
import co from "apigo.cc/gojs/console"
import file from "apigo.cc/gojs/file"
let h2c = http
let urlPrefix
@ -34,17 +33,16 @@ function main() {
},
rewrite: {
'/echo2.js': '/echo.js'
},
hotLoad: 1,
}
})
s.register({ path: '/echo', noLog200: true }, ({ args, response }) => {
// setTimeout(() => {
// response.end(args.name)
// }, 1)
rt.sleep(1)
u.sleep(1)
return args.name
})
s.load('api/echo_tmp.js', { min: 20, max: 1000, idle: 100 })
s.load('api/echo.js', { min: 20, max: 1000, idle: 100 })
s.load('api/user.js')
let host = s.start()
h2c = http.newH2C({
@ -91,7 +89,7 @@ function testUser() {
if (r.statusCode != 429) {
return r
}
rt.sleep(100)
u.sleep(100)
// 测试限流器过期后允许的 1 次请求
r = h2c.get('/userInfo').object()

13
tests/start_ws.js
View File

@ -1,16 +1,13 @@
import s from "apigo.cc/gojs/service"
import http from "apigo.cc/gojs/http"
import rt from "apigo.cc/gojs/runtime"
import u from "apigo.cc/gojs/util"
import co from "apigo.cc/gojs/console"
import task from "apigo.cc/gojs/task"
let hc = http
let urlPrefix
function main() {
s.load('api/ws.js')
// s.task('task.js', 100)
task.addTask("@every 1s", 'task.js')
task.start()
s.task('task.js', 100)
let host = s.start()
hc = http.new({ baseURL: 'http://' + host })
return host
@ -34,7 +31,7 @@ function testWS() {
co.info('test ws abc ok')
// ws.ping()
rt.sleep(10)
u.sleep(10)
let pc = ws.pingCount()
co.info('test ws ping ok', pc.pingTimes, pc.pongTimes)
@ -54,13 +51,15 @@ function testWS() {
return r
}
co.info('test ws json ok')
rt.sleep(2000)
u.sleep(1000)
for (let i = 0; i < 5; i++) {
let j = ws.read()
if (i !== j.data) {
return j
}
}
ws.close()
return true
}

35
tests/task.js
View File

@ -1,31 +1,30 @@
import s from 'apigo.cc/gojs/service'
import co from 'apigo.cc/gojs/console'
import task from 'apigo.cc/gojs/task'
function onStart() {
co.info('task start')
co.info('task start')
}
let i = 0
function onRun() {
let keys = task.keys('wsTest_')
// let connCount = s.dataCount('wsTest')
if (keys.length > 0) {
// let conns = s.dataFetch('wsTest')
let conns = task.getAll('wsTest_')
for (let id in conns) {
let conn = conns[id]
if (!conn.write(i++)) {
task.remove(id)
}
}
}
co.info('task run', keys.length)
let connCount = s.dataCount('wsTest')
if (connCount > 0) {
let conns = s.dataFetch('wsTest')
for (let id in conns) {
let conn = conns[id]
try {
conn.write(i++)
} catch (e) {
co.error(e)
s.dataRemove('wsTest', id)
}
}
}
co.info('task run', connCount)
}
function onStop() {
// s.dataRemove('wsTest')
task.removeAll('wsTest_')
co.info('task stop')
s.dataRemove('wsTest')
co.info('task stop', s.dataCount('wsTest'))
}

7
tests/tpl.js
View File

@ -1,7 +1,8 @@
import s from "apigo.cc/gojs/service"
function main(args) {
return s.tpl('tpl/page.html', { title: 'Abc' }, {
bb: text => { return '<b>' + text + '</b>' }
})
s.setTplFunc({
bb: text => { return '<b>' + text + '</b>' }
})
return s.tpl('tpl/page.html', { title: 'Abc' })
}

2
tests/tpl/header.html
View File

@ -1,3 +1,3 @@
<header>
<h1>Welcome to {{bb .title}}</h1>
<h1>Welcome to {{bb .title}}</h1>
</header>

12
tests/tpl/page.html
View File

@ -2,15 +2,15 @@
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>{{.title}}</title>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>{{.title}}</title>
</head>
<body>
{{template "header.html" .}}
<pre>
{{template "header.html" .}}
<pre>
hello world
</pre>
</body>

33
ws.go
View File

@ -18,10 +18,7 @@ func MakeWSClient(client *websocket.Conn, id string) gojs.Map {
"read": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
typ, data, err := readWSMessage(client)
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return vm.ToValue(false)
panic(vm.NewGoError(err))
}
return vm.ToValue(gojs.Map{
"type": typ,
@ -40,22 +37,16 @@ func MakeWSClient(client *websocket.Conn, id string) gojs.Map {
err = client.WriteMessage(websocket.TextMessage, u.JsonBytes(args.Any(0)))
}
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return vm.ToValue(false)
panic(vm.NewGoError(err))
}
return vm.ToValue(true)
return nil
},
"ping": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
err := client.WriteMessage(websocket.PingMessage, nil)
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return vm.ToValue(false)
panic(vm.NewGoError(err))
}
return vm.ToValue(true)
return nil
},
"writeMessage": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
args := gojs.MakeArgs(&argsIn, vm).Check(2)
@ -77,22 +68,16 @@ func MakeWSClient(client *websocket.Conn, id string) gojs.Map {
err = client.WriteMessage(websocket.TextMessage, args.Bytes(1))
}
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return vm.ToValue(false)
panic(vm.NewGoError(err))
}
return vm.ToValue(true)
return nil
},
"close": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
err := client.Close()
if err != nil {
// panic(vm.NewGoError(err))
vm.SetData("_lastError", err)
gojs.GetLogger(vm).Error(err.Error())
return vm.ToValue(false)
panic(vm.NewGoError(err))
}
return vm.ToValue(true)
return nil
},
}
}