void test_example_wikipedia_bson(size_t iterations) {
bcon_error_t ret;
size_t i;
bson b[1];
for (i = 0; i < iterations; i++) {
bson_init( b );
bson_append_string( b, "firstName", "John" );
bson_append_string( b, "lastName" , "Smith" );
bson_append_int( b, "age" , 25);
bson_append_start_object( b, "address" );
bson_append_string( b, "streetAddress", "21 2nd Street" );
bson_append_string( b, "city" , "New York" );
bson_append_string( b, "state" , "NY" );
bson_append_string( b, "postalCode" , "10021" );
bson_append_finish_object( b );
bson_append_start_array( b, "phoneNumber" );
bson_append_start_object( b, "0" );
bson_append_string( b, "type" , "home" );
bson_append_string( b, "number", "212 555-1234" );
bson_append_finish_object( b );
bson_append_start_object( b, "1" );
bson_append_string( b, "type" , "fax" );
bson_append_string( b, "number", "646 555-4567" );
bson_append_finish_object( b );
bson_append_finish_array( b );
ret = bson_finish( b );
bson_destroy( b );
}
assert(ret == BSON_OK);
}
static void log_buffer_notrunc(const uint8_t *buf, uintptr_t length)
{
if(buf == NULL || length == 0) {
return;
}
bson b;
bson_init(&b);
bson_append_string(&b, "type", "buffer");
if(range_is_readable(buf, length) != 0) {
bson_append_binary(&b, "buffer", BSON_BIN_BINARY,
(const char *) buf, length);
char checksum[64];
sha1(buf, length, checksum);
bson_append_string(&b, "checksum", checksum);
}
else {
bson_append_string(&b, "buffer", "<INVALID POINTER>");
bson_append_string(&b, "checksum", "???");
}
bson_finish(&b);
log_raw(bson_data(&b), bson_size(&b));
bson_destroy(&b);
}
//Generate a token based off of a user and the requested server
char* generateToken(mongo* conn, const char* userID, const char* serverID)
{
bson token[1];
//Generate a unique id for the token
uuid_t* tokenUID = generateUniqueID();
char* tokenID = printUniqueID(tokenUID);
free(tokenUID);
//Create a bson with the username server id and unique token id
bson_init(token);
bson_append_string(token, "_id", tokenID);
bson_append_string(token, "username", userID);
bson_append_string(token, "server", serverID);
bson_finish(token);
VyLog(5,"Created token for user ",userID," for server ",serverID,"\r\n");
//Insert the token into the server
if(mongoInsertData(conn,TOKEN_COLLECTION,token) == 1)
return tokenID;
//If no token could be returned destroy it and say so
bson_destroy(token);
return "NO Valid Token";
}
/* Remove DLR */
static void dlr_mongodb_remove(const Octstr *smsc, const Octstr *ts, const Octstr *dst)
{
DBPoolConn *pconn;
bson cond;
bson_buffer cond_buf;
mongo_connection *conn = NULL;
pconn = dbpool_conn_consume(pool);
if (pconn == NULL) {
return;
}
conn = (mongo_connection*)pconn->conn;
bson_buffer_init(&cond_buf);
bson_append_string(&cond_buf, octstr_get_cstr(fields->field_smsc), octstr_get_cstr(smsc));
bson_append_string(&cond_buf, octstr_get_cstr(fields->field_ts), octstr_get_cstr(ts));
if (dst) {
bson_append_string(&cond_buf, octstr_get_cstr(fields->field_dst), octstr_get_cstr(dst));
}
bson_from_buffer(&cond, &cond_buf);
MONGO_TRY {
mongo_remove(conn, mongodb_namespace, &cond);
} MONGO_CATCH {
mongodb_error("dlr_mongodb_remove", conn->exception.type);
}
dbpool_conn_produce(pconn);
bson_destroy(&cond);
}
void
test_mongo_sync_cmd_kill_cursors_net (void)
{
mongo_packet *p;
mongo_sync_connection *conn;
bson *b;
gint i;
mongo_reply_packet_header rh;
gint64 cid;
begin_network_tests (3);
conn = mongo_sync_connect (config.primary_host, config.primary_port, TRUE);
mongo_sync_conn_set_auto_reconnect (conn, TRUE);
b = bson_new ();
for (i = 0; i < 40; i++)
{
bson_reset (b);
bson_append_string (b, "test-name", __FILE__, -1);
bson_append_int32 (b, "seq", i);
bson_finish (b);
mongo_sync_cmd_insert (conn, config.ns, b, NULL);
}
bson_free (b);
b = bson_new ();
bson_append_string (b, "test-name", __FILE__, -1);
bson_finish (b);
p = mongo_sync_cmd_query (conn, config.ns,
MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT,
0, 2, b, NULL);
mongo_wire_reply_packet_get_header (p, &rh);
cid = rh.cursor_id;
mongo_wire_packet_free (p);
ok (mongo_sync_cmd_kill_cursors (conn, 1, cid) == TRUE,
"mongo_sync_kill_cursors() works");
p = mongo_sync_cmd_query (conn, config.ns,
MONGO_WIRE_FLAG_QUERY_NO_CURSOR_TIMEOUT,
0, 2, b, NULL);
bson_free (b);
mongo_wire_reply_packet_get_header (p, &rh);
cid = rh.cursor_id;
mongo_wire_packet_free (p);
shutdown (conn->super.fd, SHUT_RDWR);
sleep (3);
ok (mongo_sync_cmd_kill_cursors (conn, 1, cid) == TRUE,
"mongo_sync_cmd_kill_cursors() automatically reconnects");
mongo_sync_disconnect (conn);
test_mongo_sync_cmd_kill_cursors_net_secondary ();
end_network_tests ();
}
int mongodb_update_key_stat(bot_t * bot, char *db, char *key, int value)
{
bson b;
bson_iterator i;
mongo_cursor cursor;
int ret = 0;
if (!db || !key || value < 0) {
return -1;
}
debug(bot, "mongodb_update_key_stat: Entered\n");
bson_init(&b);
bson_append_string(&b, "key", key);
bson_finish(&b);
mongo_cursor_init(&cursor, &gi->mongo_conn, db);
mongo_cursor_set_query(&cursor, &b);
if (mongo_cursor_next(&cursor) != MONGO_OK) {
mongodb_insert_key_stat(bot, db, key, 0);
mongo_cursor_init(&cursor, &gi->mongo_conn, db);
mongo_cursor_set_query(&cursor, &b);
if (mongo_cursor_next(&cursor) != MONGO_OK)
goto cleanup;
}
debug(bot, "mongodb_update_key_stat: Found!\n");
if (bson_find(&i, mongo_cursor_bson(&cursor), "value")) {
bson c;
ret = (int)bson_iterator_int(&i);
ret++;
bson_init(&c);
bson_append_string(&c, "key", key);
bson_append_int(&c, "value", ret);
bson_finish(&c);
debug(bot, "mongodb_update_key_stat: updating to %i\n", ret);
mongo_update(&gi->mongo_conn, db, &b, &c, 0);
bson_destroy(&c);
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return ret;
}
debug(bot, "mongodb_update_key_stat: Key not found\n");
cleanup:
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return -1;
}
static int
set_disq_comment_func(
struct xuser_cnts_state *data,
int user_id,
const unsigned char *disq_comment)
{
struct xuser_mongo_cnts_state *state = (struct xuser_mongo_cnts_state *) data;
struct team_extra *extra = do_get_entry(state, user_id);
if (!extra) return -1;
if (!extra->disq_comment && !disq_comment) {
return 0;
}
if (extra->disq_comment && !disq_comment) {
ASSERT(ej_uuid_is_nonempty(extra->uuid));
xfree(extra->disq_comment); extra->disq_comment = NULL;
bson *doc = bson_new();
bson_append_string(doc, "disq_comment", "", 0);
bson_finish(doc);
return do_update(state, extra, "$unset", doc);
}
if (extra->disq_comment && !strcmp(extra->disq_comment, disq_comment))
return 0;
xfree(extra->disq_comment);
extra->disq_comment = xstrdup(disq_comment);
if (ej_uuid_is_nonempty(extra->uuid)) {
bson *doc = bson_new();
bson_append_string(doc, "disq_comment", extra->disq_comment, strlen(extra->disq_comment));
bson_finish(doc);
return do_update(state, extra, NULL, doc);
} else {
return do_insert(state, extra);
}
}
MONGO_EXPORT int mongo_cmd_add_user( mongo *conn, const char *db, const char *user, const char *pass ) {
bson user_obj;
bson pass_obj;
char hex_digest[33];
char *ns = bson_malloc( strlen( db ) + strlen( ".system.users" ) + 1 );
int res;
strcpy( ns, db );
strcpy( ns+strlen( db ), ".system.users" );
mongo_pass_digest( user, pass, hex_digest );
bson_init( &user_obj );
bson_append_string( &user_obj, "user", user );
bson_finish( &user_obj );
bson_init( &pass_obj );
bson_append_start_object( &pass_obj, "$set" );
bson_append_string( &pass_obj, "pwd", hex_digest );
bson_append_finish_object( &pass_obj );
bson_finish( &pass_obj );
res = mongo_update( conn, ns, &user_obj, &pass_obj, MONGO_UPDATE_UPSERT );
bson_free( ns );
bson_destroy( &user_obj );
bson_destroy( &pass_obj );
return res;
}
static void make_large( bson *out, int i ) {
int num;
char numstr[4];
bson_init( out );
bson_append_new_oid( out, "_id" );
bson_append_int( out, "x", i );
bson_append_string( out, "base_url", "http://www.example.com/test-me" );
bson_append_int( out, "total_word_count", 6743 );
bson_append_int( out, "access_time", 999 ); /*TODO use date*/
bson_append_start_object( out, "meta_tags" );
bson_append_string( out, "description", "i am a long description string" );
bson_append_string( out, "author", "Holly Man" );
bson_append_string( out, "dynamically_created_meta_tag", "who know\n what" );
bson_append_finish_object( out );
bson_append_start_object( out, "page_structure" );
bson_append_int( out, "counted_tags", 3450 );
bson_append_int( out, "no_of_js_attached", 10 );
bson_append_int( out, "no_of_images", 6 );
bson_append_finish_object( out );
bson_append_start_array( out, "harvested_words" );
for ( num=0; num < 14*20; num++ ) {
bson_numstr( numstr, num );
bson_append_string( out, numstr, words[num%14] );
}
bson_append_finish_object( out );
bson_finish( out );
}
//Verify a token
VyAccount* verifyToken(mongo* conn, const char* token, const char* serverID)
{
bson query[1];
//Create a bson object using the token and server id
bson_init(query);
bson_append_string(query,"_id",token);
bson_append_string(query,"server",serverID);
bson_finish(query);
//Query for a list of tokens matching the query infroamtion
mongo_cursor* cursor = mongoQuery(conn,query,TOKEN_COLLECTION);
//See if there are any items returned from the query
if(mongoNextItem(cursor) == NULL)
return NULL;
//Create an account object from the returned information
VyAccount* account = NULL;
if(mongoCurrentItem(cursor) != NULL)
{
account = malloc(sizeof(VyAccount));
account->username = mongoBsonString(cursor,"username");
}
//Removed the used token
mongoRemove(conn,TOKEN_COLLECTION,query);
bson_destroy(query);
//Remove the found account
return account;
}
void
test_bson_document (void)
{
bson *b, *e1, *e2;
e1 = bson_new ();
bson_append_int32 (e1, "i32", 1984);
bson_append_string (e1, "str", "hello world", -1);
bson_finish (e1);
e2 = bson_new ();
bson_append_string (e2, "foo", "bar", -1);
ok (bson_append_document (e2, "subd", e1),
"bson_append_document() works");
bson_finish (e2);
bson_free (e1);
b = bson_new ();
ok (bson_append_document (b, "doc", e2),
"bson_append_document() works still");
bson_finish (b);
bson_free (e2);
cmp_ok (bson_size (b), "==", 69, "BSON document element size check");
ok (memcmp (bson_data (b),
"\105\000\000\000\003\144\157\143\000\073\000\000\000\002\146"
"\157\157\000\004\000\000\000\142\141\162\000\003\163\165\142"
"\144\000\043\000\000\000\020\151\063\062\000\300\007\000\000"
"\002\163\164\162\000\014\000\000\000\150\145\154\154\157\040"
"\167\157\162\154\144\000\000\000\000",
bson_size (b)) == 0,
"BSON document element contents check");
bson_free (b);
e1 = bson_new ();
bson_append_int32 (e1, "foo", 42);
b = bson_new ();
ok (bson_append_document (b, "doc", e1) == FALSE,
"bson_append_document() with an unfinished document should fail");
bson_finish (e1);
ok (bson_append_document (b, NULL, e1) == FALSE,
"bson_append_document() with a NULL key should fail");
ok (bson_append_document (b, "doc", NULL) == FALSE,
"bson_append_document() with a NULL document should fail");
ok (bson_append_document (NULL, "doc", e1) == FALSE,
"bson_append_document() without a BSON object should fail");
bson_finish (b);
cmp_ok (bson_size (b), "==", 5,
"BSON object should be empty");
ok (bson_append_document (b, "doc", e1) == FALSE,
"Appending to a finished element should fail");
bson_free (e1);
bson_free (b);
}
void
test_bson_array (void)
{
bson *b, *e1, *e2;
e1 = bson_new ();
bson_append_int32 (e1, "0", 1984);
bson_append_string (e1, "1", "hello world", -1);
bson_finish (e1);
e2 = bson_new ();
bson_append_string (e2, "0", "bar", -1);
ok (bson_append_array (e2, "1", e1),
"bson_append_array() works");
bson_finish (e2);
bson_free (e1);
b = bson_new ();
ok (bson_append_array (b, "0", e2),
"bson_append_array() works still");
bson_finish (b);
bson_free (e2);
cmp_ok (bson_size (b), "==", 58, "BSON array element size check");
ok (memcmp (bson_data (b),
"\072\000\000\000\004\060\000\062\000\000\000\002\060\000\004"
"\000\000\000\142\141\162\000\004\061\000\037\000\000\000\020"
"\060\000\300\007\000\000\002\061\000\014\000\000\000\150\145"
"\154\154\157\040\167\157\162\154\144\000\000\000\000",
bson_size (b)) == 0,
"BSON array element contents check");
bson_free (b);
e1 = bson_new ();
bson_append_int32 (e1, "0", 1984);
b = bson_new ();
ok (bson_append_array (b, "array", e1) == FALSE,
"bson_append_array() with an unfinished array should fail");
bson_finish (e1);
ok (bson_append_array (b, NULL, e1) == FALSE,
"bson_append_array() with a NULL name should fail");
ok (bson_append_array (b, "foo", NULL) == FALSE,
"bson_append_array() with a NULL array should fail");
ok (bson_append_array (NULL, "foo", e1) == FALSE,
"bson_append_array() with a NULL BSON should fail");
bson_finish (b);
cmp_ok (bson_size (b), "==", 5,
"BSON object should be empty");
ok (bson_append_array (b, "array", e1) == FALSE,
"Appending to a finished element should fail");
bson_free (e1);
bson_free (b);
}
static void debug_message(const char *msg) {
bson b[1];
bson_init( b );
bson_append_string( b, "type", "debug" );
bson_append_string( b, "msg", msg );
bson_finish( b );
log_raw_direct(bson_data( b ), bson_size( b ));
bson_destroy( b );
// log_flush();
}
struct select_doc* create_select()
// BSON object indicating the fields to return
{
struct select_doc *s_doc;
s_doc = malloc(sizeof(struct select_doc));
s_doc->select = bson_new ();
bson_append_string (s_doc->select, "syslog_tag", "s", -1);
bson_append_string (s_doc->select, "msg", "ERROR", -1);
bson_append_string (s_doc->select, "sys", "sys", -1);
bson_append_utc_datetime (s_doc->select, "time_rcvd", 1ll);
bson_finish (s_doc->select);
return s_doc;
}
void testSaveLoad() {
CU_ASSERT_PTR_NOT_NULL_FATAL(jb);
bson_oid_t oid;
EJCOLL *ccoll = ejdbcreatecoll(jb, "contacts", NULL);
CU_ASSERT_PTR_NOT_NULL(ccoll);
//Save record
bson a1;
bson_init(&a1);
bson_append_string(&a1, "name", "Петров Петр");
bson_append_string(&a1, "phone", "333-222-333");
bson_append_int(&a1, "age", 33);
bson_append_long(&a1, "longage", 0xFFFFFFFFFF01LL);
bson_append_double(&a1, "doubleage", 0.333333);
bson_finish(&a1);
ejdbsavebson(ccoll, &a1, &oid);
bson_destroy(&a1);
bson *lbson = ejdbloadbson(ccoll, &oid);
CU_ASSERT_PTR_NOT_NULL(lbson);
bson_iterator it1;
bson_iterator_init(&it1, lbson);
int btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_OID);
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_STRING);
CU_ASSERT(!strcmp("name", bson_iterator_key(&it1)));
CU_ASSERT(!strcmp("Петров Петр", bson_iterator_string(&it1)));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_STRING);
CU_ASSERT(!strcmp("phone", bson_iterator_key(&it1)));
CU_ASSERT(!strcmp("333-222-333", bson_iterator_string(&it1)));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_INT);
CU_ASSERT(!strcmp("age", bson_iterator_key(&it1)));
CU_ASSERT(33 == bson_iterator_int(&it1));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_LONG);
CU_ASSERT(!strcmp("longage", bson_iterator_key(&it1)));
CU_ASSERT(0xFFFFFFFFFF01LL == bson_iterator_long(&it1));
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_DOUBLE);
CU_ASSERT(!strcmp("doubleage", bson_iterator_key(&it1)));
CU_ASSERT_DOUBLE_EQUAL(bson_iterator_double(&it1), 0.3, 0.1);
btype = bson_iterator_next(&it1);
CU_ASSERT(btype == BSON_EOO);
bson_del(lbson);
}
bson_bool_t mongo_cmd_authenticate( mongo *conn, const char *db, const char *user, const char *pass ) {
bson from_db;
bson cmd;
bson out;
const char *nonce;
bson_bool_t success = 0;
mongo_md5_state_t st;
mongo_md5_byte_t digest[16];
char hex_digest[33];
if( mongo_simple_int_command( conn, db, "getnonce", 1, &from_db ) == MONGO_OK ) {
bson_iterator it;
bson_find( &it, &from_db, "nonce" );
nonce = bson_iterator_string( &it );
} else {
return MONGO_ERROR;
}
mongo_pass_digest( user, pass, hex_digest );
mongo_md5_init( &st );
mongo_md5_append( &st, ( const mongo_md5_byte_t * )nonce, strlen( nonce ) );
mongo_md5_append( &st, ( const mongo_md5_byte_t * )user, strlen( user ) );
mongo_md5_append( &st, ( const mongo_md5_byte_t * )hex_digest, 32 );
mongo_md5_finish( &st, digest );
digest2hex( digest, hex_digest );
bson_init( &cmd );
bson_append_int( &cmd, "authenticate", 1 );
bson_append_string( &cmd, "user", user );
bson_append_string( &cmd, "nonce", nonce );
bson_append_string( &cmd, "key", hex_digest );
bson_finish( &cmd );
bson_destroy( &from_db );
/*bson_init( &from_db ); */
if( mongo_run_command( conn, db, &cmd, &out ) == MONGO_OK ) {
bson_iterator it;
if( bson_find( &it, &out, "ok" ) )
success = bson_iterator_bool( &it );
}
bson_destroy( &from_db );
bson_destroy( &cmd );
if( success )
return MONGO_OK;
else
return MONGO_ERROR;
}
int
mongodb_insert_key(bot_t * bot, char *db, char *key, char *value,
char *fmt, ...)
{
bson b;
mongo_cursor cursor;
va_list ap;
char buf[1024], *buf_ptr = "NULL";
if (!db || !key || !value) {
return -1;
}
debug(bot, "mongodb_insert_key: Entered\n");
if (fmt) {
bz(buf);
va_start(ap, fmt);
vsnprintf_buf(buf, fmt, ap);
va_end(ap);
buf_ptr = buf;
}
bson_init(&b);
bson_append_string(&b, "key", key);
bson_finish(&b);
mongo_cursor_init(&cursor, &gi->mongo_conn, db);
mongo_cursor_set_query(&cursor, &b);
if (mongo_cursor_next(&cursor) == MONGO_OK) {
debug(bot, "mongodb_insert_key: Key already exist\n");
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return -1;
}
bson_init(&b);
bson_append_string(&b, "key", key);
bson_append_string(&b, "value", value);
bson_append_string(&b, "comment", buf_ptr);
bson_finish(&b);
mongo_insert(&gi->mongo_conn, db, &b);
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return 0;
}
static void make_medium( bson *out, int i ) {
bson_init( out );
bson_append_new_oid( out, "_id" );
bson_append_int( out, "x", i );
bson_append_int( out, "integer", 5 );
bson_append_double( out, "number", 5.05 );
bson_append_bool( out, "boolean", 0 );
bson_append_start_array( out, "array" );
bson_append_string( out, "0", "test" );
bson_append_string( out, "1", "benchmark" );
bson_append_finish_object( out );
bson_finish( out );
}
void loq(int index, const char *name,
int is_success, int return_value, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
const char * fmtbak = fmt;
int argnum = 2;
int count = 1; char key = 0;
EnterCriticalSection(&g_mutex);
if(logtbl_explained[index] == 0) {
logtbl_explained[index] = 1;
const char * pname;
bson b[1];
bson_init( b );
bson_append_int( b, "I", index );
bson_append_string( b, "name", name );
bson_append_string( b, "type", "info" );
bson_append_string( b, "category", logtbl[index][1] );
bson_append_start_array( b, "args" );
bson_append_string( b, "0", "is_success" );
bson_append_string( b, "1", "retval" );
while (--count != 0 || *fmt != 0) {
// we have to find the next format specifier
if(count == 0) {
// end of format
if(*fmt == 0) break;
// set the count, possibly with a repeated format specifier
count = *fmt >= '2' && *fmt <= '9' ? *fmt++ - '0' : 1;
// the next format specifier
key = *fmt++;
}
pname = va_arg(args, const char *);
snprintf(g_istr, 4, "%u", argnum);
argnum++;
//on certain formats, we need to tell cuckoo about them for nicer display / matching
if (key == 'p' || key == 'P') {
bson_append_start_array( b, g_istr );
bson_append_string( b, "0", pname );
bson_append_string( b, "1", "p" );
bson_append_finish_array( b );
} else {
bson_append_string( b, g_istr, pname );
}
//now ignore the values
if(key == 's') {
(void) va_arg(args, const char *);
}
else if(key == 'S') {
int init_suite(void) {
assert(QRS < RS);
jb = ejdbnew();
if (!ejdbopen(jb, "dbt3", JBOWRITER | JBOCREAT | JBOTRUNC)) {
return 1;
}
srand(tcmstime());
recs = malloc(RS * sizeof (bson));
if (!recs) {
return 1;
}
for (int i = 0; i < RS; ++i) {
bson bs;
bson_init(&bs);
bson_append_long(&bs, "ts", tcmstime());
char str[128];
int len = 0;
do {
len = rand() % 128;
} while (len <= 0);
str[0] = 'A' + (i % 26);
for (int j = 1; j < len; ++j) {
str[j] = 'a' + rand() % 26;
}
str[len] = '\0';
bson_append_string(&bs, "rstring", str);
bson_finish(&bs);
recs[i] = bs;
}
return 0;
}
static void tutorial_insert_batch( mongo *conn ) {
bson *p;
bson **ps;
char *names[4];
int ages[] = { 29, 24, 24, 32 };
int i, n = 4;
names[0] = "Eliot"; names[1] = "Mike"; names[2] = "Mathias"; names[3] = "Richard";
ps = ( bson ** )malloc( sizeof( bson * ) * n);
for ( i = 0; i < n; i++ ) {
p = ( bson * )malloc( sizeof( bson ) );
bson_init( p );
bson_append_new_oid( p, "_id" );
bson_append_string( p, "name", names[i] );
bson_append_int( p, "age", ages[i] );
bson_finish( p );
ps[i] = p;
}
mongo_insert_batch( conn, "tutorial.persons", (const bson **) ps, n, 0, 0 );
for ( i = 0; i < n; i++ ) {
bson_destroy( ps[i] );
free( ps[i] );
}
}
/* Test read timeout by causing the
* server to sleep for 10s on a query.
*/
int test_read_timeout( void ) {
mongo conn[1];
bson b, obj, out, fields;
int res;
CONN_CLIENT_TEST;
bson_init( &b );
bson_append_code( &b, "$where", "sleep( 10 * 1000 );");
bson_finish( &b );
bson_init( &obj );
bson_append_string( &obj, "foo", "bar");
bson_finish( &obj );
res = mongo_insert( conn, "test.foo", &obj, NULL );
/* Set the connection timeout here. */
if( mongo_set_op_timeout( conn, 1000 ) != MONGO_OK ) {
printf("Could not set socket timeout!.");
exit(1);
}
res = mongo_find_one( conn, "test.foo", &b, bson_empty(&fields), &out );
ASSERT( res == MONGO_ERROR );
ASSERT( conn->err == MONGO_IO_ERROR );
ASSERT( conn->errcode == WSAETIMEDOUT );
return 0;
}
SEXP mongo_rename(SEXP mongo_conn, SEXP from_ns, SEXP to_ns) {
mongo* conn = _checkMongo(mongo_conn);
const char* _from_ns = CHAR(STRING_ELT(from_ns, 0));
const char* _to_ns = CHAR(STRING_ELT(to_ns, 0));
bson cmd;
bson_init(&cmd);
bson_append_string(&cmd, "renameCollection", _from_ns);
bson_append_string(&cmd, "to", _to_ns);
bson_finish(&cmd);
SEXP ret;
PROTECT(ret = allocVector(LGLSXP, 1));
LOGICAL(ret)[0] = (mongo_run_command(conn, "admin", &cmd, NULL) == MONGO_OK);
bson_destroy(&cmd);
UNPROTECT(1);
return ret;
}
int mongo_simple_str_command( mongo *conn, const char *db,
const char *cmdstr, const char *arg, bson *realout ) {
bson out = {NULL, 0};
int success = 0;
bson cmd;
bson_init( &cmd );
bson_append_string( &cmd, cmdstr, arg );
bson_finish( &cmd );
if( mongo_run_command( conn, db, &cmd, &out ) == MONGO_OK ) {
bson_iterator it;
if( bson_find( &it, &out, "ok" ) )
success = bson_iterator_bool( &it );
}
bson_destroy( &cmd );
if ( realout )
*realout = out;
else
bson_destroy( &out );
if( success )
return MONGO_OK;
else
return MONGO_ERROR;
}
void testTransactions1() {
EJCOLL *coll = ejdbcreatecoll(jb, "trans1", NULL);
bson bs;
bson_init(&bs);
bson_append_string(&bs, "foo", "bar");
bson_finish(&bs);
bson_oid_t oid;
CU_ASSERT_TRUE(ejdbtranbegin(coll));
ejdbsavebson(coll, &bs, &oid);
CU_ASSERT_TRUE(ejdbtrancommit(coll));
bson *bres = ejdbloadbson(coll, &oid);
CU_ASSERT_PTR_NOT_NULL(bres);
if (bres) {
bson_del(bres);
}
CU_ASSERT_TRUE(ejdbtranbegin(coll));
ejdbsavebson(coll, &bs, &oid);
CU_ASSERT_TRUE(ejdbtranabort(coll));
bres = ejdbloadbson(coll, &oid);
CU_ASSERT_PTR_NULL(bres);
if (bres) {
bson_del(bres);
}
bson_destroy(&bs);
}
int inode_exists(const char * path) {
bson query, fields;
mongo * conn = get_conn();
mongo_cursor curs;
int res;
bson_init(&query);
bson_append_string(&query, "dirents", path);
bson_finish(&query);
bson_init(&fields);
bson_append_int(&fields, "dirents", 1);
bson_append_int(&fields, "_id", 0);
bson_finish(&fields);
mongo_cursor_init(&curs, conn, inodes_name);
mongo_cursor_set_query(&curs, &query);
mongo_cursor_set_fields(&curs, &fields);
mongo_cursor_set_limit(&curs, 1);
res = mongo_cursor_next(&curs);
bson_destroy(&query);
bson_destroy(&fields);
mongo_cursor_destroy(&curs);
if(res == 0)
return 0;
if(curs.err != MONGO_CURSOR_EXHAUSTED)
return -EIO;
return -ENOENT;
}
int64_t mongo_count(mongo_connection* conn, const char* db, const char* ns, bson* query){
bson_buffer bb;
bson cmd;
bson out;
int64_t count = -1;
bson_buffer_init(&bb);
bson_append_string(&bb, "count", ns);
if (query && bson_size(query) > 5) /* not empty */
bson_append_bson(&bb, "query", query);
bson_from_buffer(&cmd, &bb);
MONGO_TRY{
if(mongo_run_command(conn, db, &cmd, &out)){
bson_iterator it;
if(bson_find(&it, &out, "n"))
count = bson_iterator_long(&it);
}
}MONGO_CATCH{
bson_destroy(&cmd);
MONGO_RETHROW();
}
bson_destroy(&cmd);
bson_destroy(&out);
return count;
}
/* Saves accounting information */
static int mongo_account(void *instance, REQUEST *request)
{
rlm_mongo_t *data = (rlm_mongo_t *)instance;
bson b;
bson_buffer buf;
const char *attr;
char value[MAX_STRING_LEN+1];
VALUE_PAIR *vp = request->packet->vps;
// shall we insert this packet or not
int insert;
bson_buffer_init(&buf);
bson_append_new_oid(&buf, "_id");
insert = 0;
while (vp) {
attr = vp->name;
if ((strcmp(attr, "Acct-Status-Type") == 0) && ((strcmp(data->only_stop, "") != 0))) {
if ((vp->vp_integer & 0xffffff) != 2) {
break;
} else {
insert = 1;
}
}
switch (vp->type) {
case PW_TYPE_INTEGER:
bson_append_int(&buf, attr, vp->vp_integer & 0xffffff);
break;
case PW_TYPE_BYTE:
case PW_TYPE_SHORT:
bson_append_int(&buf, attr, vp->vp_integer);
break;
case PW_TYPE_DATE:
bson_append_time_t(&buf, attr, vp->vp_date);
break;
default:
vp_prints_value(value, sizeof(value), vp, 0);
bson_append_string(&buf, attr, value);
// akh
RDEBUG("mongo default insert %s", value);
break;
}
vp = vp->next;
}
bson_from_buffer(&b, &buf);
MONGO_TRY {
if (insert == 1) {
mongo_insert(conn, data->acct_base, &b);
RDEBUG("accounting record was inserted");
}
} MONGO_CATCH {
radlog(L_ERR, "mongo_insert failed");
return RLM_MODULE_FAIL;
}
bson_destroy(&b);
return RLM_MODULE_OK;
}
result_t MongoCursor::count(bool applySkipLimit, int32_t &retVal)
{
bson bbq;
bson_init(&bbq);
bson_append_string(&bbq, "count", m_name.c_str());
Isolate* isolate = Isolate::now();
if (m_bSpecial)
encodeValue(&bbq, "query",
v8::Local<v8::Object>::New(isolate->m_isolate, m_query)->Get(v8::String::NewFromUtf8(isolate->m_isolate, "query")));
else
encodeValue(&bbq, "query", v8::Local<v8::Object>::New(isolate->m_isolate, m_query));
if (applySkipLimit)
{
if (m_cursor->limit)
bson_append_int(&bbq, "limit", m_cursor->limit);
if (m_cursor->skip)
bson_append_int(&bbq, "skip", m_cursor->skip);
}
bson_finish(&bbq);
v8::Local<v8::Object> res;
result_t hr = m_cursor->m_db->run_command(&bbq, res);
if (hr < 0)
return hr;
retVal = res->Get(v8::String::NewFromUtf8(isolate->m_isolate, "n"))->Int32Value();
return 0;
}
static void _log_stacktrace(bson *b)
{
uintptr_t addrs[RETADDRCNT], count;
char number[20], sym[512];
bson_append_start_array(b, "s");
count = stacktrace(NULL, addrs, RETADDRCNT);
for (uint32_t idx = 4; idx < count; idx++) {
ultostr(idx-4, number, 10);
symbol((const uint8_t *) addrs[idx], sym, sizeof(sym)-32);
if(sym[0] != 0) {
our_snprintf(sym + our_strlen(sym),
sizeof(sym) - our_strlen(sym), " @ ");
}
our_snprintf(sym + our_strlen(sym), sizeof(sym) - our_strlen(sym),
"%p", (const uint8_t *) addrs[idx]);
bson_append_string(b, number, sym);
}
bson_append_finish_array(b);
}