void
test_bson_cursor_get_utc_datetime (void)
{
bson *b;
bson_cursor *c;
gint64 d = (gint64)987654;
ok (bson_cursor_get_utc_datetime (NULL, &d) == FALSE,
"bson_cursor_get_utc_datetime() with a NULL cursor fails");
b = test_bson_generate_full ();
c = bson_cursor_new (b);
ok (bson_cursor_get_utc_datetime (c, NULL) == FALSE,
"bson_cursor_get_utc_datetime() with a NULL destination fails");
ok (bson_cursor_get_utc_datetime (c, &d) == FALSE,
"bson_cursor_get_utc_datetime() at the initial position fails");
cmp_ok (d, "==", 987654,
"destination remains unchanged after failed cursor operations");
bson_cursor_free (c);
c = bson_find (b, "date");
ok (bson_cursor_get_utc_datetime (c, &d),
"bson_cursor_get_utc_datetime() works");
ok (d == 1294860709000,
"bson_cursor_get_utc_datetime() returns the correct result");
bson_cursor_next (c);
ok (bson_cursor_get_utc_datetime (c, &d) == FALSE,
"bson_cursor_get_utc_datetime() should fail when the cursor points to "
"non-datetime data");
bson_cursor_free (c);
bson_free (b);
}
struct ofields* get_data(struct results *res)
{
struct ofields *fields;
const char *msg;
const char *prog;
const char *syslog_tag;
gint64 date_r;
bson_cursor *c;
fields = malloc(sizeof(struct ofields));
c = bson_find (res->result, "msg");
if (!bson_cursor_get_string (c, &msg))
{
perror ("bson_cursor_get_string()");
exit (1);
}
bson_cursor_free (c);
c = bson_find (res->result, "sys");
if (!bson_cursor_get_string (c, &prog))
{
perror ("bson_cursor_get_string()");
exit (1);
}
bson_cursor_free (c);
c = bson_find (res->result, "syslog_tag");
if (!bson_cursor_get_string (c, &syslog_tag))
{
perror ("bson_cursor_get_string()");
exit (1);
}
bson_cursor_free (c);
c = bson_find (res->result, "time_rcvd");
if (!bson_cursor_get_utc_datetime (c, &date_r))
{
perror ("bson_cursor_get_utc_datetime()");
exit (1);
}
bson_cursor_free (c);
fields->msg = msg;
fields->prog = prog;
fields->syslog_tag = syslog_tag;
fields->date_r = date_r;
return fields;
}
int
ej_bson_parse_utc_datetime(
struct _bson_cursor *bc,
const unsigned char *field_name,
time_t *p_value)
{
if (bson_cursor_type(bc) != BSON_TYPE_UTC_DATETIME) {
err("parse_bson_utc_datetime: utc_datetime field type expected for '%s'", field_name);
return -1;
}
gint64 value = 0;
if (!bson_cursor_get_utc_datetime(bc, &value)) {
err("parse_bson_utc_datetime: failed to fetch utc_datetime value of '%s'", field_name);
return -1;
}
if (p_value) {
*p_value = (time_t) (value / 1000);
}
return 1;
}
void
mongo_gridfs_list (config_t *config)
{
mongo_sync_cursor *cursor;
mongo_sync_gridfs *gfs;
gfs = mongo_gridfs_connect (config);
cursor = mongo_sync_gridfs_list (gfs, NULL);
while (mongo_sync_cursor_next (cursor))
{
bson *meta = mongo_sync_cursor_get_data (cursor);
bson_cursor *c;
const guint8 oid[12];
gint32 i32, chunk_size;
gint64 length, date;
const gchar *md5, *filename = NULL;
gchar *oid_s;
c = bson_find (meta, "_id");
if (!bson_cursor_get_oid (c, (const guint8 **)&oid))
mongo_gridfs_error (errno);
bson_cursor_find (c, "length");
if (!bson_cursor_get_int32 (c, &i32))
{
if (!bson_cursor_get_int64 (c, &length))
mongo_gridfs_error (errno);
}
else
length = i32;
bson_cursor_find (c, "chunkSize");
if (!bson_cursor_get_int32 (c, &chunk_size))
mongo_gridfs_error (errno);
bson_cursor_find (c, "uploadDate");
if (!bson_cursor_get_utc_datetime (c, &date))
mongo_gridfs_error (errno);
bson_cursor_find (c, "md5");
if (!bson_cursor_get_string (c, &md5))
mongo_gridfs_error (errno);
bson_cursor_find (c, "filename");
bson_cursor_get_string (c, &filename);
bson_cursor_free (c);
oid_s = mongo_util_oid_as_string (oid);
printf ("{ _id: ObjectID(\"%s\"), length: %" G_GINT64_FORMAT
", chunkSize: %i, uploadDate: %"
G_GINT64_FORMAT ", md5: \"%s\"",
oid_s, length, chunk_size, date, md5);
g_free (oid_s);
if (filename)
printf (", filename: \"%s\"", filename);
printf (" }\n");
if (config->verbose)
{
c = bson_cursor_new (meta);
printf ("\tExtra metadata: [ ");
while (bson_cursor_next (c))
{
if (strcmp (bson_cursor_key (c), "_id") &&
strcmp (bson_cursor_key (c), "length") &&
strcmp (bson_cursor_key (c), "chunkSize") &&
strcmp (bson_cursor_key (c), "uploadDate") &&
strcmp (bson_cursor_key (c), "md5") &&
strcmp (bson_cursor_key (c), "filename"))
{
printf ("%s (%s), ", bson_cursor_key (c),
bson_cursor_type_as_string (c));
}
}
bson_cursor_free (c);
printf ("]\n");
}
}
mongo_sync_gridfs_free (gfs, TRUE);
}
void
ej_bson_unparse(
FILE *out,
const struct _bson *b,
int is_array)
{
if (!b) {
fprintf(out, "NULL");
return;
}
if (is_array) {
fprintf(out, "[ ");
} else {
fprintf(out, "{ ");
}
bson_cursor *cursor = bson_cursor_new(b);
int first = 1;
while (bson_cursor_next(cursor)) {
if (!first) fprintf(out, ", ");
if (!is_array) {
fprintf(out, "%s : ", bson_cursor_key(cursor));
}
bson_type t = bson_cursor_type(cursor);
switch (t) {
case BSON_TYPE_DOUBLE:
break;
case BSON_TYPE_STRING:
{
const char *value = NULL;
if (bson_cursor_get_string(cursor, &value)) {
fprintf(out, "\"%s\"", value);
}
}
break;
case BSON_TYPE_DOCUMENT:
{
bson *doc = NULL;
if (bson_cursor_get_document(cursor, &doc)) {
ej_bson_unparse(out, doc, 0);
bson_free(doc);
}
}
break;
case BSON_TYPE_ARRAY:
{
bson *doc = NULL;
if (bson_cursor_get_array(cursor, &doc)) {
ej_bson_unparse(out, doc, 1);
bson_free(doc);
}
}
break;
case BSON_TYPE_BINARY:
{
bson_binary_subtype bt = 0;
const unsigned char *bd = NULL;
int bz = 0;
if (bson_cursor_get_binary(cursor, &bt, &bd, &bz)
&& bt == BSON_BINARY_SUBTYPE_UUID && bz == sizeof(ej_uuid_t)) {
ej_uuid_t value;
memcpy(&value, bd, sizeof(value));
fprintf(out, "\"%s\"", ej_uuid_unparse(&value, NULL));
}
}
break;
case BSON_TYPE_OID:
case BSON_TYPE_BOOLEAN:
break;
case BSON_TYPE_UTC_DATETIME:
{
gint64 ts = 0;
if (bson_cursor_get_utc_datetime(cursor, &ts)) {
time_t tt = (time_t) (ts / 1000);
int ms = (int) (ts % 1000);
struct tm *ptm = gmtime(&tt);
fprintf(out, "\"%d/%02d/%02d %02d:%02d:%02d.%04d\"",
ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec, ms);
}
}
break;
case BSON_TYPE_NULL:
break;
case BSON_TYPE_INT32:
{
int value = 0;
if (bson_cursor_get_int32(cursor, &value)) {
fprintf(out, "%d", value);
}
}
break;
case BSON_TYPE_INT64:
{
gint64 value = 0;
if (bson_cursor_get_int64(cursor, &value)) {
fprintf(out, "%lld", (long long) value);
}
}
break;
default:
break;
}
first = 0;
}
bson_cursor_free(cursor); cursor = NULL;
if (is_array) {
fprintf(out, " ]");
} else {
fprintf(out, " }");
}
}
