io.apigee.trireme.core.modules

Class HTTPWrap

java.lang.Object

io.apigee.trireme.core.modules.HTTPWrap

All Implemented Interfaces:

InternalNodeModule, NodeModule

public class HTTPWrap
extends Object
implements InternalNodeModule

This is a special module that wraps the generic HTTP adapter so that it may be accessed from JavaScript modules. It's the glue between the various HTTP adapters and the runtime.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	HTTPWrap.HttpImpl This is the top-level module object, aka "exports" for this module.
static class	HTTPWrap.RequestAdapter This object is used by the "ServerRequest" object in the "adaptorhttp" module to interface with the Java runtime and with the HTTP adapter.
static class	HTTPWrap.ResponseAdapter This is a JavaScript object passed to the "adaptorhttp" module for each request.
static class	HTTPWrap.ServerContainer This implements the stub that the HTTP implementation will call into to notify us of new messages and data.

Field Summary

Fields

Modifier and Type	Field and Description
protected static org.slf4j.Logger	log

Constructor Summary

Constructors

Constructor and Description
HTTPWrap()

Method Summary

Methods

Modifier and Type	Method and Description
String	getModuleName() Return the top-level name of the module as it'd be looked up in a "require" call.
org.mozilla.javascript.Scriptable	registerExports(org.mozilla.javascript.Context cx, org.mozilla.javascript.Scriptable scope, NodeRuntime runner) This is the Java equivalent of a Node module.

Methods inherited from class java.lang.Object

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

Field Detail

log

protected static final org.slf4j.Logger log

Constructor Detail

HTTPWrap

public HTTPWrap()

Method Detail

getModuleName

public String getModuleName()

Description copied from interface: NodeModule

Return the top-level name of the module as it'd be looked up in a "require" call.

Specified by:

getModuleName in interface NodeModule

registerExports

public org.mozilla.javascript.Scriptable registerExports(org.mozilla.javascript.Context cx,
                                                org.mozilla.javascript.Scriptable scope,
                                                NodeRuntime runner)
                                                  throws InvocationTargetException,
                                                         IllegalAccessException,
                                                         InstantiationException

Description copied from interface: NodeModule

This is the Java equivalent of a Node module. In here, you can set properties on "exports" just as you would set properties on "exports" in a regular Node module. You may also declare any classes using ScriptableObject.defineClass -- by defining them on the "exports" object you may make them private to your module. You may also access and define global properties using "scope." Declare any classes that this module needs, and set any other variables on the exports.

The module must create a Scriptable object using the supplied context, then set any "exports" properties on this object and return it.

For example, a module that in JavaScript would assign several functions to "exports" would create a Scriptable object using "scope" as the parent scope, and then set the various functions as properties.

Specified by:

registerExports in interface NodeModule

Parameters:

cx - The Rhino context for the current script and thread

scope - The global scope for the script

runner - an object that may be used to interact with the script runtime

Returns:

the "exports" for the specified module, which may be empty but must not be null

Throws:

InvocationTargetException

IllegalAccessException

InstantiationException