Best practice to handle the class definitions among storage enabled nodes

Question

We have a common set of cache servers that are shared among various applications. A common problem that we face upon deployment is with the missing class definition newly introduced by one of the application node. Any practical approach / best practices to address this problem?
Edited by: Mahesh Kamath on Feb 3, 2010 10:17 PM

Answer 1

Is it the cache servers themselves or your application servers that are having problems with loading classes?
In order to dynamically add classes (in our case scripts that compile to Java byte code) we are considering to use a class loader that picks up classes from a coherence cache. I am however not so sure how/if this would work for the cache servers themselves if that is your problem!?
Anyhow a simplistic cache class loader may look something like this:
import com.tangosol.net.CacheFactory;
* This trivial class loader searches a specified Coherence cache for classes to load. The classes are assumed
* to be stored as arrays of bytes keyed with the "binary name" of the class (com.zzz.xxx).
* It is probably a good idea to decide on some convention for how binary names are structured when stored in the
* cache. For example the first tree parts of the binary name (com.scania.xxxx in the example) could be the
* "application name" and this could be used as by a partitioning strategy to ensure that all classes associated with
* a specific application are stored in the same partition and this way can be updated atomically by a processor or
* transaction! This kind of partitioning policy also turns class loading into a "scalable" query since each
* application will only involve one cache node!
public class CacheClassLoader extends ClassLoader {
    public static final String DEFAULT_CLASS_CACHE_NAME = "ClassCache";
    private final String classCacheName;
    public CacheClassLoader() {
        this(DEFAULT_CLASS_CACHE_NAME);
    public CacheClassLoader(String classCacheName) {
        this.classCacheName = classCacheName;
    public CacheClassLoader(ClassLoader parent, String classCacheName) {
        super(parent);
        this.classCacheName = classCacheName;
    @Override
    public Class<?> loadClass(String className) throws ClassNotFoundException {
        byte[] bytes = (byte[]) CacheFactory.getCache(classCacheName).get(className);
        return defineClass(className, bytes, 0, bytes.length);
}And a simple "loader" that put the classes in a JAR file into the cache may look like this:
* This class loads classes from a JAR-files to a code cache
public class JarToCacheLoader {
    private final String classCacheName;
    public JarToCacheLoader(String classCacheName) {
        this.classCacheName = classCacheName;
    public JarToCacheLoader() {
        this(CacheClassLoader.DEFAULT_CLASS_CACHE_NAME);
    public void loadClassFiles(String jarFileName) throws IOException {
        JarFile jarFile = new JarFile(jarFileName);
        System.out.println("Cache size = " + CacheFactory.getCache(classCacheName).size());
        for (Enumeration<JarEntry> entries = jarFile.entries(); entries.hasMoreElements();) {
            final JarEntry entry = entries.nextElement();
            if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
                final InputStream inputStream = jarFile.getInputStream(entry);
                final long size = entry.getSize();
                int totalRead = 0;
                int read = 0;
                byte[] bytes = new byte[(int) size];
                do {
                    read = inputStream.read(bytes, totalRead, bytes.length - totalRead);
                    totalRead += read;
                } while (read > 0);
                if (totalRead != size)
                    System.out.println(entry.getName() + " failed to load completely, " + size + " ," + read);
                else
                    System.out.println(entry.getName().replace('/', '.'));
                    CacheFactory.getCache(classCacheName).put(entry.getName() + entry, bytes);
                inputStream.close();
    public static void main(String[] args) {
        JarToCacheLoader loader = new JarToCacheLoader();
        for (String jarFileName : args)
            try {
                loader.loadClassFiles(jarFileName);
            } catch (IOException e) {
                e.printStackTrace();
}Standard disclaimer - this is prototype code use on your own risk :-)
/Magnus