#319 Need flag to support AWS Static and Dynamic modes.

core/src/main/java/de/javakaffee/web/msm/MemcachedConnectionFactory.java

@@ -0,0 +1,51 @@
+package de.javakaffee.web.msm;
+
+import net.spy.memcached.BinaryConnectionFactory;
+import net.spy.memcached.DefaultConnectionFactory;
+
+/**
+ * Created by asodhi on 11/29/2016.
+ */
+public class MemcachedConnectionFactory implements StorageClientFactory.MemcachedNodeURLBasedConnectionFactory {
+    @Override
+    public BinaryConnectionFactory createBinaryConnectionFactory(final long operationTimeout,
+                                                                 final long maxReconnectDelay,
+                                                                 boolean isClientDynamicMode) {
+        try {
+            return new BinaryConnectionFactory() {
+                @Override
+                public long getOperationTimeout() {
+                    return operationTimeout;
+                }
+
+                @Override
+                public long getMaxReconnectDelay() {
+                    return maxReconnectDelay;
+                }
+            };
+        } catch (final Exception e) {
+            throw new RuntimeException("Could not create memcached client", e);
+        }
+    }
+
+    @Override
+    public DefaultConnectionFactory createDefaultConnectionFactory(final long operationTimeout,
+                                                                   final long maxReconnectDelay,
+                                                                   boolean isClientDynamicMode) {
+        try {
+            return new DefaultConnectionFactory() {
+                @Override
+                public long getOperationTimeout() {
+                    return operationTimeout;
+                }
+
+                @Override
+                public long getMaxReconnectDelay() {
+                    return maxReconnectDelay;
+                }
+            };
+        } catch (final Exception e) {
+            throw new RuntimeException("Could not create memcached client", e);
+        }
+    }
+}

core/src/main/java/de/javakaffee/web/msm/MemcachedElasticConnectionFactory.java

@@ -0,0 +1,108 @@
+package de.javakaffee.web.msm;
+
+import net.spy.memcached.BinaryConnectionFactory;
+import net.spy.memcached.ConnectionFactory;
+import net.spy.memcached.DefaultConnectionFactory;
+
+import java.lang.reflect.*;
+
+/**
+ * Created by asodhi on 11/29/2016.
+ */
+public class MemcachedElasticConnectionFactory implements StorageClientFactory.MemcachedNodeURLBasedConnectionFactory {
+
+    @Override
+    public ConnectionFactory createBinaryConnectionFactory(final long operationTimeout,
+                                                           final long maxReconnectDelay,
+                                                           boolean isClientDynamicMode) {
+        try {
+            Class clientMode = Class.forName("net.spy.memcached.ClientMode");
+            Enum clientModeEnum = getClientMode(clientMode, isClientDynamicMode);
+            Class connectionFactoryClass = Class.forName("net.spy.memcached.BinaryConnectionFactory");
+            Constructor<BinaryConnectionFactory> connectionFactoryClassConstructor = connectionFactoryClass.getConstructor(clientMode);
+            BinaryConnectionFactory binaryConnectionFactory = connectionFactoryClassConstructor.newInstance(clientModeEnum);
+            return (ConnectionFactory) Proxy.newProxyInstance(
+                    binaryConnectionFactory.getClass().getClassLoader(), new Class<?>[] {ConnectionFactory.class},
+                    new ConnectionFactoryInvocationHandler(binaryConnectionFactory,operationTimeout,operationTimeout));
+        } catch (final Exception e) {
+            throw new RuntimeException("Could not create binary connection factory", e);
+        }
+    }
+
+    @Override
+    public ConnectionFactory createDefaultConnectionFactory(final long operationTimeout,
+                                                                   final long maxReconnectDelay,
+                                                                   boolean isClientDynamicMode) {
+        try {
+            Class clientMode = Class.forName("net.spy.memcached.ClientMode");
+            Enum clientModeEnum = getClientMode(clientMode, isClientDynamicMode);
+            Class connectionFactoryClass = Class.forName("net.spy.memcached.DefaultConnectionFactory");
+            Constructor<DefaultConnectionFactory> connectionFactoryClassConstructor = connectionFactoryClass.getConstructor(Object.class);
+            DefaultConnectionFactory defaultConnectionFactory = connectionFactoryClassConstructor.newInstance(clientModeEnum);
+            return (ConnectionFactory)Proxy.newProxyInstance(
+                    defaultConnectionFactory.getClass().getClassLoader(), new Class<?>[] {ConnectionFactory.class},
+                    new ConnectionFactoryInvocationHandler(defaultConnectionFactory,operationTimeout,operationTimeout));
+        } catch (final Exception e) {
+            throw new RuntimeException("Could not create default connection factory", e);
+        }
+    }
+
+    private Enum getClientMode(Class clientMode, boolean isClientDynamicMode) {
+        if (isClientDynamicMode) {
+            return Enum.valueOf(clientMode, "Dynamic");
+        } else {
+            return Enum.valueOf(clientMode, "Static");
+        }
+    }
+    public class ConnectionFactoryInvocationHandler implements InvocationHandler {
+        private final Method TO_STRING_METHOD = getMethod("toString",
+                (Class<?>[]) null);
+
+        long operationTimeout;
+        long maxReconnectDelay;
+        DefaultConnectionFactory defaultConnectionFactory;
+        public ConnectionFactoryInvocationHandler(DefaultConnectionFactory defaultConnectionFactory,
+                                                  final long operationTimeout,
+                                                  final long maxReconnectDelay)
+        {
+            this.defaultConnectionFactory=defaultConnectionFactory;
+            this.operationTimeout = operationTimeout;
+            this.maxReconnectDelay = maxReconnectDelay;
+        }
+
+        @Override
+        public Object invoke(Object proxy, Method method, Object[] args)
+                throws Throwable {
+
+            Object returnValue;
+            try {
+                if (method.getName().equalsIgnoreCase("getOperationTimeout"))
+                {
+                    returnValue = operationTimeout;
+                }else if (method.getName().equalsIgnoreCase("getMaxReconnectDelay"))
+                {
+                    returnValue = maxReconnectDelay;
+                }else {
+                    returnValue = method.invoke(defaultConnectionFactory, args);
+                }
+            } catch (InvocationTargetException ex) {
+                throw ex.getTargetException();
+            }
+            if (TO_STRING_METHOD.equals(method)) {
+                return "Proxy (" + returnValue + ")";
+            }
+            return returnValue;
+        }
+
+        private Method getMethod(String methodName, Class<?>... paramTypes) {
+            try {
+                return Object.class.getMethod(methodName, paramTypes);
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            } catch (SecurityException e) {
+                e.printStackTrace();
+            }
+            return null;
+        }
+    }
+}

core/src/main/java/de/javakaffee/web/msm/StorageClientFactory.java

@@ -43,6 +43,15 @@ MemcachedClient createCouchbaseClient(MemcachedNodesManager memcachedNodesManage
                 long maxReconnectDelay, Statistics statistics );
     }
 
+    static interface MemcachedNodeURLBasedConnectionFactory {
+        ConnectionFactory createBinaryConnectionFactory(long operationTimeout,
+                                                        long maxReconnectDelay, boolean isClientDynamicMode);
+
+        ConnectionFactory createDefaultConnectionFactory(long operationTimeout,
+                                                         long maxReconnectDelay, boolean isClientDynamicMode);
+    }
+
+
     protected StorageClient createStorageClient(final MemcachedNodesManager memcachedNodesManager,
                                                 final String memcachedProtocol, final String username, final String password, final long operationTimeout,
                                                 final long maxReconnectDelay, final Statistics statistics ) {
@@ -78,9 +87,30 @@ static MemcachedClient createCouchbaseClient(final MemcachedNodesManager memcach
             }
         }
 
+        protected static MemcachedNodeURLBasedConnectionFactory createMemcachedNodeURLBasedConnectionFactory() {
+            try {
+                Class.forName("net.spy.memcached.ClientMode");
+                return  Class.forName("de.javakaffee.web.msm.MemcachedElasticConnectionFactory").asSubclass(MemcachedNodeURLBasedConnectionFactory.class).newInstance();
+            } catch (final ClassNotFoundException e) {
+                try {
+                    return Class.forName("de.javakaffee.web.msm.MemcachedConnectionFactory").asSubclass(MemcachedNodeURLBasedConnectionFactory.class).newInstance();
+                } catch (final Exception ex)
+                {
+                    throw new RuntimeException(ex);
+                }
+            } catch (final Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+
         static ConnectionFactory createConnectionFactory(final MemcachedNodesManager memcachedNodesManager,
                                                             final ConnectionType connectionType, final String memcachedProtocol, final String username, final String password, final long operationTimeout,
                                                             final long maxReconnectDelay, final Statistics statistics ) {
+            boolean isClientDynamicMode = false;
+            if (memcachedNodesManager.getMemcachedNodes().contains(".cfg."))
+            {
+                isClientDynamicMode=true;
+            }
             if (PROTOCOL_BINARY.equals( memcachedProtocol )) {
                 if (connectionType.isSASL()) {
                     final AuthDescriptor authDescriptor = new AuthDescriptor(new String[]{"PLAIN"}, new PlainCallbackHandler(username, password));
@@ -97,30 +127,14 @@ static ConnectionFactory createConnectionFactory(final MemcachedNodesManager mem
                 else {
                     return memcachedNodesManager.isEncodeNodeIdInSessionId() ? new SuffixLocatorBinaryConnectionFactory( memcachedNodesManager,
                             memcachedNodesManager.getSessionIdFormat(),
-                            statistics, operationTimeout, maxReconnectDelay ) : new BinaryConnectionFactory() {
-                        @Override
-                        public long getOperationTimeout() {
-                            return operationTimeout;
-                        }
-                        @Override
-                        public long getMaxReconnectDelay() {
-                            return maxReconnectDelay;
-                        }
-                    };
+                            statistics, operationTimeout, maxReconnectDelay ) :
+                            createMemcachedNodeURLBasedConnectionFactory().createBinaryConnectionFactory(operationTimeout, maxReconnectDelay,isClientDynamicMode);
                 }
             }
             return memcachedNodesManager.isEncodeNodeIdInSessionId()
                     ? new SuffixLocatorConnectionFactory( memcachedNodesManager, memcachedNodesManager.getSessionIdFormat(), statistics, operationTimeout, maxReconnectDelay )
-                    : new DefaultConnectionFactory() {
-                @Override
-                public long getOperationTimeout() {
-                    return operationTimeout;
-                }
-                @Override
-                public long getMaxReconnectDelay() {
-                    return maxReconnectDelay;
-                }
-            };
+                    : createMemcachedNodeURLBasedConnectionFactory().createDefaultConnectionFactory(operationTimeout, maxReconnectDelay,isClientDynamicMode);
+
         }
 
     }