You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by ac...@apache.org on 2019/10/03 13:37:32 UTC
[camel] branch master updated (280669e -> 5926e27)
This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git.
from 280669e Regen
new 86b61ba Adding support for meta and verifier extension
new 5926e27 Additional fixes according feedback provided in PR #3217
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../camel/component/mongodb/MongoDbComponent.java | 4 +
.../conf/ConnectionParamsConfiguration.java | 80 +++++++++++
.../mongodb/meta/MongoDBMetaExtension.java | 106 ++++++++++++++
.../verifier/MongoComponentVerifierExtension.java | 101 ++++++++++++++
.../component/mongodb/AbstractMongoDbTest.java | 33 +++++
.../component/mongodb/EmbedMongoConfiguration.java | 2 +-
.../mongodb/meta/MongoDbMetaExtensionTest.java | 153 +++++++++++++++++++++
.../verifier/MongoDbVerifierExtensionTest.java | 140 +++++++++++++++++++
8 files changed, 618 insertions(+), 1 deletion(-)
create mode 100644 components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/ConnectionParamsConfiguration.java
create mode 100644 components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java
create mode 100644 components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java
create mode 100644 components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/meta/MongoDbMetaExtensionTest.java
create mode 100644 components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/verifier/MongoDbVerifierExtensionTest.java
[camel] 01/02: Adding support for meta and verifier extension
Posted by ac...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 86b61ba6b3eb7e2139e804f05ae3e22dc056e4b8
Author: Pasquale Congiusti <pa...@gmail.com>
AuthorDate: Tue Oct 1 08:24:20 2019 +0200
Adding support for meta and verifier extension
Fixes CAMEL-14022
---
.../camel/component/mongodb/MongoDbComponent.java | 4 +
.../component/mongodb/conf/MongoConfiguration.java | 85 ++++++++++++
.../mongodb/meta/MongoDBMetaExtension.java | 104 ++++++++++++++
.../verifier/MongoComponentVerifierExtension.java | 101 ++++++++++++++
.../component/mongodb/AbstractMongoDbTest.java | 24 ++++
.../component/mongodb/EmbedMongoConfiguration.java | 2 +-
.../mongodb/meta/MongoDbMetaExtensionTest.java | 153 +++++++++++++++++++++
.../verifier/MongoDbVerifierExtensionTest.java | 140 +++++++++++++++++++
8 files changed, 612 insertions(+), 1 deletion(-)
diff --git a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/MongoDbComponent.java b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/MongoDbComponent.java
index 032620c..c0a9838 100644
--- a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/MongoDbComponent.java
+++ b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/MongoDbComponent.java
@@ -24,6 +24,8 @@ import java.util.Set;
import com.mongodb.MongoClient;
import org.apache.camel.CamelContext;
import org.apache.camel.Endpoint;
+import org.apache.camel.component.mongodb.meta.MongoDBMetaExtension;
+import org.apache.camel.component.mongodb.verifier.MongoComponentVerifierExtension;
import org.apache.camel.spi.annotations.Component;
import org.apache.camel.support.DefaultComponent;
@@ -50,6 +52,8 @@ public class MongoDbComponent extends DefaultComponent {
public MongoDbComponent(CamelContext context) {
super(context);
+ registerExtension(MongoComponentVerifierExtension::new);
+ registerExtension(MongoDBMetaExtension::new);
}
@Override
diff --git a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/MongoConfiguration.java b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/MongoConfiguration.java
new file mode 100644
index 0000000..1d8509f
--- /dev/null
+++ b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/MongoConfiguration.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.camel.component.mongodb.conf;
+
+import java.util.Map;
+
+public class MongoConfiguration {
+
+ private String host = "localhost:27017";
+ private String user;
+ private String password;
+ private String adminDB = "admin";
+
+ public MongoConfiguration() {
+ super();
+ }
+
+ public MongoConfiguration(Map<String, String> parameters) {
+ super();
+ this.host = parameters.get("host");
+ this.user = parameters.get("user");
+ this.password = parameters.get("password");
+ // Optional parameters
+ String optionalAdminDB = parameters.getOrDefault("adminDB", "");
+ if (!"".equals(optionalAdminDB)) {
+ this.adminDB = optionalAdminDB;
+ }
+ }
+
+ public String getHost() {
+ return host;
+ }
+
+ public void setHost(String host) {
+ this.host = host;
+ }
+
+ public String getUser() {
+ return user;
+ }
+
+ public void setUser(String user) {
+ this.user = user;
+ }
+
+ public String getPassword() {
+ return password;
+ }
+
+ public void setPassword(String password) {
+ this.password = password;
+ }
+
+ public String getAdminDB() {
+ return adminDB;
+ }
+
+ public void setAdminDB(String adminDB) {
+ this.adminDB = adminDB;
+ }
+
+ public String getMongoClientURI() {
+ return String.format("mongodb://%s:%s@%s/%s", this.user, this.password, this.host, this.adminDB);
+ }
+
+ @Override
+ public String toString() {
+ return "MongoConfiguration [host(s)=" + host + ", user=" + user + ", password=***, adminDB=" + adminDB + "]";
+ }
+
+}
diff --git a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java
new file mode 100644
index 0000000..5c493f3
--- /dev/null
+++ b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.camel.component.mongodb.meta;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Optional;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientURI;
+import com.mongodb.client.model.Filters;
+import org.apache.camel.CamelContext;
+import org.apache.camel.component.extension.metadata.AbstractMetaDataExtension;
+import org.apache.camel.component.extension.metadata.MetaDataBuilder;
+import org.apache.camel.component.mongodb.MongoDbComponent;
+import org.apache.camel.component.mongodb.conf.MongoConfiguration;
+import org.bson.Document;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.camel.util.CastUtils.cast;
+
+public class MongoDBMetaExtension extends AbstractMetaDataExtension {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(MongoDBMetaExtension.class);
+
+ private ObjectMapper objectMapper = new ObjectMapper();
+
+ public MongoDBMetaExtension() {
+ this(null);
+ }
+
+ public MongoDBMetaExtension(CamelContext context) {
+ super(context);
+ }
+
+ @Override
+ public Optional<MetaData> meta(Map<String, Object> parameters) {
+ Map<String, String> textParameters = cast(parameters);
+ LOGGER.debug("Fetching mongodb meta information with params: {}", textParameters);
+
+ MongoConfiguration mongoConf = new MongoConfiguration(textParameters);
+ MongoClientURI connectionURI = new MongoClientURI(mongoConf.getMongoClientURI());
+
+ JsonNode collectionInfoRoot = null;
+ try (MongoClient mongoConnection = new MongoClient(connectionURI)) {
+ Document collectionInfo = mongoConnection.getDatabase(textParameters.get("database"))
+ .listCollections()
+ .filter(Filters.eq("name", textParameters.get("collection"))).first();
+ LOGGER.debug("Collection info: {}", collectionInfo);
+ if (collectionInfo == null) {
+ LOGGER.error("Cannot read information for collection {}.{}", textParameters.get("database"),
+ textParameters.get("collection"));
+ return Optional.empty();
+ }
+ String collectionInfoJson = collectionInfo.toJson();
+ collectionInfoRoot = objectMapper.readTree(collectionInfoJson.replaceAll("bsonType", "type"));
+ } catch (IOException e) {
+ LOGGER.error("Error occurred while reading schema information", e);
+ return Optional.empty();
+ }
+
+ JsonNode schemaRoot = collectionInfoRoot.path("options").path("validator").path("$jsonSchema");
+
+ if (!schemaRoot.isMissingNode()) {
+ ObjectNode root = (ObjectNode) schemaRoot;
+ root.put("$schema", "http://json-schema.org/schema#");
+ root.put("id", String.format("urn:jsonschema:%s:%s:%s)",
+ "org:apache:camel:component:mongodb",
+ textParameters.get("database"),
+ textParameters.get("collection")));
+
+ return Optional.of(
+ MetaDataBuilder.on(getCamelContext())
+ .withAttribute(MetaData.CONTENT_TYPE, "application/schema+json")
+ .withAttribute(MetaData.JAVA_TYPE, JsonNode.class)
+ .withPayload(root)
+ .build()
+ );
+ } else {
+ LOGGER.warn("Cannot retrieve info for : {}.{} collection. Likely the collection has not been provided with a validator",
+ textParameters.get("database"),
+ textParameters.get("collection"));
+ return Optional.empty();
+ }
+ }
+}
diff --git a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java
new file mode 100644
index 0000000..99d05c9
--- /dev/null
+++ b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.camel.component.mongodb.verifier;
+
+import java.util.Map;
+
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientOptions;
+import com.mongodb.MongoClientURI;
+import com.mongodb.MongoSecurityException;
+import com.mongodb.MongoTimeoutException;
+import org.apache.camel.component.extension.verifier.DefaultComponentVerifierExtension;
+import org.apache.camel.component.extension.verifier.ResultBuilder;
+import org.apache.camel.component.extension.verifier.ResultErrorBuilder;
+import org.apache.camel.component.extension.verifier.ResultErrorHelper;
+import org.apache.camel.component.mongodb.conf.MongoConfiguration;
+import org.bson.Document;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.camel.util.CastUtils.cast;
+
+public class MongoComponentVerifierExtension extends DefaultComponentVerifierExtension {
+ private static final Logger LOG = LoggerFactory.getLogger(MongoComponentVerifierExtension.class);
+
+ private static final int CONNECTION_TIMEOUT = 2000;
+
+ public MongoComponentVerifierExtension() {
+ super("mongodb");
+ }
+
+ @Override
+ public Result verifyParameters(Map<String, Object> parameters) {
+ ResultBuilder builder = ResultBuilder.withStatusAndScope(Result.Status.OK, Scope.PARAMETERS)
+ .error(ResultErrorHelper.requiresOption("host", parameters))
+ .error(ResultErrorHelper.requiresOption("user", parameters))
+ .error(ResultErrorHelper.requiresOption("password", parameters));
+ return builder.build();
+ }
+
+ @Override
+ public Result verifyConnectivity(Map<String, Object> parameters) {
+ return ResultBuilder.withStatusAndScope(Result.Status.OK, Scope.CONNECTIVITY)
+ .error(parameters, this::verifyCredentials)
+ .build();
+ }
+
+ private void verifyCredentials(ResultBuilder builder, Map<String, Object> parameters) {
+ MongoConfiguration mongoConf = new MongoConfiguration(cast(parameters));
+ MongoClientOptions.Builder optionsBuilder = MongoClientOptions.builder();
+ // Avoid retry and long timeout
+ optionsBuilder.connectTimeout(CONNECTION_TIMEOUT);
+ optionsBuilder.serverSelectionTimeout(CONNECTION_TIMEOUT);
+ optionsBuilder.maxWaitTime(CONNECTION_TIMEOUT);
+ MongoClientURI connectionURI = new MongoClientURI(mongoConf.getMongoClientURI(), optionsBuilder);
+
+ LOG.info("Testing connection against {}", connectionURI);
+ try (MongoClient mongoClient = new MongoClient(connectionURI)) {
+ // Just ping the server
+ mongoClient.getDatabase(connectionURI.getDatabase()).runCommand(Document.parse("{ ping: 1 }"));
+ LOG.info("Testing connection successful!");
+ } catch (MongoSecurityException e) {
+ ResultErrorBuilder errorBuilder = ResultErrorBuilder.withCodeAndDescription(
+ VerificationError.StandardCode.AUTHENTICATION,
+ String.format("Unable to authenticate %s against %s authentication database!", mongoConf.getUser(), mongoConf.getAdminDB()));
+ builder.error(errorBuilder.build());
+ } catch (MongoTimeoutException e) {
+ // When there is any connection exception, the driver tries to reconnect until timeout is reached
+ // wrapping the original socket exception into a timeout exception
+ String description = null;
+ VerificationError.StandardCode code = VerificationError.StandardCode.GENERIC;
+ if (e.getMessage().contains("com.mongodb.MongoSecurityException")) {
+ code = VerificationError.StandardCode.AUTHENTICATION;
+ description = String.format("Unable to authenticate %s against %s authentication database!", mongoConf.getUser(), mongoConf.getAdminDB());
+ } else if (e.getMessage().contains("com.mongodb.MongoSocket") && e.getMessage().contains("Exception")) {
+ description = String.format("Unable to connect to %s!", mongoConf.getHost());
+ } else {
+ description = String.format("Generic exception while connecting to %s!", mongoConf.getHost());
+ }
+ ResultErrorBuilder errorBuilder = ResultErrorBuilder.withCodeAndDescription(
+ code,
+ String.format(description));
+ builder.error(errorBuilder.build());
+ }
+ }
+}
+
diff --git a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java
index ea35154..ad361d3 100644
--- a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java
+++ b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java
@@ -34,6 +34,11 @@ import org.springframework.context.annotation.AnnotationConfigApplicationContext
public abstract class AbstractMongoDbTest extends CamelTestSupport {
+ protected static final String SCHEME = "mongodb";
+ protected static final String HOST = "localhost:" + EmbedMongoConfiguration.PORT;
+ protected static final String USER = "test-user";
+ protected static final String PASSWORD = "test-pwd";
+
protected static MongoClient mongo;
protected static MongoDatabase db;
protected static MongoCollection<Document> testCollection;
@@ -83,6 +88,25 @@ public abstract class AbstractMongoDbTest extends CamelTestSupport {
return ctx;
}
+ /**
+ * Useful to simulate the presence of an authenticated user with
+ * name {@value #USER} and password {@value #PASSWORD}
+ */
+ protected void createAuthorizationUser() {
+ MongoDatabase admin = mongo.getDatabase("admin");
+ MongoCollection<Document> usersCollection = admin.getCollection("system.users");
+ if (usersCollection.count() == 0) {
+ usersCollection.insertOne(Document.parse("{\n" + " \"_id\": \"admin.test-user\",\n"
+ + " \"user\": \"test-user\",\n" + " \"db\": \"admin\",\n" + " \"credentials\": {\n"
+ + " \"SCRAM-SHA-1\": {\n" + " \"iterationCount\": 10000,\n"
+ + " \"salt\": \"gmmPAoNdvFSWCV6PGnNcAw==\",\n"
+ + " \"storedKey\": \"qE9u1Ax7Y40hisNHL2b8/LAvG7s=\",\n"
+ + " \"serverKey\": \"RefeJcxClt9JbOP/VnrQ7YeQh6w=\"\n" + " }\n" + " },\n"
+ + " \"roles\": [\n" + " {\n" + " \"role\": \"readWrite\",\n"
+ + " \"db\": \"test\"\n" + " }\n" + " ]\n" + "}" + ""));
+ }
+ }
+
protected void pumpDataIntoTestCollection() {
// there should be 100 of each
String[] scientists = {"Einstein", "Darwin", "Copernicus", "Pasteur", "Curie", "Faraday", "Newton", "Bohr", "Galilei", "Maxwell"};
diff --git a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/EmbedMongoConfiguration.java b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/EmbedMongoConfiguration.java
index 3cec1f0..0c81499 100644
--- a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/EmbedMongoConfiguration.java
+++ b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/EmbedMongoConfiguration.java
@@ -43,7 +43,7 @@ import static org.springframework.util.SocketUtils.findAvailableTcpPort;
@Configuration
public class EmbedMongoConfiguration {
- private static final int PORT = findAvailableTcpPort();
+ public static final int PORT = findAvailableTcpPort();
static {
try {
diff --git a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/meta/MongoDbMetaExtensionTest.java b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/meta/MongoDbMetaExtensionTest.java
new file mode 100644
index 0000000..51ee8a5
--- /dev/null
+++ b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/meta/MongoDbMetaExtensionTest.java
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.camel.component.mongodb.meta;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.mongodb.client.model.CreateCollectionOptions;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.ValidationOptions;
+import org.apache.camel.component.extension.MetaDataExtension;
+import org.apache.camel.component.mongodb.AbstractMongoDbTest;
+import org.apache.camel.component.mongodb.MongoDbComponent;
+import org.bson.Document;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MongoDbMetaExtensionTest extends AbstractMongoDbTest {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(MongoDbMetaExtensionTest.class);
+
+ // We simulate the presence of an authenticated user
+ @Before
+ public void createAuthorizationUser() {
+ super.createAuthorizationUser();
+ }
+
+ @Override
+ public boolean isUseRouteBuilder() {
+ return false;
+ }
+
+ protected MongoDbComponent getComponent() {
+ return context().getComponent(SCHEME, MongoDbComponent.class);
+ }
+
+ @Test
+ public void testValidMetaData() throws Exception {
+ // When
+ final String database = "test";
+ final String collection = "validatedCollection";
+ MongoDbComponent component = this.getComponent();
+ // Given
+ Document jsonSchema = Document.parse("{ \n"
+ + " bsonType: \"object\", \n"
+ + " required: [ \"name\", \"surname\", \"email\" ], \n"
+ + " properties: { \n"
+ + " name: { \n"
+ + " bsonType: \"string\", \n"
+ + " description: \"required and must be a string\" }, \n"
+ + " surname: { \n"
+ + " bsonType: \"string\", \n"
+ + " description: \"required and must be a string\" }, \n"
+ + " email: { \n"
+ + " bsonType: \"string\", \n"
+ + " pattern: \"^.+@.+$\", \n"
+ + " description: \"required and must be a valid email address\" }, \n"
+ + " year_of_birth: { \n"
+ + " bsonType: \"int\", \n"
+ + " minimum: 1900, \n"
+ + " maximum: 2018,\n"
+ + " description: \"the value must be in the range 1900-2018\" }, \n"
+ + " gender: { \n"
+ + " enum: [ \"M\", \"F\" ], \n"
+ + " description: \"can be only M or F\" } \n"
+ + " }}");
+ ValidationOptions collOptions = new ValidationOptions().validator(Filters.jsonSchema(jsonSchema));
+ AbstractMongoDbTest.mongo.getDatabase(database).createCollection(collection,
+ new CreateCollectionOptions().validationOptions(collOptions));
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("database", database);
+ parameters.put("collection", collection);
+ parameters.put("host", HOST);
+ parameters.put("user", USER);
+ parameters.put("password", PASSWORD);
+
+ MetaDataExtension.MetaData result = component.getExtension(MetaDataExtension.class).get().meta(parameters).orElseThrow(UnsupportedOperationException::new);
+ // Then
+ assertEquals("application/schema+json", result.getAttribute(MetaDataExtension.MetaData.CONTENT_TYPE));
+ assertEquals(JsonNode.class, result.getAttribute(MetaDataExtension.MetaData.JAVA_TYPE));
+ assertNotNull(result.getPayload(JsonNode.class));
+ assertNotNull(result.getPayload(JsonNode.class).get("properties"));
+ assertNotNull(result.getPayload(JsonNode.class).get("$schema"));
+ assertEquals("http://json-schema.org/schema#", result.getPayload(JsonNode.class).get("$schema").asText());
+ assertNotNull(result.getPayload(JsonNode.class).get("id"));
+ assertNotNull(result.getPayload(JsonNode.class).get("type"));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testMissingCollection() throws Exception {
+ // When
+ final String database = "test";
+ final String collection = "missingCollection";
+ MongoDbComponent component = this.getComponent();
+ // Given
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("database", database);
+ parameters.put("collection", collection);
+ parameters.put("host", HOST);
+ parameters.put("user", USER);
+ parameters.put("password", PASSWORD);
+
+ // Then
+ MetaDataExtension.MetaData result = component.getExtension(MetaDataExtension.class).get().meta(parameters).orElseThrow(IllegalArgumentException::new);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testMissingParameters() throws Exception {
+ // When
+ MongoDbComponent component = this.getComponent();
+ // Given
+ Map<String, Object> parameters = new HashMap<>();
+ // Then
+ MetaDataExtension.MetaData result = component.getExtension(MetaDataExtension.class).get().meta(parameters).orElseThrow(IllegalArgumentException::new);
+ }
+
+ @Test(expected = UnsupportedOperationException.class)
+ public void testNotValidatedCollection() throws Exception {
+ // When
+ final String database = "test";
+ final String collection = "notValidatedCollection";
+ MongoDbComponent component = this.getComponent();
+ AbstractMongoDbTest.mongo.getDatabase(database).createCollection(collection);
+ // Given
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("database", database);
+ parameters.put("collection", collection);
+ parameters.put("host", HOST);
+ parameters.put("user", USER);
+ parameters.put("password", PASSWORD);
+
+ // Then
+ MetaDataExtension.MetaData result = component.getExtension(MetaDataExtension.class).get().meta(parameters).orElseThrow(UnsupportedOperationException::new);
+ }
+
+}
diff --git a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/verifier/MongoDbVerifierExtensionTest.java b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/verifier/MongoDbVerifierExtensionTest.java
new file mode 100644
index 0000000..010bc98
--- /dev/null
+++ b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/verifier/MongoDbVerifierExtensionTest.java
@@ -0,0 +1,140 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.camel.component.mongodb.verifier;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.camel.Component;
+import org.apache.camel.component.extension.ComponentVerifierExtension;
+import org.apache.camel.component.mongodb.AbstractMongoDbTest;
+import org.apache.camel.component.mongodb.MongoDbComponent;
+import org.junit.Before;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MongoDbVerifierExtensionTest extends AbstractMongoDbTest {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(MongoDbVerifierExtensionTest.class);
+
+ // We simulate the presence of an authenticated user
+ @Before
+ public void createAuthorizationUser() {
+ super.createAuthorizationUser();
+ }
+
+ @Override
+ public boolean isUseRouteBuilder() {
+ return false;
+ }
+
+ protected MongoDbComponent getComponent() {
+ return context().getComponent(SCHEME, MongoDbComponent.class);
+ }
+
+ protected ComponentVerifierExtension getExtension() {
+ Component component = context().getComponent(SCHEME);
+ ComponentVerifierExtension verifier = component.getExtension(ComponentVerifierExtension.class).orElseThrow(IllegalStateException::new);
+
+ return verifier;
+ }
+
+ @Test
+ public void verifyConnectionOK() {
+ //When
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("host", HOST);
+ parameters.put("user", USER);
+ parameters.put("password", PASSWORD);
+ //Given
+ ComponentVerifierExtension.Result result = getExtension().verify(ComponentVerifierExtension.Scope.CONNECTIVITY, parameters);
+ //Then
+ assertEquals(ComponentVerifierExtension.Result.Status.OK, result.getStatus());
+ }
+
+ @Test
+ public void verifyConnectionKO() {
+ //When
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("host", "notReachableHost");
+ parameters.put("user", USER);
+ parameters.put("password", PASSWORD);
+ //Given
+ ComponentVerifierExtension.Result result = getExtension().verify(ComponentVerifierExtension.Scope.CONNECTIVITY, parameters);
+ //Then
+ assertEquals(ComponentVerifierExtension.Result.Status.ERROR, result.getStatus());
+ assertTrue(result.getErrors().get(0).getDescription().startsWith("Unable to connect"));
+ }
+
+ @Test
+ public void verifyConnectionMissingParams() {
+ //When
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("host", HOST);
+ parameters.put("user", USER);
+ //Given
+ ComponentVerifierExtension.Result result = getExtension().verify(ComponentVerifierExtension.Scope.PARAMETERS, parameters);
+ //Then
+ assertEquals(ComponentVerifierExtension.Result.Status.ERROR, result.getStatus());
+ assertTrue(result.getErrors().get(0).getDescription().startsWith("password should be set"));
+ }
+
+ @Test
+ public void verifyConnectionNotAuthenticated() {
+ //When
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("host", HOST);
+ parameters.put("user", USER);
+ parameters.put("password", "wrongPassword");
+ //Given
+ ComponentVerifierExtension.Result result = getExtension().verify(ComponentVerifierExtension.Scope.CONNECTIVITY, parameters);
+ //Then
+ assertEquals(ComponentVerifierExtension.Result.Status.ERROR, result.getStatus());
+ assertTrue(result.getErrors().get(0).getDescription().startsWith("Unable to authenticate"));
+ }
+
+ @Test
+ public void verifyConnectionAdminDBKO() {
+ //When
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("host", HOST);
+ parameters.put("user", USER);
+ parameters.put("password", PASSWORD);
+ parameters.put("adminDB", "someAdminDB");
+ //Given
+ ComponentVerifierExtension.Result result = getExtension().verify(ComponentVerifierExtension.Scope.CONNECTIVITY, parameters);
+ //Then
+ assertEquals(ComponentVerifierExtension.Result.Status.ERROR, result.getStatus());
+ assertTrue(result.getErrors().get(0).getDescription().startsWith("Unable to authenticate"));
+ }
+
+ @Test
+ public void verifyConnectionPortKO() {
+ //When
+ Map<String, Object> parameters = new HashMap<>();
+ parameters.put("host", "localhost:12343");
+ parameters.put("user", USER);
+ parameters.put("password", PASSWORD);
+ //Given
+ ComponentVerifierExtension.Result result = getExtension().verify(ComponentVerifierExtension.Scope.CONNECTIVITY, parameters);
+ //Then
+ assertEquals(ComponentVerifierExtension.Result.Status.ERROR, result.getStatus());
+ assertTrue(result.getErrors().get(0).getDescription().startsWith("Unable to connect"));
+ }
+
+}
[camel] 02/02: Additional fixes according feedback provided in PR
#3217
Posted by ac...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 5926e27969c8fc4ac40e0522144213e94585cf87
Author: Pasquale Congiusti <pa...@gmail.com>
AuthorDate: Thu Oct 3 09:53:05 2019 +0200
Additional fixes according feedback provided in PR #3217
---
...tion.java => ConnectionParamsConfiguration.java} | 11 +++--------
.../mongodb/meta/MongoDBMetaExtension.java | 14 ++++++++------
.../verifier/MongoComponentVerifierExtension.java | 8 ++++----
.../component/mongodb/AbstractMongoDbTest.java | 21 +++++++++++++++------
4 files changed, 30 insertions(+), 24 deletions(-)
diff --git a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/MongoConfiguration.java b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/ConnectionParamsConfiguration.java
similarity index 91%
rename from components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/MongoConfiguration.java
rename to components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/ConnectionParamsConfiguration.java
index 1d8509f..c671462 100644
--- a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/MongoConfiguration.java
+++ b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/conf/ConnectionParamsConfiguration.java
@@ -18,25 +18,20 @@ package org.apache.camel.component.mongodb.conf;
import java.util.Map;
-public class MongoConfiguration {
+public class ConnectionParamsConfiguration {
private String host = "localhost:27017";
private String user;
private String password;
private String adminDB = "admin";
- public MongoConfiguration() {
- super();
- }
-
- public MongoConfiguration(Map<String, String> parameters) {
- super();
+ public ConnectionParamsConfiguration(Map<String, String> parameters) {
this.host = parameters.get("host");
this.user = parameters.get("user");
this.password = parameters.get("password");
// Optional parameters
String optionalAdminDB = parameters.getOrDefault("adminDB", "");
- if (!"".equals(optionalAdminDB)) {
+ if (!optionalAdminDB.isEmpty()) {
this.adminDB = optionalAdminDB;
}
}
diff --git a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java
index 5c493f3..bca0131 100644
--- a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java
+++ b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/meta/MongoDBMetaExtension.java
@@ -29,8 +29,7 @@ import com.mongodb.client.model.Filters;
import org.apache.camel.CamelContext;
import org.apache.camel.component.extension.metadata.AbstractMetaDataExtension;
import org.apache.camel.component.extension.metadata.MetaDataBuilder;
-import org.apache.camel.component.mongodb.MongoDbComponent;
-import org.apache.camel.component.mongodb.conf.MongoConfiguration;
+import org.apache.camel.component.mongodb.conf.ConnectionParamsConfiguration;
import org.bson.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -56,17 +55,20 @@ public class MongoDBMetaExtension extends AbstractMetaDataExtension {
Map<String, String> textParameters = cast(parameters);
LOGGER.debug("Fetching mongodb meta information with params: {}", textParameters);
- MongoConfiguration mongoConf = new MongoConfiguration(textParameters);
+ ConnectionParamsConfiguration mongoConf = new ConnectionParamsConfiguration(textParameters);
MongoClientURI connectionURI = new MongoClientURI(mongoConf.getMongoClientURI());
- JsonNode collectionInfoRoot = null;
+ JsonNode collectionInfoRoot;
try (MongoClient mongoConnection = new MongoClient(connectionURI)) {
Document collectionInfo = mongoConnection.getDatabase(textParameters.get("database"))
.listCollections()
- .filter(Filters.eq("name", textParameters.get("collection"))).first();
+ .filter(Filters.eq("name", textParameters.get("collection")))
+ .first();
LOGGER.debug("Collection info: {}", collectionInfo);
if (collectionInfo == null) {
- LOGGER.error("Cannot read information for collection {}.{}", textParameters.get("database"),
+ LOGGER.error(
+ "Cannot read information for collection {}.{}",
+ textParameters.get("database"),
textParameters.get("collection"));
return Optional.empty();
}
diff --git a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java
index 99d05c9..0cc390f 100644
--- a/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java
+++ b/components/camel-mongodb/src/main/java/org/apache/camel/component/mongodb/verifier/MongoComponentVerifierExtension.java
@@ -27,7 +27,7 @@ import org.apache.camel.component.extension.verifier.DefaultComponentVerifierExt
import org.apache.camel.component.extension.verifier.ResultBuilder;
import org.apache.camel.component.extension.verifier.ResultErrorBuilder;
import org.apache.camel.component.extension.verifier.ResultErrorHelper;
-import org.apache.camel.component.mongodb.conf.MongoConfiguration;
+import org.apache.camel.component.mongodb.conf.ConnectionParamsConfiguration;
import org.bson.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -60,7 +60,7 @@ public class MongoComponentVerifierExtension extends DefaultComponentVerifierExt
}
private void verifyCredentials(ResultBuilder builder, Map<String, Object> parameters) {
- MongoConfiguration mongoConf = new MongoConfiguration(cast(parameters));
+ ConnectionParamsConfiguration mongoConf = new ConnectionParamsConfiguration(cast(parameters));
MongoClientOptions.Builder optionsBuilder = MongoClientOptions.builder();
// Avoid retry and long timeout
optionsBuilder.connectTimeout(CONNECTION_TIMEOUT);
@@ -80,8 +80,8 @@ public class MongoComponentVerifierExtension extends DefaultComponentVerifierExt
builder.error(errorBuilder.build());
} catch (MongoTimeoutException e) {
// When there is any connection exception, the driver tries to reconnect until timeout is reached
- // wrapping the original socket exception into a timeout exception
- String description = null;
+ // wrapping the original security/socket exception into a timeout exception
+ String description;
VerificationError.StandardCode code = VerificationError.StandardCode.GENERIC;
if (e.getMessage().contains("com.mongodb.MongoSecurityException")) {
code = VerificationError.StandardCode.AUTHENTICATION;
diff --git a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java
index ad361d3..53d2210 100644
--- a/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java
+++ b/components/camel-mongodb/src/test/java/org/apache/camel/component/mongodb/AbstractMongoDbTest.java
@@ -96,14 +96,23 @@ public abstract class AbstractMongoDbTest extends CamelTestSupport {
MongoDatabase admin = mongo.getDatabase("admin");
MongoCollection<Document> usersCollection = admin.getCollection("system.users");
if (usersCollection.count() == 0) {
- usersCollection.insertOne(Document.parse("{\n" + " \"_id\": \"admin.test-user\",\n"
- + " \"user\": \"test-user\",\n" + " \"db\": \"admin\",\n" + " \"credentials\": {\n"
- + " \"SCRAM-SHA-1\": {\n" + " \"iterationCount\": 10000,\n"
+ usersCollection.insertOne(Document.parse("{\n"
+ + " \"_id\": \"admin.test-user\",\n"
+ + " \"user\": \"test-user\",\n"
+ + " \"db\": \"admin\",\n"
+ + " \"credentials\": {\n"
+ + " \"SCRAM-SHA-1\": {\n"
+ + " \"iterationCount\": 10000,\n"
+ " \"salt\": \"gmmPAoNdvFSWCV6PGnNcAw==\",\n"
+ " \"storedKey\": \"qE9u1Ax7Y40hisNHL2b8/LAvG7s=\",\n"
- + " \"serverKey\": \"RefeJcxClt9JbOP/VnrQ7YeQh6w=\"\n" + " }\n" + " },\n"
- + " \"roles\": [\n" + " {\n" + " \"role\": \"readWrite\",\n"
- + " \"db\": \"test\"\n" + " }\n" + " ]\n" + "}" + ""));
+ + " \"serverKey\": \"RefeJcxClt9JbOP/VnrQ7YeQh6w=\"\n"
+ + " }\n" + " },\n"
+ + " \"roles\": [\n" + " {\n"
+ + " \"role\": \"readWrite\",\n"
+ + " \"db\": \"test\"\n"
+ + " }\n"
+ + " ]\n"
+ + "}"));
}
}