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_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_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);
}
static void
validate (const char *name) /* IN */
{
mongoc_stream_t *stream;
mongoc_rpc_t rpc;
#ifdef _WIN32
struct _stat st;
#else
struct stat st;
#endif
uint8_t *buf;
int32_t len;
int ret;
stream = mongoc_stream_file_new_for_path (name, O_RDONLY, 0);
if (!stream) {
perror ("failed to open file");
exit (EXIT_FAILURE);
}
#ifdef _WIN32
ret = _stat (name, &st);
#else
ret = stat (name, &st);
#endif
if (ret != 0) {
perror ("failed to stat() file.");
exit (EXIT_FAILURE);
}
if ((st.st_size > (100 * 1024 * 1024)) || (st.st_size < 16)) {
fprintf (stderr, "%s: unreasonable message size\n", name);
exit (EXIT_FAILURE);
}
buf = malloc (st.st_size);
if (buf == NULL) {
fprintf (stderr, "%s: Failed to malloc %d bytes.\n",
name, (int)st.st_size);
exit (EXIT_FAILURE);
}
if (st.st_size != mongoc_stream_read (stream, buf, st.st_size, st.st_size, -1)) {
fprintf (stderr, "%s: Failed to read %d bytes into buffer.\n",
name, (int)st.st_size);
exit (EXIT_FAILURE);
}
memcpy (&len, buf, 4);
len = BSON_UINT32_FROM_LE (len);
if (len != st.st_size) {
fprintf (stderr, "%s is invalid. Invalid Length.\n", name);
exit (EXIT_FAILURE);
}
if (!_mongoc_rpc_scatter (&rpc, buf, st.st_size)) {
fprintf (stderr, "%s is invalid. Invalid Format.\n", name);
exit (EXIT_FAILURE);
}
fprintf (stdout, "%s is valid.\n", name);
bson_free (buf);
}
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[])
{
const char *uri_string =
"mongodb://localhost:27017/?appname=new-gridfs-example";
mongoc_client_t *client;
mongoc_database_t *db;
mongoc_stream_t *file_stream;
mongoc_gridfs_bucket_t *bucket;
mongoc_cursor_t *cursor;
bson_t filter;
bool res;
bson_value_t file_id;
bson_error_t error;
const bson_t *doc;
char *str;
mongoc_init ();
if (argc != 3) {
fprintf (stderr, "usage: %s SOURCE_FILE_PATH FILE_COPY_PATH\n", argv[0]);
return EXIT_FAILURE;
}
/* 1. Make a bucket. */
client = mongoc_client_new (uri_string);
db = mongoc_client_get_database (client, "test");
bucket = mongoc_gridfs_bucket_new (db, NULL, NULL);
/* 2. Insert a file. */
file_stream = mongoc_stream_file_new_for_path (argv[1], O_RDONLY, 0);
res = mongoc_gridfs_bucket_upload_from_stream (
bucket, "my-file", file_stream, NULL, &file_id, &error);
if (!res) {
printf ("Error uploading file: %s\n", error.message);
return EXIT_FAILURE;
}
mongoc_stream_close (file_stream);
mongoc_stream_destroy (file_stream);
/* 3. Download the file in GridFS to a local file. */
file_stream = mongoc_stream_file_new_for_path (argv[2], O_CREAT | O_RDWR, 0);
if (!file_stream) {
perror ("Error opening file stream");
return EXIT_FAILURE;
}
res = mongoc_gridfs_bucket_download_to_stream (
bucket, &file_id, file_stream, &error);
if (!res) {
printf ("Error downloading file to stream: %s\n", error.message);
return EXIT_FAILURE;
}
mongoc_stream_close (file_stream);
mongoc_stream_destroy (file_stream);
/* 4. List what files are available in GridFS. */
bson_init (&filter);
cursor = mongoc_gridfs_bucket_find (bucket, &filter, NULL);
while (mongoc_cursor_next (cursor, &doc)) {
str = bson_as_canonical_extended_json (doc, NULL);
printf ("%s\n", str);
bson_free (str);
}
/* 5. Delete the file that we added. */
res = mongoc_gridfs_bucket_delete_by_id (bucket, &file_id, &error);
if (!res) {
printf ("Error deleting the file: %s\n", error.message);
return EXIT_FAILURE;
}
/* 6. Cleanup. */
mongoc_stream_close (file_stream);
mongoc_stream_destroy (file_stream);
mongoc_cursor_destroy (cursor);
bson_destroy (&filter);
mongoc_gridfs_bucket_destroy (bucket);
mongoc_database_destroy (db);
mongoc_client_destroy (client);
mongoc_cleanup ();
return EXIT_SUCCESS;
}
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;
}
