int main(){
//start();
/* Start heartbeat thread */
printf("strlen %d\n",strlen("中国人"));
mongoc_init();
initQueue(&g_qalarm);
mgclient = mongoc_client_new ("mongodb://172.16.0.7:27017/");
int result;
printf("222\n");
result = pthread_create(&tid_ping, NULL, (void *)thread_re, NULL);
if (result != 0) {
printf("error");
}
//pthread_detach(tid_ping);
pthread_join(tid_ping,NULL);
/*result = pthread_create(&tid_alarm, NULL, (void *)thread_alarm, NULL);
if (result != 0) {
printf("error");
}
pthread_detach(tid_alarm);
result = pthread_create(&tid_query, NULL, (void *)thread_query, NULL);
if (result != 0) {
printf("error");
}
printf("d%\n",tid_query);
pthread_join(tid_query,NULL); */
//pthread_detach(tid_ping);
mongoc_client_destroy (mgclient);
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
mongoc_init();
repl_1 = ha_replica_set_new("shardtest1");
node_1_1 = ha_replica_set_add_replica(repl_1, "shardtest1_1");
node_1_2 = ha_replica_set_add_replica(repl_1, "shardtest1_2");
node_1_3 = ha_replica_set_add_replica(repl_1, "shardtest1_3");
repl_2 = ha_replica_set_new("shardtest2");
node_2_1 = ha_replica_set_add_replica(repl_2, "shardtest2_1");
node_2_2 = ha_replica_set_add_replica(repl_2, "shardtest2_2");
node_2_3 = ha_replica_set_add_replica(repl_2, "shardtest2_3");
cluster = ha_sharded_cluster_new("cluster1");
ha_sharded_cluster_add_replica_set(cluster, repl_1);
ha_sharded_cluster_add_replica_set(cluster, repl_2);
ha_sharded_cluster_add_config(cluster, "config1");
ha_sharded_cluster_add_router(cluster, "router1");
ha_sharded_cluster_add_router(cluster, "router2");
ha_sharded_cluster_start(cluster);
ha_sharded_cluster_wait_for_healthy(cluster);
run_test("/ShardedCluster/basic", test1);
ha_sharded_cluster_shutdown(cluster);
mongoc_cleanup();
return 0;
}
int
main (int argc,
char *argv[])
{
double start_time, end_time, delta_time;
int64_t count;
if (argc < 3) {
fprintf(stderr, "usage: %s [options] schema_file mbdump_dir table_names", argv[0]);
DIE;
}
argc--, argv++;
strcpy(schema_file, argv[0]);
argc--, argv++;
strcpy(mbdump_dir, argv[0]);
argc--, argv++;
test_suite ();
mongoc_init ();
mongoc_log_set_handler (log_local_handler, NULL);
start_time = dtimeofday ();
count = execute (argc, &argv[0]);
end_time = dtimeofday ();
delta_time = end_time - start_time + 0.0000001;
fprintf (stderr, "total:\n");
fprintf (stderr, "info: real: %.2f, count: %"PRId64", %"PRId64" docs/sec\n", delta_time, count, (int64_t)round (count/delta_time));
mongoc_cleanup ();
return 0;
}
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 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, /* IN */
char *argv[]) /* IN */
{
char *cwd;
char buf[1024];
if (argc <= 1 || !!strcmp (argv[1], "-v")) {
mongoc_log_set_handler (log_handler, NULL);
}
mongoc_init ();
cwd = getcwd(buf, sizeof(buf));
assert(cwd);
gTestCAFile = bson_strdup_printf("%s/" CAFILE, cwd);
gTestPEMFileLocalhost = bson_strdup_printf("%s/" PEMFILE_LOCALHOST, cwd);
run_test("/ReplicaSet/ssl/client", &test_replica_set_ssl_client);
bson_free(gTestCAFile);
bson_free(gTestPEMFileLocalhost);
mongoc_cleanup();
return 0;
}
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 main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
bson_error_t error;
bson_oid_t oid;
bson_t *doc;
/* Init mongo C driver */
mongoc_init ();
/* Create a new connection to the database a get the specified collection */
client = mongoc_client_new ("mongodb://localhost:27017/");
if (!client) {
fprintf(stderr, "Connection to database failed!");
mongoc_cleanup();
return 0;
} else {
printf("Connected to the database successfully\n");
}
collection = mongoc_client_get_collection (client, "testdb", "users");
/* Create a new document (All the documents must have the _id field to be used as primary key) */
doc = bson_new ();
bson_oid_init (&oid, NULL);
BSON_APPEND_OID (doc, "_id", &oid);
BSON_APPEND_UTF8 (doc, "username", "John");
BSON_APPEND_UTF8 (doc, "password", "123456");
/* Insert the document into the collection */
if (!mongoc_collection_insert (collection, MONGOC_INSERT_NONE, doc, NULL, &error)) {
printf ("Error inserting the document. - %s\n", error.message);
} else {
printf ("Document successfully inserted!\n");
}
/* Clean the doc, colletion and client allocations */
bson_destroy (doc);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
/* Cleanup after mongo C driver */
mongoc_cleanup();
return 0;
}
dbproxy::~dbproxy() {
for(auto it : collectiondict) {
mongoc_collection_destroy(it.second);
}
mongoc_database_destroy(_db);
mongoc_client_destroy(_client);
mongoc_cleanup();
}
int
main (int argc,
char *argv[])
{
mongoc_init ();
run_command ();
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
mongoc_init ();
example ();
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error;
bson_t *query;
bson_t *update;
bson_t reply;
char *str;
mongoc_init ();
client = mongoc_client_new ("mongodb://127.0.0.1:27017/");
collection = mongoc_client_get_collection (client, "test", "test");
/*
* Build our query, {"cmpxchg": 1}
*/
query = BCON_NEW ("cmpxchg", BCON_INT32 (1));
/*
* Build our update. {"$set": {"cmpxchg": 2}}
*/
update = BCON_NEW ("$set", "{", "cmpxchg", BCON_INT32 (2), "}");
/*
* Submit the findAndModify.
*/
if (!mongoc_collection_find_and_modify (collection, query, NULL, update, NULL, false, false, true, &reply, &error)) {
fprintf (stderr, "find_and_modify() failure: %s\n", error.message);
return 1;
}
/*
* Print the result as JSON.
*/
str = bson_as_json (&reply, NULL);
printf ("%s\n", str);
bson_free (str);
/*
* Cleanup.
*/
bson_destroy (query);
bson_destroy (update);
bson_destroy (&reply);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
mongoc_client_t *client;
mongoc_apm_callbacks_t *callbacks;
stats_t stats = { 0 };
mongoc_collection_t *collection;
const char *uristr = "mongodb://127.0.0.1/?appname=cmd-monitoring-example";
const char *collection_name = "test";
bson_t doc;
mongoc_init ();
if (argc > 1) {
uristr = argv [1];
}
client = mongoc_client_new (uristr);
if (!client) {
fprintf (stderr, "Failed to parse URI.\n");
return EXIT_FAILURE;
}
mongoc_client_set_error_api (client, 2);
callbacks = mongoc_apm_callbacks_new ();
mongoc_apm_set_command_started_cb (callbacks, command_started);
mongoc_apm_set_command_succeeded_cb (callbacks, command_succeeded );
mongoc_apm_set_command_failed_cb (callbacks, command_failed);
mongoc_client_set_apm_callbacks (client,
callbacks,
(void *) &stats /* context pointer */);
bson_init (&doc);
BSON_APPEND_INT32 (&doc, "_id", 1);
collection = mongoc_client_get_collection (client, "test", collection_name);
mongoc_collection_drop (collection, NULL);
mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &doc, NULL, NULL);
/* duplicate key error on the second insert */
mongoc_collection_insert (collection, MONGOC_INSERT_NONE, &doc, NULL, NULL);
printf ("started: %d\nsucceeded: %d\nfailed: %d\n",
stats.started, stats.succeeded, stats.failed);
bson_destroy (&doc);
mongoc_collection_destroy (collection);
mongoc_apm_callbacks_destroy (callbacks);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
VOID app_exit(lua_State* ls)
{
// exit all of the modules
lua_timer_exit(ls);
lua_mongo_exit(ls);
lua_mongotp_exit(ls);
mongoc_cleanup();
lua_enet_exit(ls);
lua_tcp_exit(ls);
lua_http_exit(ls);
curl_global_cleanup();
}
int mongodb_module_close(UNUSED struct state_conf* c,
UNUSED struct state_send* s,
UNUSED struct state_recv* r)
{
if (mongodb_module_flush()) {
return EXIT_FAILURE;
}
mongoc_collection_destroy(collection);
mongoc_client_destroy(client);
mongoc_cleanup();
return EXIT_SUCCESS;
}
int
main (void)
{
mongoc_collection_t *collection;
mongoc_database_t *database;
mongoc_client_t *client;
bson_error_t error;
bson_t *options;
mongoc_init ();
client = mongoc_client_new (
"mongodb://localhost:27017/admin?appname=find-and-modify-opts-example");
mongoc_client_set_error_api (client, 2);
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_opts (collection);
fam_sort (collection);
mongoc_collection_drop (collection, NULL);
bson_destroy (options);
mongoc_database_destroy (database);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
TestSuite suite;
int ret;
mongoc_init ();
bson_snprintf (MONGOC_TEST_UNIQUE, sizeof MONGOC_TEST_UNIQUE,
"test_%u_%u", (unsigned)time (NULL),
(unsigned)gettestpid ());
set_mongoc_test_host ();
mongoc_log_set_handler (log_handler, NULL);
TestSuite_Init (&suite, "", argc, argv);
test_array_install (&suite);
test_buffer_install (&suite);
test_client_install (&suite);
test_client_pool_install (&suite);
test_write_command_install (&suite);
test_bulk_install (&suite);
test_collection_install (&suite);
test_cursor_install (&suite);
test_database_install (&suite);
test_gridfs_install (&suite);
test_gridfs_file_page_install (&suite);
test_list_install (&suite);
test_matcher_install (&suite);
test_queue_install (&suite);
test_read_prefs_install (&suite);
test_rpc_install (&suite);
test_stream_install (&suite);
test_uri_install (&suite);
test_write_concern_install (&suite);
#ifdef MONGOC_ENABLE_SSL
test_x509_install (&suite);
test_stream_tls_install (&suite);
#endif
ret = TestSuite_Run (&suite);
TestSuite_Destroy (&suite);
mongoc_cleanup();
return ret;
}
int freeDb()
{
// const char *collection_name = "test_collection";
// collection = mongoc_client_get_collection (client, DB_name , collection_name);
//
// insert = BCON_NEW("hello" ,BCON_UTF8("mongodb"));
// if(!mongoc_collection_insert(collection, MONGOC_INSERT_NONE, insert, NULL, &error)){
// fprintf (stderr, "%s\n", error.message);
// }
// mongoc_collection_destroy (collection);
free_db_connect();
mongoc_cleanup ();
return 1;
};
int main (int argc, char *argv[])
{
char db_name[100]="test2";
char collection_name[100]="students";
/*
char db_name2[100]="test";
char collection_name2[100]="OceanTest_mongo";
*/
char action[20]="collStats";
char *result;
mongoc_collection_t *collection, *collection2;
Gais_Data import;
//mongoc_client_t *client;
/*connect to db*/
collection = mongo_connect(27017,db_name,collection_name);
//collection2 = mongo_connect(27017,db_name2,collection_name2);
//client = mongo_connect(27017);
/*show collection's state*/
result = malloc(sizeof(char)*RESULT_LEN);
//run_command(result,db_name,collection_name,action);
run_command(collection,result,db_name,collection_name,action);
printf("\n%s\n",result);
free(result);
/*
result = malloc(sizeof(char)*RESULT_LEN);
run_command(collection2,result,db_name2,collection_name2,action);
//run_command(client,result,db_name,collection_name,action);
printf("\n2.%s\n",result);
free(result);
*/
/*mongo_insert*/
//strcpy(import.lan,"CHT");
//strcpy(import.author,"me");
//mongo_insert(0,import,"hello mongodb",collection,0);
mongoc_cleanup ();
return 0;
}
// Define main function as an entry to these tests.
// These test functions cannot use the main() defined for unittests because they
// call runGlobalInitializers(). The embedded C API calls mongoDbMain() which
// calls runGlobalInitializers().
int main(int argc, char** argv, char** envp) {
moe::OptionsParser parser;
moe::Environment environment;
moe::OptionSection options;
std::map<std::string, std::string> env;
options.addOptionChaining(
"tempPath", "tempPath", moe::String, "directory to place mongo::TempDir subdirectories");
std::vector<std::string> argVector(argv, argv + argc);
mongo::Status ret = parser.run(options, argVector, env, &environment);
if (!ret.isOK()) {
std::cerr << options.helpString();
return EXIT_FAILURE;
}
if (environment.count("tempPath")) {
::mongo::unittest::TempDir::setTempPath(environment["tempPath"].as<std::string>());
}
::mongo::clearSignalMask();
::mongo::setupSynchronousSignalHandlers();
::mongo::serverGlobalParams.noUnixSocket = true;
::mongo::unittest::setupTestLogger();
StatusPtr status(mongo_embedded_v1_status_create());
mongoc_init();
global_lib_handle = mongo_embedded_v1_lib_init(nullptr, status.get());
if (global_lib_handle == nullptr) {
std::cerr << "Error: " << mongo_embedded_v1_status_get_explanation(status.get());
return EXIT_FAILURE;
}
auto result = ::mongo::unittest::Suite::run(std::vector<std::string>(), "", 1);
if (mongo_embedded_v1_lib_fini(global_lib_handle, status.get()) != MONGO_EMBEDDED_V1_SUCCESS) {
std::cerr << "Error: " << mongo_embedded_v1_status_get_explanation(status.get());
return EXIT_FAILURE;
}
mongoc_cleanup();
globalTempDir.reset();
mongo::quickExit(result);
}
int
main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_init ();
client = mongoc_client_new ("mongodb://localhost/?appname=bulk-collation");
mongoc_client_set_error_api (client, 2);
collection = mongoc_client_get_collection (client, "db", "collection");
bulk_collation (collection);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
int
main (int argc,
char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_init ();
client = mongoc_client_new ("mongodb://localhost/");
collection = mongoc_client_get_collection (client, "test", "test");
bulk3 (collection);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
int
main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
mongoc_init ();
client = mongoc_client_new (
"mongodb://localhost:27017?appname=aggregation-example");
mongoc_client_set_error_api (client, 2);
collection = mongoc_client_get_collection (client, "test", "zipcodes");
print_pipeline (collection);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return 0;
}
int
main (int argc, /* IN */
char *argv[]) /* IN */
{
mongoc_init();
replica_set = ha_replica_set_new("repltest1");
r1 = ha_replica_set_add_replica(replica_set, "replica1");
r2 = ha_replica_set_add_replica(replica_set, "replica2");
r3 = ha_replica_set_add_replica(replica_set, "replica3");
a1 = ha_replica_set_add_arbiter(replica_set, "arbiter1");
ha_replica_set_start(replica_set);
ha_replica_set_wait_for_healthy(replica_set);
use_pool = false;
run_test("/ReplicaSet/single/lose_node_during_cursor", test1);
ha_replica_set_wait_for_healthy(replica_set);
use_pool = true;
run_test("/ReplicaSet/pool/lose_node_during_cursor", test1);
ha_replica_set_wait_for_healthy(replica_set);
use_pool = false;
run_test("/ReplicaSet/single/cursor_with_2_of_3_replicas_down", test2);
ha_replica_set_wait_for_healthy(replica_set);
use_pool = true;
run_test("/ReplicaSet/pool/cursor_with_2_of_3_replicas_down", test2);
ha_replica_set_wait_for_healthy(replica_set);
ha_replica_set_shutdown(replica_set);
ha_replica_set_destroy(replica_set);
mongoc_cleanup();
return 0;
}
int
main (int argc, char *argv[])
{
mongoc_client_t *client;
mongoc_collection_t *collection;
const char *uri_string = "mongodb://localhost/?appname=bulk-collation";
mongoc_uri_t *uri;
bson_error_t error;
mongoc_init ();
uri = mongoc_uri_new_with_error (uri_string, &error);
if (!uri) {
fprintf (stderr,
"failed to parse URI: %s\n"
"error message: %s\n",
uri_string,
error.message);
return EXIT_FAILURE;
}
client = mongoc_client_new_from_uri (uri);
if (!client) {
return EXIT_FAILURE;
}
mongoc_client_set_error_api (client, 2);
collection = mongoc_client_get_collection (client, "db", "collection");
bulk_collation (collection);
mongoc_uri_destroy (uri);
mongoc_collection_destroy (collection);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
int t;
int status;
mongoc_init();
if (argc == 0) {
fprintf(stderr, "usage: fastload <filename>");
exit(1);
}
configure_sharding();
for (t = 0; t < INSERT_THREADS_PER_SHARD * nshards; t++) {
if (fork() == 0) {
run_loader(t, argv[1]);
printf("Inserter thread finished\n");
exit(0);
}
}
/* Reap children */
while (wait(&status) != -1) {
}
mongoc_cleanup();
}
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;
};
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 ()
{
bson_t empty = BSON_INITIALIZER;
const bson_t *doc;
bson_t *to_insert = BCON_NEW ("x", BCON_INT32 (1));
const bson_t *err_doc;
bson_error_t error;
const char *uri_string;
mongoc_uri_t *uri;
mongoc_client_t *client;
mongoc_collection_t *coll;
mongoc_change_stream_t *stream;
mongoc_write_concern_t *wc = mongoc_write_concern_new ();
bson_t opts = BSON_INITIALIZER;
bool r;
mongoc_init ();
uri_string = "mongodb://"
"localhost:27017,localhost:27018,localhost:"
"27019/db?replicaSet=rs0";
uri = mongoc_uri_new_with_error (uri_string, &error);
if (!uri) {
fprintf (stderr,
"failed to parse URI: %s\n"
"error message: %s\n",
uri_string,
error.message);
return EXIT_FAILURE;
}
client = mongoc_client_new_from_uri (uri);
if (!client) {
return EXIT_FAILURE;
}
coll = mongoc_client_get_collection (client, "db", "coll");
stream = mongoc_collection_watch (coll, &empty, NULL);
mongoc_write_concern_set_wmajority (wc, 10000);
mongoc_write_concern_append (wc, &opts);
r = mongoc_collection_insert_one (coll, to_insert, &opts, NULL, &error);
if (!r) {
fprintf (stderr, "Error: %s\n", error.message);
return EXIT_FAILURE;
}
while (mongoc_change_stream_next (stream, &doc)) {
char *as_json = bson_as_relaxed_extended_json (doc, NULL);
fprintf (stderr, "Got document: %s\n", as_json);
bson_free (as_json);
}
if (mongoc_change_stream_error_document (stream, &error, &err_doc)) {
if (!bson_empty (err_doc)) {
fprintf (stderr,
"Server Error: %s\n",
bson_as_relaxed_extended_json (err_doc, NULL));
} else {
fprintf (stderr, "Client Error: %s\n", error.message);
}
return EXIT_FAILURE;
}
bson_destroy (to_insert);
mongoc_write_concern_destroy (wc);
bson_destroy (&opts);
mongoc_change_stream_destroy (stream);
mongoc_collection_destroy (coll);
mongoc_uri_destroy (uri);
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;
}
