static void test_write (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_client_t *client; bson_error_t error; ssize_t r; char buf[] = "foo bar"; char buf2[] = " baz"; char buf3[1000]; mongoc_gridfs_file_opt_t opt = { 0 }; mongoc_iovec_t iov[2]; mongoc_iovec_t riov; int len = sizeof buf + sizeof buf2 - 2; iov [0].iov_base = buf; iov [0].iov_len = sizeof (buf) - 1; iov [1].iov_base = buf2; iov [1].iov_len = sizeof (buf2) - 1; riov.iov_base = buf3; riov.iov_len = sizeof (buf3); opt.chunk_size = 2; client = mongoc_client_new (gTestUri); assert (client); gridfs = get_test_gridfs (client, "write", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); file = mongoc_gridfs_create_file (gridfs, &opt); assert (file); assert (mongoc_gridfs_file_save (file)); r = mongoc_gridfs_file_writev (file, iov, 2, 0); assert (r == len); assert (mongoc_gridfs_file_save (file)); r = mongoc_gridfs_file_seek (file, 0, SEEK_SET); assert (!r); r = mongoc_gridfs_file_tell (file); assert (r == 0); r = mongoc_gridfs_file_readv (file, &riov, 1, len, 0); assert (r == len); assert (memcmp (buf3, "foo bar baz", len) == 0); mongoc_gridfs_file_destroy (file); drop_collections (gridfs, &error); mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); }
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 _upload_big_file (gridfs_test_t *gridfs_test, bson_oid_t *oid /* OUT */) { mongoc_gridfs_file_t *file; mongoc_iovec_t iov; bson_error_t error; const bson_value_t *value; file = mongoc_gridfs_create_file (gridfs_test->gridfs, NULL); iov.iov_base = (void *) gridfs_test->data; iov.iov_len = gridfs_test->data_sz; if (iov.iov_len != mongoc_gridfs_file_writev (file, &iov, 1, 0)) { if (mongoc_gridfs_file_error (file, &error)) { MONGOC_ERROR ("file_writev: %s\n", error.message); } else { MONGOC_ERROR ("file_writev: unknown error\n"); } abort (); } mongoc_gridfs_file_save (file); value = mongoc_gridfs_file_get_id (file); assert (value->value_type == BSON_TYPE_OID); bson_oid_copy (&value->value.v_oid, oid); mongoc_gridfs_file_destroy (file); }
static void test_create_from_stream (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_stream_t *stream; mongoc_client_t *client; bson_error_t error; client = mongoc_client_new (gTestUri); assert (client); gridfs = get_test_gridfs (client, "from_stream", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); stream = mongoc_stream_file_new_for_path (BINARY_DIR"/gridfs.dat", O_RDONLY, 0); assert (stream); file = mongoc_gridfs_create_file_from_stream (gridfs, stream, 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_upload_thread (void *p) { multi_upload_thread_context_t *ctx; mongoc_gridfs_file_opt_t opt = { 0 }; mongoc_gridfs_file_t *file; bson_error_t error; ctx = (multi_upload_thread_context_t *) p; opt.filename = ctx->filename; /* upload chunks */ file = mongoc_gridfs_create_file_from_stream (ctx->gridfs, ctx->stream, &opt); /* create fs.files document */ if (!mongoc_gridfs_file_save (file)) { if (mongoc_gridfs_file_error (file, &error)) { MONGOC_ERROR ("file_readv: %s\n", error.message); } else { MONGOC_ERROR ("file_readv: unknown error\n"); } abort (); } mongoc_gridfs_file_destroy (file); return (void *) 1; }
static void test_remove_by_filename (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_gridfs_file_opt_t opt = { 0 }; mongoc_client_t *client; bson_error_t error; bool ret; client = mongoc_client_new (gTestUri); assert (client); gridfs = get_test_gridfs (client, "fs_remove_by_filename", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); opt.filename = "foo_file_1.txt"; file = mongoc_gridfs_create_file (gridfs, &opt); assert (file); assert (mongoc_gridfs_file_save (file)); mongoc_gridfs_file_destroy (file); opt.filename = "foo_file_2.txt"; file = mongoc_gridfs_create_file (gridfs, &opt); assert (file); assert (mongoc_gridfs_file_save (file)); ret = mongoc_gridfs_remove_by_filename (gridfs, "foo_file_1.txt", &error); if (!ret) fprintf (stderr, "ERROR: %s\n", error.message); assert (ret); mongoc_gridfs_file_destroy (file); file = mongoc_gridfs_find_one_by_filename (gridfs, "foo_file_1.txt", &error); assert (!file); file = mongoc_gridfs_find_one_by_filename (gridfs, "foo_file_2.txt", &error); assert (file); mongoc_gridfs_file_destroy (file); drop_collections (gridfs, &error); mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); }
static int _mongoc_stream_gridfs_flush (mongoc_stream_t *stream) { mongoc_stream_gridfs_t *gridfs = (mongoc_stream_gridfs_t *) stream; int ret = 0; ENTRY; BSON_ASSERT (stream); ret = mongoc_gridfs_file_save (gridfs->file); RETURN (ret); }
static void test_stream (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_client_t *client; mongoc_stream_t *stream; mongoc_stream_t *in_stream; bson_error_t error; ssize_t r; char buf[4096]; mongoc_iovec_t iov; iov.iov_base = buf; iov.iov_len = sizeof buf; client = mongoc_client_new (gTestUri); assert (client); gridfs = get_test_gridfs (client, "fs", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); in_stream = mongoc_stream_file_new_for_path (BINARY_DIR"/gridfs.dat", O_RDONLY, 0); file = mongoc_gridfs_create_file_from_stream (gridfs, in_stream, NULL); assert (file); assert (mongoc_gridfs_file_save (file)); stream = mongoc_stream_gridfs_new (file); r = mongoc_stream_readv (stream, &iov, 1, file->length, 0); assert (r == file->length); /* cleanup */ mongoc_stream_destroy (stream); mongoc_gridfs_file_destroy (file); drop_collections (gridfs, &error); mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); }
static void test_read (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_stream_t *stream; mongoc_client_t *client; bson_error_t error; ssize_t r; char buf[10], buf2[10]; mongoc_iovec_t iov[2]; iov[0].iov_base = buf; iov[0].iov_len = 10; iov[1].iov_base = buf2; iov[1].iov_len = 10; client = mongoc_client_new (gTestUri); assert (client); gridfs = get_test_gridfs (client, "read", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); stream = mongoc_stream_file_new_for_path (BINARY_DIR"/gridfs.dat", O_RDONLY, 0); file = mongoc_gridfs_create_file_from_stream (gridfs, stream, NULL); assert (file); assert (mongoc_gridfs_file_save (file)); r = mongoc_gridfs_file_readv (file, iov, 2, 20, 0); assert (r == 20); assert (memcmp (iov[0].iov_base, "Bacon ipsu", 10) == 0); assert (memcmp (iov[1].iov_base, "m dolor si", 10) == 0); mongoc_gridfs_file_destroy (file); drop_collections (gridfs, &error); mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); }
/** * _mongoc_gridfs_file_flush_page: * * Unconditionally flushes the file's current page to the database. * The page to flush is determined by page->n. * * Side Effects: * * On success, file->page is properly destroyed and set to NULL. * * Returns: * * True on success; false otherwise. */ static bool _mongoc_gridfs_file_flush_page (mongoc_gridfs_file_t *file) { bson_t *selector, *update; bool r; const uint8_t *buf; uint32_t len; ENTRY; BSON_ASSERT (file); BSON_ASSERT (file->page); buf = _mongoc_gridfs_file_page_get_data (file->page); len = _mongoc_gridfs_file_page_get_len (file->page); selector = bson_new (); bson_append_value (selector, "files_id", -1, &file->files_id); bson_append_int32 (selector, "n", -1, file->n); update = bson_sized_new (file->chunk_size + 100); bson_append_value (update, "files_id", -1, &file->files_id); bson_append_int32 (update, "n", -1, file->n); bson_append_binary (update, "data", -1, BSON_SUBTYPE_BINARY, buf, len); r = mongoc_collection_update (file->gridfs->chunks, MONGOC_UPDATE_UPSERT, selector, update, NULL, &file->error); bson_destroy (selector); bson_destroy (update); if (r) { _mongoc_gridfs_file_page_destroy (file->page); file->page = NULL; r = mongoc_gridfs_file_save (file); } RETURN (r); }
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 test_list (void) { mongoc_gridfs_t *gridfs; mongoc_gridfs_file_t *file; mongoc_client_t *client; bson_error_t error; mongoc_gridfs_file_list_t *list; mongoc_gridfs_file_opt_t opt = { 0 }; bson_t query, child; char buf[100]; int i = 0; client = mongoc_client_new (gTestUri); assert (client); gridfs = get_test_gridfs (client, "list", &error); assert (gridfs); mongoc_gridfs_drop (gridfs, &error); for (i = 0; i < 3; i++) { bson_snprintf (buf, sizeof buf, "file.%d", i); opt.filename = buf; file = mongoc_gridfs_create_file (gridfs, &opt); assert (file); assert (mongoc_gridfs_file_save (file)); mongoc_gridfs_file_destroy (file); } 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); i = 0; while ((file = mongoc_gridfs_file_list_next (list))) { bson_snprintf (buf, sizeof buf, "file.%d", i++); assert (strcmp (mongoc_gridfs_file_get_filename (file), buf) == 0); mongoc_gridfs_file_destroy (file); } assert(i == 3); mongoc_gridfs_file_list_destroy (list); bson_init (&query); bson_append_utf8 (&query, "filename", -1, "file.1", -1); file = mongoc_gridfs_find_one (gridfs, &query, &error); assert (file); assert (strcmp (mongoc_gridfs_file_get_filename (file), "file.1") == 0); mongoc_gridfs_file_destroy (file); file = mongoc_gridfs_find_one_by_filename (gridfs, "file.1", &error); assert (file); assert (strcmp (mongoc_gridfs_file_get_filename (file), "file.1") == 0); mongoc_gridfs_file_destroy (file); drop_collections (gridfs, &error); mongoc_gridfs_destroy (gridfs); mongoc_client_destroy (client); }
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; }