io.apigee.trireme.core.internal

Class AbstractModuleRegistry

java.lang.Object

io.apigee.trireme.core.internal.AbstractModuleRegistry

Direct Known Subclasses:

ChildModuleRegistry, RootModuleRegistry

public abstract class AbstractModuleRegistry
extends Object

This tracks all the built-in modules that are available to us. There are three types of modules:

1. Native modules are built in Java. They are loaded using the ServiceLoader, which means that these modules must implement NodeModule and must be listed in META-INF/services/c.a.n.r.NodeModule.
2. Compiled native modules are built in JavaScript. A Java stub that uses ServiceLoader and implements NodeScriptModule is used to pull in the JavaScript source, which is then compiled and loaded.
3. Internal native modules are also built in Java and are also loaded using the ServiceLoader. However they are loaded using process.binding, not "require" and are intended for internal use only. This way they aren't in the namespace for ordinary users. They implement InternalNodeModule.
4. Internal script modules are written in JavaScript -- their source lives in src/main/javascript and is pre-compiled using Rhino (we have a plugin for this). They are then loaded directly by this class. These modules may only reside within this Maven module.

There are two types of registries -- the root registry loads classes from the classloader that was used to load Trireme, and there is one in the environment for each node implementation. It is used for all the built-in modules for each version of Node.

A child registry can be used to load new classes (specifically for script-specific native classes loaded using the "trireme-support" module) and delegates to the rest.

The constructor for this class manually defines all compiled script modules. All the rest are loaded using the ServiceLoader, which means that new modules can add new scripts.

This registry is loaded based on a NodeImplementation, which means that there can be many if there are a lot of versions of Node available.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AbstractModuleRegistry.ModuleType

Constructor Summary

Constructors

Constructor and Description
AbstractModuleRegistry()

Method Summary

Methods

Modifier and Type	Method and Description
protected void	addNativeModule(NodeModule mod)
abstract NodeModule	get(String name) Get a "regular" module, loadable via "require".
abstract org.mozilla.javascript.Script	getCompiledModule(String name) Get a pre-compiled script, loaded via NodeScriptModule.
abstract Set<String>	getCompiledModuleNames()
abstract NodeImplementation	getImplementation()
abstract NodeModule	getInternal(String name) Get an "internal" module, loadable via "process.binding".
abstract org.mozilla.javascript.Script	getMainScript()
abstract NodeModule	getNative(String name) Get a "native" module -- a replacement for native code, loadable via "dlopen".
void	load(org.mozilla.javascript.Context cx, ClassLoader cl) Load modules from the classloader and store them in this registry.
abstract void	loadRoot(org.mozilla.javascript.Context cx) To be called once per script invocation, at startup.
protected abstract void	putCompiledModule(String name, org.mozilla.javascript.Script script)
protected abstract void	putInternalModule(String name, InternalNodeModule mod)
protected abstract void	putNativeModule(String name, NativeNodeModule mod)
protected abstract void	putRegularModule(String name, NodeModule mod)

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractModuleRegistry

public AbstractModuleRegistry()

Method Detail

getImplementation

public abstract NodeImplementation getImplementation()

loadRoot

public abstract void loadRoot(org.mozilla.javascript.Context cx)

To be called once per script invocation, at startup. Triggers one-time-only lazy initialization of the root module registry.

get

public abstract NodeModule get(String name)

Get a "regular" module, loadable via "require".

getInternal

public abstract NodeModule getInternal(String name)

Get an "internal" module, loadable via "process.binding".

getNative

public abstract NodeModule getNative(String name)

Get a "native" module -- a replacement for native code, loadable via "dlopen".

getCompiledModule

public abstract org.mozilla.javascript.Script getCompiledModule(String name)

Get a pre-compiled script, loaded via NodeScriptModule.

getCompiledModuleNames

public abstract Set<String> getCompiledModuleNames()

getMainScript

public abstract org.mozilla.javascript.Script getMainScript()

putCompiledModule

protected abstract void putCompiledModule(String name,
                     org.mozilla.javascript.Script script)

putInternalModule

protected abstract void putInternalModule(String name,
                     InternalNodeModule mod)

putNativeModule

protected abstract void putNativeModule(String name,
                   NativeNodeModule mod)

putRegularModule

protected abstract void putRegularModule(String name,
                    NodeModule mod)

load

public void load(org.mozilla.javascript.Context cx,
        ClassLoader cl)

Load modules from the classloader and store them in this registry. Modules to be loaded include any implementation that the java.util.ServiceLoader returns for:

• NativeNodeModule: for "native" modules
• InternalNodeModule: "internal" modules
• NodeModule: All other Java-based modules
• NodeScriptModule: A list of scripts that we should pre-compile

addNativeModule

protected void addNativeModule(NodeModule mod)