Update to new configuration system

Author: adrienlauer

CHANGELOG.md

@@ -1,3 +1,7 @@
+# Version 2.0.0 (2017-01-05)
+
+* [brk] Update to new configuration system.
+
 # Version 1.1.0 (2016-04-26)
 
 * [new] Automatically build indexes

core/pom.xml

@@ -14,7 +14,7 @@
     <parent>
         <groupId>org.seedstack.addons.mongodb</groupId>
         <artifactId>mongodb</artifactId>
-        <version>1.1.0-SNAPSHOT</version>
+        <version>2.0.0-SNAPSHOT</version>
     </parent>
 
 	<artifactId>mongodb-core</artifactId>
@@ -32,6 +32,7 @@
             <version>${mongodb.version}</version>
             <scope>provided</scope>
         </dependency>
+
         <dependency>
             <groupId>org.seedstack.seed</groupId>
             <artifactId>seed-testing</artifactId>

core/src/it/resources/META-INF/configuration/seed.props

@@ -0,0 +1,28 @@
+#
+# Copyright (c) 2013-2016, The SeedStack authors <http://seedstack.org>
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+mongoDb:
+  clients:
+    client1:
+      hosts: localhost
+      options:
+        connectionsPerHost: 50
+      databases: db1
+    client2:
+      async: true
+      hosts: localhost
+      settings:
+        connectionPool:
+          maxSize: 50
+      databases: db2
+    client3:
+      async: true
+      hosts: localhost
+      databases:
+        db2: db3
+

core/src/it/resources/application.yaml

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2013-2016, The SeedStack authors <http://seedstack.org>
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+package org.seedstack.mongodb;
+
+import org.seedstack.coffig.Config;
+import org.seedstack.coffig.SingleValue;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Config("mongoDb")
+public class MongoDbConfig {
+    private Map<String, ClientConfig> clients = new HashMap<>();
+
+    public Map<String, ClientConfig> getClients() {
+        return Collections.unmodifiableMap(clients);
+    }
+
+    public MongoDbConfig addClient(String name, ClientConfig config) {
+        this.clients.put(name, config);
+        return this;
+    }
+
+    public static class ClientConfig {
+        private boolean async = false;
+        @SingleValue
+        private String uri;
+        private List<String> hosts = new ArrayList<>();
+        private List<String> credentials = new ArrayList<>();
+        private Map<String, DatabaseConfig> databases = new HashMap<>();
+
+        public boolean isAsync() {
+            return async;
+        }
+
+        public ClientConfig setAsync(boolean async) {
+            this.async = async;
+            return this;
+        }
+
+        public boolean isConfiguredByUri() {
+            return uri != null;
+        }
+
+        public String getUri() {
+            return uri;
+        }
+
+        public ClientConfig setUri(String uri) {
+            if (!hosts.isEmpty()) {
+                throw new IllegalStateException("Cannot set MongoDb URI, the client is already configured through hosts");
+            }
+            this.uri = uri;
+            return this;
+        }
+
+        public List<String> getHosts() {
+            return Collections.unmodifiableList(hosts);
+        }
+
+        public ClientConfig addHost(String host) {
+            if (uri != null) {
+                throw new IllegalStateException("Cannot add MongoDb host, the client is already configured through an URI");
+            }
+            this.hosts.add(host);
+            return this;
+        }
+
+        public List<String> getCredentials() {
+            return Collections.unmodifiableList(credentials);
+        }
+
+        public ClientConfig addCredential(String credential) {
+            this.credentials.add(credential);
+            return this;
+        }
+
+        public Map<String, DatabaseConfig> getDatabases() {
+            return Collections.unmodifiableMap(databases);
+        }
+
+        public ClientConfig addDatabase(String name, DatabaseConfig databaseConfig) {
+            this.databases.put(name, databaseConfig);
+            return this;
+        }
+
+        public static class DatabaseConfig {
+            @SingleValue
+            private String alias;
+
+            public String getAlias() {
+                return alias;
+            }
+
+            public DatabaseConfig setAlias(String alias) {
+                this.alias = alias;
+                return this;
+            }
+        }
+    }
+}

core/src/main/java/org/seedstack/mongodb/MongoDbConfig.java

@@ -5,13 +5,15 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
-package org.seedstack.mongodb.morphia.internal;
+package org.seedstack.mongodb.internal;
 
+import com.google.common.base.Preconditions;
 import com.google.inject.Module;
 import com.mongodb.AuthenticationMechanism;
 import com.mongodb.MongoCredential;
 import com.mongodb.ServerAddress;
-import org.apache.commons.configuration.Configuration;
+import org.seedstack.coffig.Coffig;
+import org.seedstack.mongodb.MongoDbConfig;
 import org.seedstack.seed.SeedException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -26,23 +28,19 @@
 abstract class AbstractMongoDbManager<C, D> implements MongoDbManager {
     private static final Logger LOGGER = LoggerFactory.getLogger(AbstractMongoDbManager.class);
 
-    private final Map<String, C> mongoClients = new HashMap<String, C>();
-    private final Map<String, D> mongoDatabases = new HashMap<String, D>();
+    private final Map<String, C> mongoClients = new HashMap<>();
+    private final Map<String, D> mongoDatabases = new HashMap<>();
 
     @Override
-    public void registerClient(String clientName, Configuration clientConfiguration) {
+    public void registerClient(String clientName, MongoDbConfig.ClientConfig clientConfig, Coffig coffig) {
         LOGGER.info("Creating MongoDB client {}", clientName);
-        mongoClients.put(clientName, doCreateClient(clientConfiguration));
+        mongoClients.put(clientName, doCreateClient(clientName, clientConfig, coffig));
     }
 
     @Override
     public void registerDatabase(String clientName, String dbName, String alias) {
         C mongoClient = mongoClients.get(clientName);
-
-        if (mongoClient == null) {
-            throw SeedException.createNew(MongoDbErrorCodes.UNKNOWN_CLIENT_SPECIFIED).put("clientName", clientName).put("dbName", dbName);
-        }
-
+        Preconditions.checkNotNull(mongoClient, "Mongo client " + clientName + " is not registered");
         mongoDatabases.put(alias, doCreateDatabase(mongoClient, dbName));
     }
 
@@ -67,19 +65,11 @@ public void shutdown() {
     @SuppressWarnings("unchecked")
     public Module getModule() {
         Type[] actualTypeArguments = ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments();
-        return new MongoDbModule<C, D>((Class<C>) actualTypeArguments[0], (Class<D>) actualTypeArguments[1], mongoClients, mongoDatabases);
-    }
-
-    protected <T> T instanceFromClassName(Class<T> clazz, String className) {
-        try {
-            return Class.forName(className).asSubclass(clazz).newInstance();
-        } catch (Exception e) {
-            throw SeedException.wrap(e, MongoDbErrorCodes.UNABLE_TO_INSTANTIATE_CLASS).put("className", className);
-        }
+        return new MongoDbModule<>((Class<C>) actualTypeArguments[0], (Class<D>) actualTypeArguments[1], mongoClients, mongoDatabases);
     }
 
-    public List<ServerAddress> buildServerAddresses(String[] addresses) {
-        List<ServerAddress> serverAddresses = new ArrayList<ServerAddress>();
+    List<ServerAddress> buildServerAddresses(String clientName, List<String> addresses) {
+        List<ServerAddress> serverAddresses = new ArrayList<>();
 
         if (addresses != null) {
             for (String address : addresses) {
@@ -89,39 +79,45 @@ public List<ServerAddress> buildServerAddresses(String[] addresses) {
                 } else if (split.length == 2) {
                     serverAddresses.add(new ServerAddress(split[0], Integer.parseInt(split[1])));
                 } else {
-                    throw SeedException.createNew(MongoDbErrorCodes.UNABLE_TO_PARSE_SERVER_ADDRESS).put("address", address);
+                    throw SeedException.createNew(MongoDbErrorCode.INVALID_SERVER_ADDRESS)
+                            .put("clientName", clientName)
+                            .put("address", address);
                 }
             }
         }
 
         return serverAddresses;
     }
 
-    protected List<MongoCredential> buildMongoCredentials(String[] credentials) {
-        List<MongoCredential> mongoCredentials = new ArrayList<MongoCredential>();
+    List<MongoCredential> buildMongoCredentials(String clientName, List<String> credentials) {
+        List<MongoCredential> mongoCredentials = new ArrayList<>();
 
         if (credentials != null) {
             for (String credential : credentials) {
                 String[] elements = credential.split(":", 3);
                 if (elements.length == 3) {
                     String[] sourceElements = elements[0].split("/", 2);
                     if (sourceElements.length == 2) {
-                        mongoCredentials.add(buildMongoCredential(elements[1], elements[2], sourceElements[1], sourceElements[0]));
+                        mongoCredentials.add(buildMongoCredential(clientName, elements[1], elements[2], sourceElements[1], sourceElements[0]));
                     } else if (sourceElements.length == 1) {
-                        mongoCredentials.add(buildMongoCredential(elements[1], elements[2], sourceElements[0], null));
+                        mongoCredentials.add(buildMongoCredential(clientName, elements[1], elements[2], sourceElements[0], null));
                     } else {
-                        throw SeedException.createNew(MongoDbErrorCodes.INVALID_CREDENTIAL_SYNTAX).put("credential", credential);
+                        throw SeedException.createNew(MongoDbErrorCode.INVALID_CREDENTIAL_SYNTAX)
+                                .put("credential", credential)
+                                .put("clientName", clientName);
                     }
                 } else {
-                    throw SeedException.createNew(MongoDbErrorCodes.INVALID_CREDENTIAL_SYNTAX).put("credential", credential);
+                    throw SeedException.createNew(MongoDbErrorCode.INVALID_CREDENTIAL_SYNTAX)
+                            .put("credential", credential)
+                            .put("clientName", clientName);
                 }
             }
         }
 
         return mongoCredentials;
     }
 
-    protected MongoCredential buildMongoCredential(String user, String password, String source, String mechanism) {
+    MongoCredential buildMongoCredential(String clientName, String user, String password, String source, String mechanism) {
         if (mechanism != null) {
             AuthenticationMechanism authenticationMechanism = AuthenticationMechanism.fromMechanismName(mechanism);
             switch (authenticationMechanism) {
@@ -136,7 +132,9 @@ protected MongoCredential buildMongoCredential(String user, String password, Str
                 case GSSAPI:
                     return MongoCredential.createGSSAPICredential(user);
                 default:
-                    throw SeedException.createNew(MongoDbErrorCodes.UNSUPPORTED_AUTHENTICATION_MECHANISM).put("mechanism", authenticationMechanism.getMechanismName());
+                    throw SeedException.createNew(MongoDbErrorCode.UNSUPPORTED_AUTHENTICATION_MECHANISM)
+                            .put("clientName", clientName)
+                            .put("mechanism", authenticationMechanism.getMechanismName());
             }
         } else {
             return MongoCredential.createCredential(
@@ -147,7 +145,7 @@ protected MongoCredential buildMongoCredential(String user, String password, Str
         }
     }
 
-    protected abstract C doCreateClient(Configuration clientConfiguration);
+    protected abstract C doCreateClient(String clientName, MongoDbConfig.ClientConfig clientConfiguration, Coffig coffig);
 
     protected abstract D doCreateDatabase(C client, String dbName);