Is there any way to stop a running script with a timeout?

[Dreamacro]

In my use case, I receive a function from the user. And I passthrough params and execute it. But I need a way to stop the function running with a timeout (e.g. 2000ms).

can starlark-go provide a function like CallContext?

thread := &starlark.Thread{
    Name:  "example",
}

globals, _ := starlark.ExecFile(thread, "test.star", f, nil)

mainFn := globals["main"]
dict := starlark.StringDict{
    "param": starlark.String("test"),
}

m := starlarkstruct.FromStringDict(starlarkstruct.Default, dict)
arg := starlark.Tuple{m}

ctx, cancel := context.WithTimeout(context.background(), time.Second)
defer cancel()
starlark.CallContext(ctx, thread, mainFn, arg, nil)

[alandonovan]

Currently there is no way to stop a function in the middle of Starlark execution, though it is a feature that has been requested before and may be feasible to implement without a major performance penalty. Is the function you wish to interrupt executing a Starlark loop, or is it calling into a built-in function that takes a long time? If the latter, then you can easily make that built-in function honor the cancellation of a context carried within the thread. For example:

thread := &starlark.Thread{Name:  "example"}
ctx, cancel := context.WithTimeout(context.background(), time.Second)
defer cancel()
thread.SetLocal("context", ctx)
starlark.ExecFile(...)

...

func slowBuiltin(thread *Thread, fn *Builtin, args Tuple, kwargs []Tuple) (Value, error) {
    if (thread.Local("context").(context.Context).Err() != nil) { ... give up ... }
    ...
}

[Dreamacro]

My use cases are more like a lightweight FaaS. The user defines a function that I can't control and I call it many times. So when it runs too long, I need to stop/kill it. Is there any difficulty that doesn't implement yet?

[alandonovan]

Oh, if you can't trust the user's function then you definitely should not run it in the same address space as your code, as it can trivially consume all available memory and there's nothing we can hope to do about that.

Let the operating system help you. Fork and exec a subprocess in a cgroup or setrlimit container that bounds the memory, CPU, and running time.

[maxmcd]

@alandonovan do you think it would be a large effort to implement rough cpu/memory metering and limits? I understand if this isn't the goal of the project and that it wouldn't have a home in this codebase, but is there something about the implementation that would make this difficult?

[alandonovan]

Yes, I think it's essentially infeasible. An implementation in C++ could in principle impose limits on memory usage, but it would be a major usability challenge.

Like I said before, let the operating system help you. It has mechanisms to bound both CPU and memory usage of child process.

[maxmcd]

Yep, I'm working on something that takes advantage of those mechanisms to limit memory and cpu use with webassembly: https://github.com/embly/embly

With starlark it seemed like it might be possible to get away with an implementation that safely runs user code in the same address space, maybe not measuring the exact amount of memory used, but at least imposing some soft limits base on what is being parsed and executed. Understood though, thanks for the response.

[tv42]

Can this be marked a duplicate of #160 ?

[alandonovan]

Fixed. See Thread.SetMaxExecutionSteps and Thread.Cancel.