Package org.apache.river.start

Provides the utilities and APIs used to launch the contributed services provided in the River-Internet release.

See: Description

Interface Summary

Interface	Description
LifeCycle	The interface used to manage the lifecycle of shared, non-activatable services started by the service starter.
ServiceDescriptor	Interface that all service description objects must implement.
SharedGroup	The service starter supported interface for shared group objects.
SharedGroupBackEnd	The SharedGroupBackEnd interface

Class Summary

Class	Description
ActivateWrapper	A wrapper for activatable objects, providing separation of the import codebase (where the server classes are loaded from by the activation group) from the export codebase (where clients should load classes from for stubs, etc.) as well as providing an independent security policy file for each activatable object.
ActivateWrapper.ActivateDesc	Descriptor for registering a "wrapped" activatable object.
AggregatePolicyProvider	Security policy provider which supports associating security sub-policies with context class loaders.
ClassLoaderUtil	This class provides useful utilities for creating and manipulating class loaders.
DestroySharedGroup	This class contains the command-line interface for destroying an instance of a shared activation group.
HTTPDStatus	Class which can be used to print a descriptive warning message if a codebase accessibility problem is found.
LoaderSplitPolicyProvider	Security policy provider which handles permission queries and grants by delegating to different policy providers depending on the class loader involved.
NonActivatableServiceDescriptor	Class used to launch shared, non-activatable, in-process services.
NonActivatableServiceDescriptor.Created	Object returned by NonActivatableServiceDescriptor.create() method that returns the proxy and implementation references for the created service.
ServiceStarter	This class provides the main routine for starting shared groups, non-activatable services, and activatable services.
SharedActivatableServiceDescriptor	Class used to launch shared, activatable services.
SharedActivatableServiceDescriptor.Created	Object returned by SharedActivatableServiceDescriptor.create() method that returns the associated proxy, activation group identifier, and activation identifier for the created service.
SharedActivationGroupDescriptor	Class used to create a shared activation group.
SharedActivationPolicyPermission	Permission class used by the service starter package.
SharedGroupImpl	The provided implementation of the SharedGroup service.

Package org.apache.river.start Description

Provides the utilities and APIs used to launch the contributed services provided in the River-Internet release.

This document covers the following service starter topics:

• Operation Modes
• Running the Service Starter
• Examples for Running Contributed Services

Operation Modes

The service starter package supports starting the contributed services in the following modes:

Shared, Activatable

Allows multiple servers to be started in the same activation system group, while still maintaining per-server classpath, codebase, and security policy separation. That is, servers run as independently as possible, while still sharing a single virtual machine for the Java(TM) platform (VM) environment.

Shared activatable services are created via SharedActivatableServiceDescriptor entries in service starter's configuration.

Shared, Non-Activatable

Allows multiple servers to be started in the same VM, while still maintaining per-server classpath, codebase, and security policy separation. That is, servers run as independently as possible, while still sharing a single VM environment.

Shared non-activatable services are created via NonActivatableServiceDescriptor entries in service starter's configuration.

Resource conservation is the main reason for running multiple servers per VM. In particular, the memory footprint of a "shared" VM can be significantly smaller than the combined memory footprints of the same servers running in individual VMs.

Running the Service Starter

The Service Starter uses the following command line structure to start one or more services:

% java java_options
       -jar install_dir/lib/start.jar
       config_options

where java_options includes such things as the security policy file and security manager, install_dir is the directory where the River-Internet release is installed, and config_options includes any Configuration provider options.

Note: More information on the java command can be found for: Solaris, Linux, and Windows.

The command line, above, will invoke ServiceStarter.main(), which obtains a ServiceDescriptor[] from its Configuration (via the org.apache.river.start.serviceDescriptors entry) and invokes create() on each array element. The three provided implementations of ServiceDescriptor are:

NonActivatableServiceDescriptor

Used to create a server for in-process execution. That is, the server will run in a shared, non-activatable mode within the invoking VM.

SharedActivationGroupDescriptor

Used to create an activation system group (or VM), which can then be used to host shared, activatable servers. Group identification information is stored in a directory specified by the log argument to SharedActivationGroupDescriptor's constructor. This log directory can then be specified as the sharedGroupLog argument in SharedActivatableServiceDescriptor's constructor in order to associate the server with a particular activation system group.

Note:A SharedActivationGroupDescriptor entry (and it's associated log information) must be created before it can be referenced by subsequent SharedActivatableServiceDescriptor entries.

SharedActivatableServiceDescriptor

Used to create a server for shared, activation execution. That is, the service will be hosted in an activation system group identified by the sharedGroupLog constructor argument.

The Service Starter uses the following command line structure to destroy one or more shared groups:

% java java_options
       -jar install_dir/lib/destroy.jar
       config_options

The command line, above, will invoke DestroySharedGroup.main(), which obtains a ServiceDescriptor[] from its Configuration (via the org.apache.river.start.serviceDestructors entry) and invokes create() on each array element. All the array elements are assumed to be SharedActivatableServiceDescriptors that are configured to run SharedGroup implementations (see provided implementation: SharedGroupImpl). Once created, each element's destroyVM() method will be invoked and its associated group log will be deleted.

Notes: Group destruction:

1. unregisters the group and any registered server objects with the activation system (so the group and servers aren't restarted)
2. deletes the associated group log and
3. exits the associated VM.

It does not individually destroy any of the servers associated with the group being destroyed. Users need to explicity destroy the individual servers prior to destroying the group, if desired. This can be done for the provided services by invoking the DestroyAdmin.destroy() method on the server's Administrable object (obtained by invoking Administrable.getAdmin() on the service proxy).

Examples for Running Contributed Services

This section provides examples of running the contributed services in various configurations.

• Assumptions for running the examples
• Shared, non-activatable, transient configurations
• Shared, non-activatable, persistent configurations
• Shared, activatable, persistent configurations
• Stopping activatable configurations

Assumptions for Running the Examples

The examples below make the following assumptions:

• The Java(TM) 2 Platform, Standard Edition, (J2SE(TM)) has been installed, and its commands are available in the current path
• The River-Internet release has been installed in the install_dir directory
• The example configuration and policy files described below are available in the config_dir directory
• The local host name is your_host
• The local lookup group name is your.group
• The HTTP server for download JAR files is running on your_host and is available on port http_port. This HTTP server is serving files located in the install_dir/lib-dl directory. The ClassServer class is used for this purpose in the following examples.
• The examples are being run on UNIX platforms
• The examples are being run on a secure network where access control and authentication are not needed. See the hello example for some client and service configurations that enforce security.
• For activatable services, an activation system is running on your_host. You can use the org.apache.river.phoenix implementation for this purpose.

Throughout the examples, items in bold need to be customized for your local environment.

Shared, non-activatable, transient configurations

To run transient versions of the contributed services, which do not store any information persistently or use the activation system to restart itself, using Jini extensible remote invocation (Jini ERI) for remote communication, run the following command:

java -Djava.security.policy=config_dir/jsk-all.policy \
     -jar install_dir/lib/start.jar \
     config_dir/start-transient-jeri-services.config

This configuration uses the following files.

File config_dir/jsk-all.policy

Use this security policy file for starting and running all service configurations. This file grants all permissions to local code included in the lib subdirectory of the River-Internet release installation.

grant codebase "file:install_dir/lib/*" {
    permission java.security.AllPermission;
};

File config_dir/start-transient-jeri-services.config

Use this configuration source file to start transient versions of all the provided services using Jini ERI in the VM started by the command line above.

import org.apache.river.start.NonActivatableServiceDescriptor;
import org.apache.river.start.ServiceDescriptor;

org.apache.river.start {

    //
    // HTTPD Service
    //
    private static httpd_codebase = "";
    private static httpd_policy = "config_dir/jsk-all.policy";
    private static httpd_classpath = "install_dir/lib/classserver.jar";
    private static httpd_impl = "org.apache.river.tool.ClassServer";
    private static httpd_service = 
        new NonActivatableServiceDescriptor(
            httpd_codebase, httpd_policy, httpd_classpath, httpd_impl,
            new String[]{"-port", "8080", "-dir", "install_dir/lib-dl", "-verbose"});
           
    //     
    // Fiddler (Lookup Discovery Service)
    //
    private static fiddler_codebase = "http://your_host:http_port/fiddler-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static fiddler_policy = "config_dir/jsk-all.policy";
    private static fiddler_classpath = "install_dir/lib/fiddler.jar";
    private static fiddler_config = "config_dir/transient-fiddler.config";
    private static fiddler_impl = "org.apache.river.fiddler.TransientFiddlerImpl";
    private static fiddler_service = 
        new NonActivatableServiceDescriptor(
            fiddler_codebase, fiddler_policy, fiddler_classpath, 
            fiddler_impl, new String[] { fiddler_config });
            
    //     
    // Mahalo (Transaction Service)
    //
    private static mahalo_codebase = "http://your_host:http_port/mahalo-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static mahalo_policy = "config_dir/jsk-all.policy";
    private static mahalo_classpath = "install_dir/lib/mahalo.jar";
    private static mahalo_config = "config_dir/transient-mahalo.config";
    private static mahalo_impl = "org.apache.river.mahalo.TransientMahaloImpl";
    private static mahalo_service = 
        new NonActivatableServiceDescriptor(
            mahalo_codebase, mahalo_policy, mahalo_classpath, 
            mahalo_impl, new String[] { mahalo_config });
            
    //     
    // Mercury (Event Mailbox Service)
    //
    private static mercury_codebase = "http://your_host:http_port/mercury-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static mercury_policy = "config_dir/jsk-all.policy";
    private static mercury_classpath = "install_dir/lib/mercury.jar";
    private static mercury_config = "config_dir/transient-mercury.config";
    private static mercury_impl = "org.apache.river.mercury.TransientMercuryImpl";
    private static mercury_service = 
        new NonActivatableServiceDescriptor(
            mercury_codebase, mercury_policy, mercury_classpath, 
            mercury_impl, new String[] { mercury_config });

    //     
    // Norm (Lease Renewal Service)
    //
    private static norm_codebase = "http://your_host:http_port/norm-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static norm_policy = "config_dir/jsk-all.policy";
    private static norm_classpath = "install_dir/lib/norm.jar";
    private static norm_config = "config_dir/transient-norm.config";
    private static norm_impl = "org.apache.river.norm.TransientNormServerImpl";
    private static norm_service = 
        new NonActivatableServiceDescriptor(
            norm_codebase, norm_policy, norm_classpath, 
            norm_impl, new String[] { norm_config });

    //     
    // Outrigger (JavaSpaces Service)
    //
    private static outrigger_codebase = "http://your_host:http_port/outrigger-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static outrigger_policy = "config_dir/jsk-all.policy";
    private static outrigger_classpath = "install_dir/lib/outrigger.jar";
    private static outrigger_config = "config_dir/transient-outrigger.config";
    private static outrigger_impl = "org.apache.river.outrigger.TransientOutriggerImpl";
    private static outrigger_service = 
        new NonActivatableServiceDescriptor(
            outrigger_codebase, outrigger_policy, outrigger_classpath, 
            outrigger_impl, new String[] { outrigger_config });

    //     
    // Reggie (Lookup Service)
    //
    private static reggie_codebase = "http://your_host:http_port/reggie-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static reggie_policy = "config_dir/jsk-all.policy";
    private static reggie_classpath = "install_dir/lib/reggie.jar";
    private static reggie_config = "config_dir/transient-reggie.config";
    private static reggie_impl = "org.apache.river.reggie.TransientRegistrarImpl";
    private static reggie_service = 
        new NonActivatableServiceDescriptor(
            reggie_codebase, reggie_policy, reggie_classpath, 
            reggie_impl, new String[] { reggie_config });

    static serviceDescriptors = new ServiceDescriptor[] {
        httpd_service,
        fiddler_service,
        mahalo_service,
        mercury_service,
        norm_service,
        outrigger_service,
        reggie_service
    };
}

File config_dir/transient-fiddler.config

Use this configuration source file to run a transient Fiddler using Jini ERI.

org.apache.river.fiddler {
    initialLookupGroups = new String[] { "your.group" };
}

File config_dir/transient-mahalo.config

Use this configuration source file to run a transient Mahalo using the Jini ERI protocol.

org.apache.river.mahalo {
    initialLookupGroups = new String[] { "your.group" };
}

File config_dir/transient-mercury.config

Use this configuration source file to run a transient Mercury using Jini ERI.

org.apache.river.mercury {
    initialLookupGroups = new String[] { "your.group" };
}

File config_dir/transient-norm.config

Use this configuration source file to run a transient Norm using Jini ERI.

org.apache.river.norm {
    initialLookupGroups = new String[] { "your.group" };
}

File config_dir/transient-outrigger.config

Use this configuration source file to run a transient Outrigger using Jini ERI.

org.apache.river.outrigger {
    initialLookupGroups = new String[] { "your.group" };
}

File config_dir/transient-reggie.config

Use this configuration source file to a run transient Reggie using Jini ERI.

org.apache.river.reggie {
    initialMemberGroups = new String[] { "your.group" };
}

Shared, non-activatable, persistent configurations

To run persistent versions of the contributed services, which do not use the activation system to restart themselves and which use Jini ERI, run the following command:

java -Djava.security.policy=config_dir/jsk-all.policy \
     -jar install_dir/lib/start.jar \
     config_dir/start-persistent-jeri-services.config

This configuration uses the following files:

File config_dir/start-persistent-jeri-services.config

Use this configuration source file to start persistent services using Jini ERI.

import org.apache.river.start.NonActivatableServiceDescriptor;
import org.apache.river.start.ServiceDescriptor;

org.apache.river.start {

    //
    // HTTPD Service
    //
    private static httpd_codebase = "";
    private static httpd_policy = "config_dir/jsk-all.policy";
    private static httpd_classpath = "install_dir/lib/classserver.jar";
    private static httpd_impl = "org.apache.river.tool.ClassServer";
    private static httpd_service = 
        new NonActivatableServiceDescriptor(
            httpd_codebase, httpd_policy, httpd_classpath, httpd_impl, 
            new String[]{"-port", "8080", "-dir", "install_dir/lib-dl", "-verbose"});
           
    //     
    // Fiddler (Lookup Discovery Service)
    //
    private static fiddler_codebase = "http://your_host:http_port/fiddler-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static fiddler_policy = "config_dir/jsk-all.policy";
    private static fiddler_classpath = "install_dir/lib/fiddler.jar";
    private static fiddler_config = "config_dir/persistent-fiddler.config";
    private static fiddler_impl = "org.apache.river.fiddler.NonActivatableFiddlerImpl";
    private static fiddler_service = 
        new NonActivatableServiceDescriptor(
            fiddler_codebase, fiddler_policy, fiddler_classpath, 
            fiddler_impl, new String[] { fiddler_config });
            
    //     
    // Mahalo (Transaction Service)
    //
    private static mahalo_codebase = "http://your_host:http_port/mahalo-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static mahalo_policy = "config_dir/jsk-all.policy";
    private static mahalo_classpath = "install_dir/lib/mahalo.jar";
    private static mahalo_config = "config_dir/persistent-mahalo.config";
    private static mahalo_impl = "org.apache.river.mahalo.NonActivatableMahaloImpl";
    private static mahalo_service = 
        new NonActivatableServiceDescriptor(
            mahalo_codebase, mahalo_policy, mahalo_classpath, 
            mahalo_impl, new String[] { mahalo_config });
            
    //     
    // Mercury (Event Mailbox Service)
    //
    private static mercury_codebase = "http://your_host:http_port/mercury-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static mercury_policy = "config_dir/jsk-all.policy";
    private static mercury_classpath = "install_dir/lib/mercury.jar";
    private static mercury_config = "config_dir/persistent-mercury.config";
    private static mercury_impl = "org.apache.river.mercury.NonActivatableMercuryImpl";
    private static mercury_service = 
        new NonActivatableServiceDescriptor(
            mercury_codebase, mercury_policy, mercury_classpath, 
            mercury_impl, new String[] { mercury_config });

    //     
    // Norm (Lease Renewal Service)
    //
    private static norm_codebase = "http://your_host:http_port/norm-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static norm_policy = "config_dir/jsk-all.policy";
    private static norm_classpath = "install_dir/lib/norm.jar";
    private static norm_config = "config_dir/persistent-norm.config";
    private static norm_impl = "org.apache.river.norm.PersistentNormServerImpl";
    private static norm_service = 
        new NonActivatableServiceDescriptor(
            norm_codebase, norm_policy, norm_classpath, 
            norm_impl, new String[] { norm_config });

    //     
    // Outrigger (JavaSpaces Service)
    //
    private static outrigger_codebase = "http://your_host:http_port/outrigger-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static outrigger_policy = "config_dir/jsk-all.policy";
    private static outrigger_classpath = "install_dir/lib/outrigger.jar";
    private static outrigger_config = "config_dir/persistent-outrigger.config";
    private static outrigger_impl = "org.apache.river.outrigger.PersistentOutriggerImpl";
    private static outrigger_service = 
        new NonActivatableServiceDescriptor(
            outrigger_codebase, outrigger_policy, outrigger_classpath, 
            outrigger_impl, new String[] { outrigger_config });

    //     
    // Reggie (Lookup Service)
    //
    private static reggie_codebase = "http://your_host:http_port/reggie-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static reggie_policy = "config_dir/jsk-all.policy";
    private static reggie_classpath = "install_dir/lib/reggie.jar";
    private static reggie_config = "config_dir/persistent-reggie.config";
    private static reggie_impl = "org.apache.river.reggie.PersistentRegistrarImpl";
    private static reggie_service = 
        new NonActivatableServiceDescriptor(
            reggie_codebase, reggie_policy, reggie_classpath, 
            reggie_impl, new String[] { reggie_config });

    static serviceDescriptors = new ServiceDescriptor[] {
        httpd_service,
        fiddler_service,
        mahalo_service,
        mercury_service,
        norm_service,
        outrigger_service,
        reggie_service
    };
}

File config_dir/persistent-fiddler.config

Use this configuration source file to run a persistent Fiddler using Jini ERI.

import net.jini.id.UuidFactory;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;

org.apache.river.fiddler {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/persistent-fiddler.log";
    serverExporter = 
        new BasicJeriExporter(
            TcpServerEndpoint.getInstance(fiddler_obj_port),
            new BasicILFactory(),
            false, 
            true,
            UuidFactory.create("fiddler_obj_UUID_string"));
}

File config_dir/persistent-mahalo.config

Use this configuration source file to run a persistent Mahalo using Jini ERI.

import net.jini.id.UuidFactory;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;

org.apache.river.mahalo {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/persistent-mahalo.log";
    serverExporter = 
        new BasicJeriExporter(
            TcpServerEndpoint.getInstance(mahalo_obj_port),
            new BasicILFactory(),
            false, 
            true,
            UuidFactory.create("mahalo_obj_UUID_string"));
}

File config_dir/persistent-mercury.config

Use this configuration source file to run a persistent Mercury using Jini ERI.

import net.jini.id.UuidFactory;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;

org.apache.river.mercury {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/persistent-mercury.log";
    serverExporter = 
        new BasicJeriExporter(
            TcpServerEndpoint.getInstance(mercury_obj_port),
            new BasicILFactory(),
            false, 
            true,
            UuidFactory.create("mercury_obj_UUID_string"));
}

File config_dir/persistent-norm.config

Use this configuration source file to run a persistent Norm using Jini ERI.

import net.jini.id.UuidFactory;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;

org.apache.river.norm {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/persistent-norm.log";
    serverExporter = 
        new BasicJeriExporter(
            TcpServerEndpoint.getInstance(norm_obj_port),
            new BasicILFactory(),
            false, 
            true,
            UuidFactory.create("norm_obj_UUID_string"));
}

File config_dir/persistent-outrigger.config

Use this configuration source file to run a persistent Outrigger using Jini ERI.

import net.jini.id.UuidFactory;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;

org.apache.river.outrigger {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/persistent-outrigger.log";
    serverExporter = 
        new BasicJeriExporter(
            TcpServerEndpoint.getInstance(outrigger_obj_port),
            new BasicILFactory(),
            false, 
            true,
            UuidFactory.create("outrigger_obj_UUID_string"));
    store = new org.apache.river.outrigger.snaplogstore.LogStore(this);
}

File config_dir/persistent-reggie.config

Use this configuration source file to run a persistent Reggie using Jini ERI.

import net.jini.id.UuidFactory;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;

org.apache.river.reggie {
    initialMemberGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/persistent-reggie.log";
    serverExporter = 
        new BasicJeriExporter(
            TcpServerEndpoint.getInstance(reggie_obj_port),
            new BasicILFactory(),
            false, 
            true,
            UuidFactory.create("reggie_obj_UUID_string"));
}

The *obj_port variables are the fixed TCP ports used to listen for server requests. The *obj_UUID_string variables are the universally unique IDs for the exported servers. These IDs have the form: "01234567-01ab-cdef-0123-456789abcdef".

Remember to remove the config_dir/*.log directories before restarting persistent services if you don't want to keep the registrations and settings made by previous service invocations.

Shared, activatable, persistent configurations

To run persistent, activatable versions of the contributed services, which use the activation system to restart themselves, using Jini ERI for remote communication, run the following command:

java -Djava.security.policy=config_dir/jsk-all.policy \
     -jar install_dir/lib/start.jar \
     config_dir/start-activatable-jeri-services.config

This configuration uses the following files:

File config_dir/start-activatable-jeri-services.config

Use this configuration source file to start persistent services using Jini ERI.

import org.apache.river.start.NonActivatableServiceDescriptor;
import org.apache.river.start.ServiceDescriptor;
import org.apache.river.start.SharedActivatableServiceDescriptor;
import org.apache.river.start.SharedActivationGroupDescriptor;

org.apache.river.start {

    //
    // HTTPD Service
    //
    private static httpd_codebase = "";
    private static httpd_policy = "config_dir/jsk-all.policy";
    private static httpd_classpath = "install_dir/lib/classserver.jar";
    private static httpd_impl = "org.apache.river.tool.ClassServer";
    private static httpd_service = 
        new NonActivatableServiceDescriptor(
            httpd_codebase, httpd_policy, httpd_classpath,
            httpd_impl,
            new String[]{"-port", "8080", "-dir", "install_dir/lib-dl", "-verbose"});
           
    //
    // Shared Group Environment
    //
    private static sharedVM_policy = "config_dir/jsk-all.policy";
    private static sharedVM_classpath  = "install_dir/lib/sharedvm.jar";
    private static sharedVM_log = "config_dir/sharedvm.log";
    private static sharedVM_command = null;
    private static sharedVM_options = null;
    private static sharedVM_properties = null;
    private static sharedVM =
        new SharedActivationGroupDescriptor(
            sharedVM_policy,
            sharedVM_classpath,
            sharedVM_log,
            sharedVM_command,
            sharedVM_options,
            sharedVM_properties);
            
    //     
    // Fiddler (Lookup Discovery Service)
    //
    private static fiddler_codebase = "http://your_host:http_port/fiddler-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static fiddler_policy = "config_dir/jsk-all.policy";
    private static fiddler_classpath = "install_dir/lib/fiddler.jar";
    private static fiddler_config = "config_dir/activatable-fiddler.config";
    private static fiddler_impl = "org.apache.river.fiddler.ActivatableFiddlerImpl";
    private static fiddler_service = 
        new SharedActivatableServiceDescriptor(
            fiddler_codebase, fiddler_policy, fiddler_classpath, 
            fiddler_impl, sharedVM_log, new String[] { fiddler_config },
            true);
            
    //     
    // Mahalo (Transaction Service)
    //
    private static mahalo_codebase = "http://your_host:http_port/mahalo-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static mahalo_policy = "config_dir/jsk-all.policy";
    private static mahalo_classpath = "install_dir/lib/mahalo.jar";
    private static mahalo_config = "config_dir/activatable-mahalo.config";
    private static mahalo_impl = "org.apache.river.mahalo.ActivatableMahaloImpl";
    private static mahalo_service = 
        new SharedActivatableServiceDescriptor(
            mahalo_codebase, mahalo_policy, mahalo_classpath, 
            mahalo_impl, sharedVM_log, new String[] { mahalo_config },
            true);
            
    //     
    // Mercury (Event Mailbox Service)
    //
    private static mercury_codebase = "http://your_host:http_port/mercury-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static mercury_policy = "config_dir/jsk-all.policy";
    private static mercury_classpath = "install_dir/lib/mercury.jar";
    private static mercury_config = "config_dir/activatable-mercury.config";
    private static mercury_impl = "org.apache.river.mercury.ActivatableMercuryImpl";
    private static mercury_service = 
        new SharedActivatableServiceDescriptor(
            mercury_codebase, mercury_policy, mercury_classpath, 
            mercury_impl, sharedVM_log, new String[] { mercury_config },
            true);

    //     
    // Norm (Lease Renewal Service)
    //
    private static norm_codebase = "http://your_host:http_port/norm-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static norm_policy = "config_dir/jsk-all.policy";
    private static norm_classpath = "install_dir/lib/norm.jar";
    private static norm_config = "config_dir/activatable-norm.config";
    private static norm_impl = "org.apache.river.norm.ActivatableNormServerImpl";
    private static norm_service = 
        new SharedActivatableServiceDescriptor(
            norm_codebase, norm_policy, norm_classpath, 
            norm_impl, sharedVM_log, new String[] { norm_config },
            true);

    //     
    // Outrigger (JavaSpaces Service)
    //
    private static outrigger_codebase = "http://your_host:http_port/outrigger-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static outrigger_policy = "config_dir/jsk-all.policy";
    private static outrigger_classpath = "install_dir/lib/outrigger.jar";
    private static outrigger_config = "config_dir/activatable-outrigger.config";
    private static outrigger_impl = "org.apache.river.outrigger.PersistentOutriggerImpl";
    private static outrigger_service = 
        new SharedActivatableServiceDescriptor(
            outrigger_codebase, outrigger_policy, outrigger_classpath, 
            outrigger_impl, sharedVM_log, new String[] { outrigger_config },
            true);

    //     
    // Reggie (Lookup Service)
    //
    private static reggie_codebase = "http://your_host:http_port/reggie-dl.jar"
        + " http://your_host:http_port/jsk-dl.jar";
    private static reggie_policy = "config_dir/jsk-all.policy";
    private static reggie_classpath = "install_dir/lib/reggie.jar";
    private static reggie_config = "config_dir/activatable-reggie.config";
    private static reggie_impl = "org.apache.river.reggie.PersistentRegistrarImpl";
    private static reggie_service = 
        new SharedActivatableServiceDescriptor(
            reggie_codebase, reggie_policy, reggie_classpath, 
            reggie_impl, sharedVM_log, new String[] { reggie_config },
            true);

    //
    // Services to start -- used by ServiceStarter.main()
    //
    static serviceDescriptors = new ServiceDescriptor[] {
        httpd_service,
        sharedVM,
        fiddler_service,
        mahalo_service,
        mercury_service,
        norm_service,
        outrigger_service,
        reggie_service
    };
    
    
    //
    // Shared Group 
    //
    private static shared_group_codebase = "http://your_host:http_port/group-dl.jar";
    private static shared_group_policy = "config_dir/jsk-all.policy";
    private static shared_group_classpath = "install_dir/lib/group.jar";
    private static shared_group_config = "config_dir/activatable-group.config";
    private static shared_group_impl = "org.apache.river.start.SharedGroupImpl";
    private static shared_group_service =
        new SharedActivatableServiceDescriptor(
            shared_group_codebase,
            shared_group_policy,
            shared_group_classpath,
            shared_group_impl,
            sharedVM_log, // Same as above
            new String[] { shared_group_config },
            false);
    
    //
    // Groups to destroy -- used by DestroySharedGroup.main()
    //              
    static serviceDestructors =
        new ServiceDescriptor[] { shared_group_service };
}

File config_dir/activatable-fiddler.config

Use this configuration source file to run an activatable Fiddler using Jini ERI.

org.apache.river.fiddler {

  initialLookupGroups = new String[] { "your.group" };
  persistenceDirectory = "config_dir/activatable-fiddler.log";

}

File config_dir/activatable-mahalo.config

Use this configuration source file to run an activatable Mahalo using Jini ERI.

org.apache.river.mahalo {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/activatable-mahalo.log";
}

File config_dir/activatable-mercury.config

Use this configuration source file to run an activatable Mercury using Jini ERI.

org.apache.river.mercury {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/activatable-mercury.log";
}

File config_dir/activatable-norm.config

Use this configuration source file to run an activatable Norm using Jini ERI.

org.apache.river.norm {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/activatable-norm.log";
}

File config_dir/activatable-outrigger.config

Use this configuration source file to run an activatable Outrigger using Jini ERI.

org.apache.river.outrigger {
    initialLookupGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/activatable-outrigger.log";
    store = new org.apache.river.outrigger.snaplogstore.LogStore(this);    
}

File config_dir/activatable-reggie.config

Use this configuration source file to run an activatable Reggie using Jini ERI.

org.apache.river.reggie {
    initialMemberGroups = new String[] { "your.group" };
    persistenceDirectory = "config_dir/activatable-reggie.log";
}

File config_dir/activatable-group.config

Use this configuration source file to run an activatable shared group using Jini ERI.

org.apache.river.start {
    // Use defaults
}

Remember to remove the config_dir/*.log directories before recreating activatable services if you want it to forget registrations and settings made by previous service invocations.

Stopping activatable configurations

To stop the shared group hosting the contributed services created in the previous section, run the following command:

java -Djava.security.policy=config_dir/jsk-all.policy \
     -jar install_dir/lib/destroy.jar \
     config_dir/start-activatable-jeri-services.config

Note: The command, above, references config_dir/start-activatable-jeri-services.config, which was the configuration file used to start the services. This was done for the convenience of referencing the same sharedVM_log value for both group creation and destruction. The command line, above, could also have used a separate, independent configuration file.

Activation System

There are two activation daemon implementations available: rmid and Phoenix. rmid is part of the Java 2 SDK:

• Documentation on using rmid on Microsoft Windows
• Documentation on using rmid with the Solaris(TM) Operating System and/or Linux

Phoenix is part of the River-Internet release. Phoenix has better support for Jini ERI, is configurable, and supports net.jini.security, making it suitable for a much broader range of deployments than rmid.