NagaeJSVM/example/cmd/main.go

package main

import (
	"flag"
	"git.swzry.com/ProjectNagae/NagaeJSVM/ngjsvm"
	"git.swzry.com/zry/GoHiedaLogger/hiedabke_console"
	"git.swzry.com/zry/GoHiedaLogger/hiedalog"
	lazyquiter "git.swzry.com/zry/go-lazy-quiter"
	"github.com/oklog/run"
	"github.com/spf13/afero"
	"os"
	"path"
	"path/filepath"
)

var Logger *hiedalog.HiedaLogger
var JsFile string
var DebugMode bool
var LazyQuiter *lazyquiter.RunGroupQuiter

func main() {
	// Parse command line argument
	flag.StringVar(&JsFile, "j", "/main.js", "")
	flag.BoolVar(&DebugMode, "d", false, "")
	flag.Parse()

	// Init hiedalog logger with console output backend
	Logger = hiedalog.NewHiedaLogger()
	consoleBackend := hiedabke_console.NewConsoleBackend(os.Stdout)
	lvfil := hiedalog.DLN_INFO
	if DebugMode {
		lvfil = hiedalog.DLN_DEBUG
	}
	Logger.AddBackend(consoleBackend, Logger.LevelFilter.NameToID(lvfil))

	// Get path of js-dist
	selfPath, err := os.Executable()
	if err != nil {
		Logger.LogPrint("main", hiedalog.DLN_FATAL, "Couldn't get executable file path: ", err)
		return
	}
	execDir, err := filepath.Abs(filepath.Dir(selfPath))
	if err != nil {
		Logger.LogPrint("main", hiedalog.DLN_FATAL, "Couldn't get directory of executable file: ", err)
		return
	}
	jsPath := path.Join(execDir, "js-dist")

	// Init afero Os Filesystem
	osFs := afero.NewOsFs()
	bFs := afero.NewBasePathFs(osFs, jsPath)

	// Init NagaeJSVM engine
	cfg := &ngjsvm.JSVMConfig{
		Filesystem:          bFs,
		Logger:              Logger,
		EngineLogPrefix:     "js-engine",
		RuntimeEnvLogPrefix: "js-env",
		UseStrictMode:       true,
	}
	engine := ngjsvm.NewJSVM(cfg)

	// Ensure engine disposed before quit
	//    Tips: EngineDispose can be call multiple times, if it is already disposed,
	//          it will do nothing.
	defer engine.EngineDispose()

	// Init RtEnv
	jsenv := ngjsvm.NewJSEnv(engine, Logger, "js-env")
	jsenv.AddRt("runtime", &ngjsvm.JSRtRuntime{})
	jsenv.AddRt("logger", &ngjsvm.JSRtLogger{
		LogFunc: ngjsvm.JSRtLoggerLogFuncFromHiedaLogger(Logger, "js-log"),
	})
	jsenv.AddRt("scheduler", &ngjsvm.JSRtScheduler{})
	jsenv.AddRt("nest_test", ngjsvm.NewJSRtNest(map[string]ngjsvm.JsRtInterface{
		"logger1": &ngjsvm.JSRtLogger{
			LogFunc: ngjsvm.JSRtLoggerLogFuncFromHiedaLogger(Logger, "js-sub-log1"),
		},
	}))
	engine.SetRuntimeEnv(jsenv)

	// Load script
	err = engine.LoadScript(JsFile)
	if err != nil {
		Logger.LogPrint("main", hiedalog.DLN_FATAL, "Failed load script: ", err)
		return
	}

	// Run 'setup'
	err = engine.ExecSetup()
	if err != nil {
		Logger.LogPrint("main", hiedalog.DLN_ERROR, "Run 'setup' failed: ", err)
		// will continue even if 'setup' failed.
		// but you can end program when 'setup' failed.
		// don't forget to do engine dispose
	}

	// Init lazyquiter for catching `Ctrl+C`
	LazyQuiter = lazyquiter.NewRunGroupQuiter()
	LazyQuiter.SignalNotifyFunc = func(sig os.Signal) {
		Logger.LogPrint("main", hiedalog.DLN_INFO, "Quit by user Ctrl+C abort.")
	}

	// Run loop
	rg := &run.Group{}
	rg.Add(LazyQuiter.Run, LazyQuiter.Stop)
	rg.Add(engine.RunLoop, engine.StopLoop)
	err = rg.Run()
	if err != nil {
		if err == ngjsvm.Err_JSVMAbortByInterruit {
			// this means it exit by interrupt,
			// for example, a 'runtime.quit()' executed in script will cause this
			Logger.LogPrint("main", hiedalog.DLN_INFO, "JS VM interrupted")
		} else {
			Logger.LogPrint("main", hiedalog.DLN_FATAL, "Run 'loop' failed: ", err)
			return
		}
	}

	// Run 'cleanup'
	err = engine.ExecCleanup()
	if err != nil {
		Logger.LogPrint("main", hiedalog.DLN_ERROR, "Run 'cleanup' failed: ", err)
	}

	// because we set 'defer engine.Dispose()' so we don't need to do it.
	// but you can always call it here
	// engine.EngineDispose()

}