static void
test_create_collection (void)
{
mongoc_database_t *database;
mongoc_collection_t *collection;
mongoc_client_t *client;
bson_error_t error = { 0 };
bson_t options;
bson_t storage_opts;
bson_t wt_opts;
char *dbname;
char *name;
bool r;
client = mongoc_client_new (gTestUri);
assert (client);
dbname = gen_collection_name ("dbtest");
database = mongoc_client_get_database (client, dbname);
assert (database);
bson_free (dbname);
bson_init (&options);
BSON_APPEND_INT32 (&options, "size", 1234);
BSON_APPEND_INT32 (&options, "max", 4567);
BSON_APPEND_BOOL (&options, "capped", true);
BSON_APPEND_BOOL (&options, "autoIndexId", true);
BSON_APPEND_DOCUMENT_BEGIN(&options, "storage", &storage_opts);
BSON_APPEND_DOCUMENT_BEGIN(&storage_opts, "wiredtiger", &wt_opts);
BSON_APPEND_UTF8(&wt_opts, "configString", "block_compressor=zlib");
bson_append_document_end(&storage_opts, &wt_opts);
bson_append_document_end(&options, &storage_opts);
name = gen_collection_name ("create_collection");
collection = mongoc_database_create_collection (database, name, &options, &error);
assert (collection);
bson_destroy (&options);
bson_free (name);
r = mongoc_collection_drop (collection, &error);
assert (r);
r = mongoc_database_drop (database, &error);
assert (r);
mongoc_collection_destroy (collection);
mongoc_database_destroy (database);
mongoc_client_destroy (client);
}
// Find the spend of a specified output_reference within a given blockheight range (main chain only)
// if found, load tx and the input that spends it
int database_find_blockchain_spend(struct database* db, struct transaction_output_reference* output_reference, size_t start_height, size_t max_height, struct transaction** tx)
{
mongoc_collection_t* collection = mongoc_client_get_collection(db->client, database_name(db), "transactions");
// Build a query doc
bson_t* query = bson_new();
// Build a query that tries to find where this output_reference is spent
unsigned char hash[32];
transaction_output_reference_hash(output_reference, hash);
bson_t* output_reference_doc = bson_new();
BSON_APPEND_DOCUMENT_BEGIN(query, "inputs.output_reference", output_reference_doc);
BSON_APPEND_BINARY(output_reference_doc, "hash", BSON_SUBTYPE_BINARY, (uint8_t*)hash, 32);
BSON_APPEND_INT32(output_reference_doc, "index", transaction_output_reference_index(output_reference));
bson_append_document_end(query, output_reference_doc);
// Force the height to be valid
bson_t* height_doc = bson_new();
BSON_APPEND_DOCUMENT_BEGIN(query, "height", height_doc);
BSON_APPEND_INT32(height_doc, "$lte", (int)max_height);
BSON_APPEND_INT32(height_doc, "$gte", start_height);
bson_append_document_end(query, height_doc);
// Perform find
mongoc_cursor_t* cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
bson_error_t error;
if(cursor == NULL || mongoc_cursor_error(cursor, &error)) {
printf("MongoDB error: %s\n", (cursor == NULL) ? "NULL cursor" : error.message);
return -1;
}
bson_t const* doc;
int found = 0;
while(mongoc_cursor_next(cursor, &doc) != 0) {
if(tx != NULL) {
*tx = transaction_from_bson(doc);
}
found = 1;
break;
}
mongoc_cursor_destroy(cursor);
bson_destroy(height_doc);
bson_destroy(output_reference_doc);
bson_destroy(query);
mongoc_collection_destroy(collection);
return found;
}
/*
* Return true if we build the document, and it's not too big
* false if there's no way to prevent the doc from being too big. In this
* case, the caller shouldn't include it with isMaster
*/
bool
_mongoc_metadata_build_doc_with_application (bson_t *doc,
const char *appname)
{
const mongoc_metadata_t *md = &gMongocMetadata;
bson_t child;
if (appname) {
BSON_APPEND_DOCUMENT_BEGIN (doc, "application", &child);
BSON_APPEND_UTF8 (&child, "name", appname);
bson_append_document_end (doc, &child);
}
BSON_APPEND_DOCUMENT_BEGIN (doc, "driver", &child);
BSON_APPEND_UTF8 (&child, "name", md->driver_name);
BSON_APPEND_UTF8 (&child, "version", md->driver_version);
bson_append_document_end (doc, &child);
BSON_APPEND_DOCUMENT_BEGIN (doc, "os", &child);
BSON_ASSERT (md->os_type);
BSON_APPEND_UTF8 (&child, "type", md->os_type);
if (md->os_name) {
BSON_APPEND_UTF8 (&child, "name", md->os_name);
}
if (md->os_version) {
BSON_APPEND_UTF8 (&child, "version", md->os_version);
}
if (md->os_architecture) {
BSON_APPEND_UTF8 (&child, "architecture", md->os_architecture);
}
bson_append_document_end (doc, &child);
if (doc->len > METADATA_MAX_SIZE) {
/* We've done all we can possibly do to ensure the current
* document is below the maxsize, so if it overflows there is
* nothing else we can do, so we fail */
return false;
}
if (md->platform) {
_append_platform_field (doc, md->platform);
}
return true;
}
void SettingsOutput::SetSubbasinIDs()
{
bson_t *b = bson_new();
bson_t *child = bson_new();
bson_t *child2 = bson_new();
bson_t *child3 = bson_new();
BSON_APPEND_DOCUMENT_BEGIN(b, "$query", child);
BSON_APPEND_DOCUMENT_BEGIN(child, PARAM_FLD_NAME, child2);
BSON_APPEND_ARRAY_BEGIN(child2, "$in", child3);
BSON_APPEND_UTF8(child3,PARAM_FLD_NAME, VAR_OUTLETID);
BSON_APPEND_UTF8(child3,PARAM_FLD_NAME, VAR_SUBBSNID_NUM);
bson_append_array_end(child2, child3);
bson_append_document_end(child, child2);
bson_append_document_end(b, child);
//printf("%s\n",bson_as_json(b,NULL));
mongoc_cursor_t *cursor;
const bson_t *bsonTable;
mongoc_collection_t *collection;
collection = mongoc_client_get_collection(m_conn, m_dbName.c_str(), DB_TAB_PARAMETERS);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, b, NULL, NULL);
bson_iter_t iter;
while (mongoc_cursor_more(cursor) && mongoc_cursor_next(cursor, &bsonTable))
{
string nameTmp = "";
int numTmp = -1;
if (bson_iter_init_find(&iter, bsonTable, PARAM_FLD_NAME))
nameTmp = GetStringFromBSONITER(&iter);
if (bson_iter_init_find(&iter, bsonTable, PARAM_FLD_VALUE))
numTmp = GetIntFromBSONITER(&iter);
if(!StringMatch(nameTmp, "") && numTmp != -1)
{
if(StringMatch(nameTmp, VAR_OUTLETID))
m_outletID = GetIntFromBSONITER(&iter);
else if (StringMatch(nameTmp, VAR_SUBBSNID_NUM))
m_nSubbasins = GetIntFromBSONITER(&iter);
}
else
throw ModelException("SettingOutput","SetSubbasinIDs","No valid values found in MongoDB!");
}
bson_destroy(child);
bson_destroy(child2);
bson_destroy(child3);
bson_destroy(b);
mongoc_collection_destroy(collection);
mongoc_cursor_destroy(cursor);
return;
}
static mongoc_cursor_t *
query_collection (mongoc_collection_t *collection, uint32_t last_time)
{
mongoc_cursor_t *cursor;
bson_t query;
bson_t gt;
bson_t opts;
BSON_ASSERT (collection);
bson_init (&query);
BSON_APPEND_DOCUMENT_BEGIN (&query, "ts", >);
BSON_APPEND_TIMESTAMP (>, "$gt", last_time, 0);
bson_append_document_end (&query, >);
bson_init (&opts);
BSON_APPEND_BOOL (&opts, "tailable", true);
BSON_APPEND_BOOL (&opts, "awaitData", true);
cursor = mongoc_collection_find_with_opts (collection, &query, &opts, NULL);
bson_destroy (&query);
bson_destroy (&opts);
return cursor;
}
TBson TBson::toBson(const QVariantMap &query, const QVariantMap &orderBy)
{
TBson ret;
bson_t child;
// query clause
BSON_APPEND_DOCUMENT_BEGIN((bson_t *)ret.data(), "$query", &child);
appendBson(&child, query);
bson_append_document_end((bson_t *)ret.data(), &child);
// orderBy clause
if (!orderBy.isEmpty()) {
BSON_APPEND_DOCUMENT_BEGIN((bson_t *)ret.data(), "$orderby", &child);
appendBson(&child, orderBy);
bson_append_document_end((bson_t *)ret.data(), &child);
}
return ret;
}
mongoc_cursor_t *
mongoc_database_find_collections (mongoc_database_t *database,
const bson_t *filter,
bson_error_t *error)
{
mongoc_cursor_t *cursor;
mongoc_read_prefs_t *read_prefs;
bson_t cmd = BSON_INITIALIZER;
bson_t child;
bson_error_t lerror;
BSON_ASSERT (database);
BSON_APPEND_INT32 (&cmd, "listCollections", 1);
if (filter) {
BSON_APPEND_DOCUMENT (&cmd, "filter", filter);
BSON_APPEND_DOCUMENT_BEGIN (&cmd, "cursor", &child);
bson_append_document_end (&cmd, &child);
}
read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
cursor = _mongoc_cursor_new (database->client, database->name,
MONGOC_QUERY_SLAVE_OK, 0, 0, 0, true,
NULL, NULL, NULL, NULL);
_mongoc_cursor_cursorid_init (cursor, &cmd);
if (_mongoc_cursor_cursorid_prime (cursor)) {
/* intentionally empty */
} else {
if (mongoc_cursor_error (cursor, &lerror)) {
if (lerror.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND) {
/* We are talking to a server that doesn' support listCollections. */
/* clear out the error. */
memset (&lerror, 0, sizeof lerror);
/* try again with using system.namespaces */
mongoc_cursor_destroy (cursor);
cursor = _mongoc_database_find_collections_legacy (
database, filter, error);
} else if (error) {
memcpy (error, &lerror, sizeof *error);
}
}
}
bson_destroy (&cmd);
mongoc_read_prefs_destroy (read_prefs);
return cursor;
}
int database_find_blockchain_transaction(struct database* db, unsigned char* hash, size_t max_height, struct transaction** tx, size_t* height)
{
mongoc_collection_t* collection = mongoc_client_get_collection(db->client, database_name(db), "transactions");
// Build a query doc
bson_t* query = bson_new();
// Set the hash
BSON_APPEND_BINARY(query, "hash", BSON_SUBTYPE_BINARY, (uint8_t*)hash, 32);
// Force the height to be valid (on the main chain)
bson_t* height_doc = bson_new();
BSON_APPEND_DOCUMENT_BEGIN(query, "height", height_doc);
BSON_APPEND_INT32(height_doc, "$lte", (int)max_height);
BSON_APPEND_INT32(height_doc, "$gte", 0);
bson_append_document_end(query, height_doc);
// Perform find
mongoc_cursor_t* cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);
bson_error_t error;
if(cursor == NULL || mongoc_cursor_error(cursor, &error)) {
printf("MongoDB error: %s\n", (cursor == NULL) ? "NULL cursor" : error.message);
return -1;
}
bson_t const* doc;
int found = 0;
while(mongoc_cursor_next(cursor, &doc) != 0) {
if(height != NULL) {
bson_iter_t iter;
if(!bson_iter_init_find(&iter, doc, "height") || !BSON_ITER_HOLDS_INT32(&iter)) {
printf("MongoDB error: tx doesn't have height!\n");
return -1;
}
*height = (size_t)bson_iter_int32(&iter);
}
if(tx != NULL) {
*tx = transaction_from_bson(doc);
}
found = 1;
break;
}
mongoc_cursor_destroy(cursor);
bson_destroy(height_doc);
bson_destroy(query);
mongoc_collection_destroy(collection);
return found;
}
static void
_mongoc_monitor_legacy_write (mongoc_client_t *client,
mongoc_write_command_t *command,
const char *db,
const char *collection,
mongoc_server_stream_t *stream,
int64_t request_id)
{
bson_t doc;
bson_t wc;
mongoc_apm_command_started_t event;
ENTRY;
if (!client->apm_callbacks.started) {
EXIT;
}
bson_init (&doc);
_mongoc_write_command_init (&doc, command, collection);
BSON_APPEND_DOCUMENT_BEGIN (&doc, "writeConcern", &wc);
BSON_APPEND_INT32 (&wc, "w", 0);
bson_append_document_end (&doc, &wc);
_append_array_from_command (command, &doc);
mongoc_apm_command_started_init (
&event,
&doc,
db,
_mongoc_command_type_to_name (command->type),
request_id,
command->operation_id,
&stream->sd->host,
stream->sd->id,
client->apm_context);
client->apm_callbacks.started (&event);
mongoc_apm_command_started_cleanup (&event);
bson_destroy (&doc);
}
bool SettingsOutput::LoadSettingsOutputFromMongoDB(int subBasinID)
{
bson_t *b = bson_new();
bson_t *child1 = bson_new();
BSON_APPEND_DOCUMENT_BEGIN(b, "$query", child1);
bson_append_document_end(b, child1);
bson_destroy(child1);
mongoc_cursor_t *cursor;
const bson_t *bsonTable;
mongoc_collection_t *collection;
collection = mongoc_client_get_collection(m_conn, m_dbName.c_str(), DB_TAB_FILEOUT);
cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, b, NULL, NULL);
bson_iter_t itertor;
while (mongoc_cursor_more(cursor) && mongoc_cursor_next(cursor, &bsonTable))
{
int use = -1;
string modCls = "", outputID = "", descprition = "";
string outFileName = "", aggType = "", unit = "", subBsn = "";
string dataType = "", intervalUnit = "";
int interval = -1;
string sTimeStr = "", eTimeStr = "";
if (bson_iter_init_find(&itertor, bsonTable, Tag_OutputUSE))
use = GetIntFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_MODCLS))
modCls = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_OutputID))
outputID = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_OutputDESC))
descprition = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_FileName))
outFileName = GetStringFromBSONITER(&itertor);
string coreFileName = GetCoreFileName(outFileName);
string suffix = GetSuffix(outFileName);
if (bson_iter_init_find(&itertor, bsonTable, Tag_AggType))
aggType = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_OutputUNIT))
unit = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_OutputSubbsn))
subBsn = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_StartTime))
sTimeStr = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_EndTime))
eTimeStr = GetStringFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_Interval))
interval = GetIntFromBSONITER(&itertor);
if (bson_iter_init_find(&itertor, bsonTable, Tag_IntervalUnit))
intervalUnit = GetStringFromBSONITER(&itertor);
if(use <= 0)
continue;
/// First, if OutputID does not existed in m_printInfos, then create a new one.
if(m_printInfosMap.find(outputID) == m_printInfosMap.end())
{
m_printInfosMap[outputID] = new PrintInfo();
m_printInfosMap[outputID]->setOutputID(outputID);/// set the OUTPUTID for the new PrintInfo
}
PrintInfo *pi = NULL; /// reset the pointer
pi = m_printInfosMap[outputID];
ostringstream oss;
oss << subBasinID << "_";
string strSubbasinID = oss.str();
bool isRaster = false;
string gtiff(GTiffExtension);
if (gtiff.find(suffix) != gtiff.npos)
isRaster = true;
/// Check Tag_OutputSubbsn first
if (StringMatch(subBsn, Tag_Outlet)) /// Output of outlet, such as Qoutlet, SEDoutlet, etc.
{
pi->setInterval(interval);
pi->setIntervalUnits(intervalUnit);
pi->AddPrintItem(sTimeStr, eTimeStr, strSubbasinID + coreFileName, ValueToString(m_outletID), suffix, m_conn, m_outputGfs, true);
//pi->AddPrintItem(sTimeStr, eTimeStr, strSubbasinID + coreFileName, suffix);
}
else if (StringMatch(subBsn, Tag_AllSubbsn) && isRaster)
{
/// Output of all subbasins of DT_Raster1D or DT_Raster2D
vector<string> aggTypes = utils::SplitString(aggType, ',');
for(vector<string>::iterator it = aggTypes.begin(); it != aggTypes.end(); it++)
pi->AddPrintItem(*it, sTimeStr, eTimeStr, strSubbasinID + coreFileName, suffix, m_conn, m_outputGfs);
}
else // subbasin IDs is provided
{
pi->setInterval(interval);
pi->setIntervalUnits(intervalUnit);
vector<string> subBsns;
if (StringMatch(subBsn, Tag_AllSubbsn))
{
for(int i = 0; i <= m_nSubbasins; i++)
subBsns.push_back(ValueToString(i));
vector<string>(subBsns).swap(subBsns);
}
else
subBsns = utils::SplitString(subBsn, ',');
for(vector<string>::iterator it = subBsns.begin(); it != subBsns.end(); it++)
pi->AddPrintItem(sTimeStr, eTimeStr, strSubbasinID + coreFileName, *it, suffix, m_conn, m_outputGfs, true);
}
}
for (map<string, PrintInfo*>::iterator it = m_printInfosMap.begin(); it != m_printInfosMap.end(); it++)
{
m_printInfos.push_back(it->second);
}
vector<PrintInfo*>(m_printInfos).swap(m_printInfos);
bson_destroy(b);
mongoc_collection_destroy(collection);
mongoc_cursor_destroy(cursor);
return true;
}
void switch_value(lua_State *L, int index, bson_t* bson, int level, const char* key)
{
switch(lua_type(L, index))
{
case LUA_TTABLE:
{
int is_a=is_array(L, index);
if (is_a)
{
bson_t child;
//start array
BSON_APPEND_ARRAY_BEGIN(bson, key, &child);
iterate_table(L, index, &child, 0, level+1, NULL);
bson_append_array_end(bson, &child);
}
else
{
bson_t child;
//start map
BSON_APPEND_DOCUMENT_BEGIN(bson, key, &child);
iterate_table(L, index, &child, 1, level+1, NULL);
bson_append_document_end(bson, &child);
}
break;
}
case LUA_TNIL:
{
BSON_APPEND_NULL(bson, key);
break;
}
case LUA_TNUMBER:
{
BSON_APPEND_DOUBLE(bson, key, lua_tonumber(L, index));
break;
}
case LUA_TBOOLEAN:
{
BSON_APPEND_BOOL(bson, key, lua_toboolean(L, index));
break;
}
case LUA_TSTRING:
{
BSON_APPEND_UTF8(bson, key, lua_tostring(L, index));
break;
}
case LUA_TUSERDATA:
{
// switch userdata type
if (luaL_checkudata_ex(L, index, REGEX_METATABLE))
{
cbson_regex_t* regex = check_cbson_regex(L, index);
BSON_APPEND_REGEX (bson, key, regex->regex, regex->options);
}
else if (luaL_checkudata_ex(L, index, OID_METATABLE))
{
cbson_oid_t* oid = check_cbson_oid(L, index);
bson_oid_t boid;
bson_oid_init_from_string (&boid, oid->oid);
BSON_APPEND_OID (bson, key, &boid);
}
else if (luaL_checkudata_ex(L, index, BINARY_METATABLE))
{
cbson_binary_t* bin = check_cbson_binary(L, index);
size_t binary_len = b64_pton (bin->data, NULL, 0);
unsigned char* buf=malloc(binary_len+1);
b64_pton(bin->data, buf, binary_len+1);
BSON_APPEND_BINARY(bson, key, bin->type, buf, binary_len);
free(buf);
}
else if (luaL_checkudata_ex(L, index, SYMBOL_METATABLE))
{
cbson_symbol_t* sym = check_cbson_symbol(L, index);
BSON_APPEND_SYMBOL(bson, key, sym->symbol);
}
else if (luaL_checkudata_ex(L, index, REF_METATABLE))
{
cbson_ref_t* ref = check_cbson_ref(L, index);
bson_oid_t boid;
bson_oid_init_from_string (&boid, ref->id);
BSON_APPEND_DBPOINTER(bson, key, ref->ref, &boid);
}
else if (luaL_checkudata_ex(L, index, MINKEY_METATABLE))
{
check_cbson_minkey(L, index);
BSON_APPEND_MINKEY(bson, key);
}
else if (luaL_checkudata_ex(L, index, MAXKEY_METATABLE))
{
check_cbson_maxkey(L, index);
BSON_APPEND_MAXKEY(bson, key);
}
else if (luaL_checkudata_ex(L, index, TIMESTAMP_METATABLE))
{
cbson_timestamp_t* time = check_cbson_timestamp(L, index);
BSON_APPEND_TIMESTAMP(bson, key, time->timestamp, time->increment);
}
else if (luaL_checkudata_ex(L, index, INT64_METATABLE) || luaL_checkudata_ex(L, index, UINT64_METATABLE))
{
cbson_int64_t i = cbson_int64_check(L, index);
if (i < INT32_MIN || i > INT32_MAX)
{
BSON_APPEND_INT64(bson, key, i);
}
else
{
BSON_APPEND_INT32(bson, key, (int32_t)i);
}
}
else if (luaL_checkudata_ex(L, index, CODE_METATABLE))
{
cbson_code_t* code = check_cbson_code(L, index);
BSON_APPEND_CODE(bson, key, code->code);
}
else if (luaL_checkudata_ex(L, index, CODEWSCOPE_METATABLE))
{
cbson_codewscope_t* code = check_cbson_codewscope(L, index);
BSON_APPEND_CODE_WITH_SCOPE(bson, key, code->code, NULL);
}
else if (luaL_checkudata_ex(L, index, UNDEFINED_METATABLE))
{
check_cbson_undefined(L, index);
BSON_APPEND_UNDEFINED(bson, key);
}
else if (luaL_checkudata_ex(L, index, DATE_METATABLE))
{
BSON_APPEND_DATE_TIME(bson, key, cbson_date_check(L, index));
}
break;
}
case LUA_TFUNCTION:
case LUA_TTHREAD:
case LUA_TLIGHTUSERDATA:
default:
break; // or bail out?
}
}
/**
* _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));
}
