Engine/GCTScript: Refactor script manager (#580)

* refactor script manager

* remove singleton GCTScriptConfig
* create constant for ".gct" extension
* move GctScriptManager into vm package
* reduce script manager global dependencies
* use manager struct to store runtime override values
* enable/disable scripting subsystem now doesn't store the setting in
config (aligned with other subsystems)
* setting max VMs via start option doesn't change config

* instantiate scriptmanager as part of creating a new Engine

    * script manager config is now set during instantiation
    * run script manager when enabled in conf or explicitly enabled
    * use the Started() method to check if script manager is running

* in tests set script manager as running

* script manager adjustments

* create manager before attempting overrides
* check for nil config when creating script manager

* fix script manager waitgroup counter increased too late

* move autoload() function to autoload.go
* add tests to script manager

gctscript/modules/gct/common.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	objects "github.com/d5/tengo/v2"
+	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/common/file"
 	"github.com/thrasher-corp/gocryptotrader/gctscript/modules/ta/indicators"
 	"github.com/thrasher-corp/gocryptotrader/log"
@@ -79,7 +80,7 @@ func WriteAsCSV(args ...objects.Object) (objects.Object, error) {
 			// a client defined filename and append a date, forces the use of
 			// .csv file extension
 			switch {
-			case filepath.Ext(target) != ".csv" && strings.Contains(target, ".gct"):
+			case filepath.Ext(target) != ".csv" && strings.Contains(target, common.GctExt):
 				target += ".csv"
 			case filepath.Ext(target) == ".csv":
 				s := strings.Split(target, ".")

gctscript/vm/autoload.go

@@ -5,21 +5,22 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/log"
 )
 
 // Autoload remove entry from autoload slice
-func Autoload(name string, remove bool) error {
-	if filepath.Ext(name) != ".gct" {
-		name += ".gct"
+func (g *GctScriptManager) Autoload(name string, remove bool) error {
+	if filepath.Ext(name) != common.GctExt {
+		name += common.GctExt
 	}
 	if remove {
-		for x := range GCTScriptConfig.AutoLoad {
-			if GCTScriptConfig.AutoLoad[x] != name {
+		for x := range g.config.AutoLoad {
+			if g.config.AutoLoad[x] != name {
 				continue
 			}
-			GCTScriptConfig.AutoLoad = append(GCTScriptConfig.AutoLoad[:x], GCTScriptConfig.AutoLoad[x+1:]...)
-			if GCTScriptConfig.Verbose {
+			g.config.AutoLoad = append(g.config.AutoLoad[:x], g.config.AutoLoad[x+1:]...)
+			if g.config.Verbose {
 				log.Debugf(log.GCTScriptMgr, "Removing script: %s from autoload", name)
 			}
 			return nil
@@ -35,9 +36,35 @@ func Autoload(name string, remove bool) error {
 		}
 		return err
 	}
-	GCTScriptConfig.AutoLoad = append(GCTScriptConfig.AutoLoad, name)
-	if GCTScriptConfig.Verbose {
+	g.config.AutoLoad = append(g.config.AutoLoad, name)
+	if g.config.Verbose {
 		log.Debugf(log.GCTScriptMgr, "Adding script: %s to autoload", name)
 	}
 	return nil
 }
+
+func (g *GctScriptManager) autoLoad() {
+	for x := range g.config.AutoLoad {
+		temp := g.New()
+		if temp == nil {
+			log.Errorf(log.GCTScriptMgr, "Unable to create Virtual Machine, autoload failed for: %v",
+				g.config.AutoLoad[x])
+			continue
+		}
+		var name = g.config.AutoLoad[x]
+		if filepath.Ext(name) != common.GctExt {
+			name += common.GctExt
+		}
+		scriptPath := filepath.Join(ScriptPath, name)
+		err := temp.Load(scriptPath)
+		if err != nil {
+			log.Errorf(log.GCTScriptMgr, "%v failed to load: %v", filepath.Base(scriptPath), err)
+			err = temp.unregister()
+			if err != nil {
+				log.Errorf(log.GCTScriptMgr, "%v failed to unregister: %v", filepath.Base(scriptPath), err)
+			}
+			continue
+		}
+		go temp.CompileAndRun()
+	}
+}

gctscript/vm/autoload_test.go

@@ -0,0 +1,18 @@
+package vm
+
+import "testing"
+
+func TestGctScriptManagerAutoLoadNonExisting(t *testing.T) {
+	var vms uint8 = 1
+	g := &GctScriptManager{
+		config: &Config{
+			AutoLoad: []string{"non-existing"},
+		},
+		started:            1,
+		MaxVirtualMachines: &vms,
+	}
+	g.autoLoad()
+	if VMSCount != 0 {
+		t.Errorf("Expected no VMs, got %v", VMSCount)
+	}
+}

gctscript/vm/gctscript.go

@@ -9,16 +9,16 @@ import (
 )
 
 // New returns a new instance of VM
-func New() *VM {
-	if VMSCount.Len() >= int32(GCTScriptConfig.MaxVirtualMachines) {
-		if GCTScriptConfig.Verbose {
+func (g *GctScriptManager) New() *VM {
+	if VMSCount.Len() >= int32(g.GetMaxVirtualMachines()) {
+		if g.config.Verbose {
 			log.Warnf(log.GCTScriptMgr, "GCTScript MaxVirtualMachines (%v) hit, unable to start further instances",
-				GCTScriptConfig.MaxVirtualMachines)
+				g.GetMaxVirtualMachines())
 		}
 		return nil
 	}
 	VMSCount.add()
-	vm := NewVM()
+	vm := g.NewVM()
 	if vm == nil {
 		VMSCount.remove()
 	} else {
@@ -29,10 +29,10 @@ func New() *VM {
 
 // Validate will attempt to execute a script in a test/non-live environment
 // to confirm it passes requirements for execution
-func Validate(file string) (err error) {
+func (g *GctScriptManager) Validate(file string) (err error) {
 	validator.IsTestExecution.Store(true)
 	defer validator.IsTestExecution.Store(false)
-	tempVM := NewVM()
+	tempVM := g.NewVM()
 	err = tempVM.Load(file)
 	if err != nil {
 		return
@@ -45,8 +45,8 @@ func Validate(file string) (err error) {
 }
 
 // ShutdownAll shutdown all
-func ShutdownAll() (err error) {
-	if GCTScriptConfig.Verbose {
+func (g *GctScriptManager) ShutdownAll() (err error) {
+	if g.config.Verbose {
 		log.Debugln(log.GCTScriptMgr, "Shutting down all Virtual Machines")
 	}
 
@@ -67,14 +67,14 @@ func ShutdownAll() (err error) {
 }
 
 // RemoveVM remove VM from list
-func RemoveVM(id uuid.UUID) error {
+func (g *GctScriptManager) RemoveVM(id uuid.UUID) error {
 	if _, f := AllVMSync.Load(id); !f {
 		return fmt.Errorf(ErrNoVMFound, id.String())
 	}
 
 	AllVMSync.Delete(id)
 	VMSCount.remove()
-	if GCTScriptConfig.Verbose {
+	if g.config.Verbose {
 		log.Debugf(log.GCTScriptMgr, "VM %v removed from AllVMs", id)
 	}
 	return nil

gctscript/vm/gctscript_types.go

@@ -5,7 +5,11 @@ import (
 	"time"
 )
 
-const gctScript = "GCT Script"
+const (
+	gctScript = "GCT Script"
+	// ErrScriptFailedValidation message to display when a script fails its validation
+	ErrScriptFailedValidation = "validation failed"
+)
 
 // Config user configurable options for gctscript
 type Config struct {
@@ -25,8 +29,6 @@ type Error struct {
 }
 
 var (
-	// GCTScriptConfig initialised global copy of Config{}
-	GCTScriptConfig = &Config{}
 	// ScriptPath path to load/save scripts
 	ScriptPath string
 )

gctscript/vm/manager.go

@@ -0,0 +1,99 @@
+package vm
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"sync/atomic"
+
+	"github.com/thrasher-corp/gocryptotrader/engine/subsystem"
+	"github.com/thrasher-corp/gocryptotrader/log"
+)
+
+const gctscriptManagerName = "GCTScript"
+
+// GctScriptManager loads and runs GCT Tengo scripts
+type GctScriptManager struct {
+	config   *Config
+	started  int32
+	stopped  int32
+	shutdown chan struct{}
+	// Optional values to override stored config ('nil' if not overridden)
+	MaxVirtualMachines *uint8
+}
+
+// NewManager creates a new instance of script manager
+func NewManager(config *Config) (*GctScriptManager, error) {
+	if config == nil {
+		return nil, errors.New("config must be provided for script manager")
+	}
+	return &GctScriptManager{
+		config: config,
+	}, nil
+}
+
+// Started returns if gctscript manager subsystem is started
+func (g *GctScriptManager) Started() bool {
+	return atomic.LoadInt32(&g.started) == 1
+}
+
+// Start starts gctscript subsystem and creates shutdown channel
+func (g *GctScriptManager) Start(wg *sync.WaitGroup) (err error) {
+	if atomic.AddInt32(&g.started, 1) != 1 {
+		return fmt.Errorf("%s %s", gctscriptManagerName, subsystem.ErrSubSystemAlreadyStarted)
+	}
+
+	defer func() {
+		if err != nil {
+			atomic.CompareAndSwapInt32(&g.started, 1, 0)
+		}
+	}()
+	log.Debugln(log.Global, gctscriptManagerName, subsystem.MsgSubSystemStarting)
+
+	g.shutdown = make(chan struct{})
+	wg.Add(1)
+	go g.run(wg)
+	return nil
+}
+
+// Stop stops gctscript subsystem along with all running Virtual Machines
+func (g *GctScriptManager) Stop() error {
+	if atomic.LoadInt32(&g.started) == 0 {
+		return fmt.Errorf("%s %s", gctscriptManagerName, subsystem.ErrSubSystemNotStarted)
+	}
+
+	if atomic.AddInt32(&g.stopped, 1) != 1 {
+		return fmt.Errorf("%s %s", gctscriptManagerName, subsystem.ErrSubSystemAlreadyStopped)
+	}
+
+	log.Debugln(log.GCTScriptMgr, gctscriptManagerName, subsystem.MsgSubSystemShuttingDown)
+	close(g.shutdown)
+	err := g.ShutdownAll()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (g *GctScriptManager) run(wg *sync.WaitGroup) {
+	log.Debugln(log.Global, gctscriptManagerName, subsystem.MsgSubSystemStarted)
+
+	SetDefaultScriptOutput()
+	g.autoLoad()
+	defer func() {
+		atomic.CompareAndSwapInt32(&g.stopped, 1, 0)
+		atomic.CompareAndSwapInt32(&g.started, 1, 0)
+		wg.Done()
+		log.Debugln(log.GCTScriptMgr, gctscriptManagerName, subsystem.MsgSubSystemShutdown)
+	}()
+
+	<-g.shutdown
+}
+
+// GetMaxVirtualMachines returns the max number of VMs to create
+func (g *GctScriptManager) GetMaxVirtualMachines() uint8 {
+	if g.MaxVirtualMachines != nil {
+		return *g.MaxVirtualMachines
+	}
+	return g.config.MaxVirtualMachines
+}

gctscript/vm/manager_test.go

@@ -0,0 +1,125 @@
+package vm
+
+import (
+	"reflect"
+	"sync"
+	"testing"
+)
+
+func TestNewManager(t *testing.T) {
+	t.Parallel()
+	type args struct {
+		config *Config
+	}
+	sharedConf := &Config{
+		AllowImports: true,
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *GctScriptManager
+		wantErr bool
+	}{
+		{
+			name:    "nil config gives error",
+			wantErr: true,
+		},
+		{
+			name: "config is applied",
+			args: args{
+				config: sharedConf,
+			},
+			want: &GctScriptManager{
+				config: sharedConf,
+			},
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := NewManager(tt.args.config)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewManager() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("NewManager() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestGctScriptManagerStartStopNominal(t *testing.T) {
+	t.Parallel()
+	mgr, err := NewManager(&Config{AllowImports: true})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var wg sync.WaitGroup
+	err = mgr.Start(&wg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if mgr.started != 1 || mgr.stopped != 0 {
+		t.Errorf("Manager should be started (%v, %v)", mgr.started, mgr.stopped)
+	}
+	err = mgr.Stop()
+	if err != nil {
+		t.Fatal(err)
+	}
+	wg.Wait()
+	if mgr.stopped != 0 {
+		t.Errorf("Manager should be stopped, expected=%v, got %v", 0, mgr.stopped)
+	}
+}
+
+func TestGctScriptManagerGetMaxVirtualMachines(t *testing.T) {
+	type fields struct {
+		config             *Config
+		started            int32
+		stopped            int32
+		shutdown           chan struct{}
+		MaxVirtualMachines *uint8
+	}
+	var value uint8 = 6
+	tests := []struct {
+		name   string
+		fields fields
+		want   uint8
+	}{
+		{
+			name: "get from config",
+			fields: fields{
+				config: &Config{
+					MaxVirtualMachines: 7,
+				},
+			},
+			want: 7,
+		},
+		{
+			name: "get from manager",
+			fields: fields{
+				config: &Config{
+					MaxVirtualMachines: 7,
+				},
+				MaxVirtualMachines: &value,
+			},
+			want: 6,
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			g := &GctScriptManager{
+				config:             tt.fields.config,
+				started:            tt.fields.started,
+				stopped:            tt.fields.stopped,
+				shutdown:           tt.fields.shutdown,
+				MaxVirtualMachines: tt.fields.MaxVirtualMachines,
+			}
+			if got := g.GetMaxVirtualMachines(); got != tt.want {
+				t.Errorf("GctScriptManager.GetMaxVirtualMachines() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

gctscript/vm/vm.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/d5/tengo/v2"
 	"github.com/gofrs/uuid"
+	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/common/crypto"
 	scriptevent "github.com/thrasher-corp/gocryptotrader/database/repository/script"
 	"github.com/thrasher-corp/gocryptotrader/gctscript/modules/loader"
@@ -21,7 +22,14 @@ import (
 )
 
 // NewVM attempts to create a new Virtual Machine firstly from pool
-func NewVM() (vm *VM) {
+func (g *GctScriptManager) NewVM() (vm *VM) {
+	if !g.Started() {
+		log.Error(log.GCTScriptMgr, Error{
+			Action: "NewVM",
+			Cause:  ErrScriptingDisabled,
+		})
+		return nil
+	}
 	newUUID, err := uuid.NewV4()
 	if err != nil {
 		log.Error(log.GCTScriptMgr, Error{
@@ -31,13 +39,15 @@ func NewVM() (vm *VM) {
 		return nil
 	}
 
-	if GCTScriptConfig.Verbose {
+	if g.config.Verbose {
 		log.Debugln(log.GCTScriptMgr, "New GCTScript VM created")
 	}
 
 	vm = &VM{
-		ID:     newUUID,
-		Script: pool.Get().(*tengo.Script),
+		ID:         newUUID,
+		Script:     pool.Get().(*tengo.Script),
+		config:     g.config,
+		unregister: func() error { return g.RemoveVM(newUUID) },
 	}
 	return
 }
@@ -53,18 +63,11 @@ func (vm *VM) Load(file string) error {
 		return ErrNoVMLoaded
 	}
 
-	if !GCTScriptConfig.Enabled {
-		return &Error{
-			Action: "Load",
-			Cause:  ErrScriptingDisabled,
-		}
+	if filepath.Ext(file) != common.GctExt {
+		file += common.GctExt
 	}
 
-	if filepath.Ext(file) != ".gct" {
-		file += ".gct"
-	}
-
-	if GCTScriptConfig.Verbose {
+	if vm.config.Verbose {
 		log.Debugf(log.GCTScriptMgr, "Loading script: %s ID: %v", vm.ShortName(), vm.ID)
 	}
 
@@ -89,8 +92,8 @@ func (vm *VM) Load(file string) error {
 	vm.Script.SetImports(loader.GetModuleMap())
 	vm.Hash = vm.getHash()
 
-	if GCTScriptConfig.AllowImports {
-		if GCTScriptConfig.Verbose {
+	if vm.config.AllowImports {
+		if vm.config.Verbose {
 			log.Debugf(log.GCTScriptMgr, "File imports enabled for vm: %v", vm.ID)
 		}
 		vm.Script.EnableFileImport(true)
@@ -108,7 +111,7 @@ func (vm *VM) Compile() (err error) {
 
 // Run runs byte code
 func (vm *VM) Run() (err error) {
-	if GCTScriptConfig.Verbose {
+	if vm.config.Verbose {
 		log.Debugf(log.GCTScriptMgr, "Running script: %s ID: %v", vm.ShortName(), vm.ID)
 	}
 
@@ -130,10 +133,10 @@ func (vm *VM) RunCtx() (err error) {
 		vm.ctx = context.Background()
 	}
 
-	ct, cancel := context.WithTimeout(vm.ctx, GCTScriptConfig.ScriptTimeout)
+	ct, cancel := context.WithTimeout(vm.ctx, vm.config.ScriptTimeout)
 	defer cancel()
 
-	if GCTScriptConfig.Verbose {
+	if vm.config.Verbose {
 		log.Debugf(log.GCTScriptMgr, "Running script: %s ID: %v", vm.ShortName(), vm.ID)
 	}
 
@@ -157,7 +160,7 @@ func (vm *VM) CompileAndRun() {
 	err := vm.Compile()
 	if err != nil {
 		log.Error(log.GCTScriptMgr, err)
-		err = RemoveVM(vm.ID)
+		err = vm.unregister()
 		if err != nil {
 			log.Error(log.GCTScriptMgr, err)
 		}
@@ -167,7 +170,7 @@ func (vm *VM) CompileAndRun() {
 	err = vm.RunCtx()
 	if err != nil {
 		log.Error(log.GCTScriptMgr, err)
-		err = RemoveVM(vm.ID)
+		err = vm.unregister()
 		if err != nil {
 			log.Error(log.GCTScriptMgr, err)
 		}
@@ -209,13 +212,13 @@ func (vm *VM) Shutdown() error {
 	if vm.S != nil {
 		close(vm.S)
 	}
-	if GCTScriptConfig.Verbose {
+	if vm.config.Verbose {
 		log.Debugf(log.GCTScriptMgr, "Shutting down script: %s ID: %v", vm.ShortName(), vm.ID)
 	}
 	vm.Script = nil
 	pool.Put(vm.Script)
 	vm.event(StatusSuccess, TypeStop)
-	return RemoveVM(vm.ID)
+	return vm.unregister()
 }
 
 // Read contents of script back and create script event
@@ -226,7 +229,7 @@ func (vm *VM) Read() ([]byte, error) {
 
 // Read contents of script back
 func (vm *VM) read() ([]byte, error) {
-	if GCTScriptConfig.Verbose {
+	if vm.config.Verbose {
 		log.Debugf(log.GCTScriptMgr, "Read script: %s ID: %v", vm.ShortName(), vm.ID)
 	}
 	return ioutil.ReadFile(vm.File)

gctscript/vm/vm_test.go

@@ -35,12 +35,19 @@ func TestMain(m *testing.M) {
 	log.RWM.Lock()
 	log.GlobalLogConfig = &c
 	log.RWM.Unlock()
-	GCTScriptConfig = configHelper(true, true, maxTestVirtualMachines)
 	os.Exit(m.Run())
 }
 
 func TestNewVM(t *testing.T) {
-	x := New()
+	manager := GctScriptManager{
+		config: configHelper(true, true, maxTestVirtualMachines),
+	}
+	x := manager.New()
+	if x != nil {
+		t.Error("Should not create a VM when manager not started")
+	}
+	manager.started = 1
+	x = manager.New()
 	xType := reflect.TypeOf(x).String()
 	if xType != "*vm.VM" {
 		t.Fatalf("vm.New should return pointer to VM instead received: %v", x)
@@ -48,32 +55,38 @@ func TestNewVM(t *testing.T) {
 }
 
 func TestVMLoad(t *testing.T) {
-	GCTScriptConfig = configHelper(true, true, maxTestVirtualMachines)
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testScript)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	testScript = testScript[0 : len(testScript)-4]
-	testVM = New()
+	testVM = manager.New()
 	err = testVM.Load(testScript)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	GCTScriptConfig = configHelper(false, false, maxTestVirtualMachines)
+	manager.config = configHelper(false, false, maxTestVirtualMachines)
 	err = testVM.Load(testScript)
 	if err != nil {
 		if !errors.Is(err, ErrScriptingDisabled) {
 			t.Fatal(err)
 		}
 	}
-	GCTScriptConfig = configHelper(true, true, maxTestVirtualMachines)
 }
 
 func TestVMLoad1s(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testScriptRunner1s)
 	if err != nil {
 		t.Fatal(err)
@@ -90,7 +103,11 @@ func TestVMLoad1s(t *testing.T) {
 }
 
 func TestVMLoadNegativeTimer(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testScriptRunnerNegative)
 	if err != nil {
 		if !errors.Is(err, ErrNoVMLoaded) {
@@ -105,7 +122,11 @@ func TestVMLoadNegativeTimer(t *testing.T) {
 }
 
 func TestVMLoadNilVM(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testScript)
 	if err != nil {
 		if !errors.Is(err, ErrNoVMLoaded) {
@@ -122,8 +143,12 @@ func TestVMLoadNilVM(t *testing.T) {
 }
 
 func TestCompileAndRunNilVM(t *testing.T) {
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
 	vmcount := VMSCount.Len()
-	testVM := New()
+	testVM := manager.New()
 	err := testVM.Load(testScript)
 	if err != nil {
 		if !errors.Is(err, ErrNoVMLoaded) {
@@ -149,7 +174,11 @@ func TestCompileAndRunNilVM(t *testing.T) {
 }
 
 func TestVMLoadNoFile(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load("missing file")
 	if err != nil {
 		if !errors.Is(err, os.ErrNotExist) {
@@ -159,7 +188,11 @@ func TestVMLoadNoFile(t *testing.T) {
 }
 
 func TestVMCompile(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testScript)
 	if err != nil {
 		t.Fatal(err)
@@ -172,7 +205,11 @@ func TestVMCompile(t *testing.T) {
 }
 
 func TestVMRun(t *testing.T) {
-	testVM := NewVM()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.NewVM()
 	err := testVM.Load(testScript)
 	if err != nil {
 		t.Fatal(err)
@@ -190,7 +227,11 @@ func TestVMRun(t *testing.T) {
 }
 
 func TestVMRunTX(t *testing.T) {
-	testVM := NewVM()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.NewVM()
 	err := testVM.Load(testScript)
 	if err != nil {
 		t.Fatal(err)
@@ -208,8 +249,12 @@ func TestVMRunTX(t *testing.T) {
 }
 
 func TestVMWithRunner(t *testing.T) {
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
 	vmCount := VMSCount.Len()
-	VM := New()
+	VM := manager.New()
 	if VM == nil {
 		t.Fatal("Failed to allocate new VM exiting")
 	}
@@ -231,8 +276,12 @@ func TestVMWithRunner(t *testing.T) {
 }
 
 func TestVMWithRunnerOnce(t *testing.T) {
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
 	vmCount := VMSCount.Len()
-	VM := New()
+	VM := manager.New()
 	if VM == nil {
 		t.Fatal("Failed to allocate new VM exiting")
 	}
@@ -251,8 +300,12 @@ func TestVMWithRunnerOnce(t *testing.T) {
 }
 
 func TestVMWithRunnerNegativeTimer(t *testing.T) {
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
 	vmCount := VMSCount.Len()
-	VM := New()
+	VM := manager.New()
 	if VM == nil {
 		t.Fatal("Failed to allocate new VM exiting")
 	}
@@ -274,8 +327,12 @@ func TestVMWithRunnerNegativeTimer(t *testing.T) {
 }
 
 func TestShutdownAll(t *testing.T) {
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
 	vmCount := VMSCount.Len()
-	VM := New()
+	VM := manager.New()
 	err := VM.Load(testScriptRunner)
 	if err != nil {
 		t.Fatal(err)
@@ -286,7 +343,7 @@ func TestShutdownAll(t *testing.T) {
 	if VMSCount.Len() == vmCount {
 		t.Fatal("expected VM count to increase")
 	}
-	err = ShutdownAll()
+	err = manager.ShutdownAll()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -297,7 +354,11 @@ func TestShutdownAll(t *testing.T) {
 }
 
 func TestRead(t *testing.T) {
-	VM := NewVM()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	VM := manager.NewVM()
 	err := VM.Load(testScriptRunner)
 	if err != nil {
 		t.Fatal(err)
@@ -315,8 +376,12 @@ func TestRead(t *testing.T) {
 }
 
 func TestRemoveVM(t *testing.T) {
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
 	id, _ := uuid.FromString("6f20c907-64a0-48f2-848a-7837dee61672")
-	err := RemoveVM(id)
+	err := manager.RemoveVM(id)
 
 	if err != nil {
 		if err.Error() != "VM 6f20c907-64a0-48f2-848a-7837dee61672 not found" {
@@ -338,7 +403,11 @@ func TestError_Error(t *testing.T) {
 }
 
 func TestVM_CompileInvalid(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testInvalidScript)
 	if err != nil {
 		t.Fatal(err)
@@ -353,7 +422,7 @@ func TestVM_CompileInvalid(t *testing.T) {
 		t.Fatal("unexpected result broken script compiled successfully ")
 	}
 
-	testVM = New()
+	testVM = manager.New()
 	err = testVM.Load(testInvalidScript)
 	if err != nil {
 		t.Fatal(err)
@@ -369,7 +438,7 @@ func TestVM_CompileInvalid(t *testing.T) {
 		t.Fatal("unexpected result broken script compiled successfully ")
 	}
 
-	testVM = New()
+	testVM = manager.New()
 	err = testVM.Load(testInvalidScript)
 	if err != nil {
 		t.Fatal(err)
@@ -383,7 +452,11 @@ func TestVM_CompileInvalid(t *testing.T) {
 }
 
 func TestVM_CompileBroken(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testBrokenScript)
 	if err != nil {
 		t.Fatal(err)
@@ -396,7 +469,11 @@ func TestVM_CompileBroken(t *testing.T) {
 }
 
 func TestVM_CompileAndRunBroken(t *testing.T) {
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	testVM := manager.New()
 	err := testVM.Load(testBrokenScript)
 	if err != nil {
 		t.Fatal(err)
@@ -410,48 +487,56 @@ func TestVM_CompileAndRunBroken(t *testing.T) {
 }
 
 func TestValidate(t *testing.T) {
-	err := Validate(testBrokenScript)
+	manager := GctScriptManager{
+		config:  configHelper(true, true, maxTestVirtualMachines),
+		started: 1,
+	}
+	err := manager.Validate(testBrokenScript)
 	if err == nil {
 		t.Fatal(err)
 	}
-	err = Validate(testScript)
+	err = manager.Validate(testScript)
 	if err != nil {
 		t.Fatal(err)
 	}
 }
 
 func TestVMLimit(t *testing.T) {
-	GCTScriptConfig = configHelper(true, false, 0)
-	testVM := New()
+	manager := GctScriptManager{
+		config:  configHelper(true, false, 0),
+		started: 1,
+	}
+	testVM := manager.New()
 	if testVM != nil {
 		t.Fatal("expected nil but received pointer to VM")
 	}
-	GCTScriptConfig = configHelper(true, true, maxTestVirtualMachines)
 }
 
 func TestAutoload(t *testing.T) {
-	GCTScriptConfig = &Config{
-		Enabled: true,
-		AutoLoad: []string{
-			scriptName,
+	manager := GctScriptManager{
+		config: &Config{
+			Enabled: true,
+			AutoLoad: []string{
+				scriptName,
+			},
+			Verbose: true,
 		},
-		Verbose: true,
 	}
 
 	ScriptPath = filepath.Join("..", "..", "testdata", "gctscript")
-	err := Autoload(scriptName, true)
+	err := manager.Autoload(scriptName, true)
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = Autoload(scriptName, true)
+	err = manager.Autoload(scriptName, true)
 	if err == nil {
 		t.Fatal("expected err to be script not found received nil")
 	}
-	err = Autoload("once", false)
+	err = manager.Autoload("once", false)
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = Autoload(scriptName, false)
+	err = manager.Autoload(scriptName, false)
 	if err == nil {
 		t.Fatal("expected err to be script not found received nil")
 	}

gctscript/vm/vm_types.go

@@ -48,14 +48,16 @@ var (
 
 // VM contains a pointer to "script" (precompiled source) and "compiled" (compiled byte code) instances
 type VM struct {
-	ID       uuid.UUID
-	Hash     string
-	File     string
-	Path     string
-	Script   *tengo.Script
-	Compiled *tengo.Compiled
-	ctx      context.Context
-	T        time.Duration
-	NextRun  time.Time
-	S        chan struct{}
+	ID         uuid.UUID
+	Hash       string
+	File       string
+	Path       string
+	Script     *tengo.Script
+	Compiled   *tengo.Compiled
+	ctx        context.Context
+	T          time.Duration
+	NextRun    time.Time
+	S          chan struct{}
+	config     *Config
+	unregister func() error
 }