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;
}
/** save a gridfs file */
bool
mongoc_gridfs_file_save (mongoc_gridfs_file_t *file)
{
bson_t *selector, *update, child;
const char *md5;
const char *filename;
const char *content_type;
const bson_t *aliases;
const bson_t *metadata;
bool r;
ENTRY;
if (!file->is_dirty) {
return 1;
}
if (file->page && _mongoc_gridfs_file_page_is_dirty (file->page)) {
_mongoc_gridfs_file_flush_page (file);
}
md5 = mongoc_gridfs_file_get_md5 (file);
filename = mongoc_gridfs_file_get_filename (file);
content_type = mongoc_gridfs_file_get_content_type (file);
aliases = mongoc_gridfs_file_get_aliases (file);
metadata = mongoc_gridfs_file_get_metadata (file);
selector = bson_new ();
bson_append_value (selector, "_id", -1, &file->files_id);
update = bson_new ();
bson_append_document_begin (update, "$set", -1, &child);
bson_append_int64 (&child, "length", -1, file->length);
bson_append_int32 (&child, "chunkSize", -1, file->chunk_size);
bson_append_date_time (&child, "uploadDate", -1, file->upload_date);
if (md5) {
bson_append_utf8 (&child, "md5", -1, md5, -1);
}
if (filename) {
bson_append_utf8 (&child, "filename", -1, filename, -1);
}
if (content_type) {
bson_append_utf8 (&child, "contentType", -1, content_type, -1);
}
if (aliases) {
bson_append_array (&child, "aliases", -1, aliases);
}
if (metadata) {
bson_append_document (&child, "metadata", -1, metadata);
}
bson_append_document_end (update, &child);
r = mongoc_collection_update (file->gridfs->files, MONGOC_UPDATE_UPSERT,
selector, update, NULL, &file->error);
file->failed = !r;
bson_destroy (selector);
bson_destroy (update);
file->is_dirty = 0;
RETURN (r);
}
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;
}