Provides the utilities and APIs used to launch the contributed services provided in the Jini(TM) Technology Starter Kit (starter kit).

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 {@link com.sun.jini.start.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 {@link com.sun.jini.start.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 starter kit is installed, and config_options includes any {@link net.jini.config.Configuration Configuration} provider options.

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

The command line, above, will invoke {@link com.sun.jini.start.ServiceStarter#main(java.lang.String[]) ServiceStarter.main()}, which obtains a {@link com.sun.jini.start.ServiceDescriptor ServiceDescriptor[]} from its `Configuration` (via the `com.sun.jini.start.serviceDescriptors` entry) and invokes `create()` on each array element. The three provided implementaions of `ServiceDescriptor` are:

{@link com.sun.jini.start.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.

{@link com.sun.jini.start.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 {@link com.sun.jini.start.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.

{@link com.sun.jini.start.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 {@link com.sun.jini.start.DestroySharedGroup#main(java.lang.String[]) DestroySharedGroup.main()}, which obtains a {@link com.sun.jini.start.ServiceDescriptor ServiceDescriptor[]} from its `Configuration` (via the `com.sun.jini.start.serviceDestructors` entry) and invokes `create()` on each array element. All the array elements are assumed to be `SharedActivatableServiceDescriptor`s that are configured to run {@link com.sun.jini.start.SharedGroup} implementations (see provided implementation: {@link com.sun.jini.start.SharedGroupImpl}). Once created, each element's {@link com.sun.jini.start.SharedGroup#destroyVM() 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 {@link com.sun.jini.admin.DestroyAdmin#destroy() DestroyAdmin.destroy()} method on the server's {@link net.jini.admin.Administrable} object (obtained by invoking {@link net.jini.admin.Administrable#getAdmin() 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 starter kit 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 directory. The {@link com.sun.jini.tool.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 {@link com.sun.jini.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 starter kit 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 com.sun.jini.start.NonActivatableServiceDescriptor;
>     import com.sun.jini.start.ServiceDescriptor;

>     com.sun.jini.start {

>         //
>         // HTTPD Service
>         //
>         private static httpd_codebase = "";
>         private static httpd_policy = "config_dir/jsk-all.policy";
>         private static httpd_classpath = "install_dir/lib/tools.jar";
>         private static httpd_impl = "com.sun.jini.tool.ClassServer";
>         private static httpd_service =
>             new NonActivatableServiceDescriptor(
>                 httpd_codebase, httpd_policy, httpd_classpath, httpd_impl,
>                 new String[]{"-port", "8080", "-dir", "install_dir/lib", "-verbose"});

>         //
>         // Fiddler (Lookup Discovery Service)
>         //
>         private static fiddler_codebase = "http://your_host:http_port/fiddler-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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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 com.sun.jini.start.NonActivatableServiceDescriptor;
>     import com.sun.jini.start.ServiceDescriptor;

>     com.sun.jini.start {

>         //
>         // HTTPD Service
>         //
>         private static httpd_codebase = "";
>         private static httpd_policy = "config_dir/jsk-all.policy";
>         private static httpd_classpath = "install_dir/lib/tools.jar";
>         private static httpd_impl = "com.sun.jini.tool.ClassServer";
>         private static httpd_service =
>             new NonActivatableServiceDescriptor(
>                 httpd_codebase, httpd_policy, httpd_classpath, httpd_impl,
>     	    new String[]{"-port", "8080", "-dir", "install_dir/lib", "-verbose"});

>         //
>         // Fiddler (Lookup Discovery Service)
>         //
>         private static fiddler_codebase = "http://your_host:http_port/fiddler-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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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;

>     com.sun.jini.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;

>     com.sun.jini.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;

>     com.sun.jini.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;

>     com.sun.jini.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;

>     com.sun.jini.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"));
>     }

#### 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;

>     com.sun.jini.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 {@linkplain net.jini.id.Uuid universally unique ID}s 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 com.sun.jini.start.NonActivatableServiceDescriptor;
>     import com.sun.jini.start.ServiceDescriptor;
>     import com.sun.jini.start.SharedActivatableServiceDescriptor;
>     import com.sun.jini.start.SharedActivationGroupDescriptor;

>     com.sun.jini.start {

>         //
>         // HTTPD Service
>         //
>         private static httpd_codebase = "";
>         private static httpd_policy = "config_dir/jsk-all.policy";
>         private static httpd_classpath = "install_dir/lib/tools.jar";
>         private static httpd_impl = "com.sun.jini.tool.ClassServer";
>         private static httpd_service =
>             new NonActivatableServiceDescriptor(
>                 httpd_codebase, httpd_policy, httpd_classpath,
>                 httpd_impl,
>                 new String[]{"-port", "8080", "-dir", "install_dir/lib", "-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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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";
>         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 = "com.sun.jini.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 = "com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.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.

>     com.sun.jini.outrigger {
>         initialLookupGroups = new String[] { "your.group" };
>         persistenceDirectory = "config_dir/activatable-outrigger.log";
>     }

#### File config_dir/activatable-reggie.config

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

>     com.sun.jini.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.

>     com.sun.jini.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 {@link com.sun.jini.phoenix 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 starter kit. `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`.