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 void test_create (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_client_t *client; bson_error_t error; client = mongoc_client_new (gTestUri); assert (client); gridfs = mongoc_client_get_gridfs (client, "test", "foo", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); file = mongoc_gridfs_create_file (gridfs, NULL); assert (file); assert (mongoc_gridfs_file_save (file)); mongoc_gridfs_file_destroy (file); drop_collections (gridfs, &error); mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); }
static void multi_download_before (perf_test_t *test) { multi_download_test_t *download_test; bson_error_t error; multi_download_thread_context_t *ctx; int i; perf_test_before (test); prep_tmp_dir (test->data_path); download_test = (multi_download_test_t *) test; for (i = 0; i < download_test->cnt; i++) { ctx = &download_test->contexts[i]; ctx->client = mongoc_client_pool_pop (download_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 (); } } }
ModuleFactory::ModuleFactory(const string& configFileName, const string& modulePath, mongoc_client_t* conn, const string& dbName) :m_modulePath(modulePath), m_conn(conn), m_dbName(dbName), m_layingMethod(UP_DOWN) { Init(configFileName); #ifdef USE_MONGODB bson_error_t *err = NULL; m_spatialData = mongoc_client_get_gridfs(m_conn,m_dbName.c_str(),DB_TAB_SPATIAL,err); if (err != NULL) { throw ModelException("ModuleFactory","Constructor","Failed to connect to GridFS!\n"); } #endif }
static mongoc_gridfs_t * get_test_gridfs (mongoc_client_t *client, const char *name, bson_error_t *error) { char *gen; char n [48]; gen = gen_collection_name ("fs"); bson_snprintf (n, sizeof n, "%s_%s", gen, name); bson_free (gen); return mongoc_client_get_gridfs (client, "test", n, error); }
static void _init_gridfs (gridfs_test_t *gridfs_test) { bson_error_t error; /* ensures indexes */ gridfs_test->gridfs = mongoc_client_get_gridfs (gridfs_test->client, "perftest", NULL, &error); if (!gridfs_test->gridfs) { MONGOC_ERROR ("get_gridfs: %s\n", error.message); abort (); } }
static void test_remove (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_gridfs_file_opt_t opts = { 0 }; mongoc_client_t *client; bson_error_t error; bool r; char name[32]; client = mongoc_client_new (gTestUri); assert (client); gridfs = mongoc_client_get_gridfs (client, "test", "foo", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); bson_snprintf (name, sizeof name, "test-remove.%u", rand ()); opts.filename = name; file = mongoc_gridfs_create_file (gridfs, &opts); assert (file); assert (mongoc_gridfs_file_save (file)); r = mongoc_gridfs_file_remove (file, &error); if (!r) fprintf (stderr, "%s\n", error.message); assert (r); mongoc_gridfs_file_destroy (file); file = mongoc_gridfs_find_one_by_filename (gridfs, name, &error); assert (!file); drop_collections (gridfs, &error); mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); }
static void * background_mongoc_client_get_gridfs (void *data) { future_t *future = (future_t *) data; future_value_t return_value; return_value.type = future_value_mongoc_gridfs_ptr_type; future_value_set_mongoc_gridfs_ptr ( &return_value, mongoc_client_get_gridfs ( future_value_get_mongoc_client_ptr (future_get_param (future, 0)), future_value_get_const_char_ptr (future_get_param (future, 1)), future_value_get_const_char_ptr (future_get_param (future, 2)), future_value_get_bson_error_ptr (future_get_param (future, 3)) )); future_resolve (future, return_value); return NULL; }
int main (int argc, char *argv[]) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_gridfs_file_list_t *list; mongoc_gridfs_file_opt_t opt = { 0 }; mongoc_client_t *client; mongoc_stream_t *stream; bson_t query; bson_t child; bson_error_t error; ssize_t r; char buf[4096]; mongoc_iovec_t iov; const char * filename; const char * command; if (argc < 2) { fprintf(stderr, "usage - %s command ...\n", argv[0]); return 1; } mongoc_init(); iov.iov_base = (void *)buf; iov.iov_len = sizeof buf; /* connect to localhost client */ client = mongoc_client_new ("mongodb://127.0.0.1:27017"); assert(client); /* grab a gridfs handle in test prefixed by fs */ gridfs = mongoc_client_get_gridfs (client, "test", "fs", &error); assert(gridfs); command = argv[1]; filename = argv[2]; if (strcmp(command, "read") == 0) { if (argc != 3) { fprintf(stderr, "usage - %s read filename\n", argv[0]); return 1; } file = mongoc_gridfs_find_one_by_filename(gridfs, filename, &error); assert(file); stream = mongoc_stream_gridfs_new (file); assert(stream); for (;;) { r = mongoc_stream_readv (stream, &iov, 1, -1, 0); assert (r >= 0); if (r == 0) { break; } if (fwrite (iov.iov_base, 1, r, stdout) != r) { MONGOC_ERROR ("Failed to write to stdout. Exiting.\n"); exit (1); } } mongoc_stream_destroy (stream); mongoc_gridfs_file_destroy (file); } else if (strcmp(command, "list") == 0) { bson_init (&query); bson_append_document_begin (&query, "$orderby", -1, &child); bson_append_int32 (&child, "filename", -1, 1); bson_append_document_end (&query, &child); bson_append_document_begin (&query, "$query", -1, &child); bson_append_document_end (&query, &child); list = mongoc_gridfs_find (gridfs, &query); bson_destroy (&query); while ((file = mongoc_gridfs_file_list_next (list))) { const char * name = mongoc_gridfs_file_get_filename(file); printf("%s\n", name ? name : "?"); mongoc_gridfs_file_destroy (file); } mongoc_gridfs_file_list_destroy (list); } else if (strcmp(command, "write") == 0) { if (argc != 4) { fprintf(stderr, "usage - %s write filename input_file\n", argv[0]); return 1; } stream = mongoc_stream_file_new_for_path (argv [3], O_RDONLY, 0); assert (stream); opt.filename = filename; file = mongoc_gridfs_create_file_from_stream (gridfs, stream, &opt); assert(file); mongoc_gridfs_file_save(file); mongoc_gridfs_file_destroy(file); } else { fprintf(stderr, "Unknown command"); return 1; } mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); mongoc_cleanup (); return 0; }
int main (int argc, char *argv[]) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_gridfs_file_list_t *list; mongoc_gridfs_file_opt_t opt = {0}; mongoc_client_t *client; mongoc_stream_t *stream; bson_t filter; bson_t opts; bson_t child; bson_error_t error; ssize_t r; char buf[4096]; mongoc_iovec_t iov; const char *filename; const char *command; bson_value_t id; if (argc < 2) { fprintf (stderr, "usage - %s command ...\n", argv[0]); return 1; } mongoc_init (); iov.iov_base = (void *) buf; iov.iov_len = sizeof buf; /* connect to localhost client */ client = mongoc_client_new ("mongodb://127.0.0.1:27017?appname=gridfs-example"); assert (client); mongoc_client_set_error_api (client, 2); /* grab a gridfs handle in test prefixed by fs */ gridfs = mongoc_client_get_gridfs (client, "test", "fs", &error); assert (gridfs); command = argv[1]; filename = argv[2]; if (strcmp (command, "read") == 0) { if (argc != 3) { fprintf (stderr, "usage - %s read filename\n", argv[0]); return 1; } file = mongoc_gridfs_find_one_by_filename (gridfs, filename, &error); assert (file); stream = mongoc_stream_gridfs_new (file); assert (stream); for (;;) { r = mongoc_stream_readv (stream, &iov, 1, -1, 0); assert (r >= 0); if (r == 0) { break; } if (fwrite (iov.iov_base, 1, r, stdout) != r) { MONGOC_ERROR ("Failed to write to stdout. Exiting.\n"); exit (1); } } mongoc_stream_destroy (stream); mongoc_gridfs_file_destroy (file); } else if (strcmp (command, "list") == 0) { bson_init (&filter); bson_init (&opts); bson_append_document_begin (&opts, "sort", -1, &child); BSON_APPEND_INT32 (&child, "filename", 1); bson_append_document_end (&opts, &child); list = mongoc_gridfs_find_with_opts (gridfs, &filter, &opts); bson_destroy (&filter); bson_destroy (&opts); while ((file = mongoc_gridfs_file_list_next (list))) { const char *name = mongoc_gridfs_file_get_filename (file); printf ("%s\n", name ? name : "?"); mongoc_gridfs_file_destroy (file); } mongoc_gridfs_file_list_destroy (list); } else if (strcmp (command, "write") == 0) { if (argc != 4) { fprintf (stderr, "usage - %s write filename input_file\n", argv[0]); return 1; } stream = mongoc_stream_file_new_for_path (argv[3], O_RDONLY, 0); assert (stream); opt.filename = filename; /* the driver generates a file_id for you */ file = mongoc_gridfs_create_file_from_stream (gridfs, stream, &opt); assert (file); id.value_type = BSON_TYPE_INT32; id.value.v_int32 = 1; /* optional: the following method specifies a file_id of any BSON type */ if (!mongoc_gridfs_file_set_id (file, &id, &error)) { fprintf (stderr, "%s\n", error.message); return 1; } mongoc_gridfs_file_save (file); mongoc_gridfs_file_destroy (file); } else { fprintf (stderr, "Unknown command"); return 1; } mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); mongoc_cleanup (); return 0; }