static void
test_mongoc_client_authenticate (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_error_t error;
char *username;
char *uri;
bool r;
bson_t q;
username = gen_test_user ();
uri = gen_good_uri (username);
/*
* Add a user to the test database.
*/
client = mongoc_client_new(gTestUri);
database = mongoc_client_get_database(client, "test");
mongoc_database_remove_user (database, username, &error);
r = mongoc_database_add_user(database, username, "testpass", NULL, NULL, &error);
ASSERT_CMPINT(r, ==, 1);
mongoc_database_destroy(database);
mongoc_client_destroy(client);
/*
* Try authenticating with that user.
*/
bson_init(&q);
client = mongoc_client_new(uri);
collection = mongoc_client_get_collection(client, "test", "test");
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 1, 0,
&q, NULL, NULL);
r = mongoc_cursor_next(cursor, &doc);
if (!r) {
r = mongoc_cursor_error(cursor, &error);
if (r) {
MONGOC_ERROR("Authentication failure: \"%s\"", error.message);
}
assert(!r);
}
mongoc_cursor_destroy(cursor);
/*
* Remove all test users.
*/
database = mongoc_client_get_database (client, "test");
r = mongoc_database_remove_all_users (database, &error);
assert (r);
mongoc_database_destroy (database);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
bson_free (username);
bson_free (uri);
}
int
main (int argc,
char *argv[])
{
const char *default_uristr = "mongodb://localhost/test";
char *uristr;
const char *database_name;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_database_t *db;
mongoc_collection_t *collection;
mongoc_init ();
uristr = getenv ("MONGODB_URI");
uristr = uristr ? uristr : (char*)default_uristr;
uri = mongoc_uri_new (uristr);
client = mongoc_client_new_from_uri (uri);
database_name = mongoc_uri_get_database (uri);
db = mongoc_client_get_database (client, database_name);
collection = mongoc_database_get_collection (db, "test");
test_suite (db, collection);
mongoc_collection_destroy (collection);
mongoc_database_destroy (db);
mongoc_client_destroy (client);
mongoc_uri_destroy (uri);
mongoc_cleanup ();
return 0;
}
int mainnn(int argc, char** argv) {
mongoc_init();
mongoc_client_t *client;
mongoc_database_t *database;
mongoc_collection_t *collection;
client = mongoc_client_new("mongodb://localhost/?appname=insert-example");
database = mongoc_client_get_database(client, "test");
collection = mongoc_client_get_collection(client, "test", "devices");
iot::messaging::Message m(m1);
std::cerr << m.toString() << std::endl;
m.fromString(m2);
std::cerr << m.toString() << std::endl;
iot::messaging::Message mm;
const std::string s = mm.toString();
std::cerr << mm.toString() << std::endl;
mongoc_collection_destroy(collection);
mongoc_database_destroy(database);
mongoc_client_destroy(client);
mongoc_cleanup();
return EXIT_SUCCESS;
}
int
main (int argc,
char *argv[])
{
bson_t *options;
bson_error_t error;
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_init ();
client = mongoc_client_new ("mongodb://localhost/");
database = mongoc_client_get_database (client, "testasdf");
/* Create schema validator */
options = BCON_NEW ("validator", "{", "number", "{", "$gte", BCON_INT32 (5), "}", "}");
collection = mongoc_database_create_collection (database, "collname", options, &error);
if (collection) {
bulk5_fail (collection);
bulk5_success (collection);
mongoc_collection_destroy (collection);
} else {
fprintf(stderr, "Couldn't create collection: '%s'\n", error.message);
}
bson_free (options);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
int main(void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
bson_error_t error;
bson_t *options;
client = mongoc_client_new ("mongodb://localhost:27017/admin");
database = mongoc_client_get_database (client, "databaseName");
options = BCON_NEW ( "validator", "{", "age", "{", "$lte", BCON_INT32 (34), "}", "}", "validationAction", BCON_UTF8 ("error"), "validationLevel", BCON_UTF8 ("moderate"));
collection = mongoc_database_create_collection (database, "collectionName", options, &error);
if (!collection) {
fprintf(stderr, "Got error: \"%s\" on line %d\n", error.message, __LINE__);
return 1;
}
fam_flags (collection);
fam_bypass (collection);
fam_update (collection);
fam_fields (collection);
fam_sort (collection);
mongoc_collection_drop (collection, NULL);
bson_destroy (options);
mongoc_database_destroy (database);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
return 0;
}
int64_t
execute (int argc,
char *argv[])
{
int64_t count = 0;
const char *uristr = MONGODB_DEFAULT_URI;
const char *database_name;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_database_t *db;
bson_t bson_schema;
bson_error_t error;
int argi;
uristr = getenv ("MONGODB_URI");
uri = mongoc_uri_new (uristr);
client = mongoc_client_new (uristr);
database_name = mongoc_uri_get_database (uri);
db = mongoc_client_get_database (client, database_name);
bson_init_from_json_file (&bson_schema, schema_file) || WARN_ERROR;
for (argi = 0; argi < argc; argi++) {
fprintf (stderr, "[%d/%d] %s\n", argi + 1, argc, argv[argi]);
count += load_table (db, argv[argi], &bson_schema);
}
bson_destroy (&bson_schema);
mongoc_database_destroy (db);
mongoc_client_destroy (client);
mongoc_uri_destroy (uri);
return count;
}
dbproxy::dbproxy(boost::shared_ptr<config::config> _config) {
mongoc_init();
mongoc_uri_t * _uri = mongoc_uri_new_for_host_port(_config->get_value_string("ip").c_str(), _config->get_value_int("port"));
_client = mongoc_client_new(mongoc_uri_get_string(_uri));
mongoc_uri_destroy(_uri);
_db = mongoc_client_get_database(_client, _config->get_value_string("db").c_str());
}
static void
test_create_collection (void)
{
mongoc_database_t *database;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error = { 0 };
bson_t options;
bson_t storage_opts;
bson_t wt_opts;
char *dbname;
char *name;
bool r;
client = mongoc_client_new (gTestUri);
assert (client);
dbname = gen_collection_name ("dbtest");
database = mongoc_client_get_database (client, dbname);
assert (database);
bson_free (dbname);
bson_init (&options);
BSON_APPEND_INT32 (&options, "size", 1234);
BSON_APPEND_INT32 (&options, "max", 4567);
BSON_APPEND_BOOL (&options, "capped", true);
BSON_APPEND_BOOL (&options, "autoIndexId", true);
BSON_APPEND_DOCUMENT_BEGIN(&options, "storage", &storage_opts);
BSON_APPEND_DOCUMENT_BEGIN(&storage_opts, "wiredtiger", &wt_opts);
BSON_APPEND_UTF8(&wt_opts, "configString", "block_compressor=zlib");
bson_append_document_end(&storage_opts, &wt_opts);
bson_append_document_end(&options, &storage_opts);
name = gen_collection_name ("create_collection");
collection = mongoc_database_create_collection (database, name, &options, &error);
assert (collection);
bson_destroy (&options);
bson_free (name);
r = mongoc_collection_drop (collection, &error);
assert (r);
r = mongoc_database_drop (database, &error);
assert (r);
mongoc_collection_destroy (collection);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
}
static void
test_command (void)
{
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
bool r;
bson_t cmd = BSON_INITIALIZER;
bson_t reply;
client = mongoc_client_new (gTestUri);
assert (client);
database = mongoc_client_get_database (client, "admin");
/*
* Test a known working command, "ping".
*/
bson_append_int32 (&cmd, "ping", 4, 1);
cursor = mongoc_database_command (database, MONGOC_QUERY_NONE, 0, 1, 0, &cmd, NULL, NULL);
assert (cursor);
r = mongoc_cursor_next (cursor, &doc);
assert (r);
assert (doc);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
assert (!doc);
mongoc_cursor_destroy (cursor);
/*
* Test a non-existing command to ensure we get the failure.
*/
bson_reinit (&cmd);
bson_append_int32 (&cmd, "a_non_existing_command", -1, 1);
r = mongoc_database_command_simple (database, &cmd, NULL, &reply, &error);
assert (!r);
assert (error.domain == MONGOC_ERROR_QUERY);
assert (error.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND);
assert (!strcmp ("no such cmd: a_non_existing_command", error.message));
mongoc_database_destroy (database);
mongoc_client_destroy (client);
bson_destroy (&cmd);
}
static void
test_load (mongoc_client_t *client,
unsigned iterations)
{
mongoc_collection_t *col;
mongoc_database_t *db;
bson_error_t error;
unsigned i;
bson_t b;
bson_t q;
bson_init(&b);
bson_append_int32(&b, "ping", 4, 1);
bson_init(&q);
db = mongoc_client_get_database(client, "admin");
col = mongoc_client_get_collection(client, "test", "test");
for (i = 0; i < iterations; i++) {
ping(db, &b);
fetch(col, &q);
}
if (!mongoc_collection_drop(col, &error)) {
MONGOC_WARNING("Failed to drop collection: %s", error.message);
}
mongoc_database_destroy(db);
db = mongoc_client_get_database(client, "test");
if (!mongoc_database_drop(db, &error)) {
MONGOC_WARNING("Failed to drop database: %s", error.message);
}
mongoc_database_destroy(db);
mongoc_collection_destroy(col);
bson_destroy(&b);
}
static void
_drop_database (gridfs_test_t *gridfs_test)
{
mongoc_database_t *db;
bson_error_t error;
db = mongoc_client_get_database (gridfs_test->client, "perftest");
if (!mongoc_database_drop (db, &error)) {
MONGOC_ERROR ("database_drop: %s\n", error.message);
abort ();
}
mongoc_database_destroy (db);
}
mongoc_database_t *
mongoc_client_get_default_database (mongoc_client_t *client)
{
const char *db;
BSON_ASSERT (client);
db = mongoc_uri_get_database (client->uri);
if (db) {
return mongoc_client_get_database (client, db);
}
return NULL;
}
static void
multi_upload_before (perf_test_t *test)
{
multi_upload_test_t *upload_test;
mongoc_client_t *client;
mongoc_gridfs_t *gridfs;
bson_error_t error;
mongoc_database_t *db;
multi_upload_thread_context_t *ctx;
int i;
perf_test_before (test);
upload_test = (multi_upload_test_t *) test;
client = mongoc_client_pool_pop (upload_test->pool);
db = mongoc_client_get_database (client, "perftest");
if (!mongoc_database_drop (db, &error)) {
MONGOC_ERROR ("database_drop: %s\n", error.message);
abort ();
}
gridfs = mongoc_client_get_gridfs (client, "perftest", NULL, &error);
if (!gridfs) {
MONGOC_ERROR ("get_gridfs: %s\n", error.message);
abort ();
}
write_one_byte_file (gridfs);
mongoc_gridfs_destroy (gridfs);
mongoc_client_pool_push (upload_test->pool, client);
for (i = 0; i < upload_test->cnt; i++) {
ctx = &upload_test->contexts[i];
ctx->client = mongoc_client_pool_pop (upload_test->pool);
ctx->gridfs = mongoc_client_get_gridfs (ctx->client, "perftest",
NULL, &error);
if (!ctx->gridfs) {
MONGOC_ERROR ("get_gridfs: %s\n", error.message);
abort ();
}
ctx->stream = mongoc_stream_file_new_for_path (ctx->path, O_RDONLY, 0);
if (!ctx->stream) {
perror ("stream_new_for_path");
abort ();
}
}
mongoc_database_destroy (db);
}
static bson_bool_t
ha_replica_set_get_status (ha_replica_set_t *replica_set,
bson_t *status)
{
mongoc_database_t *db;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_bool_t ret = FALSE;
ha_node_t *node;
bson_t cmd;
char *uristr;
bson_init(&cmd);
bson_append_int32(&cmd, "replSetGetStatus", -1, 1);
for (node = replica_set->nodes; !ret && node; node = node->next) {
uristr = bson_strdup_printf("mongodb://127.0.0.1:%hu/?slaveOk=true",
node->port);
client = mongoc_client_new(uristr);
#ifdef MONGOC_ENABLE_SSL
if (replica_set->ssl_opt) {
mongoc_client_set_ssl_opts(client, replica_set->ssl_opt);
}
#endif
bson_free(uristr);
db = mongoc_client_get_database(client, "admin");
if ((cursor = mongoc_database_command(db,
MONGOC_QUERY_SLAVE_OK,
0,
1,
&cmd,
NULL,
NULL))) {
if (mongoc_cursor_next(cursor, &doc)) {
bson_copy_to(doc, status);
ret = TRUE;
}
mongoc_cursor_destroy(cursor);
}
mongoc_database_destroy(db);
mongoc_client_destroy(client);
}
return ret;
}
int
main (int argc,
char *argv[])
{
mongoc_database_t *database;
mongoc_cursor_t *cursor;
mongoc_client_t *client;
const bson_t *reply;
bson_uint16_t port;
bson_error_t error;
bson_t ping;
char *host_and_port;
char *str;
if (argc < 2 || argc > 3) {
fprintf(stderr, "usage: %s HOSTNAME [PORT]\n", argv[0]);
return 1;
}
port = (argc == 3) ? atoi(argv[2]) : 27017;
host_and_port = bson_strdup_printf("mongodb://%s:%hu", argv[1], port);
client = mongoc_client_new(host_and_port);
if (!client) {
fprintf(stderr, "Invalid hostname or port: %s\n", host_and_port);
return 2;
}
bson_init(&ping);
bson_append_int32(&ping, "ping", 4, 1);
database = mongoc_client_get_database(client, "test");
cursor = mongoc_database_command(database, 0, 0, 1, 0, &ping, NULL, NULL);
if (mongoc_cursor_next(cursor, &reply)) {
str = bson_as_json(reply, NULL);
fprintf(stdout, "%s\n", str);
bson_free(str);
} else if (mongoc_cursor_error(cursor, &error)) {
fprintf(stderr, "Ping failure: %s\n", error.message);
return 3;
}
mongoc_cursor_destroy(cursor);
bson_destroy(&ping);
mongoc_client_destroy(client);
bson_free(host_and_port);
return 0;
}
static void
test_has_collection (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
bson_error_t error;
char *name;
bool r;
bson_oid_t oid;
bson_t b;
client = mongoc_client_new (gTestUri);
assert (client);
name = gen_collection_name ("has_collection");
collection = mongoc_client_get_collection (client, "test", name);
assert (collection);
database = mongoc_client_get_database (client, "test");
assert (database);
bson_init (&b);
bson_oid_init (&oid, NULL);
bson_append_oid (&b, "_id", 3, &oid);
bson_append_utf8 (&b, "hello", 5, "world", 5);
r = mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &b, NULL,
&error);
if (!r) {
MONGOC_WARNING ("%s\n", error.message);
}
assert (r);
bson_destroy (&b);
r = mongoc_database_has_collection (database, name, &error);
assert (!error.domain);
assert (r);
bson_free (name);
mongoc_database_destroy (database);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
static void
test_create_collection (void)
{
mongoc_database_t *database;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error = { 0 };
bson_t options;
char *dbname;
char *name;
bool r;
client = mongoc_client_new (gTestUri);
assert (client);
dbname = gen_collection_name ("dbtest");
database = mongoc_client_get_database (client, dbname);
assert (database);
bson_free (dbname);
bson_init (&options);
BSON_APPEND_INT32 (&options, "size", 1234);
BSON_APPEND_INT32 (&options, "max", 4567);
BSON_APPEND_BOOL (&options, "capped", true);
BSON_APPEND_BOOL (&options, "autoIndexId", true);
name = gen_collection_name ("create_collection");
collection = mongoc_database_create_collection (database, name, &options, &error);
assert (collection);
bson_free (name);
r = mongoc_collection_drop (collection, &error);
assert (r);
r = mongoc_database_drop (database, &error);
assert (r);
mongoc_collection_destroy (collection);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
}
static void
test_mongoc_client_authenticate (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_error_t error;
bool r;
bson_t q;
/*
* Add a user to the test database.
*/
client = mongoc_client_new(gTestUri);
database = mongoc_client_get_database(client, "test");
mongoc_database_remove_user (database, "testuser", &error);
r = mongoc_database_add_user(database, "testuser", "testpass", NULL, NULL, &error);
ASSERT_CMPINT(r, ==, 1);
mongoc_database_destroy(database);
mongoc_client_destroy(client);
/*
* Try authenticating with that user.
*/
bson_init(&q);
client = mongoc_client_new(gTestUriWithPassword);
collection = mongoc_client_get_collection(client, "test", "test");
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 1, 0,
&q, NULL, NULL);
r = mongoc_cursor_next(cursor, &doc);
if (!r) {
r = mongoc_cursor_error(cursor, &error);
if (r) MONGOC_ERROR("%s", error.message);
assert(!r);
}
mongoc_cursor_destroy(cursor);
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
}
bool
copydb (mongoc_client_t *client, const char *other_host_and_port)
{
mongoc_database_t *admindb;
bson_t *command;
bson_t reply;
bson_error_t error;
bool res;
BSON_ASSERT (other_host_and_port);
/* Must do this from the admin db */
admindb = mongoc_client_get_database (client, "admin");
command = BCON_NEW ("copydb",
BCON_INT32 (1),
"fromdb",
BCON_UTF8 ("test"),
"todb",
BCON_UTF8 ("test2"),
/* If you want from a different host */
"fromhost",
BCON_UTF8 (other_host_and_port));
res =
mongoc_database_command_simple (admindb, command, NULL, &reply, &error);
if (!res) {
fprintf (stderr, "Error with copydb: %s\n", error.message);
goto cleanup;
}
/* Do something with the reply */
print_res (&reply);
cleanup:
bson_destroy (&reply);
bson_destroy (command);
mongoc_database_destroy (admindb);
return res;
}
void connect_mongo_db(const char *host, const char *name)
{
bson_t *command,
reply;
bson_error_t error;
char *str;
bool retval;
mongoc_init();
client = mongoc_client_new(host);
//连接失败
if(client == NULL){
printf("connect mongodb fail db_host: %s" , host);
return;
}
command = BCON_NEW ("ping", BCON_INT32 (1));
retval = mongoc_client_command_simple (client, "admin", command, NULL, &reply, &error);
if (!retval) {
fprintf (stderr, "%s\n", error.message);
bson_destroy (&reply);
return;
}
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_destroy (&reply);
bson_destroy (command);
bson_free (str);
database = mongoc_client_get_database(client, name);
mongoc_cleanup();
return;
};
RESULTCODE TileWorkspaceMongo::Open()
{
if(m_mongo!=NULL)
{
return AG_FAILURE;
}
const char* szServer = m_props.GetValue(AUGE_DB_SERVER);
const char* szInstance = m_props.GetValue(AUGE_DB_INSTANCE);
const char* szDatabase = m_props.GetValue(AUGE_DB_DATABASE);
const char* szUser = m_props.GetValue(AUGE_DB_USER);
const char* szPassword = m_props.GetValue(AUGE_DB_PASSWORD);
const char* szEncoding = m_props.GetValue(AUGE_DB_ENCODING);
if(szServer==NULL||szDatabase==NULL||szUser==NULL||szPassword==NULL)
{
return AG_FAILURE;
}
char constr[AUGE_NAME_MAX] = {0};
g_sprintf(constr, "mongodb://%s:%s/", szServer, szInstance);
m_mongo = mongoc_client_new(constr);
if(m_mongo == NULL)
{
char msg[AUGE_MSG_MAX];
g_snprintf(msg, AUGE_MSG_MAX, "Cannot to connect to mongdo %s:%s", szServer, szInstance);
GLogger* pLogger = augeGetLoggerInstance();
pLogger->Error(msg, __FILE__, __LINE__);
GError* pError = augeGetErrorInstance();
pError->SetError(msg);
return AG_FAILURE;
}
m_mongo_db = mongoc_client_get_database(m_mongo, szDatabase);
m_database = szDatabase;
return AG_SUCCESS;
}
static void
test_drop (void)
{
mongoc_database_t *database;
mongoc_client_t *client;
bson_error_t error = { 0 };
char *dbname;
bool r;
client = mongoc_client_new (gTestUri);
assert (client);
dbname = gen_collection_name ("db_drop_test");
database = mongoc_client_get_database (client, dbname);
bson_free (dbname);
r = mongoc_database_drop (database, &error);
assert (r);
assert (!error.domain);
assert (!error.code);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
}
static int init()
{
str_t tmp = empty_str;
str_t host = conf_lookup(&robot.conf, str_from("DB_HOST")).string;
str_t name = conf_lookup(&robot.conf, str_from("DB_NAME")).string;
size_t i;
int rc = 1;
str_cat(&tmp, "mongodb://");
str_ncat(&tmp, host.ptr, host.len);
robot.mongoc_client = mongoc_client_new(tmp.ptr);
if (robot.mongoc_client == NULL)
{
rc = 0;
fprintf(stderr, "mongoc_client_new(\"%s\") error!!!!\n", tmp.ptr);
goto end;
}
robot.mongoc_database = mongoc_client_get_database(robot.mongoc_client, name.ptr);
if (robot.mongoc_database == NULL)
{
rc = 0;
fprintf(stderr, "mongoc_client_get_database(\"%s\") error!!!!\n", name.ptr);
goto end;
}
{
mongoc_collection_t* message_collection;
mongoc_index_opt_t opt;
bson_error_t error;
bson_t keys;
message_collection = mongoc_database_get_collection(robot.mongoc_database, "message");
if (message_collection == NULL)
{
rc = 0;
fprintf(stderr, "mongoc_database_get_collection(\"message\") error!!!!\n");
goto end;
}
mongoc_index_opt_init(&opt);
// from+type 做联合索引
bson_init(&keys);
BSON_APPEND_INT32(&keys, "from", 1);
BSON_APPEND_INT32(&keys, "type", 1);
if (!mongoc_collection_create_index(message_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message);
bson_destroy(&keys);
// time 做逆序索引
bson_init(&keys);
BSON_APPEND_INT32(&keys, "time", -1);
if (!mongoc_collection_create_index(message_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message);
bson_destroy(&keys);
// content 做全文索引
bson_init(&keys);
BSON_APPEND_UTF8(&keys, "content", "text");
if (!mongoc_collection_create_index(message_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message);
bson_destroy(&keys);
}
{
mongoc_collection_t* unprocessed_collection;
mongoc_index_opt_t opt;
bson_error_t error;
bson_t keys;
unprocessed_collection = mongoc_database_get_collection(robot.mongoc_database, "unprocessed");
if (unprocessed_collection == NULL)
{
rc = 0;
fprintf(stderr, "mongoc_database_get_collection(\"unprocessed\") error!!!!\n");
goto end;
}
mongoc_index_opt_init(&opt);
// time 做逆序索引
bson_init(&keys);
BSON_APPEND_INT32(&keys, "time", -1);
if (!mongoc_collection_create_index(unprocessed_collection, &keys, &opt, &error)) MONGOC_WARNING("%s\n", error.message);
bson_destroy(&keys);
}
for (i = 0; modules[i]; ++i)
{
if (modules[i]->module_init)
{
rc = modules[i]->module_init();
if (!rc) goto end;
}
}
end:
str_free(tmp);
return rc;
}
static void
test_get_collection_names (void)
{
mongoc_database_t *database;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error = { 0 };
bson_t options;
int r;
int namecount = 0;
char **names;
char **name;
char *curname;
char *dbname;
char *name1;
char *name2;
char *name3;
char *name4;
char *name5;
const char *system_prefix = "system.";
client = mongoc_client_new (gTestUri);
assert (client);
dbname = gen_collection_name ("dbtest");
database = mongoc_client_get_database (client, dbname);
assert (database);
bson_free (dbname);
bson_init (&options);
name1 = gen_collection_name ("name1");
name2 = gen_collection_name ("name2");
name3 = gen_collection_name ("name3");
name4 = gen_collection_name ("name4");
name5 = gen_collection_name ("name5");
collection = mongoc_database_create_collection (database, name1, &options,
&error);
assert (collection);
mongoc_collection_destroy (collection);
collection = mongoc_database_create_collection (database, name2, &options,
&error);
assert (collection);
mongoc_collection_destroy (collection);
collection = mongoc_database_create_collection (database, name3, &options,
&error);
assert (collection);
mongoc_collection_destroy (collection);
collection = mongoc_database_create_collection (database, name4, &options,
&error);
assert (collection);
mongoc_collection_destroy (collection);
collection = mongoc_database_create_collection (database, name5, &options,
&error);
assert (collection);
mongoc_collection_destroy (collection);
names = mongoc_database_get_collection_names (database, &error);
assert (!error.domain);
assert (!error.code);
for (name = names; *name; ++name) {
/* inefficient, but OK for a unit test. */
curname = *name;
if (0 == strcmp (curname, name1) ||
0 == strcmp (curname, name2) ||
0 == strcmp (curname, name3) ||
0 == strcmp (curname, name4) ||
0 == strcmp (curname, name5)) {
++namecount;
} else if (0 ==
strncmp (curname, system_prefix, strlen (system_prefix))) {
/* Collections prefixed with 'system.' are system collections */
} else {
assert (false);
}
bson_free (curname);
}
assert (namecount == 5);
bson_free (name1);
bson_free (name2);
bson_free (name3);
bson_free (name4);
bson_free (name5);
bson_free (names);
r = mongoc_database_drop (database, &error);
assert (r);
assert (!error.domain);
assert (!error.code);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
}
static void
test_get_collection_info (void)
{
mongoc_database_t *database;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error = { 0 };
bson_iter_t iter;
bson_iter_t col_array;
bson_iter_t col_iter;
bson_t capped_options = BSON_INITIALIZER;
bson_t autoindexid_options = BSON_INITIALIZER;
bson_t noopts_options = BSON_INITIALIZER;
bson_t name_filter = BSON_INITIALIZER;
int r;
int num_infos = 0;
bson_t *infos = NULL;
const char *name;
char *dbname;
char *capped_name;
char *autoindexid_name;
char *noopts_name;
client = mongoc_client_new (gTestUri);
assert (client);
dbname = gen_collection_name ("dbtest");
database = mongoc_client_get_database (client, dbname);
assert (database);
bson_free (dbname);
capped_name = gen_collection_name ("capped");
BSON_APPEND_BOOL (&capped_options, "capped", true);
BSON_APPEND_INT32 (&capped_options, "size", 10000000);
BSON_APPEND_INT32 (&capped_options, "max", 1024);
autoindexid_name = gen_collection_name ("autoindexid");
BSON_APPEND_BOOL (&autoindexid_options, "autoIndexId", false);
noopts_name = gen_collection_name ("noopts");
collection = mongoc_database_create_collection (database, capped_name,
&capped_options, &error);
assert (collection);
mongoc_collection_destroy (collection);
collection = mongoc_database_create_collection (database, autoindexid_name,
&autoindexid_options,
&error);
assert (collection);
mongoc_collection_destroy (collection);
collection = mongoc_database_create_collection (database, noopts_name,
&noopts_options, &error);
assert (collection);
mongoc_collection_destroy (collection);
/* first we filter on collection name. */
BSON_APPEND_UTF8 (&name_filter, "name", noopts_name);
/* We only test with filters since get_collection_names will
* test w/o filters for us. */
/* Filter on an exact match of name */
infos = mongoc_database_get_collection_info (database, &name_filter, &error);
assert (infos);
assert (!error.domain);
assert (!error.code);
if (bson_iter_init_find (&iter, infos, "collections") &&
BSON_ITER_HOLDS_ARRAY (&iter) &&
bson_iter_recurse (&iter, &col_array)) {
while (bson_iter_next (&col_array)) {
if (BSON_ITER_HOLDS_DOCUMENT (&col_array) &&
bson_iter_recurse (&col_array, &col_iter) &&
bson_iter_find (&col_iter, "name") &&
BSON_ITER_HOLDS_UTF8 (&col_iter) &&
(name = bson_iter_utf8 (&col_iter, NULL))) {
++num_infos;
assert (0 == strcmp (name, noopts_name));
} else {
assert (false);
}
}
}
assert (1 == num_infos);
num_infos = 0;
bson_destroy (infos);
infos = NULL;
r = mongoc_database_drop (database, &error);
assert (r);
assert (!error.domain);
assert (!error.code);
bson_free (capped_name);
bson_free (noopts_name);
bson_free (autoindexid_name);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
}
int
main (int argc,
char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
const char *uristr = "mongodb://*****:*****@localhost/?authMechanism=PLAIN&authSource=$external";
const char *database_name = "test";
const char *collection_name = "query1";
const char *user_role = "ro";
if (argc == 2 && !strcmp("--help",argv[1])) {
printf ("Usage: [uri [database [collection [ro|rw]]]]\n");
return EXIT_FAILURE;
}
if (argc > 1) {
uristr = argv [1];
}
if (argc > 2) {
database_name = argv [2];
}
if (argc > 3) {
collection_name = argv [3];
}
if (argc > 4) {
user_role = argv [4];
}
mongoc_init ();
client = mongoc_client_new (uristr);
collection = mongoc_client_get_collection (client, database_name, collection_name);
if (!client) {
fprintf (stderr, "Failed to parse URI.\n");
return EXIT_FAILURE;
}
// write
if (!strcasecmp(user_role,"rw")) {
bson_t *rwbson;
bson_error_t rwerror;
rwbson = bson_new();
time_t now = time(NULL);
bson_append_utf8(rwbson,"db",-1,database_name,-1);
bson_append_time_t(rwbson,"date",-1,now);
mongoc_client_get_database(client, database_name);
bool ret = mongoc_collection_insert(collection, MONGOC_INSERT_NONE, rwbson, NULL,
&rwerror);
bson_destroy(rwbson);
if (!ret)
return EXIT_FAILURE;
}
// read
bson_t roquery;
bson_init (&roquery);
char *str;
#if 0
eson_append_utf8 (&roquery, "hello", -1, "world", -1);
#endif
cursor = mongoc_collection_find (collection,
MONGOC_QUERY_NONE,
0,
0,
0,
&roquery,
NULL, /* Fields, NULL for all. */
NULL); /* Read Prefs, NULL for default */
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_json (doc, NULL);
fprintf (stdout, "%s\n", str);
bson_free (str);
}
if (mongoc_cursor_error (cursor, &error)) {
fprintf (stderr, "Cursor Failure: %s\n", error.message);
return EXIT_FAILURE;
}
bson_destroy (&roquery);
// close server connection
mongoc_cursor_destroy (cursor);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
int
main (int argc,
char *argv[])
{
mongoc_database_t *database = NULL;
mongoc_client_t *client = NULL;
mongoc_collection_t *collection = NULL;
char *host_and_port;
int res = 0;
char* other_host_and_port = NULL;
if (argc < 2 || argc > 3) {
fprintf (stderr, "usage: %s MONGOD-1-CONNECTION-STRING "
"[MONGOD-2-HOST-NAME:MONGOD-2-PORT]\n",
argv[0]);
fprintf (stderr,
"MONGOD-1-CONNECTION-STRING can be "
"of the following forms:\n");
fprintf (stderr, "localhost\t\t\t\tlocal machine\n");
fprintf (stderr, "localhost:27018\t\t\t\tlocal machine on port 27018\n");
fprintf (stderr,
"mongodb://*****:*****@localhost:27017\t"
"local machine on port 27017, and authenticate with username "
"user and password pass\n");
return 1;
}
mongoc_init ();
if (strncmp (argv[1], "mongodb://", 10) == 0) {
host_and_port = bson_strdup (argv [1]);
} else {
host_and_port = bson_strdup_printf ("mongodb://%s", argv[1]);
}
other_host_and_port = argc > 2 ? argv[2] : NULL;
client = mongoc_client_new (host_and_port);
if (!client) {
fprintf(stderr, "Invalid hostname or port: %s\n", host_and_port);
res = 2;
goto cleanup;
}
database = mongoc_client_get_database (client, "test");
collection = mongoc_database_get_collection (database, COLLECTION_NAME);
printf ("Inserting data\n");
if (!insert_data (collection)) {
res = 3;
goto cleanup;
}
printf ("explain\n");
if (!explain (collection)) {
res = 4;
goto cleanup;
}
if (other_host_and_port) {
printf ("copydb\n");
if (!copydb (client, other_host_and_port)) {
res = 5;
goto cleanup;
}
printf ("clone collection\n");
if (!clone_collection (database, other_host_and_port)) {
res = 6;
goto cleanup;
}
}
cleanup:
if (collection) {
mongoc_collection_destroy (collection);
}
if (database) {
mongoc_database_destroy (database);
}
if (client) {
mongoc_client_destroy (client);
}
bson_free (host_and_port);
mongoc_cleanup ();
return res;
}
int
main (int argc, char *argv[])
{
const char *uri_str = "mongodb://localhost:27017";
mongoc_client_t *client;
mongoc_database_t *database;
mongoc_collection_t *collection;
bson_t *command, reply, *insert;
bson_error_t error;
char *str;
bool retval;
/*
* Required to initialize libmongoc's internals
*/
mongoc_init ();
/*
* Optionally get MongoDB URI from command line
*/
if (argc > 1) {
uri_str = argv[1];
}
/*
* Create a new client instance
*/
client = mongoc_client_new (uri_str);
/*
* Register the application name so we can track it in the profile logs
* on the server. This can also be done from the URI (see other examples).
*/
mongoc_client_set_appname (client, "connect-example");
/*
* Get a handle on the database "db_name" and collection "coll_name"
*/
database = mongoc_client_get_database (client, "db_name");
collection = mongoc_client_get_collection (client, "db_name", "coll_name");
/*
* Do work. This example pings the database, prints the result as JSON and
* performs an insert
*/
command = BCON_NEW ("ping", BCON_INT32 (1));
retval = mongoc_client_command_simple (
client, "admin", command, NULL, &reply, &error);
if (!retval) {
fprintf (stderr, "%s\n", error.message);
return EXIT_FAILURE;
}
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
insert = BCON_NEW ("hello", BCON_UTF8 ("world"));
if (!mongoc_collection_insert (
collection, MONGOC_INSERT_NONE, insert, NULL, &error)) {
fprintf (stderr, "%s\n", error.message);
}
bson_destroy (insert);
bson_destroy (&reply);
bson_destroy (command);
bson_free (str);
/*
* Release our handles and clean up libmongoc
*/
mongoc_collection_destroy (collection);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
static void
ha_replica_set_configure (ha_replica_set_t *replica_set,
ha_node_t *primary)
{
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
const bson_t *doc;
bson_error_t error;
bson_iter_t iter;
ha_node_t *node;
bson_t ar;
bson_t cmd;
bson_t config;
bson_t member;
char *str;
char *uristr;
char hoststr[32];
char key[8];
int i = 0;
uristr = bson_strdup_printf("mongodb://127.0.0.1:%hu/", primary->port);
client = mongoc_client_new(uristr);
#ifdef MONGOC_ENABLE_SSL
if (replica_set->ssl_opt) {
mongoc_client_set_ssl_opts(client, replica_set->ssl_opt);
}
#endif
bson_free(uristr);
bson_init(&cmd);
bson_append_document_begin(&cmd, "replSetInitiate", -1, &config);
bson_append_utf8(&config, "_id", 3, replica_set->name, -1);
bson_append_array_begin(&config, "members", -1, &ar);
for (node = replica_set->nodes; node; node = node->next) {
snprintf(key, sizeof key, "%u", i);
key[sizeof key - 1] = '\0';
snprintf(hoststr, sizeof hoststr, "127.0.0.1:%hu", node->port);
hoststr[sizeof hoststr - 1] = '\0';
bson_append_document_begin(&ar, key, -1, &member);
bson_append_int32(&member, "_id", -1, i);
bson_append_utf8(&member, "host", -1, hoststr, -1);
bson_append_bool(&member, "arbiterOnly", -1, node->is_arbiter);
bson_append_document_end(&ar, &member);
i++;
}
bson_append_array_end(&config, &ar);
bson_append_document_end(&cmd, &config);
str = bson_as_json(&cmd, NULL);
MONGOC_DEBUG("Config: %s", str);
bson_free(str);
database = mongoc_client_get_database(client, "admin");
again:
cursor = mongoc_database_command(database,
MONGOC_QUERY_NONE,
0,
1,
&cmd,
NULL,
NULL);
while (mongoc_cursor_next(cursor, &doc)) {
str = bson_as_json(doc, NULL);
MONGOC_DEBUG("Reply: %s", str);
bson_free(str);
if (bson_iter_init_find(&iter, doc, "ok") &&
bson_iter_as_bool(&iter)) {
goto cleanup;
}
}
if (mongoc_cursor_error(cursor, &error)) {
mongoc_cursor_destroy(cursor);
MONGOC_WARNING("%s: Retrying in 1 second.", error.message);
sleep(1);
goto again;
}
cleanup:
mongoc_cursor_destroy(cursor);
mongoc_database_destroy(database);
mongoc_client_destroy(client);
bson_destroy(&cmd);
}
static void
test_bypass_validation (void *context)
{
mongoc_collection_t *collection;
bson_t reply = BSON_INITIALIZER;
mongoc_bulk_operation_t *bulk;
mongoc_database_t *database;
mongoc_write_concern_t *wr;
mongoc_client_t *client;
bson_error_t error;
bson_t *options;
char *collname;
char *dbname;
int r;
int i;
client = test_framework_client_new ();
assert (client);
dbname = gen_collection_name ("dbtest");
collname = gen_collection_name ("bypass");
database = mongoc_client_get_database (client, dbname);
collection = mongoc_database_get_collection (database, collname);
assert (collection);
options = tmp_bson ("{'validator': {'number': {'$gte': 5}}, 'validationAction': 'error'}");
ASSERT_OR_PRINT (mongoc_database_create_collection (database, collname, options, &error), error);
/* {{{ Default fails validation */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT(!r);
ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation");
mongoc_bulk_operation_destroy (bulk);
/* }}} */
/* {{{ bypass_document_validation=false Fails validation */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
mongoc_bulk_operation_set_bypass_document_validation (bulk, false);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT(!r);
ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, 121, "Document failed validation");
mongoc_bulk_operation_destroy (bulk);
/* }}} */
/* {{{ bypass_document_validation=true ignores validation */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
mongoc_bulk_operation_set_bypass_document_validation (bulk, true);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT_OR_PRINT(r, error);
mongoc_bulk_operation_destroy (bulk);
/* }}} */
/* {{{ w=0 and bypass_document_validation=set fails */
bulk = mongoc_collection_create_bulk_operation(collection, true, NULL);
wr = mongoc_write_concern_new ();
mongoc_write_concern_set_w (wr, 0);
mongoc_bulk_operation_set_write_concern (bulk, wr);
mongoc_bulk_operation_set_bypass_document_validation (bulk, true);
for (i = 0; i < 3; i++) {
bson_t *doc = tmp_bson (bson_strdup_printf ("{'number': 3, 'high': %d }", i));
mongoc_bulk_operation_insert (bulk, doc);
}
r = mongoc_bulk_operation_execute (bulk, &reply, &error);
ASSERT_OR_PRINT(!r, error);
ASSERT_ERROR_CONTAINS (error, MONGOC_ERROR_COMMAND, MONGOC_ERROR_COMMAND_INVALID_ARG,
"Cannot set bypassDocumentValidation for unacknowledged writes");
mongoc_bulk_operation_destroy (bulk);
mongoc_write_concern_destroy (wr);
/* }}} */
ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
}
