Package mandala.jacob

Specification and implementation of the Java Active Container of Objects concept.

See:
Description

Interface Summary

ActiveMap

An active map is a map with threads activity over its stored objects.

Class Summary

CleanerCallback	Cleaner callback.
Instanciator	Allows indirect instanciation of objects.
SORFactory	Creates asynchronous references of object stored in a given active map.
StoredObjectReference	Convenience class for stored object manipulation.

Package mandala.jacob Description

Specification and implementation of the Java Active Container of Objects concept.

Package Specification

Concept overview

JACOb is a platform for distributed computing entirely based on the active container concept.

An active container is a standard container as usual containers (see Collection). Objects contained in an active container are called stored objects. Once an object is inserted in an active container, one of its method can be invoked with a particular call method. This invocation is done by the active container, not by the caller itself. This is the reason why this method is considered as generating activities over the stored objects.

JACOb's specific features

JACOb contains some specifities which are not defined in the active container concept.

• JACOb's define the ActiveMap which extends the Map interface and defines a new method ActiveMap.call(java.lang.Object, mandala.rami.FutureServer) -- the generator of activities into the container.
• JACOb' active map may be remote objects. The first consequence of this is that when an object is stored, its methods cannot be invoked in a standard manner since the object may not be in the current JVM. Hence, the call method. The second consequence, is that stored objects may be remotely accessibles without any compilation, interfaces implementations nor class extension. Any objects can be remote in JACOb by being stored in a remote active container. This property is the main advantage of JACOb : legacy code is highly enable by this feature since an object has not to be developed for being remotely accessible - as it is the case with others mechanisms (e.g RMI, CORBA and many others). The remote aspect of an object is not part of the implementation of the object.
• in JACOb, the invocation of a method of a stored object via call is server-sided asynchronous. This property means that when you invoked the call method, you're not blocked during the invocation of the stored object's method. Hence, if the active container is remote, the object is also remote and parallelism is provided.

The ActiveMap interface

This interface is the raw access of an active container. Since this interface extends the standard java.util.Map you can use any implementation as an usual map instance. If the implemenation is a remote object, then you access a map remotely. Be aware that a special exception mechanism is provided to handle exceptions that may occurs when using a remote object as a local object (see the RemoteActiveMap interface) !

When an object is stored into an active map, you can :

• use it as you would do if you manipulate a standard map instance or
• use the method call() to invoke some of its methods asynchronously.

If your active map is remote, then it may be impossible to invoke methods of its stored objects directly.

Moreover, implementation make copy of objects so when you put an objet into an active map implementation, the stored object is not accessible directly. In this case, you must use the method call().

The StoredObjectReference class

As you may imagine, it may be very unconvenient to use call() invocation instead of standard method invocation. Also, passing the key of a stored object each time an invocation is made can be very painfull.

The reference of a stored object in the active container model is a pair (activeContainer, key) where activeContainer is the active container where the stored object is mapped to key. Such a reference may be invalid if no such mapping occurs in the active container.

The StoredObjectReference class represents such a reference. Moreover, it implements the AsynchronousReference interface of the mandala.rami package so transparency is available meaning you can invoke methods of your stored objects asynchronously in a (semi/fully) transparent manner ! See the mandala.rami.transparency package for details.

The factory to create StoredObjectReference is given by the class SORFactory.

Implementations of the ActiveMap interface

JACOb provides some implementations of the ActiveMap interface:

• ActiveMapImpl is a basic local implementations;
• RMIActiveMap is a direct Java-RMI implementation;
• Many other implementations are easy to provide using the Generic Protocol Framework (GPF) found in the mandala.jacob.remote.gpf package (currently UDP, TCP and RMI are already provided).

• JACOb Documentations