/dev/websphere

Major update of ObjectGrid just shipped

We just shipped ifix 3 for ObjectGrid which despite being packaged as an ifix is basically a major release for ObjectGrid. We added some amazing new features in this build including:

• Spring Container Managed Transaction Support
• Spring Bean Factory integration
• Support for zone or multi-data center replication (industry first)
• Zones allow customers to easily separate primaries and replicas spacially from each other for better high availability.
• HTTP Session support with multi-data center support
• Better integration with WebSphere
• FIFO style access to query result sets (use Maps as queues)

You can read more about it on the wiki. The update can be applied to XD DataGrid installs and then copied to WAS V6.0.2 or customers using J2SE.

You can find it here.

Openspaces is more testable, not true.

I've been pushing non invasive middleware for some time now. ObjectGrid was the first result of that in so much as it is a Java jar. You put it on the class path and then you use it. Easy. Of course, it also works within any recent version of WebSphere and should work in competitive application servers. A big advantage of non invasive middleware is testability as you can test in a lightweight container such as J2SE. We don't force a special container on you, you use J2SE or the one you already have invested in.

I was just reading Natis blog on testing and anyone would think that what he was describing was new. Of course it isn't, as ObjectGrid customers already know. ObjectGrid has been lightweight since the beginning and can run within a simple J2SE environment that can be started in eclipse easily. This is how the ObjectGrid development team does most of its work on ObjectGrid itself. Just start your two containers using eclipse, set your breakpoints and then test it. You can use JUnit to do testing of course as we do for our testing within the team.

We have customers using ObjectGrid with eclipse in exactly this fashion and needless to say it's pretty productive when compared with using a full stack, i.e. J2EE etc. As usual, Nati makes great points; they just also apply to most products on the market including ObjectGrid of course. It is not an exclusive quality of anything gigaspaces is doing; most vendors are doing the whole non invasive middleware gig today. This isn't a differentiator.

Until some other vendors pick up Open spaces, it remains a proprietary API for Gigaspaces. I'm looking forward more and more to the spring experience conference in December as it'll be interesting to have some discussions face to face rather than in the blogosphere.

Synchronous replication edge cases

This is a test video blog I did to explain how we do synchronous replication with the ObjectGrid, what can go wrong, how we handle that and more importantly how your application can be told whats happening to make sure it's doing what you think.

Some vendors may tell you that you don't need to worry about it but when doing replication in the presence of another data source such as a database it's very easy to get in to the situation where the cache is either N transactions in front or behind the database when failures occur. The post just shows how we do it and how we handle these edge conditions.

Download ObjectGridSyncReplicationRecovery.wmv

Thanks

Verifying a backend systems status in a cluster using WebSphere XD

I've seen a scenario over the last couple of days where a customer had a cluster and wanted to monitor the state of a backend system. They didn't want each cluster member to monitor the backend because of load etc but this resulting in a single point of failure or SPOF for the monitoring.

Partition Facility (XD)

So, I suggested the following. Use XD. The XD application creates a single partition called "MONITOR". The task of the MONITOR partition is the following:

PartitionStart:

• Check the status of the backend and publish it on a non persistent but reliable JMS TOPIC.
• Start an alarm (async beans API) to expire in say 10 seconds.

AlarmFired:

• Check the backend status and publish it on the topic if the status changed.
• Reset the alarm (async beans API) to fire in another 10 seconds.

When the application starts on a cluster member then do the following using a startup bean.

ApplicationStart:

• Make an IIOP call to the partition routable session bean and call a method to determine the backend status.
• If it fails (i.e. the partition is in the process of recovery) then simply mark as unknown and wait for a JMS message once the partition restarts (seconds).

An application using partitioning has a single special stateless session bean called the PSSB (partition stateless session bean). Client IIOP calls to this session bean use partition specific routing. The client uses a Java Bean called the PRSB (partition routable ...). The JavaBean has methods with the same signatures as the remote interface of the PSSB except they always return a String. The string tells the client which partition to route the method request to. The check status method always returns the string 'MONITOR' in this case. The routing is static, i.e. always route to where 'MONITOR' is running. The method call will be routed to the cluster member where the MONITOR partition is currently running and returns the current backend status.

Add an MDB that listens to this topic to the application. Make sure the JMS provider is configured to deliver any messages published on the topic to ALL subscribers. Each cluster member will receive a status message from the partition when the status changes. If the server with the partition fails then XD will reassign the partition to one of the surviving cluster members. This member will then do the partitionStart logic and we're back to monitoring again.

It's a simple problem that has an elegant solution using WebSphere XD, the partition facility and the async beans APIs (startup beans, alarms). We only monitor the backend from a single cluster member, everybody gets timely information on backend availability. The monitoring service is highly available using the partition facility.