com.zfabrik.launch
Class ProcessRunner

java.lang.Object
  com.zfabrik.launch.ProcessRunner

public class ProcessRunner
extends java.lang.Object

This utility class is used to initialize a z2 core within another Java process. In other words this class allows to use z2 embedded.

This class can be used on its own and is provided with the jar library z_embedded.jar that can be found in the bin folder of a z2 home installation.

There are some important considerations and pre-requisites to run z2 embedded successfully:

1. The location of a z2 home installation must be set be either setting the system property com.zfabrik.home or by specifying an environment property Z2_HOME pointing to a z2 home installation. This is required so that the root repository information (in Z2_HOME/run/bin/runtime.properties) local repository caches (in Z2_HOME/work) as well as the core implementation (in in Z2_HOME/run/bin/z.jar) can be found. The system property takes precedence over the environment variable.
2. The Java process using this class MUST NOT have the core APIs on its class path without the core implementation, as core API classes need to be able to load core implementation classes. This may happen when using the eclipsoid tool in eclipse and hence embedding Java applications should not be developed using that tool. So either use the library z_embedded.jar or the complete core implementation in z.jar on the classpath.
3. Many control flows in z2 require a WorkUnit on the current thread. In order to execute code safely within the z2 environment, encapsulate it as a Runnable or a Callable and use the work methods below.

In order to lookup z2 hosted components without having the core implementation on the class path, the Resource Management JNDI provider may be used. A typical invocation of an embedded z2 environment looks like this:

 public static void main(String[] args) throws Exception {
        ProcessRunner.start();
        ProcessRunner.work(new Callable() {
                public Void call() throws Exception {
                        ((Runnable) new InitialContext().lookup("components:<my component>?type="+Runnable.class.getName())).run();
                        return null;
                }
        });
        ProcessRunner.stop();
 }
 

Process running is cumulative. Repeated start/stop calls will be counted and only the outer calls are really effectiv.

Author:

hb

Field Summary

static java.lang.String	COM_ZFABRIK_HOME
static java.lang.String	Z2_HOME

Method Summary

static void	beginWork() Begin a unit of work.
static void	closeWork() End a unit of work.
boolean	isRunning() check if the process is already initialized
static void	setRollBackOnly() Flag a unit of work as rollback only.
static void	start() Initialize the z2 environment in this process.
static void	stop() stop the z2 environment in this process.
static <T> T	work(java.util.concurrent.Callable<T> c) Tasks in z2 generally require an association with a work unit (an abstract transaction).
static void	work(java.lang.Runnable r) Tasks in z2 generally require an association with a work unit (an abstract transaction).

Methods inherited from class java.lang.Object

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

Field Detail

Z2_HOME

public static final java.lang.String Z2_HOME

See Also:

Constant Field Values

COM_ZFABRIK_HOME

public static final java.lang.String COM_ZFABRIK_HOME

See Also:

Constant Field Values

Method Detail

start

public static void start()

Initialize the z2 environment in this process. Repeated calls will be ignored.

work

public static void work(java.lang.Runnable r)

Tasks in z2 generally require an association with a work unit (an abstract transaction). In order to execute code safely within the z2 environment, encapsulate it as a Runnable or a Callable and use the work(java.lang.Runnable) methods.

work

public static <T> T work(java.util.concurrent.Callable<T> c)

Tasks in z2 generally require an association with a work unit (an abstract transaction). In order to execute code safely within the z2 environment, encapsulate it as a Runnable or a Callable and use the work(java.lang.Runnable) methods.

beginWork

public static void beginWork()

Begin a unit of work. Make your to close the unit of work again. Better use the work methods, unless you are really required to spread begin and end of a unit of work to different points in the control flow.

closeWork

public static void closeWork()

End a unit of work. Better use the work methods, unless you are really required to spread begin and end of a unit of work to different points in the control flow.

setRollBackOnly

public static void setRollBackOnly()

Flag a unit of work as rollback only. I.e. the work will not be committed at the close of the unit of work but rather rolled back (if there is any).

isRunning

public boolean isRunning()

check if the process is already initialized

stop

public static void stop()

stop the z2 environment in this process.