service/service.go

package service

import (
	"bytes"
	_ "embed"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	"regexp"
	"strings"
	"sync"
	"syscall"
	"text/template"
	"time"

	"apigo.cc/gojs"
	"apigo.cc/gojs/goja"
	"github.com/gorilla/websocket"
	"github.com/ssgo/config"
	"github.com/ssgo/discover"
	"github.com/ssgo/log"
	"github.com/ssgo/redis"
	"github.com/ssgo/s"
	"github.com/ssgo/standard"
	"github.com/ssgo/u"
)

//go:embed service.ts
var serviceTS string

//go:embed README.md
var serviceMD string

var server *s.AsyncServer

var pools = map[string]*gojs.Pool{}

var poolExists = map[string]bool{}
var poolActionRegistered = map[string]bool{}
var poolsLock = sync.RWMutex{}
var waitChan chan bool

type TplCache struct {
	FileModTime map[string]int64
	Tpl         *template.Template
}

var tplFunc = map[string]any{}
var tplFuncLock = sync.RWMutex{}
var tplCache = map[string]*TplCache{}
var tplCacheLock = sync.RWMutex{}

type LimiterConfig struct {
	From  string
	Time  int
	Times int
}

type Config struct {
	SessionKey         string
	DeviceKey          string
	ClientKey          string
	UserIdKey          string
	SessionProvider    string
	SessionTimeout     int64
	AuthFieldMessage   string
	VerifyFieldMessage string
	LimitedMessage     string
	Limiters           map[string]*LimiterConfig
	LimiterRedis       string

	Proxy   map[string]string
	Rewrite map[string]string
	Static  map[string]string
}

var serviceConfig Config
var onStop goja.Callable

var limiters = map[string]*s.Limiter{}
var configed = false

func initConfig(opt *gojs.Obj, logger *log.Logger, vm *goja.Runtime) {
	configed = true
	s.InitConfig()
	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, "", 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
	if opt != nil {
		u.Convert(opt.O.Export(), &serviceConfig)
		u.Convert(opt.O.Export(), &s.Config)
		u.Convert(opt.O.Export(), &discover.Config)
		// auth = conf.Func("auth")
		onStop = opt.Func("onStop")

		if serviceConfig.SessionProvider != "" {
			sessionRedis = redis.GetRedis(serviceConfig.SessionProvider, logger)
		}
		sessionTimeout = serviceConfig.SessionTimeout
		if sessionTimeout < 0 {
			sessionTimeout = 0
		}
	}

	// 身份验证和Session
	authAccessToken := len(s.Config.AccessTokens) > 0
	s.SetClientKeys(serviceConfig.DeviceKey, serviceConfig.ClientKey, serviceConfig.SessionKey)
	if serviceConfig.SessionKey != "" {
		s.SetAuthChecker(func(authLevel int, logger *log.Logger, url *string, args map[string]any, request *s.Request, response *s.Response, options *s.WebServiceOptions) (pass bool, object any) {
			var session *Session
			setAuthLevel := 0
			if serviceConfig.SessionKey != "" {
				sessionID := request.GetSessionId()

				if sessionID != "" {
					session = NewSession(sessionID, logger)
				}
				if userId, ok := session.data[serviceConfig.UserIdKey]; ok {
					request.SetUserId(u.String(userId))
				}
				// 优先使用session中的authLevel
				if authLevel > 0 {
					if authLevelBySession, ok := session.data["_authLevel"]; ok {
						setAuthLevel = u.Int(authLevelBySession)
					}
				}
			}
			// 如果没有session中的authLevel验证失败，则使用Access-Token中的authLevel（服务间调用）
			if authAccessToken && setAuthLevel < authLevel {
				setAuthLevel = s.GetAuthTokenLevel(request.Header.Get("Access-Token"))
			}
			if setAuthLevel >= authLevel {
				return true, session
			} else {
				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()
	}

	// 限流器
	if serviceConfig.Limiters != nil {
		var limiterRedis *redis.Redis
		if serviceConfig.LimiterRedis != "" {
			limiterRedis = redis.GetRedis(serviceConfig.LimiterRedis, logger)
		}
		for name, limiter := range serviceConfig.Limiters {
			switch limiter.From {
			case "ip":
				limiter.From = "header." + standard.DiscoverHeaderClientIp
			case "user":
				limiter.From = "header." + standard.DiscoverHeaderUserId
			case "device":
				limiter.From = "header." + standard.DiscoverHeaderDeviceId
			}
			if limiterRedis != nil {
				limiters[name] = s.NewLimiter(name, limiter.From, time.Duration(limiter.Time)*time.Millisecond, limiter.Times, limiterRedis)
			} else {
				limiters[name] = s.NewLocalLimiter(name, limiter.From, time.Duration(limiter.Time)*time.Millisecond, limiter.Times)
			}
		}
	}
}

func init() {
	s.Config.KeepKeyCase = true
	obj := map[string]any{
		"config": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm)
			initConfig(args.Obj(0), args.Logger, vm)
			return nil
		},
		"start": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			if !configed {
				initConfig(nil, gojs.GetLogger(vm), vm)
				// panic(vm.NewGoError(errors.New("must run service.config frist")))
			}
			if server != nil {
				panic(vm.NewGoError(errors.New("server already started")))
			}
			// 处理静态文件
			if len(serviceConfig.Static) > 0 {
				UpdateStatic(serviceConfig.Static)
			}
			if len(serviceConfig.Rewrite) > 0 {
				UpdateRewrite(serviceConfig.Rewrite)
				s.SetRewriteBy(rewrite)
			}
			if len(serviceConfig.Proxy) > 0 {
				UpdateProxy(serviceConfig.Proxy)
				s.SetProxyBy(proxy)
			}

			// 处理Watch
			if vm.GoData["inWatch"] == true {
				onWatchConn := map[string]*websocket.Conn{}
				onWatchLock := sync.Mutex{}
				vm.GoData["onWatch"] = func(filename string) {
					onWatchLock.Lock()
					defer onWatchLock.Unlock()
					for id, conn := range onWatchConn {
						if err := conn.WriteMessage(websocket.TextMessage, []byte(filename)); err != nil {
							delete(onWatchConn, id)
						}
					}
				}
				s.AddShutdownHook(func() {
					for _, conn := range onWatchConn {
						conn.Close()
					}
				})
				s.RegisterSimpleWebsocket(0, "/_watch", func(request *s.Request, conn *websocket.Conn) {
					onWatchLock.Lock()
					onWatchConn[request.Id] = conn
					onWatchLock.Unlock()
				}, "")
				s.SetOutFilter(func(in map[string]any, request *s.Request, response *s.Response, out any, logger *log.Logger) (newOut any, isOver bool) {
					if strings.HasPrefix(response.Header().Get("Content-Type"), "text/html") {
						outStr := u.String(out)
						if strings.Contains(outStr, "let _watchWS = null") {
							return nil, false
						}
						// 注入自动刷新的代码
						outStr = strings.ReplaceAll(outStr, "</html>", `<script>
	let _watchWS = null
	let _watchWSConnection = false
	let _watchWSIsFirst = true
    function connect() {
		_watchWSConnection = true
        let ws = new WebSocket(location.protocol.replace('http', 'ws') + '//' + location.host + '/_watch')
        ws.onopen = () => {
			_watchWS = ws
			_watchWSConnection = false
			if( !_watchWSIsFirst ) location.reload()
			_watchWSIsFirst = false
		}
        ws.onmessage = () => {
			location.reload()
		}
        ws.onclose = () => {
			_watchWS = null
			_watchWSConnection = false
		}
    }
	setInterval(()=>{
		if(_watchWS!= null){
			try{
				_watchWS.send("ping")
			}catch(err){
				_watchWS = null
				_watchWSConnection = false
			}
		} else if(!_watchWSConnection){
			connect()
		}
	}, 1000)
    connect()
</script>
</html>`)
						return []byte(outStr), false
					}
					return nil, false
				})
			}

			// 启动服务
			server = s.AsyncStart()
			waitChan = make(chan bool, 1)
			server.OnStop(func() {
				if onStop != nil {
					onStop(nil)
				}
			})
			server.OnStopped(func() {
				ClearRewritesAndProxies()
				pools = map[string]*gojs.Pool{}
				poolExists = map[string]bool{}
				poolActionRegistered = map[string]bool{}
				server = nil
				if waitChan != nil {
					waitChan <- true
				}
			})
			return vm.ToValue(server.Addr)
		},
		"stop": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			if server == nil {
				panic(vm.NewGoError(errors.New("server not started")))
			}
			server.Stop()
			s.ResetAllSets()
			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))
		},
		"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")))
			}

			authLevel := o.Int("authLevel")
			host := o.Str("host")
			method := strings.ToUpper(o.Str("method"))
			path := o.Str("path")
			memo := o.Str("memo")
			var usedLimiters []*s.Limiter
			for _, limiterName := range o.Array("limiters") {
				if limiter1, ok := limiters[u.String(limiterName)]; ok {
					usedLimiters = append(usedLimiters, limiter1)
				}
			}
			if requiresObj := o.Array("requires"); requiresObj != nil {
				requires := make([]string, len(requiresObj))
				for i, require := range requiresObj {
					requires[i] = u.String(require)
				}
				vm.GoData[fmt.Sprint("REQUIRE_"+host, method, path)] = requires
			}
			if verifiesObj := o.Obj("verifies"); verifiesObj != nil {
				verifiesSet := map[string]func(any, *goja.Runtime) bool{}
				for _, field := range verifiesObj.Keys() {
					v := verifiesObj.Get(field)
					// 根据类型设置验证器，存储到vm中，在请求到达时进行有效性验证
					switch v.ExportType().Kind() {
					case reflect.String:
						verifiesSet[field] = verifyRegexp(u.String(v.Export()))
					case reflect.Int, reflect.Int64:
						verifiesSet[field] = verifyLen(u.Int(v.Export()))
					case reflect.Bool:
						verifiesSet[field] = verifyRequire()
					case reflect.Slice:
						list := make([]string, 0)
						vm.ForOf(v, func(v1 goja.Value) bool {
							list = append(list, u.String(v1.Export()))
							return true
						})
						verifiesSet[field] = verifyIn(list)
					default:
						if fn, ok := goja.AssertFunction(v); ok {
							verifiesSet[field] = verifyFunc(fn, verifiesObj)
						} else if obj := v.ToObject(vm); obj != nil {
							// 支持传入js的正则表达式对象
							if testV := obj.Get("test"); testV != nil {
								if testFn, ok := goja.AssertFunction(testV); ok {
									verifiesSet[field] = verifyFunc(testFn, obj)
								}
							}
						}
					}
				}
				vm.GoData[fmt.Sprint("VERIFY_"+host, method, path)] = verifiesSet
			}

			opt := s.WebServiceOptions{
				NoBody:   o.Bool("noBody"),
				NoLog200: o.Bool("noLog200"),
				Host:     host,
				//Ext:      nil,
				Limiters: usedLimiters,
			}

			startFile := u.String(vm.GoData["startFile"])
			poolsLock.RLock()
			poolExist := poolExists[startFile]
			poolsLock.RUnlock()
			if poolExist {
				// 从对象调用（支持并发）
				actionKey := "REGISTER_" + host + method + path
				vm.GoData[actionKey] = action
				vm.GoData[actionKey+"This"] = args.This
				if method == "WS" {
					vm.GoData[actionKey+"onMessage"] = o.Func("onMessage")
					vm.GoData[actionKey+"onClose"] = o.Func("onClose")
				}
				poolsLock.Lock()
				actionRegistered := poolActionRegistered[actionKey]
				if !actionRegistered {
					poolActionRegistered[actionKey] = true
				}
				poolsLock.Unlock()
				if !actionRegistered {
					if strings.ToUpper(method) == "WS" {
						s.RegisterWebsocketWithOptions(authLevel, path, &websocket.Upgrader{}, makeWSAction(startFile, actionKey), nil, nil, nil, true, "", opt)
					} else {
						s.RestfulWithOptions(authLevel, method, path, makeOuterAction(startFile, actionKey), memo, opt)
					}
				}
			} else {
				// 无对象池，直接调用（单线程）
				s.RestfulWithOptions(authLevel, method, path, makeInnerAction(action, vm, args.This), memo, opt)
			}
			return nil
		},
		"load": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			actionFile := args.Path(0)
			opt := args.Obj(1)
			var mi, ma, idle uint
			//var num uint
			mainArgs := make([]any, 0)
			debug := false
			if opt != nil {
				mi = uint(opt.Int("min"))
				ma = uint(opt.Int("max"))
				idle = uint(opt.Int("idle"))
				//num = uint(opt.Int("num"))
				debug = opt.Bool("debug")
				if mainArgs1 := opt.Array("args"); mainArgs1 != nil {
					mainArgs = mainArgs1
				}
			}
			if !u.FileExists(actionFile) {
				fullActionFile, _ := filepath.Abs(actionFile)
				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 and call service.register")))
			}
			poolsLock.Lock()
			poolExists[actionFile] = true
			poolsLock.Unlock()
			p := gojs.NewPoolByCode(actionCode, actionFile, gojs.PoolConfig{
				Min:   mi,
				Max:   ma,
				Idle:  idle,
				Debug: debug,
				Args:  mainArgs,
			}, args.Logger)
			//p := gojs.NewLBByCode(actionCode, actionFile, gojs.LBConfig{
			//	Num:   num,
			//	Debug: debug,
			//	Args:  mainArgs,
			//}, args.Logger)
			poolsLock.Lock()
			pools[actionFile] = p
			poolsLock.Unlock()
			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])
							}
							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()
				}
			}
			return nil
		},
		"tpl": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			filename := args.Path(0)
			info := u.GetFileInfo(filename)
			if info == nil {
				panic(vm.NewGoError(errors.New("tpl file " + filename + " not exists")))
			}

			data := args.Any(1)
			tplCacheLock.RLock()
			t := tplCache[filename]
			tplCacheLock.RUnlock()
			if t != nil {
				for f, tm := range t.FileModTime {
					info := u.GetFileInfo(f)
					if info == nil || info.ModTime.UnixMilli() != tm {
						t = nil
						break
					}
				}
			}
			if t == nil {
				tpl := template.New("main")
				if len(tplFunc) > 0 {
					tpl = tpl.Funcs(tplFunc)
				}

				fileModTime := map[string]int64{
					filename: info.ModTime.UnixMilli(),
				}
				var err error
				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 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.ParseFiles(filename)
				if err != nil {
					panic(vm.NewGoError(err))
				}
				t = &TplCache{
					Tpl:         tpl,
					FileModTime: fileModTime,
				}
			}

			buf := bytes.NewBuffer(make([]byte, 0))
			err := t.Tpl.ExecuteTemplate(buf, filepath.Base(filename), data)
			if err != 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,
	}

	gojs.Register("apigo.cc/gojs/service", gojs.Module{
		Object:  obj,
		TsCode:  serviceTS,
		Example: serviceMD,
		OnKill: func() {
			if server != nil {
				server.Stop()
			}
		},
		OnSignal: func(sig os.Signal) {
			switch sig {
			case syscall.SIGUSR1:

			}
		},
		WaitForStop: func() {
			if waitChan != nil {
				<-waitChan
			}
		},
	})
}

var tplIncludeMatcher = regexp.MustCompile(`{{\s*template\s+"([^"]+)"`)

func verifyRegexp(regexpStr string) func(any, *goja.Runtime) bool {
	if rx, err := regexp.Compile(regexpStr); err != nil {
		return func(value any, vm *goja.Runtime) bool {
			return rx.MatchString(u.String(value))
		}
	}
	return nil
}

func verifyLen(checkLength int) func(any, *goja.Runtime) bool {
	return func(value any, vm *goja.Runtime) bool {
		v := u.FinalType(reflect.ValueOf(value))
		if v.Kind() == reflect.Slice || v.Kind() == reflect.Map {
			return v.Len() >= checkLength
		}
		return len(u.String(value)) >= checkLength
	}
}

func verifyRequire() func(any, *goja.Runtime) bool {
	return func(value any, vm *goja.Runtime) bool {
		value = u.FixPtr(value)
		switch realValue := value.(type) {
		case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
			return u.Int64(realValue) != 0
		case bool:
			return realValue
		default:
			v := u.FinalType(reflect.ValueOf(value))
			if v.Kind() == reflect.Slice || v.Kind() == reflect.Map {
				return v.Len() >= 0
			}
			return len(u.String(value)) >= 0
		}
	}
}

func verifyIn(list []string) func(any, *goja.Runtime) bool {
	return func(value any, vm *goja.Runtime) bool {
		return u.StringIn(list, u.String(value))
	}
}

func verifyFunc(callback goja.Callable, thisObj goja.Value) func(any, *goja.Runtime) bool {
	return func(value any, vm *goja.Runtime) bool {
		if r, err := callback(thisObj, vm.ToValue(value)); err == nil {
			return u.Bool(r.Export())
		} else {
			log.DefaultLogger.Error(err.Error())
		}
		return false
	}
}

func makeRequestParams(args map[string]any, headers map[string]string, request *s.Request, response *s.Response, client *websocket.Conn, caller *discover.Caller, session *Session, logger *log.Logger) (gojs.Map, *Response) {
	var resp *Response
	params := gojs.Map{
		"args":    args,
		"logger":  gojs.MakeLogger(logger),
		"request": MakeRequest(request, args, headers),
		"client":  MakeWSClient(client, request.Id),
	}
	if response != nil {
		resp = &Response{
			resp:  response,
			endCh: make(chan bool, 1),
			Id:    response.Id,
		}
		params["response"] = gojs.MakeMap(resp)
	}
	if headers != nil {
		params["headers"] = headers
	}
	if session != nil {
		params["session"] = gojs.MakeMap(session)
	}
	if caller != nil {
		params["caller"] = gojs.MakeMap(&Caller{client: caller})
	}
	return params, resp
}

func runAction(action goja.Callable, vm *goja.Runtime, thisArg goja.Value, args map[string]any, headers map[string]string, request *s.Request, response *s.Response, client *websocket.Conn, caller *discover.Caller, session *Session, logger *log.Logger) (any, error) {
	vm.CallbackLocker.Lock()
	defer vm.CallbackLocker.Unlock()

	// 验证请求参数的有效性
	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.GoData["REQUIRE_"+u.String(request.Get("registerTag"))].([]string); ok {
			for _, requireField := range requires {
				if _, ok := args[requireField]; !ok {
					failedFields = append(failedFields, requireField)
				}
			}
		}
		// 验证数据有效性
		for k, v := range args {
			if verifier, ok1 := verifies[k]; ok1 {
				if !verifier(v, vm) {
					failedFields = append(failedFields, k)
				}
			}
		}
		// 数据有效性验证失败
		if len(failedFields) > 0 {
			response.WriteHeader(400)
			msg := serviceConfig.VerifyFieldMessage
			if strings.Contains(msg, "{{") {
				msg = strings.ReplaceAll(msg, "{{FAILED_FIELDS}}", strings.Join(failedFields, ", "))
			}
			var obj any
			if json.Unmarshal([]byte(msg), &obj) == nil {
				return obj, nil
			} else {
				return msg, nil
			}
		}
	}

	requestParams, resp := makeRequestParams(args, headers, request, response, client, caller, session, logger)
	var r any

	r1, err := action(thisArg, vm.ToValue(requestParams))
	if err == nil && r1 != nil {
		r = r1.Export()
	}
	if err != nil {
		logger.Error(err.Error())
	}
	if response != nil && r == nil && err == nil {
		<-resp.endCh
		r = resp.result
	}
	return r, err
}

func makeInnerAction(action goja.Callable, vm *goja.Runtime, thisArg goja.Value) any {
	return func(args map[string]any, headers map[string]string, request *s.Request, response *s.Response, caller *discover.Caller, session *Session, logger *log.Logger) any {
		r, _ := runAction(action, vm, thisArg, args, headers, request, response, nil, caller, session, logger)
		return r
	}
}

func getPool(startFile string) *gojs.Pool {
	var pool *gojs.Pool
	for i := 0; i < 10; i++ {
		poolsLock.RLock()
		pool = pools[startFile]
		poolsLock.RUnlock()
		if pool != nil {
			return pool
		}
		time.Sleep(time.Millisecond * 100)
	}
	return nil
}

func makeOuterAction(startFile string, actionKey string) any {
	return func(args map[string]any, headers map[string]string, request *s.Request, response *s.Response, caller *discover.Caller, session *Session, logger *log.Logger) any {
		if pool := getPool(startFile); pool != nil {
			rt := pool.Get()
			defer pool.Put(rt)
			if action, ok := rt.GetGoData(actionKey).(goja.Callable); ok {
				var thisArg goja.Value
				if thisArgV, ok := rt.GetGoData(actionKey + "This").(goja.Value); ok {
					thisArg = thisArgV
				}
				r, _ := rt.RunVM(func(vm *goja.Runtime) (any, error) {
					r2, err2 := runAction(action, vm, thisArg, args, headers, request, response, nil, caller, session, logger)
					return r2, err2

				})
				return r
			}
		}
		return nil
	}
}

type PoolStatus struct {
	Total       uint
	MaxTotal    uint
	MaxWaiting  uint
	CreateTimes uint
}

func GetPoolStatus() map[string]PoolStatus {
	out := map[string]PoolStatus{}
	for k, v := range pools {
		total, maxTotal, maxWaiting, createTimes := v.Count()
		out[k] = PoolStatus{
			Total:       total,
			MaxTotal:    maxTotal,
			MaxWaiting:  maxWaiting,
			CreateTimes: createTimes,
		}
	}
	return out
}