Expose API that take in code and return the the executed result

[kw7oe]

Hey, I'm just wondering is it possible to expose an API that take in code as input and have the executor run the code and return the result? It will allow a few interesting use case such as:

• It could then be extended to build an Elixir playground, where you can execute Elixir code on the browser.
  • The benefits of having this, is limited since, Elixir already have a iex and Livebook. Furthermore, some of the browser based IDE such as repl.it has support for Elixir as well.
• Documentation generated by ExDoc can then support running code block in the documentation, similar to Rust documentation, which used some of the mdBook specific features.
  • Having an API that is able to do that is not sufficient. Client side code are required to be added to the generated HTML of ExDoc in order to format the response from the API and display it correctly. So, while it sounds cool, I'm not sure if the benefits outweighs the costs.
• Lastly for personal reason, this mean that I can run by Livebook server, and integrated it into my blog post and enabled the readers to interact with Elixir in the browser itself, without having to run in Livebook. It could also be hosted by Livebook Pro (in the future) as a service?

One of the limitations/challenges/concerns I could thought of:

• The user might be sending long running task, that will be executed in the background. For example, starting a TCP connection. In this case, it's not possible to return the result. And implementing it means complicating the executor logic further as well.
• Security. Since now the Livebook server API for code execution will be exposed to the public, so the users have to bear the security risks, unless the Livebook server is running in a sandbox environment of the OS?

Given that Livebook is already such an amazing software to use, I understand that the costs of implementing this might outweighs the benefits or use cases mentioned above.

As I'm unsure about the complexity involved, I would like to hear different perspectives on this. So, what's you all thoughts about this?

[josevalim]

Unfortunately I don't think Livebook is a good model for this because it runs via Distributed Erlang. Which means any notebook (code execution) has access to all other notebooks. You need a different execution model (it is not easier nor harder, just different) in order to enable functionality like this.

[kw7oe]

Ahh okay, that make sense. Just manage to read through a bit of the implementation after seeing this and get a better understanding. While in Livebook we are spawning an Elixir node which will communicate with the Livebook server, this doesn't mean that it's totally isolated. That's partly why I got some misconception about it and thought each session is isolated.

So, when you say that:

Which means any notebook (code execution) has access to all other notebooks.

I'm understanding it as: through code execution, the user can get access to the other notebook content , which is not the level of sandboxing suitable for what I mentioned. Am I understanding it correctly?

[jonatanklosko]

Livebook application runs as an Elixir node, the runtime responsible for code evaluation runs in another node, they communicate via Distributed Erlang. Since the user can evaluate arbitrary code within the runtime node, they can effectively do anything to the Livebook application itself.

[jonatanklosko]

The use cases you mentioned are more about stateless evaluation and that itself is fairly straightforward to implement. The important part is sandboxing the evaluation and as @josevalim mentioned that's not something Livebook does.

[kw7oe]

I see, as mentioned in the above reply, I thought that it's a stateless (or I would say state independent?) evaluation as each session is another elixir node. But that's not entirely correct since it's possible to get the state of the other code evaluation. Hence, that make it stateful. Am I understanding it correctly here?

So the code evaluation part is mainly consist of calling Code.eval_* function. But in order to have the level of sandboxing I mentioned, it's not what Livebook is currently doing.

So the next question I have is:

Can Elixir or the BEAM VM provide that kind of isolation?

What I have in mind is we definitely need a layer below to achieve that. E.g. spinning up a VM in the server, and execute the code in the VM, so it's executed in a totally isolated environment that have it's own file system and etc.

Let me know if this is off topic and I should move the conversation elsewhere 😅

[jonatanklosko]

By stateless I meant a single evaluation (like elixir script.exs) as opposed to a sequence of evaluations (like in iex), which is what Livebook does together with all state management.

As for isolation, the server would need to talk to the runtime node over TCP (basically anything else than Erlang distribution). Since both are running on the same machine arbitrary code evaluation would still be an issue, so in addition to that the runtime process would need to be sandboxed, perhaps using Docker.

[kw7oe]

Thanks for the clarification! Now I'm super clear on what needs to be done to make it a reality. Thanks for your time and work in Livebook 💯