DATAMONGO-1158 - Add config option for credentials to mongo-client.

Added credentials attribute to <monog-client> which allows to define a set of credentials used for setting up the MongoClient correctly using authentication data.

Author: christophstrobl

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MongoClientParser.java

@@ -50,6 +50,7 @@ public BeanDefinition parse(Element element, ParserContext parserContext) {
 
 		ParsingUtils.setPropertyValue(builder, element, "port", "port");
 		ParsingUtils.setPropertyValue(builder, element, "host", "host");
+		ParsingUtils.setPropertyValue(builder, element, "credentials", "credentials");
 
 		MongoParsingUtils.parseMongoClientOptions(element, builder);
 		MongoParsingUtils.parseReplicaSet(element, builder);
@@ -73,6 +74,10 @@ public BeanDefinition parse(Element element, ParserContext parserContext) {
 				.getReadPreferencePropertyEditorBuilder());
 		parserContext.registerBeanComponent(readPreferenceEditor);
 
+		BeanComponentDefinition credentialsEditor = helper.getComponent(MongoParsingUtils
+				.getMongoCredentialPropertyEditor());
+		parserContext.registerBeanComponent(credentialsEditor);
+
 		parserContext.popAndRegisterContainingComponent();
 
 		return mongoComponent.getBeanDefinition();

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MongoCredentialPropertyEditor.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2015 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.config;
+
+import java.beans.PropertyEditorSupport;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+import org.springframework.util.StringUtils;
+
+import com.mongodb.MongoCredential;
+
+/**
+ * Parse a {@link String} to a Collection of {@link MongoCredential}.
+ * 
+ * @author Christoph Strobl
+ * @since 1.7
+ */
+public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
+
+	private static final String AUTH_MECHANISM_KEY = "uri.authMechanism";
+	private static final String USERNAME_PASSWORD_DELIMINATOR = ":";
+	private static final String DATABASE_DELIMINATOR = "@";
+	private static final String OPTIONS_DELIMINATOR = "?";
+	private static final String OPTION_VALUE_DELIMINATOR = "&";
+
+	@Override
+	public void setAsText(String text) throws IllegalArgumentException {
+
+		if (!StringUtils.hasText(text)) {
+			return;
+		}
+
+		List<MongoCredential> credentials = new ArrayList<MongoCredential>();
+		for (String credentialString : text.split(",")) {
+
+			if (!text.contains(USERNAME_PASSWORD_DELIMINATOR) || !text.contains(DATABASE_DELIMINATOR)) {
+				throw new IllegalArgumentException("Credentials need to be in format 'username:password@database'!");
+			}
+
+			String[] userNameAndPassword = extractUserNameAndPassword(credentialString);
+			String database = extractDB(credentialString);
+			Properties options = extractOptions(credentialString);
+
+			if (!options.isEmpty()) {
+				if (options.containsKey(AUTH_MECHANISM_KEY)) {
+					String authMechanism = options.getProperty(AUTH_MECHANISM_KEY);
+					if (MongoCredential.GSSAPI_MECHANISM.equals(authMechanism)) {
+						credentials.add(MongoCredential.createGSSAPICredential(userNameAndPassword[0]));
+					} else if (MongoCredential.MONGODB_CR_MECHANISM.equals(authMechanism)) {
+						credentials.add(MongoCredential.createMongoCRCredential(userNameAndPassword[0], database,
+								userNameAndPassword[1].toCharArray()));
+					} else if (MongoCredential.MONGODB_X509_MECHANISM.equals(authMechanism)) {
+						credentials.add(MongoCredential.createMongoX509Credential(userNameAndPassword[0]));
+					} else if (MongoCredential.PLAIN_MECHANISM.equals(authMechanism)) {
+						credentials.add(MongoCredential.createPlainCredential(userNameAndPassword[0], database,
+								userNameAndPassword[1].toCharArray()));
+					} else if (MongoCredential.SCRAM_SHA_1_MECHANISM.equals(authMechanism)) {
+						credentials.add(MongoCredential.createScramSha1Credential(userNameAndPassword[0], database,
+								userNameAndPassword[1].toCharArray()));
+					} else {
+						throw new IllegalArgumentException(String.format(
+								"Cannot create MongoCredentials for unknown auth mechanism '%s'!", authMechanism));
+					}
+				}
+			} else {
+				credentials.add(MongoCredential.createCredential(userNameAndPassword[0], database,
+						userNameAndPassword[1].toCharArray()));
+			}
+		}
+
+		setValue(credentials);
+	}
+
+	private String[] extractUserNameAndPassword(String text) {
+
+		int dbSeperationIndex = text.lastIndexOf(DATABASE_DELIMINATOR);
+		String userNameAndPassword = text.substring(0, dbSeperationIndex);
+		return userNameAndPassword.split(USERNAME_PASSWORD_DELIMINATOR);
+	}
+
+	private String extractDB(String text) {
+
+		int dbSeperationIndex = text.lastIndexOf(DATABASE_DELIMINATOR);
+
+		String tmp = text.substring(dbSeperationIndex + 1);
+		int optionsSeperationIndex = tmp.lastIndexOf(OPTIONS_DELIMINATOR);
+
+		return optionsSeperationIndex > -1 ? tmp.substring(0, optionsSeperationIndex) : tmp;
+	}
+
+	private Properties extractOptions(String text) {
+
+		int optionsSeperationIndex = text.lastIndexOf(OPTIONS_DELIMINATOR);
+		int dbSeperationIndex = text.lastIndexOf(OPTIONS_DELIMINATOR);
+
+		if (optionsSeperationIndex == -1 || dbSeperationIndex > optionsSeperationIndex) {
+			return new Properties();
+		}
+
+		Properties properties = new Properties();
+
+		for (String option : text.substring(optionsSeperationIndex + 1).split(OPTION_VALUE_DELIMINATOR)) {
+			String[] optionArgs = option.split("=");
+			properties.put(optionArgs[0], optionArgs[1]);
+		}
+
+		return properties;
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MongoParsingUtils.java

@@ -147,6 +147,22 @@ static BeanDefinitionBuilder getWriteConcernPropertyEditorBuilder() {
 		return builder;
 	}
 
+	/**
+	 * One should only register one bean definition but want to have the convenience of using
+	 * AbstractSingleBeanDefinitionParser but have the side effect of registering a 'default' property editor with the
+	 * container.
+	 */
+	static BeanDefinitionBuilder getServerAddressPropertyEditorBuilder() {
+
+		Map<String, String> customEditors = new ManagedMap<String, String>();
+		customEditors.put("com.mongodb.ServerAddress[]",
+				"org.springframework.data.mongodb.config.ServerAddressPropertyEditor");
+
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
+		builder.addPropertyValue("customEditors", customEditors);
+		return builder;
+	}
+
 	/**
 	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
 	 * {@link ReadPreferencePropertyEditor}.
@@ -166,18 +182,20 @@ static BeanDefinitionBuilder getReadPreferencePropertyEditorBuilder() {
 	}
 
 	/**
-	 * One should only register one bean definition but want to have the convenience of using
-	 * AbstractSingleBeanDefinitionParser but have the side effect of registering a 'default' property editor with the
-	 * container.
+	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
+	 * {@link MongoCredentialPropertyEditor}.
+	 * 
+	 * @return
+	 * @since 1.7
 	 */
-	static BeanDefinitionBuilder getServerAddressPropertyEditorBuilder() {
+	static BeanDefinitionBuilder getMongoCredentialPropertyEditor() {
 
-		Map<String, String> customEditors = new ManagedMap<String, String>();
-		customEditors.put("com.mongodb.ServerAddress[]",
-				"org.springframework.data.mongodb.config.ServerAddressPropertyEditor");
+		Map<String, Class<?>> customEditors = new ManagedMap<String, Class<?>>();
+		customEditors.put("com.mongodb.MongoCredential[]", MongoCredentialPropertyEditor.class);
 
 		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
 		builder.addPropertyValue("customEditors", customEditors);
+
 		return builder;
 	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoClientFactoryBean.java

@@ -68,8 +68,8 @@ public void setMongoClientOptions(MongoClientOptions mongoClientOptions) {
 	 * 
 	 * @param credentials can be {@literal null}.
 	 */
-	public void setCredentials(List<MongoCredential> credentials) {
-		this.credentials = credentials;
+	public void setCredentials(MongoCredential[] credentials) {
+		this.credentials = filterNonNullElementsAsList(credentials);
 	}
 
 	public void setReplicaSetSeeds(ServerAddress[] replicaSetSeeds) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoFactoryBean.java

@@ -30,7 +30,6 @@
 import org.springframework.util.StringUtils;
 
 import com.mongodb.Mongo;
-import com.mongodb.MongoCredential;
 import com.mongodb.MongoOptions;
 import com.mongodb.ServerAddress;
 import com.mongodb.WriteConcern;
@@ -59,7 +58,6 @@ public class MongoFactoryBean implements FactoryBean<Mongo>, InitializingBean, D
 	private WriteConcern writeConcern;
 	private List<ServerAddress> replicaSetSeeds;
 	private List<ServerAddress> replicaPair;
-	private List<MongoCredential> credentials;
 
 	private PersistenceExceptionTranslator exceptionTranslator = new MongoExceptionTranslator();
 

spring-data-mongodb/src/main/resources/org/springframework/data/mongodb/config/spring-mongo-1.7.xsd

@@ -586,7 +586,7 @@ The comma delimited list of host:port entries to use for replica set/pairs.
 		<xsd:attribute name="credentials" type="xsd:string" use="optional">
 			<xsd:annotation>
 				<xsd:documentation><![CDATA[
-The comma delimited list of username:password entries to use for authentication.
+The comma delimited list of username:password@database entries to use for authentication. Appending ?uri.authMechanism allows to specify the authentication challenge mechanism.
 							]]></xsd:documentation>
 			</xsd:annotation>
 		</xsd:attribute>

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoClientParserIntegrationTests.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.mongodb.config;
 
+import static org.hamcrest.collection.IsIterableContainingInOrder.*;
 import static org.hamcrest.core.Is.*;
 import static org.hamcrest.core.IsInstanceOf.*;
 import static org.junit.Assert.*;
@@ -29,6 +30,7 @@
 import org.springframework.core.io.ClassPathResource;
 
 import com.mongodb.MongoClient;
+import com.mongodb.MongoCredential;
 import com.mongodb.ReadPreference;
 import com.mongodb.WriteConcern;
 
@@ -102,4 +104,25 @@ public void createsMongoClientWithDefaultsCorrectly() {
 			context.close();
 		}
 	}
+
+	/**
+	 * @see DATAMONGO-1158
+	 */
+	@Test
+	public void createsMongoClientWithCredentialsCorrectly() {
+
+		reader.loadBeanDefinitions(new ClassPathResource("namespace/mongoClient-bean.xml"));
+
+		AbstractApplicationContext context = new GenericApplicationContext(factory);
+		context.refresh();
+
+		try {
+			MongoClient client = context.getBean("mongo-client-with-credentials", MongoClient.class);
+
+			assertThat(client.getCredentialsList(),
+					contains(MongoCredential.createPlainCredential("jon", "snow", "warg".toCharArray())));
+		} finally {
+			context.close();
+		}
+	}
 }