void
mongoc_gridfs_file_destroy (mongoc_gridfs_file_t *file)
{
ENTRY;
BSON_ASSERT (file);
if (file->page) {
_mongoc_gridfs_file_page_destroy (file->page);
}
if (file->bson.len) {
bson_destroy (&file->bson);
}
if (file->cursor) {
mongoc_cursor_destroy (file->cursor);
}
if (file->files_id.value_type) {
bson_value_destroy (&file->files_id);
}
if (file->md5) {
bson_free (file->md5);
}
if (file->filename) {
bson_free (file->filename);
}
if (file->content_type) {
bson_free (file->content_type);
}
if (file->aliases.len) {
bson_destroy (&file->aliases);
}
if (file->bson_aliases.len) {
bson_destroy (&file->bson_aliases);
}
if (file->metadata.len) {
bson_destroy (&file->metadata);
}
if (file->bson_metadata.len) {
bson_destroy (&file->bson_metadata);
}
bson_free (file);
EXIT;
}
bool _aggregate_have_same_id(bson_t *doc, bson_value_t *id_value) {;
bson_value_t *doc_id_value = _aggregate_get_value_at_key(doc, "_id");
bson_t new_doc1;
bson_init (&new_doc1);
bson_append_value(&new_doc1, "_id", -1, doc_id_value);
bson_t new_doc2;
bson_init (&new_doc2);
bson_append_value(&new_doc2, "_id", -1, id_value);
bool are_equal = bson_equal(&new_doc1, &new_doc2);
bson_value_destroy(doc_id_value);
return are_equal;
}
static void
test_value_decimal128 (void)
{
const bson_value_t *value;
bson_value_t copy;
bson_iter_t iter;
bson_decimal128_t dec;
bson_t other = BSON_INITIALIZER;
bson_t *doc;
assert (bson_decimal128_from_string ("123.5", &dec));
doc = BCON_NEW ("decimal128", BCON_DECIMAL128 (&dec));
assert (bson_iter_init (&iter, doc) && bson_iter_next (&iter));
assert (value = bson_iter_value (&iter));
bson_value_copy (value, ©);
assert (bson_append_value (&other, bson_iter_key (&iter), -1, ©));
bson_value_destroy (©);
bson_destroy (doc);
bson_destroy (&other);
}
static void
test_value_basic (void)
{
static const uint8_t raw[16] = { 0 };
const bson_value_t *value;
bson_value_t copy;
bson_iter_t iter;
bson_oid_t oid;
bson_t other = BSON_INITIALIZER;
bson_t *doc;
bson_t sub = BSON_INITIALIZER;
bool r;
int i;
bson_oid_init (&oid, NULL);
doc = BCON_NEW ("double", BCON_DOUBLE (123.4),
"utf8", "this is my string",
"document", BCON_DOCUMENT (&sub),
"array", BCON_DOCUMENT (&sub),
"binary", BCON_BIN (BSON_SUBTYPE_BINARY, raw, sizeof raw),
"undefined", BCON_UNDEFINED,
"oid", BCON_OID (&oid),
"bool", BCON_BOOL (true),
"datetime", BCON_DATE_TIME (12345678),
"null", BCON_NULL,
"regex", BCON_REGEX ("^hello", "i"),
"dbpointer", BCON_DBPOINTER ("test.test", &oid),
"code", BCON_CODE ("var a = function() {}"),
"symbol", BCON_SYMBOL ("my_symbol"),
"codewscope", BCON_CODEWSCOPE ("var a = 1;", &sub),
"int32", BCON_INT32 (1234),
"timestamp", BCON_TIMESTAMP (1234, 4567),
"int64", BCON_INT32 (4321),
"maxkey", BCON_MAXKEY,
"minkey", BCON_MINKEY);
r = bson_iter_init (&iter, doc);
assert (r);
for (i = 0; i < 20; i++) {
r = bson_iter_next (&iter);
assert (r);
value = bson_iter_value (&iter);
assert (value);
bson_value_copy (value, ©);
r = bson_append_value (&other, bson_iter_key (&iter), -1, ©);
assert (r);
bson_value_destroy (©);
}
r = bson_iter_next (&iter);
assert (!r);
bson_destroy (doc);
bson_destroy (&other);
}
/* fire command-succeeded event as if we'd used a modern write command.
* note, cluster.request_id was incremented once for the write, again
* for the getLastError, so cluster.request_id is no longer valid; used the
* passed-in request_id instead.
*/
static void
_mongoc_monitor_legacy_write_succeeded (mongoc_client_t *client,
int64_t duration,
mongoc_write_command_t *command,
const bson_t *gle,
mongoc_server_stream_t *stream,
int64_t request_id)
{
bson_iter_t iter;
bson_t doc;
int64_t ok = 1;
int64_t n = 0;
uint32_t code = 8;
bool wtimeout = false;
/* server error message */
const char *errmsg = NULL;
size_t errmsg_len = 0;
/* server errInfo subdocument */
bool has_errinfo = false;
uint32_t len;
const uint8_t *data;
bson_t errinfo;
/* server upsertedId value */
bool has_upserted_id = false;
bson_value_t upserted_id;
/* server updatedExisting value */
bool has_updated_existing = false;
bool updated_existing = false;
mongoc_apm_command_succeeded_t event;
ENTRY;
if (!client->apm_callbacks.succeeded) {
EXIT;
}
/* first extract interesting fields from getlasterror response */
if (gle) {
bson_iter_init (&iter, gle);
while (bson_iter_next (&iter)) {
if (!strcmp (bson_iter_key (&iter), "ok")) {
ok = bson_iter_as_int64 (&iter);
} else if (!strcmp (bson_iter_key (&iter), "n")) {
n = bson_iter_as_int64 (&iter);
} else if (!strcmp (bson_iter_key (&iter), "code")) {
code = (uint32_t) bson_iter_as_int64 (&iter);
if (code == 0) {
/* server sent non-numeric error code? */
code = 8;
}
} else if (!strcmp (bson_iter_key (&iter), "upserted")) {
has_upserted_id = true;
bson_value_copy (bson_iter_value (&iter), &upserted_id);
} else if (!strcmp (bson_iter_key (&iter), "updatedExisting")) {
has_updated_existing = true;
updated_existing = bson_iter_as_bool (&iter);
} else if ((!strcmp (bson_iter_key (&iter), "err") ||
!strcmp (bson_iter_key (&iter), "errmsg")) &&
BSON_ITER_HOLDS_UTF8 (&iter)) {
errmsg = bson_iter_utf8_unsafe (&iter, &errmsg_len);
} else if (!strcmp (bson_iter_key (&iter), "errInfo") &&
BSON_ITER_HOLDS_DOCUMENT (&iter)) {
bson_iter_document (&iter, &len, &data);
bson_init_static (&errinfo, data, len);
has_errinfo = true;
} else if (!strcmp (bson_iter_key (&iter), "wtimeout")) {
wtimeout = true;
}
}
}
/* based on PyMongo's _convert_write_result() */
bson_init (&doc);
bson_append_int32 (&doc, "ok", 2, (int32_t) ok);
if (errmsg && !wtimeout) {
/* Failure, but pass to the success callback. Command Monitoring Spec:
* "Commands that executed on the server and return a status of {ok: 1}
* are considered successful commands and fire CommandSucceededEvent.
* Commands that have write errors are included since the actual command
* did succeed, only writes failed." */
append_write_err (
&doc, code, errmsg, errmsg_len, has_errinfo ? &errinfo : NULL);
} else {
/* Success, perhaps with a writeConcernError. */
if (errmsg) {
append_write_concern_err (&doc, errmsg, errmsg_len);
}
if (command->type == MONGOC_WRITE_COMMAND_INSERT) {
/* GLE result for insert is always 0 in most MongoDB versions. */
n = command->n_documents;
} else if (command->type == MONGOC_WRITE_COMMAND_UPDATE) {
if (has_upserted_id) {
append_upserted (&doc, &upserted_id);
} else if (has_updated_existing && !updated_existing && n == 1) {
bson_t tmp;
int32_t bson_len = 0;
memcpy (&bson_len, command->payload.data, 4);
bson_len = BSON_UINT32_FROM_LE (bson_len);
bson_init_static (&tmp, command->payload.data, bson_len);
has_upserted_id = get_upserted_id (&tmp, &upserted_id);
if (has_upserted_id) {
append_upserted (&doc, &upserted_id);
}
}
}
}
bson_append_int32 (&doc, "n", 1, (int32_t) n);
mongoc_apm_command_succeeded_init (
&event,
duration,
&doc,
_mongoc_command_type_to_name (command->type),
request_id,
command->operation_id,
&stream->sd->host,
stream->sd->id,
client->apm_context);
client->apm_callbacks.succeeded (&event);
mongoc_apm_command_succeeded_cleanup (&event);
bson_destroy (&doc);
if (has_upserted_id) {
bson_value_destroy (&upserted_id);
}
EXIT;
}
