mirror of
https://github.com/SagerNet/sing-box.git
synced 2025-04-04 20:37:37 +03:00
281 lines
7.5 KiB
Go
281 lines
7.5 KiB
Go
package console
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/xml"
|
|
"sync"
|
|
"time"
|
|
|
|
sLog "github.com/sagernet/sing-box/log"
|
|
"github.com/sagernet/sing-box/script/jsc"
|
|
"github.com/sagernet/sing-box/script/modules/boxctx"
|
|
F "github.com/sagernet/sing/common/format"
|
|
"github.com/sagernet/sing/common/logger"
|
|
|
|
"github.com/dop251/goja"
|
|
)
|
|
|
|
type Console struct {
|
|
class jsc.Class[*Module, *Console]
|
|
access sync.Mutex
|
|
countMap map[string]int
|
|
timeMap map[string]time.Time
|
|
}
|
|
|
|
func NewConsole(class jsc.Class[*Module, *Console]) goja.Value {
|
|
return class.New(&Console{
|
|
class: class,
|
|
countMap: make(map[string]int),
|
|
timeMap: make(map[string]time.Time),
|
|
})
|
|
}
|
|
|
|
func createConsole(m *Module) jsc.Class[*Module, *Console] {
|
|
class := jsc.NewClass[*Module, *Console](m)
|
|
class.DefineMethod("assert", (*Console).assert)
|
|
class.DefineMethod("clear", (*Console).clear)
|
|
class.DefineMethod("count", (*Console).count)
|
|
class.DefineMethod("countReset", (*Console).countReset)
|
|
class.DefineMethod("debug", (*Console).debug)
|
|
class.DefineMethod("dir", (*Console).dir)
|
|
class.DefineMethod("dirxml", (*Console).dirxml)
|
|
class.DefineMethod("error", (*Console).error)
|
|
class.DefineMethod("group", (*Console).stub)
|
|
class.DefineMethod("groupCollapsed", (*Console).stub)
|
|
class.DefineMethod("groupEnd", (*Console).stub)
|
|
class.DefineMethod("info", (*Console).info)
|
|
class.DefineMethod("log", (*Console)._log)
|
|
class.DefineMethod("profile", (*Console).stub)
|
|
class.DefineMethod("profileEnd", (*Console).profileEnd)
|
|
class.DefineMethod("table", (*Console).table)
|
|
class.DefineMethod("time", (*Console).time)
|
|
class.DefineMethod("timeEnd", (*Console).timeEnd)
|
|
class.DefineMethod("timeLog", (*Console).timeLog)
|
|
class.DefineMethod("timeStamp", (*Console).stub)
|
|
class.DefineMethod("trace", (*Console).trace)
|
|
class.DefineMethod("warn", (*Console).warn)
|
|
return class
|
|
}
|
|
|
|
func (c *Console) stub(call goja.FunctionCall) any {
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) assert(call goja.FunctionCall) any {
|
|
assertion := call.Argument(0).ToBoolean()
|
|
if !assertion {
|
|
return c.log(logger.ContextLogger.ErrorContext, call.Arguments[1:])
|
|
}
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) clear(call goja.FunctionCall) any {
|
|
return nil
|
|
}
|
|
|
|
func (c *Console) count(call goja.FunctionCall) any {
|
|
label := jsc.AssertString(c.class.Runtime(), call.Argument(0), "label", true)
|
|
if label == "" {
|
|
label = "default"
|
|
}
|
|
c.access.Lock()
|
|
newValue := c.countMap[label] + 1
|
|
c.countMap[label] = newValue
|
|
c.access.Unlock()
|
|
writeLog(c.class.Runtime(), logger.ContextLogger.InfoContext, F.ToString(label, ": ", newValue))
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) countReset(call goja.FunctionCall) any {
|
|
label := jsc.AssertString(c.class.Runtime(), call.Argument(0), "label", true)
|
|
if label == "" {
|
|
label = "default"
|
|
}
|
|
c.access.Lock()
|
|
delete(c.countMap, label)
|
|
c.access.Unlock()
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) log(logFunc func(logger.ContextLogger, context.Context, ...any), args []goja.Value) any {
|
|
var buffer bytes.Buffer
|
|
var formatString string
|
|
if len(args) > 0 {
|
|
formatString = args[0].String()
|
|
}
|
|
format(c.class.Runtime(), &buffer, formatString, args[1:]...)
|
|
writeLog(c.class.Runtime(), logFunc, buffer.String())
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) debug(call goja.FunctionCall) any {
|
|
return c.log(logger.ContextLogger.DebugContext, call.Arguments)
|
|
}
|
|
|
|
func (c *Console) dir(call goja.FunctionCall) any {
|
|
object := jsc.AssertObject(c.class.Runtime(), call.Argument(0), "object", false)
|
|
var buffer bytes.Buffer
|
|
for _, key := range object.Keys() {
|
|
value := object.Get(key)
|
|
buffer.WriteString(key)
|
|
buffer.WriteString(": ")
|
|
buffer.WriteString(value.String())
|
|
buffer.WriteString("\n")
|
|
}
|
|
writeLog(c.class.Runtime(), logger.ContextLogger.InfoContext, buffer.String())
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) dirxml(call goja.FunctionCall) any {
|
|
var buffer bytes.Buffer
|
|
encoder := xml.NewEncoder(&buffer)
|
|
encoder.Indent("", " ")
|
|
encoder.Encode(call.Argument(0).Export())
|
|
writeLog(c.class.Runtime(), logger.ContextLogger.InfoContext, buffer.String())
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) error(call goja.FunctionCall) any {
|
|
return c.log(logger.ContextLogger.ErrorContext, call.Arguments)
|
|
}
|
|
|
|
func (c *Console) info(call goja.FunctionCall) any {
|
|
return c.log(logger.ContextLogger.InfoContext, call.Arguments)
|
|
}
|
|
|
|
func (c *Console) _log(call goja.FunctionCall) any {
|
|
return c.log(logger.ContextLogger.InfoContext, call.Arguments)
|
|
}
|
|
|
|
func (c *Console) profileEnd(call goja.FunctionCall) any {
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) table(call goja.FunctionCall) any {
|
|
return c.dir(call)
|
|
}
|
|
|
|
func (c *Console) time(call goja.FunctionCall) any {
|
|
label := jsc.AssertString(c.class.Runtime(), call.Argument(0), "label", true)
|
|
if label == "" {
|
|
label = "default"
|
|
}
|
|
c.access.Lock()
|
|
c.timeMap[label] = time.Now()
|
|
c.access.Unlock()
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) timeEnd(call goja.FunctionCall) any {
|
|
label := jsc.AssertString(c.class.Runtime(), call.Argument(0), "label", true)
|
|
if label == "" {
|
|
label = "default"
|
|
}
|
|
c.access.Lock()
|
|
startTime, ok := c.timeMap[label]
|
|
if !ok {
|
|
c.access.Unlock()
|
|
return goja.Undefined()
|
|
}
|
|
delete(c.timeMap, label)
|
|
c.access.Unlock()
|
|
writeLog(c.class.Runtime(), logger.ContextLogger.InfoContext, F.ToString(label, ": ", time.Since(startTime).String(), " - - timer ended"))
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) timeLog(call goja.FunctionCall) any {
|
|
label := jsc.AssertString(c.class.Runtime(), call.Argument(0), "label", true)
|
|
if label == "" {
|
|
label = "default"
|
|
}
|
|
c.access.Lock()
|
|
startTime, ok := c.timeMap[label]
|
|
c.access.Unlock()
|
|
if !ok {
|
|
writeLog(c.class.Runtime(), logger.ContextLogger.ErrorContext, F.ToString("Timer \"", label, "\" doesn't exist."))
|
|
return goja.Undefined()
|
|
}
|
|
writeLog(c.class.Runtime(), logger.ContextLogger.InfoContext, F.ToString(label, ": ", time.Since(startTime)))
|
|
return goja.Undefined()
|
|
}
|
|
|
|
func (c *Console) trace(call goja.FunctionCall) any {
|
|
return c.log(logger.ContextLogger.TraceContext, call.Arguments)
|
|
}
|
|
|
|
func (c *Console) warn(call goja.FunctionCall) any {
|
|
return c.log(logger.ContextLogger.WarnContext, call.Arguments)
|
|
}
|
|
|
|
func writeLog(runtime *goja.Runtime, logFunc func(logger.ContextLogger, context.Context, ...any), message string) {
|
|
var (
|
|
ctx context.Context
|
|
sLogger logger.ContextLogger
|
|
)
|
|
boxCtx := boxctx.FromRuntime(runtime)
|
|
if boxCtx != nil {
|
|
ctx = boxCtx.Context
|
|
sLogger = boxCtx.Logger
|
|
} else {
|
|
ctx = context.Background()
|
|
sLogger = sLog.StdLogger()
|
|
}
|
|
logFunc(sLogger, ctx, message)
|
|
}
|
|
|
|
func format(runtime *goja.Runtime, b *bytes.Buffer, f string, args ...goja.Value) {
|
|
pct := false
|
|
argNum := 0
|
|
for _, chr := range f {
|
|
if pct {
|
|
if argNum < len(args) {
|
|
if format1(runtime, chr, args[argNum], b) {
|
|
argNum++
|
|
}
|
|
} else {
|
|
b.WriteByte('%')
|
|
b.WriteRune(chr)
|
|
}
|
|
pct = false
|
|
} else {
|
|
if chr == '%' {
|
|
pct = true
|
|
} else {
|
|
b.WriteRune(chr)
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, arg := range args[argNum:] {
|
|
b.WriteByte(' ')
|
|
b.WriteString(arg.String())
|
|
}
|
|
}
|
|
|
|
func format1(runtime *goja.Runtime, f rune, val goja.Value, w *bytes.Buffer) bool {
|
|
switch f {
|
|
case 's':
|
|
w.WriteString(val.String())
|
|
case 'd':
|
|
w.WriteString(val.ToNumber().String())
|
|
case 'j':
|
|
if json, ok := runtime.Get("JSON").(*goja.Object); ok {
|
|
if stringify, ok := goja.AssertFunction(json.Get("stringify")); ok {
|
|
res, err := stringify(json, val)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
w.WriteString(res.String())
|
|
}
|
|
}
|
|
case '%':
|
|
w.WriteByte('%')
|
|
return false
|
|
default:
|
|
w.WriteByte('%')
|
|
w.WriteRune(f)
|
|
return false
|
|
}
|
|
return true
|
|
}
|