All Packages  This Package  Class Hierarchy  Class Search  Index

java.lang.Object
   |
   +----edu.utah.janos.nodeos.Flow

Summary

public final class  Flow
     extends java.lang.Object
{
          // Fields 10
     private final Vector channels;
     private final Credentials cred;
     FlowRun flowRun;
     FlowClassLoader loader;
     private final MemSpec memSpec;
     private String name;
     private Object obj;
     private final Flow parentFlow;
     final FlowState state;
     private final ThreadPool tPool;

          // Constructors 1
     Flow(Flow, Credentials, ThreadPoolSpec, MemSpec, FlowStartSpec);

          // Methods 17
     public static final Flow currentFlow();

     void addChannel(CutThroughChannel);
     void addChannel(InChannel);
     void addChannel(OutChannel);
     public void addClass(String, byte[]);
     public void addSystemPackage(String);
     public void allowPackage(String);
     public void destroy();
     public void enablePackageControls(boolean);
     public String getName();
     public Object getObject();
     public Class loadClass(String) throws ClassNotFoundException;
     public FlowHandle newFlow(Credentials, ThreadPoolSpec, MemSpec, FlowStartSpec, Runnable);
     public void setName(String);
     public void setObject(Object);
     public ThreadPool threadPool();
     public String toString();
}

Java wrapper for a flow. A flow is the closest approximation to a process in Janos.

XXX: A lot of this will have to change so that starting a Flow starts a new process (somehow).

Author:

Janos Ministry of Development

Cross Reference

Returned By:

FlowRegister.findFlow(), Flow.currentFlow(), ThreadPool.getFlow(), Thread.getFlow(), TestMain.getRootFlow()

   private final Credentials cred

The credentials provided when this Flow was created. This is the bucket from which the Flow gets to extract resources and access Node facilities.

   private final ThreadPool tPool

A ThreadPool to be used for Flow-specific actions, mostly just initialization and termination handling.

   private final MemSpec memSpec

The Memory limit for this flow.

   private final Vector channels

Channels created in this Flow. This list only exists so that the channels can be cleanly destroyed when the flow is terminated.

   private final Flow parentFlow

The parent flow of this flow. Used for handling termination requests.

XXX this is a cross-process pointer and must be treated specially.

   private Object obj

A per-flow Object that user code can set and get. (for associating things with the flow).

   FlowClassLoader loader

The Flow ClassLoader for this flow.

This object is allocated and initialized by the flow's run() method. Thus it isn't final.

See Also: run

   final FlowState state

Per-flow data.

   FlowRun flowRun

   private String name

Constructors

· Flow

Summary  |  Top

   Flow(Flow parent, 
        Credentials cred, 
        ThreadPoolSpec tPoolSpec, 
        MemSpec memSpec, 
        FlowStartSpec flowStartSpec) 

Initalize a new Flow. See newFlow().

XXX implicitly starts threads. Gak.

   public FlowHandle newFlow(Credentials cred, 
                             ThreadPoolSpec tPoolSpec, 
                             MemSpec memSpec, 
                             FlowStartSpec flowStartSpec, 
                             Runnable termHandler) 

Create a new Flow, which is a child of the current Flow.

This is the only interface for creating a Flow.

The termHandler will be invoked by a thread in the parent Flow's if the child Flow is terminated. This handler has a short limit for execution.

If termHandler is null, then no termination handler is called.

XXX Should be called "createFlow()" to sync back with NodeOS spec.

Parameter	Description
cred	The principal associated with this Flow
tPoolSpec	The specification for the new Flow's ThreadPool
memSpec	The memory limit for this flow
flowStartSpec	Class loading and startup information
termHandler	Termination handler invoked by the NodeOS when an immediate child flow is being terminated.

   public void destroy() 

   void addChannel(InChannel c) 

   void addChannel(OutChannel c) 

   void addChannel(CutThroughChannel c) 

   public Object getObject() 

   public void setObject(Object obj) 

   public ThreadPool threadPool() 

   public String toString() 

Overrides:

toString in class Object

   public void addClass(String name, 
                        byte[] bytecode) 

Add a new class to an existing flow.

   public void addSystemPackage(String name) 

Add a package to the list of "system" packages. System packages will be loaded by the system class loader. All other classes will be loaded by the per-flow classloader.

All sub-flows *share* the same definition of "system" packages for now. This is because only one EE System is loaded on the NodeOS. This will have to change.

Implicitly allows the package.

   public void allowPackage(String pkgPrefix) 

Allow access to a Java package. Must be invoked in the context of this flow.

addLocalPackage implicitly allows those packages, so addPackage need not be called on those packages.

Allowed packages that are not local are either dynamically loaded over the net, or are found locally.

   public void enablePackageControls(boolean doit) 

   public Class loadClass(String name)  throws ClassNotFoundException

   public static final Flow currentFlow() 

Get the current flow. The current Flow is the flow associated with the current Thread.

See Also: getFlow

   public void setName(String name) 

   public String getName() 

All Packages  This Package  Class Hierarchy  Class Search  Index