/**
* Creates a GridFS instance for the specified bucket in the given database. Set the preferred
* WriteConcern on the give DB with DB.setWriteConcern
*
* @see com.mongodb.WriteConcern
* @param db database to work with
* @param bucket bucket to use in the given database
* @throws MongoException
*/
public GridFS(DB db, String bucket) {
_db = db;
_bucketName = bucket;
_filesCollection = _db.getCollection(_bucketName + ".files");
_chunkCollection = _db.getCollection(_bucketName + ".chunks");
// ensure standard indexes as long as collections are small
try {
if (_filesCollection.count() < 1000) {
_filesCollection.ensureIndex(
BasicDBObjectBuilder.start().add("filename", 1).add("uploadDate", 1).get());
}
if (_chunkCollection.count() < 1000) {
_chunkCollection.ensureIndex(
BasicDBObjectBuilder.start().add("files_id", 1).add("n", 1).get(),
BasicDBObjectBuilder.start().add("unique", true).get());
}
} catch (MongoException e) {
LOGGER.info(
String.format(
"Unable to ensure indices on GridFS collections in database %s", db.getName()));
}
_filesCollection.setObjectClass(GridFSDBFile.class);
}
public MongoConnection(DB db) {
this.db = db;
// TODO proper initialisation of the connection info
connectionInfo.setMajorVersion("" + Mongo.MAJOR_VERSION);
connectionInfo.setMinorVersion("" + Mongo.MINOR_VERSION);
connectionInfo.setDatabase(db.getName());
}
/**
* Initialises the MongoDB connection using the Mongo object provided to the endpoint
*
* @throws CamelMongoDbException
*/
public void initializeConnection() throws CamelMongoDbException {
LOG.info("Initialising MongoDb endpoint: {}", this.toString());
if (database == null || collection == null) {
throw new CamelMongoDbException(
"Missing required endpoint configuration: database and/or collection");
}
db = mongoConnection.getDB(database);
if (db == null) {
throw new CamelMongoDbException(
"Could not initialise MongoDbComponent. Database " + database + " does not exist.");
}
if (!createCollection && !db.collectionExists(collection)) {
throw new CamelMongoDbException(
"Could not initialise MongoDbComponent. Collection "
+ collection
+ " and createCollection is false.");
}
dbCollection = db.getCollection(collection);
LOG.info(
"MongoDb component initialised and endpoint bound to MongoDB collection with the following paramters. Address list: {}, Db: {}, Collection: {}",
new Object[] {
mongoConnection.getAllAddress().toString(), db.getName(), dbCollection.getName()
});
}
@Override
protected void updateNode() {
label = db.getName();
if (stats != null) {
label += " (" + stats.getInt("objects") + "/" + stats.getInt("dataSize") + ")";
}
// if (db.isAuthenticated())
// addOverlay("overlay/unlock.png");
}
/** @see DATAMONGO-306 */
@Test
public void setsUpMongoDbFactoryUsingAMongoUriWithoutCredentials() {
reader.loadBeanDefinitions(new ClassPathResource("namespace/mongo-uri-no-credentials.xml"));
BeanDefinition definition = factory.getBeanDefinition("mongoDbFactory");
ConstructorArgumentValues constructorArguments = definition.getConstructorArgumentValues();
assertThat(constructorArguments.getArgumentCount(), is(1));
ValueHolder argument = constructorArguments.getArgumentValue(0, MongoURI.class);
assertThat(argument, is(notNullValue()));
MongoDbFactory dbFactory = factory.getBean("mongoDbFactory", MongoDbFactory.class);
DB db = dbFactory.getDb();
assertThat(db.getName(), is("database"));
}
private static void assertWriteConcern(
ClassPathXmlApplicationContext ctx, WriteConcern expectedWriteConcern) {
SimpleMongoDbFactory dbFactory = ctx.getBean("first", SimpleMongoDbFactory.class);
DB db = dbFactory.getDb();
assertThat(db.getName(), is("db"));
WriteConcern configuredConcern =
(WriteConcern) ReflectionTestUtils.getField(dbFactory, "writeConcern");
MyWriteConcern myDbFactoryWriteConcern = new MyWriteConcern(configuredConcern);
MyWriteConcern myDbWriteConcern = new MyWriteConcern(db.getWriteConcern());
MyWriteConcern myExpectedWriteConcern = new MyWriteConcern(expectedWriteConcern);
assertThat(myDbFactoryWriteConcern, is(myExpectedWriteConcern));
assertThat(myDbWriteConcern, is(myExpectedWriteConcern));
assertThat(myDbWriteConcern, is(myDbFactoryWriteConcern));
}
@AfterClass
public void cleanUp() {
// super.deleteRiver();
logger.info("Drop database " + mongoDB.getName());
mongoDB.dropDatabase();
}
@Test
public void getDb() {
DB db = template.getCollection().getDB();
assertEquals("junit", db.getName());
}
/**
* Factory method for creating a MongoDB provider within the plugin manager.
*
* @param collectionName The name of the MongoDB collection to which log events should be written.
* @param writeConcernConstant The {@link WriteConcern} constant to control writing details,
* defaults to {@link WriteConcern#ACKNOWLEDGED}.
* @param writeConcernConstantClassName The name of a class containing the aforementioned static
* WriteConcern constant. Defaults to {@link WriteConcern}.
* @param databaseName The name of the MongoDB database containing the collection to which log
* events should be written. Mutually exclusive with {@code
* factoryClassName&factoryMethodName!=null}.
* @param server The host name of the MongoDB server, defaults to localhost and mutually exclusive
* with {@code factoryClassName&factoryMethodName!=null}.
* @param port The port the MongoDB server is listening on, defaults to the default MongoDB port
* and mutually exclusive with {@code factoryClassName&factoryMethodName!=null}.
* @param userName The username to authenticate against the MongoDB server with.
* @param password The password to authenticate against the MongoDB server with.
* @param factoryClassName A fully qualified class name containing a static factory method capable
* of returning a {@link DB} or a {@link MongoClient}.
* @param factoryMethodName The name of the public static factory method belonging to the
* aforementioned factory class.
* @return a new MongoDB provider.
*/
@PluginFactory
public static MongoDbProvider createNoSqlProvider(
@PluginAttribute("collectionName") final String collectionName,
@PluginAttribute("writeConcernConstant") final String writeConcernConstant,
@PluginAttribute("writeConcernConstantClass") final String writeConcernConstantClassName,
@PluginAttribute("databaseName") final String databaseName,
@PluginAttribute(value = "server", defaultString = "localhost") @ValidHost
final String server,
@PluginAttribute(value = "port", defaultString = "" + DEFAULT_PORT) @ValidPort
final String port,
@PluginAttribute("userName") final String userName,
@PluginAttribute(value = "password", sensitive = true) final String password,
@PluginAttribute("factoryClassName") final String factoryClassName,
@PluginAttribute("factoryMethodName") final String factoryMethodName) {
DB database;
String description;
if (Strings.isNotEmpty(factoryClassName) && Strings.isNotEmpty(factoryMethodName)) {
try {
final Class<?> factoryClass = LoaderUtil.loadClass(factoryClassName);
final Method method = factoryClass.getMethod(factoryMethodName);
final Object object = method.invoke(null);
if (object instanceof DB) {
database = (DB) object;
} else if (object instanceof MongoClient) {
if (Strings.isNotEmpty(databaseName)) {
database = ((MongoClient) object).getDB(databaseName);
} else {
LOGGER.error(
"The factory method [{}.{}()] returned a MongoClient so the database name is "
+ "required.",
factoryClassName,
factoryMethodName);
return null;
}
} else if (object == null) {
LOGGER.error(
"The factory method [{}.{}()] returned null.", factoryClassName, factoryMethodName);
return null;
} else {
LOGGER.error(
"The factory method [{}.{}()] returned an unsupported type [{}].",
factoryClassName,
factoryMethodName,
object.getClass().getName());
return null;
}
description = "database=" + database.getName();
final List<ServerAddress> addresses = database.getMongo().getAllAddress();
if (addresses.size() == 1) {
description +=
", server=" + addresses.get(0).getHost() + ", port=" + addresses.get(0).getPort();
} else {
description += ", servers=[";
for (final ServerAddress address : addresses) {
description += " { " + address.getHost() + ", " + address.getPort() + " } ";
}
description += "]";
}
} catch (final ClassNotFoundException e) {
LOGGER.error("The factory class [{}] could not be loaded.", factoryClassName, e);
return null;
} catch (final NoSuchMethodException e) {
LOGGER.error(
"The factory class [{}] does not have a no-arg method named [{}].",
factoryClassName,
factoryMethodName,
e);
return null;
} catch (final Exception e) {
LOGGER.error(
"The factory method [{}.{}()] could not be invoked.",
factoryClassName,
factoryMethodName,
e);
return null;
}
} else if (Strings.isNotEmpty(databaseName)) {
final List<MongoCredential> credentials = new ArrayList<>();
description = "database=" + databaseName;
if (Strings.isNotEmpty(userName) && Strings.isNotEmpty(password)) {
description +=
", username="******", passwordHash="
+ NameUtil.md5(password + MongoDbProvider.class.getName());
credentials.add(
MongoCredential.createCredential(userName, databaseName, password.toCharArray()));
}
try {
final int portInt = TypeConverters.convert(port, int.class, DEFAULT_PORT);
description += ", server=" + server + ", port=" + portInt;
database =
new MongoClient(new ServerAddress(server, portInt), credentials).getDB(databaseName);
} catch (final Exception e) {
LOGGER.error(
"Failed to obtain a database instance from the MongoClient at server [{}] and "
+ "port [{}].",
server,
port);
return null;
}
} else {
LOGGER.error("No factory method was provided so the database name is required.");
return null;
}
try {
database.getCollectionNames(); // Check if the database actually requires authentication
} catch (final Exception e) {
LOGGER.error(
"The database is not up, or you are not authenticated, try supplying a username and password to the MongoDB provider.",
e);
return null;
}
final WriteConcern writeConcern =
toWriteConcern(writeConcernConstant, writeConcernConstantClassName);
return new MongoDbProvider(database, writeConcern, collectionName, description);
}
private synchronized Response findOne(DB db, String coll, DBObject q) throws IOException {
OutMessage msg = OutMessage.query(db._mongo, 0, db.getName() + "." + coll, 0, -1, q, null);
Response res = go(msg, db.getCollection(coll), null);
return res;
}
private void cleanUp() {
super.deleteRiver();
logger.info("Drop database " + mongoDB.getName());
mongoDB.dropDatabase();
}