The source code of the InitializedHello class is in Example C.28, “InitializedHello.java”.

initActivity and endActivity here just log messages onto the console, so you can see when they are called.

initActivity is called at the creation of the active object, while endActive is called after the activity has terminated (thanks to the method terminate).

Here is the initActivity method:

public void initActivity(Body body) {
        System.out.println("I am about to start my activity");
}         

Here is the endActivity method:

public void endActivity(Body body) {
        System.out.println("I have finished my activity");
}          

The following code shows how to terminate the activity of the active object:

public void terminate() throws IOException {
        // the termination of the activity is done through a call on the
        // terminate method of the body associated to the current active object
        ProActive.getBodyOnThis().terminate();
}          

The only differences from the the previous example is the classes instantiated, which are now InitializedHello (and not Hello) and InitializedHelloClient, and you will add a call to hello.terminate().

The source code of InitializedHello is in Example C.28, “InitializedHello.java”, and the code for InitializedHelloClient is in Example C.29, “InitializedHelloClient.java”.

So, create InitializedHelloClient.java and InitializedHello.java in src/org/objectweb/proactive/examples/hello

Now compile all proactive sources

cd compile
windows>build.bat examples
linux>build examples
cd ..          

Add './classes' directory to CLASSPATH to use these two new source files

windows>set  CLASSPATH=.;.\classes;.\ProActive_examples.jar;.\ProActive.jar;.\lib\bcel.jar;.\lib\asm.jar;.\lib\log4j.jar;\
        .\lib\xercesImpl.jar;.\lib\fractal.jar;.\lib\bouncycastle.jar

linux>export  CLASSPATH=.:./classes:./ProActive_examples.jar:./ProActive.jar:./lib/bcel.jar:./lib/asm.jar:./lib/log4j.jar:\
        ./lib/xercesImpl.jar:./lib/fractal.jar:./lib/bouncycastle.jar

linux> java -Djava.security.policy=scripts/proactive.java.policy \
            -Dlog4j.configuration=file:scripts/proactive-log4j 
            org.objectweb.proactive.examples.hello.InitializedHello 

windows> java -Djava.security.policy=scripts\proactive.java.policy  \
              -Dlog4j.configuration=file:scripts\proactive-log4j \
              org.objectweb.proactive.examples.hello.InitializedHello &

linux> java -Djava.security.policy=scripts/proactive.java.policy 
            -Dlog4j.configuration=file:scripts/proactive-log4j  \
            org.objectweb.proactive.examples.hello.InitializedHelloClient //localhost/Hello 

windows> java -Djava.security.policy=scripts\proactive.java.policy \
              -Dlog4j.configuration=file:scripts\proactive-log4j 
              org.objectweb.proactive.examples.hello.InitializedHelloClient //localhost/Hello 

The code of the MigratableHello class is in Example C.30, “MigratableHello.java”.

MigratableHello derives from the Hello class from the previous example

MigratableHello being the active object itself, it has to:

- implement the Serializable interface

- provide a no-arg constructor

- provide an implementation for using ProActive's migration mechanism.

A new method getCurrentNodeLocation is added for the object to tell the node where it resides..

A factory static method is added for ease of creation.

The migration is initiated by the moveTo method:

/** method for migrating
* @param destination_node destination node
*/
public void moveTo(String destination_node) {
        System.out.println("\n-----------------------------");
        System.out.println("starting migration to node: " + destination_node);
        System.out.println("...");
        try {
                // THIS MUST BE THE LAST CALL OF THE METHOD
                ProActive.migrateTo(destination_node);
        } catch (MigrationException me) {
                System.out.println("migration failed: " + me.toString());
        }
}          

Note that the call to the ProActive primitive migrateTo is the last one of the method moveTo. See Chapter 16, Active Object Migration for more information.

The entry point of the program is written in a separate class: MigratableHelloClient (see Example C.31, “MigratableHelloClient.java”).

It takes as arguments the locations of the nodes the object will be migrated to.

The program calls the factory method of MigratableHello to create an instance of an active object. It then moves it from node to node, pausing for a while between the transfers.

The code of the HelloFrameController is in Example C.32, “HelloFrameController.java”.

This class extends MigratableHello, and adds an activity and a migration strategy manager to the object .

It creates a graphical frame upon call of the sayHello method.

Here we have a more complex migration process than with the previous example. We need to make the graphical window disappear before and reappear in a new location after the migration (in this example though, we wait for a call to sayHello). The migration of the frame is actually controlled by a MigrationStrategyManager, that will be attached to the body of the active object.. An ideal location for this operation is the initActivity method (from InitActive interface), that we override:

/**
 * This method attaches a migration strategy manager to the current active object.
 * The migration strategy manager will help to define which actions to take before
 * and after migrating
 */
public void initActivity(Body body) {
        // add a migration strategy manager on the current active object
        migrationStrategyManager = new MigrationStrategyManagerImpl((Migratable)
 ProActive.getBodyOnThis());
        // specify what to do when the active object is about to migrate
        // the specified method is then invoked by reflection
        migrationStrategyManager.onDeparture('clean');
}          

The MigrationStrategyManager defines methods such as 'onDeparture', that can be configured in the application. For example here, the method 'clean' will be called before the migration, conveniently killing the frame:

public void clean() {
        System.out.println("killing frame");
        helloFrame.dispose();
        helloFrame = null;
        System.out.println("frame is killed");
}          

This is an example of a graphical class that could be associated with the active object (see code in Example C.33, “HelloFrame.java” ).