scale_t *get_signatures(mongo *conn) {
scale_t *scales;
bson query[1];
mongo_cursor cursor[1];
bson_init(query);
bson_finish(query);
mongo_cursor_init(cursor, conn, "1101.scales");
mongo_cursor_set_query(cursor, query);
int num_scales = 0;
while (mongo_cursor_next(cursor) == MONGO_OK) {
num_scales++;
scales = (scale_t *) realloc(scales, sizeof(scale_t) * num_scales);
bson_iterator iterator[1];
bson b[1];
bson_init(b);
int i;
if (bson_find(iterator, mongo_cursor_bson(cursor), "name")) {
printf("name: %s, scale: ", bson_iterator_string(iterator));
strcpy(scales[num_scales - 1].description, bson_iterator_string(iterator));
}
if (bson_find(iterator, mongo_cursor_bson(cursor), "scale")) {
int scale = bson_iterator_int(iterator);
scales[num_scales - 1].mask = scale;
for (i = 11; i >= 0; i--) {
printf("%s", (scale >> i) & 1 ? "1" : "0");
}
printf("\n");
}
}
dlist_t *mongodb_dump_keyvalue(bot_t * bot, char *db)
{
dlist_t *dl, *dptr;
keyvalue_t *keyvalue_ptr;
mongo_cursor *cursor;
bson b;
bson_iterator bi;
char *key;
char *value;
dl = dptr = NULL;
cursor = NULL;
if (!db)
return NULL;
debug(bot, "mongodb_dump_keyvalue: Entered\n");
cursor =
mongo_find(&gi->mongo_conn, db, bson_empty(&b),
bson_empty(&b), 0, 0, 0);
while (mongo_cursor_next(cursor) == MONGO_OK) {
key = value = NULL;
if (bson_find(&bi, mongo_cursor_bson(cursor), "key")) {
key = (char *)bson_iterator_string(&bi);
}
if (bson_find(&bi, mongo_cursor_bson(cursor), "value")) {
value = (char *)bson_iterator_string(&bi);
}
if (!key && !value)
continue;
keyvalue_ptr = (keyvalue_t *) calloc(1, sizeof(keyvalue_t));
if (key)
keyvalue_ptr->key = strdup(key);
if (value)
keyvalue_ptr->value = strdup(value);
dlist_Dinsert_after(&dl, keyvalue_ptr);
}
mongo_cursor_destroy(cursor);
return dl;
}
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 const char* get_field_value(bson_iterator* iterator, mongo_cursor* cursor, char* field) {
if(bson_find(iterator, mongo_cursor_bson(cursor), field)) {
return bson_iterator_string(iterator);
}else{
return NULL;
}
}
result_t MongoCursor::_bsonCursor(bson &out, AsyncEvent *ac)
{
if (!ac)
return CHECK_ERROR(CALL_E_NOSYNC);
out = *(mongo_cursor_bson(m_cursor));
return 0;
}
UInfo* MongoLink::query(int uid) {
UInfo* uinfo = NULL;
bson query[1];
mongo_cursor cursor[1];
bson_init( query );
bson_append_int( query, "uid", uid );
bson_finish( query );
mongo_cursor_init( cursor, &m_mongo, m_strDBName.c_str() );
mongo_cursor_set_query( cursor, query );
if( mongo_cursor_next( cursor ) == MONGO_OK ) {
bson_iterator iterator[1];
uinfo = new UInfo();
//uinfo->linkid = 0;
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "uid" ) != BSON_EOO ) {
uinfo->uid= bson_iterator_int( iterator );
}
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "router" ) != BSON_EOO ) {
uinfo->router= bson_iterator_string( iterator );
}
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "dispatcher" ) != BSON_EOO ) {
uinfo->dispatcher= bson_iterator_string( iterator );
}
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "proxy" ) != BSON_EOO ) {
uinfo->proxy= bson_iterator_string( iterator );
}
} else {
LOG(TAG_ROUTER, "query uid failed, uid=%d.", uid);
}
exit:
bson_destroy( query );
mongo_cursor_destroy( cursor );
return uinfo;
}
//------------------------------------------------------------------------------
int main( int argc, char * argv[] ){
mongo conn;
if( mongo_client( &conn , TEST_SERVER, TEST_PORT ) != MONGO_OK ) {
std::cout << "failed to connect\n";
return EXIT_FAILURE;
}
mongo_cursor cursor;
mongo_cursor_init( &cursor, &conn, "test.test" );
char hex_oid[25];
while( mongo_cursor_next( &cursor ) == MONGO_OK ) {
std::cout << "row:\n";
bson_iterator it;
bson_iterator_init( &it, mongo_cursor_bson( &cursor ) );
while( bson_iterator_next( &it ) ) {
std::cout << " " << bson_iterator_key( &it ) << " = ";
switch( bson_iterator_type( &it ) ) {
case BSON_DOUBLE:
std::cout << "(double) " << bson_iterator_double( &it ) << std::endl;
break;
case BSON_INT:
std::cout << "(int) " << bson_iterator_int( &it ) << std::endl;
break;
case BSON_STRING:
std::cout << "(string) \"" << bson_iterator_string( &it ) << "\"\n";
break;
case BSON_OID:
bson_oid_to_string( bson_iterator_oid( &it ), hex_oid );
std::cout << "(oid) \"" << hex_oid << "\"\n";
break;
case BSON_OBJECT:
std::cout << "(subobject) {...}\n";
break;
case BSON_ARRAY:
std::cout << "(array) [...]\n";
break;
case BSON_TIMESTAMP:
std::cout << "(timestamp) [...]\n";
break;
default:
std::cout << "(type " << bson_iterator_type( &it ) << std::endl;
break;
}
}
std::cout << std::endl;
}
mongo_disconnect( &conn );
return EXIT_SUCCESS;
}
result_t MongoCursor::next(v8::Local<v8::Object> &retVal)
{
bool has;
result_t hr = hasNext(has);
if (hr < 0)
return hr;
if (!has)
return CALL_RETURN_NULL;
retVal = decodeObject(mongo_cursor_bson(m_cursor));
m_state = CUR_NONE;
return 0;
}
int test_copy_cursor_data( mongo *conn ) {
mongo_cursor cursor[1];
bson b[1];
insert_sample_data( conn, 10 );
mongo_cursor_init( cursor, conn, "test.cursors" );
mongo_cursor_next( cursor );
ASSERT( bson_copy( b, mongo_cursor_bson( cursor ) ) == MONGO_OK );
ASSERT( memcmp( (void *)b->data, (void *)(cursor->current).data,
bson_size( &cursor->current ) ) == 0 );
mongo_cursor_destroy( cursor );
bson_destroy( b );
return 0;
}
char *mongodb_retrieve_key(bot_t * bot, char *db, char *key, char *which)
{
char *str = NULL;
bson b;
mongo_cursor cursor;
if (!db || !key || !which) {
return NULL;
}
debug(bot,
"mongodb_retrieve_key: Entered :db=%s. key=%s, which=%s\n", db,
key, which);
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) {
bson_iterator i;
debug(bot, "mongodb_retrieve_key: Found!\n");
if (bson_find(&i, mongo_cursor_bson(&cursor), which)) {
str = (char *)bson_iterator_string(&i);
str = strdup(str);
}
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return str;
}
debug(bot, "mongodb_retrieve_key: Key not found\n");
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return NULL;
}
static void tutorial_simple_query( mongo *conn ) {
bson query[1];
mongo_cursor cursor[1];
bson_init( query );
bson_append_int( query, "age", 24 );
bson_finish( query );
mongo_cursor_init( cursor, conn, "tutorial.persons" );
mongo_cursor_set_query( cursor, query );
while( mongo_cursor_next( cursor ) == MONGO_OK ) {
bson_iterator iterator[1];
if ( bson_find( iterator, mongo_cursor_bson( cursor ), "name" )) {
printf( "name: %s\n", bson_iterator_string( iterator ) );
}
}
bson_destroy( query );
mongo_cursor_destroy( cursor );
}
int mongodb_retrieve_key_stat(bot_t * bot, char *db, char *key)
{
bson b;
mongo_cursor cursor;
int ret = 0;
if (!db || !key) {
return -1;
}
debug(bot, "mongodb_retrieve_key: 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) {
bson_iterator i;
debug(bot, "mongodb_retrieve_key: Found!\n");
if (bson_find(&i, mongo_cursor_bson(&cursor), "value")) {
ret = (int)bson_iterator_int(&i);
}
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return ret;
}
debug(bot, "mongodb_retrieve_key: Key not found\n");
bson_destroy(&b);
mongo_cursor_destroy(&cursor);
return -1;
}
void MongodbClient::DumpDB()
{
Logger::Debug("***** MONGO DUMP *******");
bson query;
bson_empty(&query);
mongo_cursor *cursor = mongo_find(clientData->connection, namespaceName.c_str(), &query, NULL, 0, 0, 0);
int32 count = 0;
while( mongo_cursor_next( cursor ) == MONGO_OK )
{
const bson *currentObject = mongo_cursor_bson(cursor);
Logger::Debug(Format("BSON[%d]:", count));
bson_print(currentObject);
++count;
}
mongo_cursor_destroy(cursor);
Logger::Debug("Count: %d", count);
Logger::Debug("************************");
}
static int resolve_block(struct inode * e, uint8_t hash[HASH_LEN], char * buf) {
bson query;
int res;
mongo_cursor curs;
bson_iterator i;
bson_type bt;
const char * key;
mongo * conn = get_conn();
bson_init(&query);
bson_append_binary(&query, "_id", 0, (char*)hash, 20);
bson_finish(&query);
mongo_cursor_init(&curs, conn, blocks_name);
mongo_cursor_set_query(&curs, &query);
mongo_cursor_set_limit(&curs, 1);
res = mongo_cursor_next(&curs);
bson_destroy(&query);
if(res != MONGO_OK) {
mongo_cursor_destroy(&curs);
return -EIO;
}
bson_iterator_init(&i, mongo_cursor_bson(&curs));
size_t outsize, compsize = 0;
const char * compdata = NULL;
uint32_t offset = 0, size = 0;
while((bt = bson_iterator_next(&i)) > 0) {
key = bson_iterator_key(&i);
if(strcmp(key, "data") == 0) {
compsize = bson_iterator_bin_len(&i);
compdata = bson_iterator_bin_data(&i);
}
else if(strcmp(key, "offset") == 0)
offset = bson_iterator_int(&i);
else if(strcmp(key, "size") == 0)
size = bson_iterator_int(&i);
}
if(curs.err != MONGO_CURSOR_EXHAUSTED) {
fprintf(stderr, "Error getting extents %d", curs.err);
return -EIO;
}
if(!compdata) {
fprintf(stderr, "No data in block?\n");
return -EIO;
}
outsize = MAX_BLOCK_SIZE;
if((res = snappy_uncompress(compdata, compsize,
buf + offset, &outsize)) != SNAPPY_OK) {
fprintf(stderr, "Error uncompressing block %d\n", res);
return -EIO;
}
if(offset > 0)
memset(buf, 0, offset);
compsize = outsize + offset;
if(compsize < size)
memset(buf + compsize, 0, size - compsize);
mongo_cursor_destroy(&curs);
return 0;
}
int main() {
bson b, sub, out;
bson_iterator it;
mongo conn;
mongo_cursor cursor;
int result;
/* Create a rich document like this one:
*
* { _id: ObjectId("4d95ea712b752328eb2fc2cc"),
* user_id: ObjectId("4d95ea712b752328eb2fc2cd"),
*
* items: [
* { sku: "col-123",
* name: "John Coltrane: Impressions",
* price: 1099,
* },
*
* { sku: "young-456",
* name: "Larry Young: Unity",
* price: 1199
* }
* ],
*
* address: {
* street: "59 18th St.",
* zip: 10010
* },
*
* total: 2298
* }
*/
bson_init( &b );
bson_append_new_oid( &b, "_id" );
bson_append_new_oid( &b, "user_id" );
bson_append_start_array( &b, "items" );
bson_append_start_object( &b, "0" );
bson_append_string( &b, "name", "John Coltrane: Impressions" );
bson_append_int( &b, "price", 1099 );
bson_append_finish_object( &b );
bson_append_start_object( &b, "1" );
bson_append_string( &b, "name", "Larry Young: Unity" );
bson_append_int( &b, "price", 1199 );
bson_append_finish_object( &b );
bson_append_finish_object( &b );
bson_append_start_object( &b, "address" );
bson_append_string( &b, "street", "59 18th St." );
bson_append_int( &b, "zip", 10010 );
bson_append_finish_object( &b );
bson_append_int( &b, "total", 2298 );
/* Finish the BSON obj. */
bson_finish( &b );
printf("Here's the whole BSON object:\n");
bson_print( &b );
/* Advance to the 'items' array */
bson_find( &it, &b, "items" );
/* Get the subobject representing items */
bson_iterator_subobject_init( &it, &sub, 0 );
/* Now iterate that object */
printf("And here's the inner sub-object by itself.\n");
bson_print( &sub );
bson_destroy( &sub );
/* Now make a connection to MongoDB. */
if( mongo_client( &conn, "127.0.0.1", 27017 ) != MONGO_OK ) {
switch( conn.err ) {
case MONGO_CONN_SUCCESS:
break;
case MONGO_CONN_NO_SOCKET:
printf( "FAIL: Could not create a socket!\n" );
break;
case MONGO_CONN_FAIL:
printf( "FAIL: Could not connect to mongod. Make sure it's listening at 127.0.0.1:27017.\n" );
break;
default:
printf( "MongoDB connection error number %d.\n", conn.err );
break;
}
exit( 1 );
}
/* Insert the sample BSON document. */
if( mongo_insert( &conn, "test.records", &b, NULL ) != MONGO_OK ) {
printf( "FAIL: Failed to insert document with error %d\n", conn.err );
exit( 1 );
}
/* Query for the sample document. */
mongo_cursor_init( &cursor, &conn, "test.records" );
mongo_cursor_set_query( &cursor, bson_shared_empty() );
if( mongo_cursor_next( &cursor ) != MONGO_OK ) {
printf( "FAIL: Failed to find inserted document." );
exit( 1 );
}
printf( "Found saved BSON object:\n" );
bson_print( (bson *)mongo_cursor_bson( &cursor ) );
mongo_cmd_drop_collection( &conn, "test", "records", NULL );
mongo_cursor_destroy( &cursor );
bson_destroy( &b );
mongo_destroy( &conn );
return 0;
}
/**
* \brief This function tries to load tag group from MongoDB
*
* \param[in] *vs_ctx The verse server context
* \param[in] *oid The pointer at ObjectID of tag group in MongoDB
* \param[in] *node The node containing tag group
* \param[in] taggroup_id The tag group ID that is requested from database
* \param[in] version The version of tag group id that is requested
* from database. When version is equal to -1, then
* current version is loaded from MongoDB.
*
* \return This function returns pointer at tag group, when tag group is found.
* Otherwise it returns NULL.
*/
struct VSTagGroup *vs_mongo_taggroup_load_linked(struct VS_CTX *vs_ctx,
bson_oid_t *oid,
struct VSNode *node,
uint16 taggroup_id,
uint32 req_version)
{
struct VSTagGroup *tg = NULL;
bson query;
mongo_cursor cursor;
uint32 node_id = -1, tmp_taggroup_id = -1,
current_version = -1, custom_type = -1;
int found = 0;
bson_iterator tg_data_iter;
const bson *bson_tg;
bson_init(&query);
bson_append_oid(&query, "_id", oid);
bson_finish(&query);
mongo_cursor_init(&cursor, vs_ctx->mongo_conn, vs_ctx->mongo_tg_ns);
mongo_cursor_set_query(&cursor, &query);
/* ObjectID should be unique */
while( mongo_cursor_next(&cursor) == MONGO_OK ) {
bson_tg = mongo_cursor_bson(&cursor);
/* Try to get node id */
if( bson_find(&tg_data_iter, bson_tg, "node_id") == BSON_INT ) {
node_id = bson_iterator_int(&tg_data_iter);
}
/* Try to get tag group id */
if( bson_find(&tg_data_iter, bson_tg, "taggroup_id") == BSON_INT ) {
tmp_taggroup_id = bson_iterator_int(&tg_data_iter);
}
/* ObjectID is ALMOST unique. So it is check, if node id and
* tag group id matches */
if(node_id == node->id && tmp_taggroup_id == taggroup_id) {
found = 1;
break;
}
}
/* When tag group was found, then load required data from MongoDB */
if(found == 1) {
/* Try to get current version of tag group */
if( bson_find(&tg_data_iter, bson_tg, "current_version") == BSON_INT ) {
current_version = bson_iterator_int(&tg_data_iter);
}
/* Try to get custom type of tag group */
if( bson_find(&tg_data_iter, bson_tg, "custom_type") == BSON_INT ) {
custom_type = bson_iterator_int(&tg_data_iter);
}
/* Create tag group with specific ID */
if((int)current_version != -1 && (int)custom_type != -1) {
tg = vs_taggroup_create(node, taggroup_id, custom_type);
if(tg != NULL) {
tg->state = ENTITY_CREATED;
/* Save ObjectID to tag group */
memcpy(&tg->oid, oid, sizeof(bson_oid_t));
/* Try to get versions of tag group */
if( bson_find(&tg_data_iter, bson_tg, "versions") == BSON_OBJECT ) {
bson bson_versions;
bson_iterator version_iter;
char str_num[15];
/* Initialize sub-object of versions */
bson_iterator_subobject_init(&tg_data_iter, &bson_versions, 0);
sprintf(str_num, "%u", req_version);
/* Try to find required version of tag group */
if( bson_find(&version_iter, &bson_versions, str_num) == BSON_OBJECT ) {
bson bson_version;
/* Set version of tag group */
tg->version = tg->saved_version = current_version;
bson_iterator_subobject_init(&version_iter, &bson_version, 0);
/* Try to load tags */
vs_mongo_taggroup_load_data(tg, &bson_version);
}
}
}
}
}
bson_destroy(&query);
mongo_cursor_destroy(&cursor);
return tg;
}
int main(int argc, char **argv)
{
bson b[1];
bson query[1];
mongo conn[1];
mongo_cursor cursor[1];
int result;
if(mongo_client(conn, "127.0.0.1", 27017) != MONGO_OK) {
switch(conn->err)
{
case MONGO_CONN_SUCCESS:
fprintf(stderr, "OK: Connected to MongoDB!\n");
break;
case MONGO_CONN_NO_SOCKET:
fprintf(stderr, "FAIL: Cloud not create a socket!\n");
break;
case MONGO_CONN_FAIL:
fprintf(stderr, "FAIL: Could not connect to mongod!.");
break;
default:
fprintf(stderr, "MongoDB connection error number: %d.\n", conn->err);
}
}
bson_init(query);
bson_append_string(query, "city_name", "南京");
bson_finish(query);
mongo_cursor_init(cursor, conn, "bangboox.city_shop");
mongo_cursor_set_query(cursor, query);
while(mongo_cursor_next(cursor) == MONGO_OK) {
bson_print((bson *)mongo_cursor_bson(cursor));
}
bson_init(b);
bson_append_new_oid(b, "_id");
bson_append_new_oid(b, "record_id");
bson_append_start_array(b, "items");
bson_append_start_object(b, "0");
bson_append_string(b, "name", "roy.lieu");
bson_append_int(b, "age", 30);
bson_append_finish_object(b);
bson_append_start_object(b, "1");
bson_append_string(b, "name", "jimmy.chen");
bson_append_int(b, "age", 35);
bson_append_finish_object(b);
bson_append_finish_object(b);
bson_append_start_object(b, "address");
bson_append_string(b, "stree", "Jufeng RD.");
bson_append_int(b, "zip", 232044);
bson_append_finish_object(b);
bson_finish(b);
//printf("\n\n");
//bson_print(b);
if(mongo_insert(conn, "test.record", b, NULL) != MONGO_OK) {
fprintf(stderr, "FAIL: Failed to insert document whth err: %d\n", conn->err);
}
return 0;
}
