io.apigee.trireme.core.internal

Class ScriptRunner

java.lang.Object

io.apigee.trireme.core.internal.ScriptRunner

All Implemented Interfaces:

NodeRuntime, GenericNodeRuntime, Callable<ScriptStatus>

public class ScriptRunner
extends Object
implements NodeRuntime, Callable<ScriptStatus>

This class actually runs the script.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	ScriptRunner.Activity

Field Summary

Fields

Modifier and Type	Field and Description
protected AbstractProcess	process
static String	RUNNER
static String	TIMEOUT_TIMESTAMP_KEY

Constructor Summary

Constructors

Constructor and Description
ScriptRunner(NodeScript so, NodeEnvironment env, Sandbox sandbox, File scriptFile, String[] args)
ScriptRunner(NodeScript so, NodeEnvironment env, Sandbox sandbox, String[] args, boolean forceRepl)
ScriptRunner(NodeScript so, NodeEnvironment env, Sandbox sandbox, String scriptName, String script, String[] args)

Method Summary

Methods

Modifier and Type	Method and Description
void	awaitInitialization() We use this when spawning child scripts to avoid sending them messages before they are ready.
void	cacheInternalModule(String name, Object module)
void	cacheModule(String name, NativeModule.ModuleImpl module)
ScriptStatus	call() Execute the script.
void	clearErrno()
void	close()
Future<Boolean>	createTimedTask(Runnable r, long delay, TimeUnit unit, boolean repeating, Object domain) This is a more generic way of creating a timer that can be used in the kernel, and which works even if we are not in the main thread.
ScriptRunner.Activity	createTimer(long delay, boolean repeating, long repeatInterval, ScriptTask task, org.mozilla.javascript.Scriptable scope) This method puts the task directly on the timer queue, which is unsynchronized.
void	enqueueCallback(org.mozilla.javascript.Function f, org.mozilla.javascript.Scriptable scope, org.mozilla.javascript.Scriptable thisObj, Object[] args) This method uses a concurrent queue so it may be called from any thread.
void	enqueueCallback(org.mozilla.javascript.Function f, org.mozilla.javascript.Scriptable scope, org.mozilla.javascript.Scriptable thisObj, Object domain, Object[] args) This method uses a concurrent queue so it may be called from any thread.
void	enqueueIpc(org.mozilla.javascript.Context cx, Object message, TriremeProcess child) This method is used by the "child_process" module when sending an IPC message between child processes in the same JVM.
void	enqueueTask(ScriptTask task) This method uses a concurrent queue so it may be called from any thread.
void	enqueueTask(ScriptTask task, Object domain) This method uses a concurrent queue so it may be called from any thread.
void	executeCallback(org.mozilla.javascript.Context cx, Object[] args, org.mozilla.javascript.Function function, org.mozilla.javascript.Scriptable thisObj) Immediately execute the specified callback.
void	executeScriptTask(Runnable r, Object domain)
void	executeTicks(org.mozilla.javascript.Context cx) Execute ticks as defined by process.nextTick() and anything put on the queue from Java code.
ExecutorService	getAsyncPool() This thread pool is a thread pool that has a fixed maximum size and a queue.
Object	getCachedInternalModule(String name) Return a module that is used internally and exposed by "process.binding".
NativeModule.ModuleImpl	getCachedModule(String name) Return a module that was created implicitly or by the "native module"
Object	getDomain()
NodeEnvironment	getEnvironment() Return the Environment used to create this script.
Object	getErrno()
BasicFilesystem	getFilesystem()
ScriptFuture	getFuture()
long	getLoopTimestamp()
NativeModule.NativeImpl	getNativeModule()
NetworkPolicy	getNetworkPolicy()
TriremeProcess	getParentProcess()
PathTranslator	getPathTranslator()
AbstractProcess	getProcess()
AbstractModuleRegistry	getRegistry()
Sandbox	getSandbox() Return the sandbox used to limit script execution, or null if none was set
NodeScript	getScriptObject() Return the "NodeScript" used to create this script.
org.mozilla.javascript.Scriptable	getScriptScope()
Selector	getSelector()
OutputStream	getStderr()
InputStream	getStdin()
OutputStream	getStdout()
ExecutorService	getUnboundedPool() This thread pool is a "cached thread pool" with no maximum size, which means that any task submitted will run in its own thread until it completes.
String	getWorkingDirectory()
Object	initializeModule(String modName, AbstractModuleRegistry.ModuleType type, org.mozilla.javascript.Context cx, org.mozilla.javascript.Scriptable scope) Initialize a native module implemented in Java code.
boolean	isNativeModule(String name) This is where we load native modules.
void	pin()
void	registerCloseable(Closeable c)
Object	require(String modName, org.mozilla.javascript.Context cx) This is used internally when one native module depends on another.
Object	requireInternal(String modName, org.mozilla.javascript.Context cx)
String	reverseTranslatePath(String path) Given a file path, return what the path would be within the Node environment.
protected ScriptStatus	runScript(org.mozilla.javascript.Context cx)
void	setErrno(String err)
void	setFuture(ScriptFuture future)
void	setParentProcess(TriremeProcess parentProcess)
void	setRegistry(AbstractModuleRegistry registry)
void	setWorkingDirectory(String wd)
File	translatePath(String path) Translate a path based on the root.
void	unPin()
void	unregisterCloseable(Closeable c)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

RUNNER

public static final String RUNNER

See Also:

Constant Field Values

TIMEOUT_TIMESTAMP_KEY

public static final String TIMEOUT_TIMESTAMP_KEY

See Also:

Constant Field Values

process

protected AbstractProcess process

Constructor Detail

ScriptRunner

public ScriptRunner(NodeScript so,
            NodeEnvironment env,
            Sandbox sandbox,
            File scriptFile,
            String[] args)

ScriptRunner

public ScriptRunner(NodeScript so,
            NodeEnvironment env,
            Sandbox sandbox,
            String scriptName,
            String script,
            String[] args)

ScriptRunner

public ScriptRunner(NodeScript so,
            NodeEnvironment env,
            Sandbox sandbox,
            String[] args,
            boolean forceRepl)

Method Detail

close

public void close()

setFuture

public void setFuture(ScriptFuture future)

getFuture

public ScriptFuture getFuture()

getEnvironment

public NodeEnvironment getEnvironment()

Description copied from interface: NodeRuntime

Return the Environment used to create this script.

Specified by:

getEnvironment in interface NodeRuntime

getLoopTimestamp

public long getLoopTimestamp()

getRegistry

public AbstractModuleRegistry getRegistry()

setRegistry

public void setRegistry(AbstractModuleRegistry registry)

getSandbox

public Sandbox getSandbox()

Description copied from interface: NodeRuntime

Return the sandbox used to limit script execution, or null if none was set

Specified by:

getSandbox in interface NodeRuntime

getNetworkPolicy

public NetworkPolicy getNetworkPolicy()

Specified by:

getNetworkPolicy in interface GenericNodeRuntime

getScriptObject

public NodeScript getScriptObject()

Description copied from interface: NodeRuntime

Return the "NodeScript" used to create this script.

Specified by:

getScriptObject in interface NodeRuntime

getWorkingDirectory

public String getWorkingDirectory()

setWorkingDirectory

public void setWorkingDirectory(String wd)
                         throws IOException

Throws:

IOException

getScriptScope

public org.mozilla.javascript.Scriptable getScriptScope()

getNativeModule

public NativeModule.NativeImpl getNativeModule()

getSelector

public Selector getSelector()

Specified by:

getSelector in interface GenericNodeRuntime

getAsyncPool

public ExecutorService getAsyncPool()

This thread pool is a thread pool that has a fixed maximum size and a queue. It is intended to be used for tasks that would block the main thread, but that have a reasonable chance of completing in a timely fashion. For instance, filesystem operations, DNS requests, and certain TLS operations should operate in this pool. The thread pool is also configured with a "caller runs" error policy, which means that if the thread pool is full, operations will run in the main script thread. This will have the effect of slowing down the whole system so that the thread pool will start to catch up, and is preferable to the alternative of just throwing an unrecoverable error. But that means that any tasks that might run for an unreasonably long time, or never exit (like polling file) MUST NOT use this thread pool. In other words, this thread pool is for maintaining system performance.

Specified by:

getAsyncPool in interface GenericNodeRuntime

getUnboundedPool

public ExecutorService getUnboundedPool()

This thread pool is a "cached thread pool" with no maximum size, which means that any task submitted will run in its own thread until it completes. It is less efficient than the "async thread pool" because it does not queue anything. It should not be used for performance. However, any code that needs to allocate a long-running task, such as a file poller, must use this thread pool. We also use this thread pool to allocate a "main" thread for each script.

Specified by:

getUnboundedPool in interface GenericNodeRuntime

getFilesystem

public BasicFilesystem getFilesystem()

getStdin

public InputStream getStdin()

getStdout

public OutputStream getStdout()

getStderr

public OutputStream getStderr()

getParentProcess

public TriremeProcess getParentProcess()

getProcess

public AbstractProcess getProcess()

setParentProcess

public void setParentProcess(TriremeProcess parentProcess)

awaitInitialization

public void awaitInitialization()

We use this when spawning child scripts to avoid sending them messages before they are ready.

translatePath

public File translatePath(String path)

Translate a path based on the root.

Specified by:

translatePath in interface NodeRuntime

reverseTranslatePath

public String reverseTranslatePath(String path)
                            throws IOException

Description copied from interface: NodeRuntime

Given a file path, return what the path would be within the Node environment. This is used to convert native path names to path names that will work within the script. This uses the PathTranslator, if set. In other words, this is supposed to be the inverse of "translatePath."

Specified by:

reverseTranslatePath in interface NodeRuntime

Throws:

IOException

getPathTranslator

public PathTranslator getPathTranslator()

enqueueCallback

public void enqueueCallback(org.mozilla.javascript.Function f,
                   org.mozilla.javascript.Scriptable scope,
                   org.mozilla.javascript.Scriptable thisObj,
                   Object[] args)

This method uses a concurrent queue so it may be called from any thread.

Specified by:

enqueueCallback in interface NodeRuntime

Parameters:

f - Function to call

scope - the scope where the function should run

thisObj - the value of "this" where the function should run, or null

args - arguments for the function, or null

enqueueCallback

public void enqueueCallback(org.mozilla.javascript.Function f,
                   org.mozilla.javascript.Scriptable scope,
                   org.mozilla.javascript.Scriptable thisObj,
                   Object domain,
                   Object[] args)

This method uses a concurrent queue so it may be called from any thread.

Specified by:

enqueueCallback in interface NodeRuntime

Parameters:

f - Function to call

scope - the scope where the function should run

thisObj - the value of "this" where the function should run, or null

domain - the domain where this callback should run -- should set to the current domain

args - arguments for the function, or null

enqueueTask

public void enqueueTask(ScriptTask task)

This method uses a concurrent queue so it may be called from any thread.

Specified by:

enqueueTask in interface NodeRuntime

enqueueTask

public void enqueueTask(ScriptTask task,
               Object domain)

This method uses a concurrent queue so it may be called from any thread.

Specified by:

enqueueTask in interface NodeRuntime

executeScriptTask

public void executeScriptTask(Runnable r,
                     Object domain)

Specified by:

executeScriptTask in interface GenericNodeRuntime

executeCallback

public void executeCallback(org.mozilla.javascript.Context cx,
                   Object[] args,
                   org.mozilla.javascript.Function function,
                   org.mozilla.javascript.Scriptable thisObj)

Immediately execute the specified callback. This function wraps up the function to be called, because certain types of anonymous functions in Rhino can't be called by just calling "call".

enqueueIpc

public void enqueueIpc(org.mozilla.javascript.Context cx,
              Object message,
              TriremeProcess child)

This method is used by the "child_process" module when sending an IPC message between child processes in the same JVM.

Parameters:

message - A JavaScript object, String, or Buffer. We will make a copy to prevent confusion.

child - If null, deliver the message to the "process" object. Otherwise, deliver it to the specified child.

getDomain

public Object getDomain()

Specified by:

getDomain in interface GenericNodeRuntime

createTimer

public ScriptRunner.Activity createTimer(long delay,
                                boolean repeating,
                                long repeatInterval,
                                ScriptTask task,
                                org.mozilla.javascript.Scriptable scope)

This method puts the task directly on the timer queue, which is unsynchronized. If it is ever used outside the context of the "TimerWrap" module then we need to check for synchronization, add an assertion check, or synchronize the timer queue.

createTimedTask

public Future<Boolean> createTimedTask(Runnable r,
                              long delay,
                              TimeUnit unit,
                              boolean repeating,
                              Object domain)

This is a more generic way of creating a timer that can be used in the kernel, and which works even if we are not in the main thread.

Specified by:

createTimedTask in interface GenericNodeRuntime

pin

public void pin()

Specified by:

pin in interface GenericNodeRuntime

unPin

public void unPin()

Specified by:

unPin in interface GenericNodeRuntime

setErrno

public void setErrno(String err)

clearErrno

public void clearErrno()

getErrno

public Object getErrno()

registerCloseable

public void registerCloseable(Closeable c)

Specified by:

registerCloseable in interface GenericNodeRuntime

unregisterCloseable

public void unregisterCloseable(Closeable c)

Specified by:

unregisterCloseable in interface GenericNodeRuntime

call

public ScriptStatus call()
                  throws NodeException

Execute the script.

Specified by:

call in interface Callable<ScriptStatus>

Throws:

NodeException

runScript

protected ScriptStatus runScript(org.mozilla.javascript.Context cx)

executeTicks

public void executeTicks(org.mozilla.javascript.Context cx)
                  throws org.mozilla.javascript.RhinoException

Execute ticks as defined by process.nextTick() and anything put on the queue from Java code. Each one is timed separately, and error handling is done in here so that we fire other things in the loop (such as timers) in the event of an error.

Throws:

org.mozilla.javascript.RhinoException

initializeModule

public Object initializeModule(String modName,
                      AbstractModuleRegistry.ModuleType type,
                      org.mozilla.javascript.Context cx,
                      org.mozilla.javascript.Scriptable scope)
                        throws InvocationTargetException,
                               InstantiationException,
                               IllegalAccessException

Initialize a native module implemented in Java code.

Throws:

InvocationTargetException

InstantiationException

IllegalAccessException

require

public Object require(String modName,
             org.mozilla.javascript.Context cx)

This is used internally when one native module depends on another.

Specified by:

require in interface NodeRuntime

requireInternal

public Object requireInternal(String modName,
                     org.mozilla.javascript.Context cx)

isNativeModule

public boolean isNativeModule(String name)

This is where we load native modules.

getCachedModule

public NativeModule.ModuleImpl getCachedModule(String name)

Return a module that was created implicitly or by the "native module"

cacheModule

public void cacheModule(String name,
               NativeModule.ModuleImpl module)

getCachedInternalModule

public Object getCachedInternalModule(String name)

Return a module that is used internally and exposed by "process.binding".

cacheInternalModule

public void cacheInternalModule(String name,
                       Object module)