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 * _multi_download_thread (void *p) { multi_download_thread_context_t *ctx; FILE *fp; mongoc_gridfs_file_t *file; bson_error_t error; char buf[BUF_SZ]; mongoc_iovec_t iov; ssize_t sz; ctx = (multi_download_thread_context_t *) p; fp = fopen (ctx->path, "w+"); if (!fp) { perror ("fopen"); abort (); } file = mongoc_gridfs_find_one_by_filename (ctx->gridfs, ctx->filename, &error); if (!file) { MONGOC_ERROR ("find_one_by_filename: %s\n", error.message); abort (); } iov.iov_base = buf; iov.iov_len = BUF_SZ; for (;;) { /* a 255k chunk at a time */ sz = mongoc_gridfs_file_readv (file, &iov, 1, /* iov count */ 1, /* min bytes */ 0 /* timeout */); if (!sz) { break; } assert (sz > 0); fwrite (iov.iov_base, sizeof (char), (size_t) sz, fp); } if (mongoc_gridfs_file_error (file, &error)) { MONGOC_ERROR ("gridfs_file_readv: %s\n", error.message); abort (); } mongoc_gridfs_file_destroy (file); fclose (fp); return (void *) 1; }
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 * background_mongoc_gridfs_file_readv (void *data) { future_t *future = (future_t *) data; future_value_t return_value; return_value.type = future_value_ssize_t_type; future_value_set_ssize_t ( &return_value, mongoc_gridfs_file_readv ( future_value_get_mongoc_gridfs_file_t_ptr (future_get_param (future, 0)), future_value_get_mongoc_iovec_t_ptr (future_get_param (future, 1)), future_value_get_size_t (future_get_param (future, 2)), future_value_get_size_t (future_get_param (future, 3)), future_value_get_uint32_t (future_get_param (future, 4)) )); future_resolve (future, return_value); return NULL; }
static void download_task (perf_test_t *test) { download_test_t *gridfs_test; bson_t query = BSON_INITIALIZER; mongoc_gridfs_file_t *file; mongoc_iovec_t iov; bson_error_t error; ssize_t read_sz; gridfs_test = (download_test_t *) test; bson_append_oid (&query, "_id", 3, &gridfs_test->file_id); file = mongoc_gridfs_find_one (gridfs_test->base.gridfs, &query, &error); if (!file) { MONGOC_ERROR ("gridfs_find_one: %s\n", error.message); abort (); } /* overwrite the buffer we used for _upload_big_file */ iov.iov_base = (void *) gridfs_test->base.data; iov.iov_len = gridfs_test->base.data_sz; read_sz = mongoc_gridfs_file_readv (file, &iov, 1, gridfs_test->base.data_sz, 0); if (read_sz != gridfs_test->base.data_sz) { 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); bson_destroy (&query); }
static ssize_t _mongoc_stream_gridfs_readv (mongoc_stream_t *stream, mongoc_iovec_t *iov, size_t iovcnt, size_t min_bytes, int32_t timeout_msec) { mongoc_stream_gridfs_t *file = (mongoc_stream_gridfs_t *) stream; ssize_t ret = 0; ENTRY; BSON_ASSERT (stream); BSON_ASSERT (iov); BSON_ASSERT (iovcnt); /* timeout_msec is unused by mongoc_gridfs_file_readv */ ret = mongoc_gridfs_file_readv (file->file, iov, iovcnt, min_bytes, 0); mongoc_counter_streams_ingress_add (ret); RETURN (ret); }
static ssize_t _mongoc_stream_gridfs_readv (mongoc_stream_t *stream, struct iovec *iov, size_t iovcnt, size_t min_bytes, bson_int32_t timeout_msec) { mongoc_stream_gridfs_t *file = (mongoc_stream_gridfs_t *)stream; ssize_t ret = 0; ENTRY; BSON_ASSERT (stream); BSON_ASSERT (iov); BSON_ASSERT (iovcnt); BSON_ASSERT (timeout_msec <= INT_MAX); ret = mongoc_gridfs_file_readv (file->file, iov, iovcnt, min_bytes, timeout_msec); mongoc_counter_streams_ingress_add (ret); RETURN (ret); }