Engine: Scripting support (#383)

* WIP

* updated appveyor and increased deadline 5 seconds due to increased linters being added

* revert files to upstream/engine

* WIP

* WIP

* mod file changes

* added script manager

* Added manager/and cli interfaces to scripting

* Added script task handler

* WIP - Added timer/repeat support and fleshed out wrapper further

* autoload support added + WIP

* WIP commit

* added account balance info

* btc markets temp work around

* WIP - merged with upstream for new order package BTC Markets responses broken

* Cancel order wrapper WIP

*  order wrapper update

* Added test coverage for VM

* moved to map for VM List shutdown of all VM now handled added gctcli commands for list and stop of running scripts

* added override to load/execute for path

* fixed incorrect channel shutdown added further test coverage and restructured gctcli commands into sub commands

* increased test coverage for packages

* Added docs cleaned up tests and example scripts

* Test coverage increased for module/gct/exchange package

* windows fixes

* merged upstream/engine

* WIP

* logger fixes - removed pointer to bool check removed duplicate test check for logger

* remove unused mutex

* added inital upload support

* fix linter issues for go-fmt

* added zip support for uploading and added base for fund withdrawing

* changed error return types and also log errors, fix zip path issue

* improved error outputs and code flow

* pairs response fix added protobuf defs for stop all and list all

* added stop all running scripts general clean up and moved across to OrderManager

* linter fixes (gofmt)

* added list all command

* rewrote zip handler to be cleaner also fixed file overwrite on upload

* added query command reworked tests

* added further error checking to compileandrun corrected use of pointers for accountinfo

* bumped tengo version

* Removed named returns reworded log messages removed unused falseptr

* WIP

* Added virutal machine limit improved config options

* added model for script event added upload validation

* script_event table has been completed, tests for wrapper functions implemented

* README updates

* reverted changes opened new PR to move withdraw struct outs

* intial work on adding withdraw support after merger of withdraw package

* started work on examples

* Added crypto withdraw support

* fix switch case assignment and gofmt project

* Reworking Fiat withdraw request pending #402

* removed double pointer call

* added withdraw support for fiat  currencies

* added tests for withdraw methods increased readme

* removed local tengo require and also fix linter issues

* Added default log size const added basic test for invalid script execution

* First pass at moving wrapper to validator package to allow proper validation of uploaded scripts

* Added script details to README added config test added test for no file extension

* moved tests to const and fixed incorrect pathing

* added test coverage to withdraw package

* corrected file close handling

* point to included configtest.json

* extended validator support when a script is uploaded

* Bug fix on bool logic

* Added mutex

* Don't create autit events on test execution

* reverted common to master

* moved file rename to unix timestamp format

* converted logger enabled back to pointer as i need nilness check also moved scriptid to text over blob

* started work on autoload add/remove support

* First round of PR fixes (mostly commented exports)

* Moved GCTScript load to last, removed unneeded error from cleanup()

* Comment clairty for AuitEventID

* added autoload add/remove command to cli

* added tests for autoload

* Test updates for Exchanges

* linter fixes (gofmt)

* Removed double check of engine pointer

* remove possible nil pointer on GetSpecificTicker

* Fixed not closing file handler on write that causes archive removal to fail

* file handler Close clean ups

* corrected spelling on error return and return invalid name n autoload

* moved strings to cosnt moved bool pointer creation to convert package

* new zip extractor added

* Validation has been added to archive uploads

* removed shadow var on err

* added ok check to conversion

* converted condition check

* basic test for zip extract added

* new zip handler

* reverted back to old atomic loading system

* removed shadow err

* lets add a new line

* added space to error return

* command line toggle for script now works properly

* readme updated

* set configLoaded to true

* check for configLoaded condition

* added mutex to allow for multiple access on virtual machine increased test coverage disable script manager if scripting is disabled

* linked up to enable/disablesubsystem commands

* added start/stop example to readme

* reworked logic on test as check should be done on Load()

* updated to tengo v2

* linters

* lower time on ntp client to stop slippage

* remove all fails if any fail validtion from an archive

* remove vm from list if timer is invalid

* removed shadow on err

* remove config creation from NTPCheck test

* WIP testing DB changes

* add unique constraint

* WIP: created has many model

* linters run

* basic sqlite3 support added for new database format

* linters run

* Added test coverage for script repo

* removed unused print

* updated env vars for CI instances

* updated env vars for CI instances

* Updated test packages

* Test updates for postgresql

* removed invalid tests from postgres

* remove duplication of struct and improved code flow

* general cleanup

* wording changes on log output

* use databasemgr logger and add support for autoload without file extension

* corrected test naming

* return correct error

* return correct error again version 82

* store scriptdata on creation

* Hello

* Errorln -> Errorf

* Removed unused vars

* Read me updates

* testing without parallel

* comment on exported type

* added nil check against VM for test

* add debugging information

* gofmt

* remove verbose and data sent to channel

* Added debug information

* linter fixes (gofmt)

* remove unused CompileAndRun() call

* test sleep to see if issue is timing related

* semi-concurrent map fixes

* one day i will run gofmt or setup precommit hooks

* new line :D

* increased test coverage

* added correct sleep time

* Moved over to sync map

* linter fixes (gofmt)

* goimports

* moved VM related methods to vm.go

* new line at end of file

* trying increased timeout on golangci-lint for appveyor

* add debugging information

* removed timeout

* reworked timeout logic

* linter fixes (gofmt)

* increased test coverage

* increased test coverage

* one day i will run gofmt or setup precommit hooks

* removed unused exchange test

* increased golangci-lint timeout

* Added nil check on shutdown and test coverage for it lowered timeout back to 1:30

* reworked ID system

* removed script hash as it was unused

* added comments on exported methods and read me update

* reorder code

* removed to atomic.value for test execution flag

* increased test coverage

* move add further up execution

* point to correct script file
This commit is contained in:
Andrew
2020-01-23 13:54:04 +11:00
committed by Adrian Gallagher
parent 4c33a0738a
commit f6fd94ea69
102 changed files with 15181 additions and 370 deletions

View File

@@ -4,8 +4,10 @@ import (
"context"
"errors"
"fmt"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv"
"strings"
@@ -2915,3 +2917,436 @@ func getAuditEvent(c *cli.Context) error {
jsonOutput(result)
return nil
}
var uuid, filename, path string
var gctScriptCommand = cli.Command{
Name: "gctscript",
Usage: "execute gctscript command",
ArgsUsage: "<command> <args>",
Subcommands: []cli.Command{
{
Name: "execute",
Usage: "execute script filename",
ArgsUsage: "<filename> <path>",
Flags: []cli.Flag{
cli.StringFlag{
Name: "filename",
Usage: "<filename>",
Destination: &filename,
},
cli.StringFlag{
Name: "path",
Usage: "<script path>",
Destination: &path,
},
},
Action: gctScriptExecute,
},
{
Name: "query",
Usage: "query running virtual machine",
Flags: []cli.Flag{
cli.StringFlag{
Name: "uuid",
Usage: "<uuid>",
Destination: &uuid,
},
},
Action: gctScriptQuery,
},
{
Name: "read",
Usage: "read script",
Flags: []cli.Flag{
cli.StringFlag{
Name: "name",
Usage: "<name>",
Destination: &uuid,
},
},
Action: gctScriptRead,
},
{
Name: "status",
Usage: "get status of running scripts",
Action: gctScriptStatus,
},
{
Name: "list",
Usage: "lists all scripts in default scriptpath",
Action: gctScriptList,
},
{
Name: "stop",
Usage: "terminate running script",
Flags: []cli.Flag{
cli.StringFlag{
Name: "uuid",
Usage: "<uuid>",
Destination: &uuid,
},
},
Action: gctScriptStop,
},
{
Name: "stopall",
Usage: "terminate running script",
Action: gctScriptStopAll,
},
{
Name: "upload",
Usage: "upload a new script/archive",
Flags: []cli.Flag{
cli.StringFlag{
Name: "path",
Usage: "<path> to single script or zip collection",
Destination: &filename,
},
cli.BoolFlag{
Name: "overwrite",
Usage: "<true/false>",
},
cli.BoolFlag{
Name: "archived",
Usage: "<true/false>",
},
},
Action: gctScriptUpload,
},
{
Name: "autoload",
Usage: "add or remove script from autoload list",
Flags: []cli.Flag{
cli.StringFlag{
Name: "command",
Usage: "<add/remove>",
},
cli.StringFlag{
Name: "script",
Usage: "<script name>",
},
},
Action: gctScriptAutoload,
},
},
}
func gctScriptAutoload(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
_ = cli.ShowSubcommandHelp(c)
return nil
}
var command, script string
var status bool
if !c.IsSet("command") {
if c.Args().Get(0) != "" {
command = c.Args().Get(0)
}
}
if !c.IsSet("script") {
if c.Args().Get(1) != "" {
script = c.Args().Get(1)
}
}
switch command {
case "add":
status = false
case "remove":
status = true
default:
_ = cli.ShowSubcommandHelp(c)
return nil
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptAutoLoadToggle(context.Background(),
&gctrpc.GCTScriptAutoLoadRequest{
Script: script,
Status: status,
})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptExecute(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
_ = cli.ShowSubcommandHelp(c)
return nil
}
if !c.IsSet("filename") {
if c.Args().Get(0) != "" {
filename = c.Args().Get(0)
}
}
if !c.IsSet("path") {
if c.Args().Get(1) != "" {
path = c.Args().Get(1)
}
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptExecute(context.Background(),
&gctrpc.GCTScriptExecuteRequest{
Script: &gctrpc.GCTScript{
Name: filename,
Path: path,
},
})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptStatus(c *cli.Context) error {
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptStatus(context.Background(),
&gctrpc.GCTScriptStatusRequest{})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptList(c *cli.Context) error {
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptListAll(context.Background(),
&gctrpc.GCTScriptListAllRequest{})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptStop(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
_ = cli.ShowSubcommandHelp(c)
return nil
}
if !c.IsSet("uuid") {
if c.Args().Get(0) != "" {
uuid = c.Args().Get(0)
}
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptStop(context.Background(),
&gctrpc.GCTScriptStopRequest{
Script: &gctrpc.GCTScript{UUID: uuid},
})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptStopAll(c *cli.Context) error {
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptStopAll(context.Background(),
&gctrpc.GCTScriptStopAllRequest{})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptRead(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
_ = cli.ShowSubcommandHelp(c)
return nil
}
if !c.IsSet("name") {
if c.Args().Get(0) != "" {
uuid = c.Args().Get(0)
}
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptReadScript(context.Background(),
&gctrpc.GCTScriptReadScriptRequest{
Script: &gctrpc.GCTScript{
Name: uuid,
},
})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptQuery(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
_ = cli.ShowSubcommandHelp(c)
return nil
}
if !c.IsSet("uuid") {
if c.Args().Get(0) != "" {
uuid = c.Args().Get(0)
}
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
executeCommand, err := client.GCTScriptQuery(context.Background(),
&gctrpc.GCTScriptQueryRequest{
Script: &gctrpc.GCTScript{
UUID: uuid,
},
})
if err != nil {
return err
}
jsonOutput(executeCommand)
return nil
}
func gctScriptUpload(c *cli.Context) error {
if c.NArg() == 0 && c.NumFlags() == 0 {
_ = cli.ShowSubcommandHelp(c)
return nil
}
var overwrite bool
var archived bool
if !c.IsSet("path") {
if c.Args().Get(0) != "" {
filename = c.Args().Get(0)
}
}
if c.IsSet("overwrite") {
overwrite = c.Bool("overwrite")
} else {
ow, err := strconv.ParseBool(c.Args().Get(1))
if err == nil {
overwrite = ow
}
}
if c.IsSet("archived") {
archived = c.Bool("archived")
} else {
ow, err := strconv.ParseBool(c.Args().Get(1))
if err == nil {
archived = ow
}
}
if filepath.Ext(filename) != ".gct" && filepath.Ext(filename) != ".zip" {
return errors.New("file type must be gct or zip")
}
file, err := os.Open(filename)
if err != nil {
return err
}
conn, err := setupClient()
if err != nil {
return err
}
defer conn.Close()
client := gctrpc.NewGoCryptoTraderClient(conn)
data, err := ioutil.ReadAll(file)
if err != nil {
return err
}
uploadCommand, err := client.GCTScriptUpload(context.Background(),
&gctrpc.GCTScriptUploadRequest{
ScriptName: filepath.Base(file.Name()),
Data: data,
Archived: archived,
Overwrite: overwrite,
})
if err != nil {
return err
}
jsonOutput(uploadCommand)
return nil
}

View File

@@ -133,6 +133,7 @@ func main() {
getTickerStreamCommand,
getExchangeTickerStreamCommand,
getAuditEventCommand,
gctScriptCommand,
}
err := app.Run(os.Args)