Sandboxed java scripting replacement for Nashorn

Question

I've been using Nashorn for awk-like bulk data processing. The idea is, that there's a lot of incoming data, coming row by row, one by another. And each row consists of named fields. These data are processed by user-defined scripts stored somewhere externally and editable by users. Scripts are simple, like if( c>10) a=b+3, where a, b and c are fields in the incoming data rows. The amount of data is really huge. Code is like that (an example to show the use case):

    ScriptEngine engine = new NashornScriptEngineFactory().getScriptEngine(
            new String[]{"-strict", "--no-java", "--no-syntax-extensions", "--optimistic-types=true"},
            null,
            scr -> false);

    CompiledScript cs;
    Invocable inv=(Invocable) engine;
    Bindings bd=engine.getBindings(ScriptContext.ENGINE_SCOPE);

    bd.remove("load");
    bd.remove("loadWithNewGlobal");
    bd.remove("exit");
    bd.remove("eval");
    bd.remove("quit");

    String scriptText=readScriptText();

    cs = ((Compilable) engine).compile("function foo() {\n"+scriptText+"\n}");
    cs.eval();


    Map params=readIncomingData();

    while(params!=null)
    {
        Map<String, Object> res = (Map) inv.invokeFunction("foo", params);
        writeProcessedData(res);
        params=readIncomingData();
    }

Now nashorn is obsolete and I'm looking for alternatives. Was googling for a few days but didn't found exact match for my needs. The requirements are:

Speed. There's a lot of data so it shall be really fast. So I assume as well, precompilation is the must
Shall work under linux/openJDK
Support sandboxing at least for data access/code execution

Nice to have:

Simple, c-like syntax (not lua;)
Support sandboxing for CPU usage

So far I found that Rhino is still alive (last release dated 13 Jan 2020) but I'm not sure is it still supported and how fast it is - as I remember, one of reasons Java switched to Nashorn was speed. And speed is very important in my case. Also found J2V8 but linux is not supported. GraalVM looks like a bit overkill, also didn't get how to use it for such a task yet - maybe need to explore further if it is suitable for that, but looks like it is complete jvm replacement and cannot be used as a library.

It's not necessary shall be javascript, maybe there are other alternatives. Thank you.

GraalVM's JavaScript can be used as a library: https://www.graalvm.org/docs/reference-manual/languages/JavaScript/user/RunOnJDK You can restrict things script should have access to, like Java classes, creating threads, etc. Faster than Nashorn too: https://medium.com/graalvm/oracle-graalvm-announces-support-for-nashorn-migration-c04810d75c1f — Oleg Šelajev, Mar 23 '20 at 20:06
@OlegŠelajev Tank you so much, you helped me a lot! Really, just tried, it's really fast! Could you please point me where can I read about sandboxing it as well? — BUKTOP, Mar 23 '20 at 22:05
For example a starting point can be https://www.graalvm.org/docs/reference-manual/embed/#access-privilege-configuration. — Oleg Šelajev, Mar 24 '20 at 09:53
I added all this info to an answer for people who don't read the comments — Oleg Šelajev, Mar 24 '20 at 09:59
Another solution would appear to be this: https://stackoverflow.com/questions/65265629 — Stephen C, Dec 13 '20 at 04:11

score 1 · Accepted Answer · answered Mar 24 '20 at 09:58

GraalVM's JavaScript can be used as a library with the dependencies obtained as any Maven artifact. While the recommended way to run it is to use the GraalVM distribution, there are some explanations how to run it on OpenJDK.

You can restrict things script should have access to, like Java classes, creating threads, etc:

From the documentation:

The following access parameters may be configured:

* Allow access to other languages using allowPolyglotAccess.
* Allow and customize access to host objects using allowHostAccess.
* Allow and customize host lookup to host types using allowHostLookup.
* Allow host class loading using allowHostClassLoading.
* Allow the creation of threads using allowCreateThread.
* Allow access to native APIs using allowNativeAccess.
* Allow access to IO using allowIO and proxy file accesses using fileSystem.

And it is several times faster than Nashorn. Some measurements can be found for example in this article:

GraalVM CE provides performance comparable or superior to Nashorn with 
the composite score being 4 times higher. GraalVM EE is even faster.

Thank you, Oleg, for your help. You really helped me a lot. Already found all of that about accesses etc. The only problem now is, that test run on 10mln iterations lasts 4sec with nashorn and 20 with graaljs (using their pom example). I suppose it’s due to compiler usage, will try further — BUKTOP, Mar 24 '20 at 12:17
As i get deeper into it, it’s not such an easy replacement. It’s really difficult to exchange data between graal js script and java code — BUKTOP, Feb 18 '21 at 07:22

Sandboxed java scripting replacement for Nashorn

1 Answers1