Thanks to posts from Subbu one finds it easy to create and configure an RMI client to OES by replacing jps-config of a normal Java SM in the same host. What I want to show here is how to invoke entitlement requests remotely by an RMI client which send requests to a non-controlled RMI SM server. This is almost identical to a XACML/Web Service client except that it’s using RMI which is faster, more convinced an  less error prone.

As I said, I will try keep my RMI SM in non-controlled mode. I found it less problematic this way. Using controlled security modules you may end up in some GUI issues which prevent proper distribution.

Security Module (SM)

PRP

So here is my PRP file for this NC (non-controlled) RMI SM:

oracle.security.jps.runtime.pd.client.sm_name=Telstra_RMI_NC_SM
# Policy dustribution mode. Possible values:
oracle.security.jps.runtime.pd.client.policyDistributionMode=non-controlled
# -------- Policy Distributor connectivity information - required for controlled-push distribution mode
# Only needed for controlled-push policy distribution mode
oracle.security.jps.runtime.pd.client.RegistrationServerHost=[OES-Server]
oracle.security.jps.runtime.pd.client.RegistrationServerPort=[OES-Port]
# --Policy Store Service Configuration parameters - required only for controlled-pull or non-controlled modes
# Policy store type
oracle.security.jps.policystore.type=DB
# Policy Store URL for DB policy store
jdbc.url=jdbc:oracle:thin:@[DB-Host]:[DB-Port]/[DB-SID]
# Policy Store URL for LDAP policy store
ldap.url=
# For both LDAP and DB Policy Store
oracle.security.jps.farm.name=cn=oes_domain
oracle.security.jps.ldap.root.name=cn=jpsroot
#Communication between SM and Policy Distributor is over SSL by default
oracle.security.jps.pd.client.sslMode=true
bootstrap.security.principal.key=oes_sm_key
bootstrap.security.principal.map=oes_sm_map
jdbc.driver=oracle.jdbc.driver.OracleDriver
#---------- ONLY for RMI SM -----------------------------
# port number to accept authorization requests
oracle.security.jps.pdp.rmism.RMIRegistryPortNumber=2099
#--- Only for Java SM, WS SM, and RMI SM in controlled-push mode ---
# port to listen for policy distribution. Picked automatically by SM config tool if not specified
oracle.security.jps.runtime.pd.client.DistributionServicePort=
oracle.security.jps.runtime.pd.client.sm_type=rmi

Setup

You may put this in [OES-Client-Home]/oessm/SMConfigTool folder and run  [OES-Client-Home]/oessm/bin/config.sh to add SM to OES. Like this:

./config.sh -prpFileName ../SMConfigTool/smconfig.Telstra_RMI_NC_SM.prp

Now enter your database Policy Store username and password. Note that policy stores are in APM. If things all go well, you’ll have your SM folder under [OES-Client-Home]/oes_sm_instances.

Logging

Before we start the RMI server, it’s better to go and modify start-up script to add more logging stuff. Put a simple JUL config file in config folder and add it to Java argument in startRMIServer.sh. You’d better create a logs folder too.

handlers= java.util.logging.FileHandler
.level= FINER
java.util.logging.FileHandler.pattern = ./logs/log
java.util.logging.FileHandler.limit = 50000000
java.util.logging.FileHandler.count = 1
java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter

And this is line in startRMIServer.sh

${JAVA_HOME}/bin/java <strong>-Djava.util.logging.config.file=./config/logging.properties</strong> -Djava.security.policy=file:${OES_INSTANCE_HOME}/config/java.policy -Doracle.security.jps.config=${OES_INSTANCE_HOME}/config/jps-config.xml com.bea.security.ssmrmi.LauncherWrapper

Run

Now make logs folder and run it.

mkdir logs
nohup ./startRMIServer.sh &
tail -f nohup.out logs/log

OES

SM Setup

Add a new SM to OES:

Application Binding

Bind this new SM to your application:

Attributed Based Authorization Policy

And finally an authorization policy based on resource, role and a dynamic attribute (key):

All done in OES. No need to distribute changes in policies to modules. It all will be done periodically and automatically (see waitDistributionTime variable).

Client

Code

Here is Client source code. Put it in oes/rmi/client/RmiAuthorizationServiceImpl.java

package oes.rmi.client;
import com.bea.security.ssmrmi.services.RMIAuthorizationService;
import com.bea.security.ssmrmi.socket.SocketConfiguration;
import com.bea.security.ssmrmi.socket.SocketFactory;
import com.bea.security.ssmrmi.types.*;
import weblogic.security.principal.WLSGroupImpl;
import weblogic.security.principal.WLSUserImpl;
import weblogic.security.spi.IdentityAssertionException;

import javax.naming.ServiceUnavailableException;
import javax.security.auth.Subject;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.security.Principal;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

/**
 * User: Amin Abbaspour
 * A simple client for Oracle Entitlement Server (OES) RMI SM
 */
public class RmiAuthorizationServiceImpl {
    private final RMIAuthorizationService authorizationService;

    public RmiAuthorizationServiceImpl(String host, int port) throws RemoteException, NotBoundException, ServiceUnavailableException, InterruptedException {
        final Registry registry;
        try {
            registry= LocateRegistry.getRegistry(host, port);
            authorizationService = (RMIAuthorizationService) registry.lookup("ALES_Authorization_Service");
        } catch (RemoteException e) {
            throw new ExceptionInInitializerError(e);
        } catch (NotBoundException e) {
            throw new ExceptionInInitializerError(e);
        }

        SocketConfiguration socketConfiguration = new SocketConfiguration();
        socketConfiguration.setServerHost(host);
        SocketFactory.setConfiguration(socketConfiguration);
    }

    public RMIAuthenticatedSubject getUnauthenticatedSubject(String username, String... groups) {

        final Set<Principal> principals = new HashSet<Principal>(groups.length + 1);

        principals.add(new WLSUserImpl(username));
        for(final String group : groups)
            principals.add(new WLSGroupImpl(group));

        final Subject subject = new Subject(false, principals, new HashSet<String>(), new HashSet<Object>());

       RMIAuthenticatedSubject authenticatedSubject = new RMIAuthenticatedSubject();
        authenticatedSubject.addSubject(subject);

        return authenticatedSubject;
    }

    public RMIAuthenticatedSubject authenticate(RMIAuthenticatedSubject authenticatedSubject) throws ServiceUnavailableException, RemoteException {
        RMIContext rmiContext = new RMIContext(new HashMap());
        RMIAuthenticationResponse response = authorizationService.establishSession(authenticatedSubject, rmiContext);
        return response.getSubject();
    }

    public String  getActionsOnResource(RMIAuthenticatedSubject authenticatedSubject,
                                        String applicationName, String resourceType, String resource,
                                        String actionName, String namingAuthority, HashMap<String, Object> attributes)
            throws ServiceUnavailableException, IdentityAssertionException, RemoteException {

        RMIRuntimeAction runtimeAction = new RMIRuntimeAction(actionName, namingAuthority);
        RMIRuntimeResource runtimeResource = new RMIRuntimeResource(applicationName, resourceType, resource);
        RMIRuntimeResourceAction runtimeResourceAction = new RMIRuntimeResourceAction(runtimeResource, runtimeAction);

        return authorizationService.queryActionsOnResource(authenticatedSubject, runtimeResourceAction, new RMIContext(attributes)).toString();
    }

    public static void main(String[] args) throws RemoteException, NotBoundException, ServiceUnavailableException, InterruptedException {
        final String serverAddress = "host-name-where-rmi-sm-server-is-running";
        final int port = 2099; // non-controlled one

        RmiAuthorizationServiceImpl authorizationService = new RmiAuthorizationServiceImpl(serverAddress, port);
        final HashMap<String, Object> attributes = new HashMap<String, Object>(1);
        attributes.put("key", 101);
        try {
            RMIAuthenticatedSubject unauthenticatedSubject =  authorizationService.getUnauthenticatedSubject("username", "group");
            RMIAuthenticatedSubject authenticatedSubject =  authorizationService.authenticate(unauthenticatedSubject);
            final String actions =  authorizationService.getActionsOnResource(authenticatedSubject,
                    "AppName", "ResourceType", "Resource", "Action", "", attributes);
            System.out.println("actions = " + actions);

        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Maven

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>oes-demo</groupId>
    <artifactId>authorization-client-rmi</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <version.oes>11.1.1</version.oes>
        <version.wls>10.3</version.wls>
    </properties>

    <build>
        <defaultGoal>compile</defaultGoal>
    </build>

    <dependencies>

        <!-- wls client for principals and general rmi types -->
        <dependency>
            <!-- see: http://download.oracle.com/docs/cd/E12840_01/wls/docs103/client/jarbuilder.html -->
            <groupId>weblogic</groupId>
            <artifactId>wlfullclient</artifactId>
            <version>${version.wls}</version>
        </dependency>

        <!-- RMI types and stubs -->
        <dependency>
            <groupId>oracle.oes.sm.rmism</groupId>
            <artifactId>rmi-types</artifactId>
            <version>${version.oes}</version>
            <scope>system</scope>
            <systemPath>D:/project/OES/oes_client/oessm/rmism/rmi-types.jar</systemPath>
        </dependency>

        <dependency>
            <groupId>oracle.oes.sm.rmism</groupId>
            <artifactId>rmi-stubs</artifactId>
            <version>${version.oes}</version>
            <scope>system</scope>
            <systemPath>D:/project/OES/oes_client/oessm/rmism/rmi-stubs.jar</systemPath>
        </dependency>
    </dependencies>
</project>

Test

If the connection to RMI server is OK, then run the application and enjoy. Once serverAddress, port, application name and other settings in code is correct, will result something like:

actions = Granted=true. Responses={oracle.security.oes.authorization.decision_reason=grant_policy_found}

def hit(p):
    for i in range(len(p) - 1):
        for j in range(i + 1, len(p)):
            if j - i == abs(p[i] - p[j]): return True
    return False

def n_queen(n):
    for p in itertools.permutations(range(n)):
        if not hit(p): yield p

One may add just a bit more code to print the board like this:

base_char = ord('A')

def print_board(s):
    end = len(s)
    board = ['   '.join([str(i) for i in range(1, end + 1)]) + '\n']
    for i, r in enumerate(s):
        board += "%s: %s * %s\n" % (chr(base_char+i), (' - ' * r), (' - ' * (end - r - 1)))
    return ''.join(board)

def solve(n):
    count = 0
    for s in n_queen(n):
        count += 1
        print "==== solution %d =====" % count
        print s
        print print_board(s)
    return count

I used this code snippet to compare Python 2.6.5 with PyPy 1.5.0 JIT. It is interesting that for this CPU intensive problem, Python does not use all 100% CPU in User space and only about 30% of CPU usage is spent in User space and the rest 70% for System and Nice while PyPy dedicated most of CPU cycles to User CPU and hence finished up much faster.

Here are my results in an old single core 1.7G Pentium M processor. I expect PyPy JIT to do even better in a modern SSE-2 multi-core processor.

# board count cpython2.6.5 pypy1.5
5 10 0.012 0.007
6 4 0.048 0.064
7 40 0.327 0.224
8 92 1.556 0.562
9 352 15.207 3.685
10 724 156.736 37.676
11 2680 1723.404 427.216

Bellow is the chart comparing the performance upon above benchmark:

Next I tried to speed up the code by making a minor change in hit() method. To prevent len(p) call I passed the length as argument and replaced abs() call with a check for both positive and negative results. These two simple changes as bellow made the code almost 3 times faster:

def hit(p, n):
    for i in range(n - 1):
        for j in range(i + 1, n):
            d = p[i] - p[j]
            if j - i == d or i - j == d: return True
    return False

def n_queen(n):
    for p in itertools.permutations(range(n)):
        if not hit(p, n): yield p

I was expecting the PyPy fail to speed up the execution times as it did for basic code but amazingly the second code’s speed up is even better in PyPy.

Update 31 May 2011 :
Just one update which seemed necessary, back to some comments to this post and also in YCombinator news forum, it is obvious that what I proposed above was not an optimal solution for N-Queen. In fact N-Queen is a classic backtracking problem and can be solved much efficiently using BT but what I tried to show was 1st the power of Python generators and itertools to solve this problem is a few lines (while preserving simplicity) and 2nd using this CPU intensive brute-force search to compare CPython and PyPy implementations.

So I decided to mention a backtracking implementation which solves the problem much much faster and easily covers boards of size up to 14.

def last_one_hits(answers, size):
    i = size - 1
    x, j = answers[i], 0
    for y in answers[:i]:
        d = x - y
        if x == y or i - j == d or j - i == d: return True
        j += 1
    return False

def n_queen_bt(n):
    found = [0] * n # initiate an answer of size n
    size = 1 # in start, we have 1 queen in cloumn/row (0,0)

    while size > 0:
        hits = last_one_hits(found, size) # new queen hits prevs

        if size == n and not hits: #full and does not hit
            yield found

        if size < n and not hits: #not full or hit, add a new
            found[size] = 0
            size += 1
        else:
            while size > 0: #move last or maybe the ones before
                found[size-1] += 1
                if found[size-1] == n: #end of this clmn,go back
                    size -= 1
                else:
                    break #did the movement job, let's continue

Steup Reources:

To setup JMS Queues and Connection Factories in IBM WebSphere 6.1 you
may visit here.

Download J2SE Client libs:

Also need to download IBM Client for JMS on J2SE with IBM WebSphere Application Server.

Main Application:

Now that you have JMS resources and unziped Client libraries, here is a sample code to:

package au.com.osaglobal;

import org.apache.log4j.Logger;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;

/**
* Note: Compile and run this with IBM JDK in ~/IBM/WebSphere6.1/java */
public class App {

private static final Logger log = Logger.getLogger(App.class);

public static void publish() {
final Hashtable env = new Hashtable(); env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.ibm.websphere.naming.WsnInitialContextFactory");
env.put(Context.PROVIDER_URL, "iiop://localhost:2810");

final Context jndiContext;
try {
jndiContext = new InitialContext(env);
} catch (NamingException e) {
log.error("Could not create JNDI API context: " + e.toString(), e); System.exit(1);
return;
}

try {
ConnectionFactory connectionFactory = (ConnectionFactory) jndiContext.lookup("jms/queueConnectionFactory");
Connection qConn = connectionFactory.createConnection(); Session qSession = qConn.createSession(false,
Session.AUTO_ACKNOWLEDGE);
Queue q = (Queue) jndiContext.lookup("jms/inQueue");

MessageProducer producer = qSession.createProducer(q); TextMessage message = qSession.createTextMessage(); message.setText("test message");
producer.send(message);

producer.close();
qSession.close();
qConn.close();
} catch (Exception e) {
log.error("Could not perfrom JMS operation: " + e.toString(), e); System.exit(2);
}
}

private static void spring_receiver() {
new ClassPathXmlApplicationContext(new
String[]{"applicationContext.xml"});
}

public static void main(String[] args) {
publish();
//spring_receiver();
}
}

Spring Application Context

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
        <property name="environment">
            <props>
                <prop key="java.naming.factory.initial">com.ibm.websphere.naming.WsnInitialContextFactory</prop>
                <prop key="java.naming.provider.url">iiop://localhost:2810</prop>
            </props>
        </property>
    </bean>

    <bean id="queueConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiTemplate" ref="jndiTemplate"/>
        <property name="jndiName" value="jms/queueConnectionFactory"/>
    </bean>

    <bean id="inQueue" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiTemplate" ref="jndiTemplate"/>
        <property name="jndiName" value="jms/inQueue"/>
    </bean>

    <bean class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="destination" ref="inQueue"/>
        <property name="connectionFactory" ref="queueConnectionFactory"/>
        <property name="messageListener" ref="inMessageListener"/>
    </bean>

    <bean id="inMessageListener" class="au.com.osaglobal.JmsReceiver"/>
</beans>

Jms Receiver Object

package au.com.osaglobal;

import org.apache.log4j.Logger;

import javax.jms.Message;
import javax.jms.MessageListener;

public class JmsReceiver implements MessageListener {

private static final Logger log = Logger.getLogger(JmsReceiver.class);

public void onMessage(Message message) {
log.info("Received message: " + message);
}
}

Log4J Properties

log4j.rootCategory=DEBUG, S

log4j.appender.S=org.apache.log4j.ConsoleAppender
log4j.appender.S.layout=org.apache.log4j.PatternLayout
log4j.appender.S.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %c{1} [%p] %m%n

Maven Project pom.xml And Dependencies

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>au.com.osaglobal</groupId>
    <artifactId>sample-spring-was-jms</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>

    <name>sample-spring-was-jms</name>
    <url>http://www.osaglobal.com.au/</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <version.spring>2.5.6</version.spring>
        <version.was>6.1</version.was>
    </properties>

    <dependencies>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>

        <!-- javax.jms api -->
        <dependency>
            <groupId>org.apache.geronimo.specs</groupId>
            <artifactId>geronimo-jms_1.1_spec</artifactId>
            <version>1.1.1</version>
        </dependency>

        <!-- Springs 2.5.6 (core, beans, jms) -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${version.spring}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${version.spring}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${version.spring}</version>
        </dependency>

        <!-- WebSphere 6.1 (rt, mq, mqjms, thinclient) -->
        <dependency>
            <groupId>com.ibm.websphere</groupId>
            <artifactId>runtime</artifactId>
            <version>${version.was</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/WebSphere6.1/AppServer1/deploytool/ itp/plugins/com.ibm.websphere.v61_6.1.0/ws_runtime.jar</systemPath>
        </dependency>

        <dependency>
            <groupId>com.ibm.mq</groupId>
            <artifactId>mq</artifactId>
            <version>${version.was}</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/WebSphere6.1/AppServer1/lib/WMQ/java/ lib/com.ibm.mq.jar</systemPath>
        </dependency>

        <dependency>
            <groupId>com.ibm.mq</groupId>
            <artifactId>mqjms</artifactId>
            <version>${version.was}</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/WebSphere6.1/AppServer1/lib/WMQ/java/ lib/com.ibm.mqjms.jar</systemPath>
        </dependency>

        <dependency>
            <groupId>com.ibm.mq</groupId>
            <artifactId>dhbcore</artifactId>
            <version>${version.was}</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/WebSphere6.1/AppServer1/lib/WMQ/java/ lib/dhbcore.jar</systemPath>
        </dependency>

        <dependency>
            <groupId>com.ibm.ws.webservices</groupId>
            <artifactId>thinclient</artifactId>
            <version>${version.was}</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/WebSphere6.1/AppServer1/runtimes/ com.ibm.ws.webservices.thinclient_6.1.0.jar</systemPath>
        </dependency>

        <!-- IBM Client for JMS on J2SE with IBM WebSphere Application Server -->
        <!-- see: http://www-01.ibm.com/support/docview.wss?uid=swg24012804 -->
        <dependency>
            <groupId>com.ibm.sibc</groupId>
            <artifactId>sibc.jms</artifactId>
            <version>6.1</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/sibc/sibc.jms.jar</systemPath>
        </dependency>

        <dependency>
            <groupId>com.ibm.sibc</groupId>
            <artifactId>sibc.jndi</artifactId>
            <version>6.1</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/sibc/sibc.jndi.jar</systemPath>
        </dependency>

        <dependency>
            <groupId>com.ibm.sibc</groupId>
            <artifactId>sibc.orb</artifactId>
            <version>6.1</version>
            <scope>system</scope>
            <systemPath>/home/amin/IBM/sibc/sibc.orb.jar</systemPath>
        </dependency>

    </dependencies>
</project>

Note: You will need to fix systemPath to fit your installation. Now can submit and receive simply by (un)commenting related methods in main().

It is somehow even better than what I was expecting. It’s interesting that I believe to be very good at threading but I don’t know why result does not reflect this. Anyway, IMHO this is one of the good results one has achieved in IKM J2SE :) Wont believe me unless you take this hard test yourself!

Update 17 July 2011: For those friends whom ask for sample questions, well I don’t have any but bellow documents seem of great help:

• Java JDK Documents (javadoc)
• Thinking in Java
• More Java Pitfalls
• Java Puzzlers
• Effective Java
• SCJP Sun Certified Programmer for Java 6 Exam

Soon after the incident Mr.Behbahani – our superb minister finds out the reasons:

“
It’s a good news in fact since unlike recent crashes, this time plane did not explode and most of passengers (33 out of 105) are yet alive. Reason was merely the poor weather not our 40 years old plane nor the airport which lacks any auto pilot infrastructure.
And yet US is the as responsible as bad weather since their sanctions prevents us from buying planes, hence we have to invest this budget in nuclear bombs, to force them change this behavior in the future. and by the way, martyrdomed people are as much responsible as as poor weather and Sam, since we already told them this plane has issues, but they were so eager for martyrdom that forced us hope them in the plane.
he finishes his words by noting that while we handle around 30% of world plane crash share in recent years we are still among the worlds safest airlines and I am ready to go to parliament and tell this to those who don’t understand. plane crash is something normal and I am so amazed why the wanna probe it every time happens.
“

Yes dude. this is the land I am running off. Land where alives are unimportant regular moving object and deaths are praised to its full. A good Iranian citizen is a death one.

I committed a very simple web based zookeeper browser console into github. Source code is available at https://github.com/abbaspour/zkbrowser-lite

It requires zookeeper python binding and web.py. I call it lite browser since I may commit another version with more feature soon.

It’s interesting that the LOC is very small:
wc -l *.py templates/page.html
21 code.py
16 zk.py
13 templates/page.html
50 total

Here is an snapshot:

Now after running my third project project on top of it, I’ve got better feeling of it’s pros and cons.

You know, the great thing behind JGroups is that it hits its goal quite well. The goal is to have a Java Group Communication framework and JGroups does this very well.

We are setting up a large cluster for Image processing. The nodes count in the initial demo is only 128 but it may soon increase to 2K in later setups. Configuring JGroups to run in such an environment not an easy task at all. One need to have deep understanding of UDP/IP and Java internals to get the results. This is maybe one minor deficiency of JGroups but it’s bearable due.

The second issue is all about that big ‘J’ :) IMHO JGroups is far beyond a framework just to be limited to Java. JGroups highly depends on Java and it’s serialization and the commiters do not seem to be much interested to standards communication stack and and permit pluggable serialization mechanism. Something somehow similar to Inifispan HotRod.

For example, we have noticed that our native image processing code running better in SMP machines with Python/SWIG than Java/JNA/JNI but there is almost no way to keep servers in Java and switch clients to Python.

This sometimes makes me think of switching to ZooKeeper/Google Protocol Buffer rather than staying with JGroups. I don’t know till when I can resist it :) Recently I saw a LinkedIn project called Norbet that is almost exactly what I had in mind, but will ZK give me a fast distributed hash map like JGroups? Norbet code base is young but definitely deserves a try.

After I fixed performance issues preventing proper usage in the initial days of registration system (fixing mysql/php/apache/etc) I sat and wrote this small one line bash scripts which checks if all the uploaded files are images in fact.

for a in *; do file "$a" | grep image -i > /dev/null; if [ $? != 0 ]; then echo "*** $a --> Check it! ***"; else echo -n "."; fi; done

Bash is a great tool :)