/** refresh a gridfs file's underlying page
*
* This unconditionally fetches the current page, even if the current page
* covers the same theoretical chunk.
*/
static bool
_mongoc_gridfs_file_refresh_page (mongoc_gridfs_file_t *file)
{
bson_t *query, *fields, child, child2;
const bson_t *chunk;
const char *key;
bson_iter_t iter;
uint32_t n;
const uint8_t *data;
uint32_t len;
ENTRY;
BSON_ASSERT (file);
n = (uint32_t)(file->pos / file->chunk_size);
if (file->page) {
_mongoc_gridfs_file_page_destroy (file->page);
file->page = NULL;
}
/* if the file pointer is past the end of the current file (I.e. pointing to
* a new chunk) and we're on a chunk boundary, we'll pass the page
* constructor a new empty page */
if ((int64_t)file->pos >= file->length && !(file->pos % file->chunk_size)) {
data = (uint8_t *)"";
len = 0;
} else {
/* if we have a cursor, but the cursor doesn't have the chunk we're going
* to need, destroy it (we'll grab a new one immediately there after) */
if (file->cursor &&
!(file->cursor_range[0] >= n && file->cursor_range[1] <= n)) {
mongoc_cursor_destroy (file->cursor);
file->cursor = NULL;
}
if (!file->cursor) {
query = bson_new ();
bson_append_document_begin(query, "$query", -1, &child);
bson_append_value (&child, "files_id", -1, &file->files_id);
bson_append_document_begin (&child, "n", -1, &child2);
bson_append_int32 (&child2, "$gte", -1, (int32_t)(file->pos / file->chunk_size));
bson_append_document_end (&child, &child2);
bson_append_document_end(query, &child);
bson_append_document_begin(query, "$orderby", -1, &child);
bson_append_int32 (&child, "n", -1, 1);
bson_append_document_end(query, &child);
fields = bson_new ();
bson_append_int32 (fields, "n", -1, 1);
bson_append_int32 (fields, "data", -1, 1);
bson_append_int32 (fields, "_id", -1, 0);
/* find all chunks greater than or equal to our current file pos */
file->cursor = mongoc_collection_find (file->gridfs->chunks,
MONGOC_QUERY_NONE, 0, 0, 0, query,
fields, NULL);
file->cursor_range[0] = n;
file->cursor_range[1] = (uint32_t)(file->length / file->chunk_size);
bson_destroy (query);
bson_destroy (fields);
BSON_ASSERT (file->cursor);
}
/* we might have had a cursor before, then seeked ahead past a chunk.
* iterate until we're on the right chunk */
while (file->cursor_range[0] <= n) {
if (!mongoc_cursor_next (file->cursor, &chunk)) {
if (file->cursor->failed) {
memcpy (&(file->error), &(file->cursor->error),
sizeof (bson_error_t));
file->failed = true;
}
RETURN (0);
}
file->cursor_range[0]++;
}
bson_iter_init (&iter, chunk);
/* grab out what we need from the chunk */
while (bson_iter_next (&iter)) {
key = bson_iter_key (&iter);
if (strcmp (key, "n") == 0) {
n = bson_iter_int32 (&iter);
} else if (strcmp (key, "data") == 0) {
bson_iter_binary (&iter, NULL, &len, &data);
} else {
RETURN (0);
}
}
/* we're on the wrong chunk somehow... probably because our gridfs is
* missing chunks.
*
* TODO: maybe we should make more noise here?
*/
if (!(n == file->pos / file->chunk_size)) {
return 0;
}
}
file->page = _mongoc_gridfs_file_page_new (data, len, file->chunk_size);
/* seek in the page towards wherever we're supposed to be */
RETURN (_mongoc_gridfs_file_page_seek (file->page, file->pos %
file->chunk_size));
}
/**
* _mongoc_gridfs_file_refresh_page:
*
* Refresh a GridFS file's underlying page. This recalculates the current
* page number based on the file's stream position, then fetches that page
* from the database.
*
* Note that this fetch is unconditional and the page is queried from the
* database even if the current page covers the same theoretical chunk.
*
*
* Side Effects:
*
* file->page is loaded with the appropriate buffer, fetched from the
* database. If the file position is at the end of the file and on a new
* chunk boundary, a new page is created. If the position is far past the
* end of the file, _mongoc_gridfs_file_extend is responsible for creating
* chunks to file the gap.
*
* file->n is set based on file->pos. file->error is set on error.
*/
static bool
_mongoc_gridfs_file_refresh_page (mongoc_gridfs_file_t *file)
{
bson_t query;
bson_t child;
bson_t opts;
const bson_t *chunk;
const char *key;
bson_iter_t iter;
int64_t existing_chunks;
int64_t required_chunks;
const uint8_t *data = NULL;
uint32_t len;
ENTRY;
BSON_ASSERT (file);
file->n = (int32_t) (file->pos / file->chunk_size);
if (file->page) {
_mongoc_gridfs_file_page_destroy (file->page);
file->page = NULL;
}
/* if the file pointer is past the end of the current file (i.e. pointing to
* a new chunk), we'll pass the page constructor a new empty page. */
existing_chunks = divide_round_up (file->length, file->chunk_size);
required_chunks = divide_round_up (file->pos + 1, file->chunk_size);
if (required_chunks > existing_chunks) {
data = (uint8_t *) "";
len = 0;
} else {
/* if we have a cursor, but the cursor doesn't have the chunk we're going
* to need, destroy it (we'll grab a new one immediately there after) */
if (file->cursor && !_mongoc_gridfs_file_keep_cursor (file)) {
mongoc_cursor_destroy (file->cursor);
file->cursor = NULL;
}
if (!file->cursor) {
bson_init (&query);
BSON_APPEND_VALUE (&query, "files_id", &file->files_id);
BSON_APPEND_DOCUMENT_BEGIN (&query, "n", &child);
BSON_APPEND_INT32 (&child, "$gte", file->n);
bson_append_document_end (&query, &child);
bson_init (&opts);
BSON_APPEND_DOCUMENT_BEGIN (&opts, "sort", &child);
BSON_APPEND_INT32 (&child, "n", 1);
bson_append_document_end (&opts, &child);
BSON_APPEND_DOCUMENT_BEGIN (&opts, "projection", &child);
BSON_APPEND_INT32 (&child, "n", 1);
BSON_APPEND_INT32 (&child, "data", 1);
BSON_APPEND_INT32 (&child, "_id", 0);
bson_append_document_end (&opts, &child);
/* find all chunks greater than or equal to our current file pos */
file->cursor = mongoc_collection_find_with_opts (
file->gridfs->chunks, &query, &opts, NULL);
file->cursor_range[0] = file->n;
file->cursor_range[1] = (uint32_t) (file->length / file->chunk_size);
bson_destroy (&query);
bson_destroy (&opts);
BSON_ASSERT (file->cursor);
}
/* we might have had a cursor before, then seeked ahead past a chunk.
* iterate until we're on the right chunk */
while (file->cursor_range[0] <= file->n) {
if (!mongoc_cursor_next (file->cursor, &chunk)) {
/* copy cursor error; if there's none, we're missing a chunk */
if (!mongoc_cursor_error (file->cursor, &file->error)) {
missing_chunk (file);
}
RETURN (0);
}
file->cursor_range[0]++;
}
BSON_ASSERT (bson_iter_init (&iter, chunk));
/* grab out what we need from the chunk */
while (bson_iter_next (&iter)) {
key = bson_iter_key (&iter);
if (strcmp (key, "n") == 0) {
if (file->n != bson_iter_int32 (&iter)) {
missing_chunk (file);
RETURN (0);
}
} else if (strcmp (key, "data") == 0) {
bson_iter_binary (&iter, NULL, &len, &data);
} else {
/* Unexpected key. This should never happen */
RETURN (0);
}
}
if (file->n != file->pos / file->chunk_size) {
return 0;
}
}
if (!data) {
bson_set_error (&file->error,
MONGOC_ERROR_GRIDFS,
MONGOC_ERROR_GRIDFS_CHUNK_MISSING,
"corrupt chunk number %" PRId32,
file->n);
RETURN (0);
}
file->page = _mongoc_gridfs_file_page_new (data, len, file->chunk_size);
/* seek in the page towards wherever we're supposed to be */
RETURN (
_mongoc_gridfs_file_page_seek (file->page, file->pos % file->chunk_size));
}
