I am pleased to announce the release of GridGain Open Source In-Memory Computing Platform 6.2.0. The main components of the platform are: compute grid, data grid (or in-memory distributed cache), and CEP streaming. This release revolves primarily around Portable Object functionality as well as Distributed (or Guaranteed) Services.

Portable Objects

One of the main benefits of Portable Objects, which was not available in our prior release, is the ability to access any data or field without having to deserialize the entire object. This brings significant performance improvements to the server-side processing of in-memory cached data, as filtering remote caches and executing SQL or predicate-based queries becomes very inexpensive and fast. As a matter of fact, you don’t even need to have class definitions on the server side, which essentially allows for dynamic structural changes of cached data without the need to restart the cluster.

Here is an example of how a single field can be accessed from a portable object without having to deserialize it into a concrete class representation:

GridCacheProjection<Integer, GridPortableObject> prj = cache.keepPortable();

int myKey = 123;

GridPortableObject val = prj.get(myKey);

String field = val.field("myFieldName");

In addition, portable objects also include the ability to perform the following:

• Make any object portable with zero code change to your existing code.
• Nest portable objects within each other.
• Automatically handle circular or null references.
• Optionally avoid deserialization of objects on the server side (objects are stored in GridPortableObject format).
• Avoid the need to have concrete class definitions on the server side.
• Dynamically change the structure of the classes without having to restart the cluster.
• Index into portable objects for querying purposes.

Distributed Services

Distributed Services allow for controlled deployment of any service on the grid. You can think of a distributed service as a fault-tolerant thread pool, for which you can configure how many threads are allowed to be deployed on each grid node.

For example, what if you need to deploy a web server within your cluster, but you are only allowed to have one instance of it deployed? If the node on which your web server is deployed fails, then you want it to automatically start up on another server. Distributed Services allow you to have such functionality, in this case by deploying a cluster-wide singleton service which will start your web server.

With distributed services you can do the following:

• Automatically deploy any number of service instances in the grid.
• Automatically deploy singletons, including cluster-singleton, node-singleton, or key-affinity-singleton.
• Automatically deploy services on node start-up by specifying them in grid configuration.
• Undeploy any of the deployed services.
• Get information about service deployment topology within the grid.

Here is an example of how a simple cluster singleton service can be deployed:

// Simple service implementation.
public class MyGridService implements GridService {
    @Override public void cancel(GridServiceContext ctx) {
        // No-op.
    }

    @Override public void execute(GridServiceContext ctx) {
        // Loop until service is cancelled.
        while (!ctx.isCancelled()) {
            // Do something.
            ...
        }
    }
}
...
GridServices svcs = grid.services();

GridFuture<?> fut = svcs.deployClusterSingleton("mySingleton", new MyGridService());

// Wait for deployment to complete.
fut.get();

Click here to download GridGain 6.2.0.