feat(cli): LE-001 concept #39

CHANGELOG.md

@@ -8,6 +8,8 @@
 - feat(error): impproved error messages for missing members
 - feat(stdlib): introduced `apps`
 - feat(error): improved error messages for dicts
+- feat(cli): whitelist external definitions #39 LE-001
+- feat(cli): timeout for scripts #39 LE-001
 
 ## v0.0.18
 

app/lithia/cmd/repl.go

@@ -32,8 +32,13 @@ func runPrompt() {
 		world.Current.Env.Exit(1)
 	}
 	reader := bufio.NewReader(world.Current.Stdin)
-	inter := lithia.NewDefaultInterpreter(importRoot)
+	inter, ctx := lithia.NewDefaultInterpreter(importRoot)
 	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
 		fmt.Print("> ")
 		line, err := reader.ReadString('\n')
 		if err == io.EOF {

app/lithia/cmd/run.go

@@ -29,7 +29,8 @@ func runFile(fileName string, args []string) {
 		fmt.Fprint(world.Current.Stderr, err)
 		world.Current.Env.Exit(1)
 	}
-	inter := lithia.NewDefaultInterpreter(path.Dir(fileName))
+
+	inter, _ := lithia.NewDefaultInterpreter(path.Dir(fileName))
 	script := string(scriptData) + "\n"
 	_, err = inter.Interpret(fileName, script)
 	if err != nil {

lithia.go

@@ -1,18 +1,69 @@
 package lithia
 
 import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
 	extdocs "github.com/vknabel/lithia/external/docs"
 	extfs "github.com/vknabel/lithia/external/fs"
 	extos "github.com/vknabel/lithia/external/os"
 	extrx "github.com/vknabel/lithia/external/rx"
 	"github.com/vknabel/lithia/runtime"
+	"github.com/vknabel/lithia/world"
 )
 
-func NewDefaultInterpreter(referenceFile string, importRoots ...string) *runtime.Interpreter {
-	inter := runtime.NewIsolatedInterpreter(referenceFile, importRoots...)
-	inter.ExternalDefinitions["os"] = extos.New(inter)
-	inter.ExternalDefinitions["rx"] = extrx.New(inter)
-	inter.ExternalDefinitions["docs"] = extdocs.New(inter)
-	inter.ExternalDefinitions["fs"] = extfs.New(inter)
-	return inter
+func NewDefaultInterpreter(referenceFile string, importRoots ...string) (*runtime.Interpreter, context.Context) {
+	ctx := context.Background()
+	if timeout, ok := world.Current.Env.LookupEnv("LITHIA_TIMEOUT"); ok {
+		duration, err := time.ParseDuration(timeout)
+		if err != nil {
+			fmt.Fprint(world.Current.Stderr, err)
+			world.Current.Env.Exit(1)
+		}
+		var cancel context.CancelFunc
+		ctx, cancel = context.WithTimeout(ctx, duration)
+
+		go func() {
+			<-time.After(duration)
+			cancel()
+		}()
+	}
+	inter := runtime.NewIsolatedInterpreter(ctx, referenceFile, importRoots...)
+
+	externalDefinitions := "*"
+	if defs, ok := world.Current.Env.LookupEnv("LITHIA_EXTERNAL_DEFINITIONS"); ok {
+		externalDefinitions = defs
+	}
+	var whitelistExternals []string
+	if externalDefinitions != "*" {
+		whitelistExternals = strings.Split(externalDefinitions, ",")
+	}
+
+	if allowsWhitelistExternal(whitelistExternals, "os") {
+		inter.ExternalDefinitions["os"] = extos.New(inter)
+	}
+	if allowsWhitelistExternal(whitelistExternals, "rx") {
+		inter.ExternalDefinitions["rx"] = extrx.New(inter)
+	}
+	if allowsWhitelistExternal(whitelistExternals, "docs") {
+		inter.ExternalDefinitions["docs"] = extdocs.New(inter)
+	}
+	if allowsWhitelistExternal(whitelistExternals, "fs") {
+		inter.ExternalDefinitions["fs"] = extfs.New(inter)
+	}
+	return inter, ctx
+}
+
+func allowsWhitelistExternal(whitelistExternals []string, name string) bool {
+	if whitelistExternals == nil {
+		return true
+	}
+	for _, allowed := range whitelistExternals {
+		if allowed == name {
+			return true
+		}
+	}
+	return false
 }

runtime/evaluatable-expr.go

@@ -18,7 +18,7 @@ func MakeEvaluatableExpr(context *InterpreterContext, expr ast.Expr) Evaluatable
 	if context.fileDef.Path != expr.Meta().Source.FileName {
 		panic("Mixing files in declared evaluatable expr!")
 	}
-	return EvaluatableExpr{&copy, expr, NewLazyEvaluationCache()}
+	return EvaluatableExpr{&copy, expr, NewLazyEvaluationCache(context.interpreter.Context)}
 }
 
 func (e EvaluatableExpr) Evaluate() (RuntimeValue, *RuntimeError) {

runtime/interpreter-context.go

@@ -26,7 +26,7 @@ func (inter *Interpreter) NewInterpreterContext(fileDef *ast.SourceFile, module
 		module:      module,
 		path:        []string{},
 		environment: environment,
-		evalCache:   NewLazyEvaluationCache(),
+		evalCache:   NewLazyEvaluationCache(inter.Context),
 	}
 }
 
@@ -37,7 +37,7 @@ func (i *InterpreterContext) NestedInterpreterContext(name string) *InterpreterC
 		module:      i.module,
 		path:        append(i.path, name),
 		environment: NewEnvironment(i.environment),
-		evalCache:   NewLazyEvaluationCache(),
+		evalCache:   NewLazyEvaluationCache(i.interpreter.Context),
 	}
 }
 
@@ -48,6 +48,11 @@ func (i *InterpreterContext) Evaluate() (RuntimeValue, *RuntimeError) {
 		}
 		var result RuntimeValue
 		for _, stmt := range i.fileDef.Statements {
+			select {
+			case <-i.interpreter.Context.Done():
+				return nil, NewRuntimeError(i.interpreter.Context.Err())
+			default:
+			}
 			expr := MakeEvaluatableExpr(i, stmt)
 			value, err := expr.Evaluate()
 			if err != nil {

runtime/interpreter.go

@@ -1,22 +1,26 @@
 package runtime
 
 import (
+	"context"
+
 	"github.com/vknabel/lithia/ast"
 	"github.com/vknabel/lithia/parser"
 	"github.com/vknabel/lithia/resolution"
 	"github.com/vknabel/lithia/world"
 )
 
 type Interpreter struct {
+	Context             context.Context
 	Resolver            resolution.ModuleResolver
 	Parser              *parser.Parser
 	Modules             map[ast.ModuleName]*RuntimeModule
 	ExternalDefinitions map[ast.ModuleName]ExternalDefinition
 	Prelude             *Environment
 }
 
-func NewIsolatedInterpreter(referenceFile string, importRoots ...string) *Interpreter {
+func NewIsolatedInterpreter(ctx context.Context, referenceFile string, importRoots ...string) *Interpreter {
 	inter := &Interpreter{
+		Context:             ctx,
 		Resolver:            resolution.NewDefaultModuleResolver(importRoots...),
 		Parser:              parser.NewParser(),
 		Modules:             make(map[ast.ModuleName]*RuntimeModule),

runtime/lazy-evaluation-cache.go

@@ -1,20 +1,33 @@
 package runtime
 
-import "sync"
+import (
+	"context"
+	"sync"
+)
 
 type LazyEvaluationCache struct {
+	ctx   context.Context
 	once  *sync.Once
 	value RuntimeValue
 	err   *RuntimeError
 }
 
-func NewLazyEvaluationCache() *LazyEvaluationCache {
-	return &LazyEvaluationCache{once: &sync.Once{}}
+func NewLazyEvaluationCache(ctx context.Context) *LazyEvaluationCache {
+	return &LazyEvaluationCache{ctx: ctx, once: &sync.Once{}}
 }
 
 func (c *LazyEvaluationCache) Evaluate(f func() (RuntimeValue, *RuntimeError)) (RuntimeValue, *RuntimeError) {
 	c.once.Do(func() {
-		c.value, c.err = f()
+		done := make(chan struct{})
+		go func() {
+			c.value, c.err = f()
+			close(done)
+		}()
+		select {
+		case <-c.ctx.Done():
+			c.err = NewRuntimeError(c.ctx.Err())
+		case <-done:
+		}
 	})
 	return c.value, c.err
 }

runtime/runtime-stdlib_test.go

@@ -12,7 +12,8 @@ import (
 
 func TestStdlib(t *testing.T) {
 	pathToStdlib := "../stdlib"
-	inter := l.NewDefaultInterpreter(pathToStdlib, "../stdlib")
+	inter, ctx := l.NewDefaultInterpreter(pathToStdlib, "../stdlib")
+	defer ctx.Done()
 	mockOS := &mockExternalOS{
 		calledExitCode: -1,
 		env:            map[string]string{"LITHIA_TESTS": "1"},