MemcachedServer.java

package org.jgroups.demos;

import org.jgroups.blocks.Cache;
import org.jgroups.blocks.MemcachedConnector;
import org.jgroups.blocks.PartitionedHashMap;
import org.jgroups.jmx.JmxConfigurator;

import javax.management.MBeanServer;
import java.net.InetAddress;
import java.lang.management.ManagementFactory;

/** Server process which listens for memcached requests and forwards them to an instance of PartitionedHashMap.
 * Uses MemcachedConnector and PartitionedHashMap.
 * @author Bela Ban
 */
public class MemcachedServer {
    private MemcachedConnector connector;
    private PartitionedHashMap<String, byte[]> cache;
    private static final String BASENAME="memcached";


    private void start(String props, InetAddress bind_addr, int port, int min_threads, int max_threads,
                       long rpc_timeout, long caching_time, boolean migrate_data, boolean use_l1_cache,
                       int l1_max_entries, long l1_reaping_interval,
                       int l2_max_entries, long l2_reaping_interval) throws Exception {
        MBeanServer server=ManagementFactory.getPlatformMBeanServer();
        connector=new MemcachedConnector(bind_addr, port, null);
        connector.setThreadPoolCoreThreads(min_threads);
        connector.setThreadPoolMaxThreads(max_threads);
        JmxConfigurator.register(connector, server, BASENAME + ":name=connector");

        cache=new PartitionedHashMap(props, "memcached-cluster");
        cache.setCallTimeout(rpc_timeout);
        cache.setCachingTime(caching_time);
        cache.setMigrateData(migrate_data);
        JmxConfigurator.register(cache, server, BASENAME + ":name=cache");
        JmxConfigurator.register(cache.getL2Cache(), server, BASENAME + ":name=l2-cache");

        if(use_l1_cache) {
            Cache<String,byte[]> l1_cache=new Cache<String,byte[]>();
            cache.setL1Cache(l1_cache);
            if(l1_reaping_interval > 0)
                l1_cache.enableReaping(l1_reaping_interval);
            if(l1_max_entries > 0)
                l1_cache.setMaxNumberOfEntries(l1_max_entries);
            JmxConfigurator.register(cache.getL1Cache(), server, BASENAME + ":name=l1-cache");
        }

        if(l2_max_entries > 0 || l2_reaping_interval > 0) {
            Cache<String,byte[]> l2_cache=cache.getL2Cache();
            if(l2_max_entries > 0)
                l2_cache.setMaxNumberOfEntries(l2_max_entries);
            if(l2_reaping_interval > 0)
                l2_cache.enableReaping(l2_reaping_interval);
        }

        connector.setCache(cache);

        Runtime.getRuntime().addShutdownHook(new Thread() {
            public void run() {
                cache.stop();
                try {connector.stop();} catch(Exception e) {}
            }
        });

        cache.start();
        connector.start();
    }



    public static void main(String[] args) throws Exception {
        InetAddress bind_addr=null;
        int port=11211;
        String props="udp.xml";
        int min_threads=1, max_threads=500;
        long rpc_timeout=1500L, caching_time=30000L;
        boolean migrate_data=true, use_l1_cache=true;
        int l1_max_entries=5000, l2_max_entries=-1;
        long l1_reaping_interval=-1, l2_reaping_interval=30000L;

        for(int i=0; i < args.length; i++) {
            if(args[i].equals("-bind_addr")) {
                bind_addr=InetAddress.getByName(args[++i]);
                continue;
            }
            if(args[i].equals("-port") || args[i].equals("-p")) {
                port=Integer.parseInt(args[++i]);
                continue;
            }
            if(args[i].equals("-props")) {
                props=args[++i];
                continue;
            }
            if(args[i].equals("-min_threads")) {
                min_threads=Integer.parseInt(args[++i]);
                continue;
            }
            if(args[i].equals("-max_threads")) {
                max_threads=Integer.parseInt(args[++i]);
                continue;
            }
            if(args[i].equals("-rpc_timeout")) {
                rpc_timeout=Long.parseLong(args[++i]);
                continue;
            }
            if(args[i].equals("-caching_time")) {
                caching_time=Long.parseLong(args[++i]);
                continue;
            }
            if(args[i].equals("-migrate_data")) {
                migrate_data=Boolean.parseBoolean(args[++i]);
                continue;
            }
            if(args[i].equals("-use_l1_cache")) {
                use_l1_cache=Boolean.parseBoolean(args[++i]);
                continue;
            }
            if(args[i].equals("-l1_max_entries")) {
                l1_max_entries=Integer.parseInt(args[++i]);
                continue;
            }
            if(args[i].equals("-l1_reaping_interval")) {
                l1_reaping_interval=Long.parseLong(args[++i]);
                continue;
            }
            if(args[i].equals("-l2_max_entries")) {
                l2_max_entries=Integer.parseInt(args[++i]);
                continue;
            }
            if(args[i].equals("-l2_reaping_interval")) {
                l2_reaping_interval=Long.parseLong(args[++i]);
                continue;
            }
            
            help();
            return;
        }
        new MemcachedServer().start(props, bind_addr, port, min_threads, max_threads, rpc_timeout, caching_time,
                                    migrate_data, use_l1_cache, l1_max_entries, l1_reaping_interval,
                                    l2_max_entries, l2_reaping_interval);
    }

    private static void help() {
        System.out.println("MemcachedServer [-help] [-bind_addr <address>] [-port <port>] [-props <props>] " +
                "[-min_threads <min>] [-max_threads <max>] [-rpc_timeout <ms>] [-caching_time <ms>] " +
                "[-migrate_data <true|false>] [-use_l1_cache <true|false>] " +
                "[-l1_max_entries <num>] [-l1_reaping_interval <ms>] " +
                "[-l2_max_entries <num>] [-l2_reaping_interval <ms>] ");
    }
}