Exemplo n.º 1
0
static void
mongo_cursor_set_property (GObject      *object,
                           guint         prop_id,
                           const GValue *value,
                           GParamSpec   *pspec)
{
   MongoCursor *cursor = MONGO_CURSOR(object);

   switch (prop_id) {
   case PROP_BATCH_SIZE:
      mongo_cursor_set_batch_size(cursor, g_value_get_uint(value));
      break;
   case PROP_CONNECTION:
      mongo_cursor_set_connection(cursor, g_value_get_object(value));
      break;
   case PROP_COLLECTION:
      mongo_cursor_set_collection(cursor, g_value_get_string(value));
      break;
   case PROP_DATABASE:
      mongo_cursor_set_database(cursor, g_value_get_string(value));
      break;
   case PROP_FIELDS:
      mongo_cursor_set_fields(cursor, g_value_get_boxed(value));
      break;
   case PROP_FLAGS:
      mongo_cursor_set_flags(cursor, g_value_get_uint(value));
      break;
   case PROP_LIMIT:
      mongo_cursor_set_limit(cursor, g_value_get_uint(value));
      break;
   case PROP_QUERY:
      mongo_cursor_set_query(cursor, g_value_get_boxed(value));
      break;
   case PROP_SKIP:
      mongo_cursor_set_skip(cursor, g_value_get_uint(value));
      break;
   default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
   }
}
Exemplo n.º 2
0
int test_bad_query( mongo *conn ) {
    mongo_cursor cursor[1];
    bson b[1];

    bson_init( b );
    bson_append_start_object( b, "foo" );
        bson_append_int( b, "$bad", 1 );
    bson_append_finish_object( b );
    bson_finish( b );

    mongo_cursor_init( cursor, conn, "test.cursors" );
    mongo_cursor_set_query( cursor, b );

    ASSERT( mongo_cursor_next( cursor ) == MONGO_ERROR );
    ASSERT( cursor->err == MONGO_CURSOR_QUERY_FAIL );
    ASSERT( cursor->conn->lasterrcode == 10068 );
    ASSERT( strlen( cursor->conn->lasterrstr ) > 0 );

    mongo_cursor_destroy( cursor );
    bson_destroy( b );
    return 0;
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
0
int mongo_find_one( mongo *conn, const char *ns, bson *query,
                    bson *fields, bson *out ) {

    mongo_cursor cursor[1];
    mongo_cursor_init( cursor, conn, ns );
    mongo_cursor_set_query( cursor, query );
    mongo_cursor_set_fields( cursor, fields );
    mongo_cursor_set_limit( cursor, 1 );
    // Always use slave OK.
    mongo_cursor_set_options( cursor, MONGO_SLAVE_OK );

    if ( mongo_cursor_next( cursor ) == MONGO_OK ) {
        bson_init_size( out, bson_size( (bson *)&cursor->current ) );
        memcpy( out->data, cursor->current.data,
            bson_size( (bson *)&cursor->current ) );
        out->finished = 1;
        mongo_cursor_destroy( cursor );
        return MONGO_OK;
    } else {
        mongo_cursor_destroy( cursor );
        return MONGO_ERROR;
    }
}
Exemplo n.º 5
0
int main() {
    mongo conn[1];
    bson b, empty;
    mongo_cursor cursor[1];
    unsigned char not_utf8[3];
    int result = 0;
    const char *ns = "test.c.validate";

    int i=0, j=0;
    bson bs[BATCH_SIZE];
    bson *bp[BATCH_SIZE];

    not_utf8[0] = 0xC0;
    not_utf8[1] = 0xC0;
    not_utf8[2] = '\0';

    INIT_SOCKETS_FOR_WINDOWS;

    if ( mongo_connect( conn, TEST_SERVER, 27017 ) ) {
        printf( "failed to connect\n" );
        exit( 1 );
    }

    /* Test checking for finished bson. */
    bson_init( &b );
    bson_append_int( &b, "foo", 1 );
    ASSERT( mongo_insert( conn, "test.foo", &b, NULL ) == MONGO_ERROR );
    ASSERT( conn->err == MONGO_BSON_NOT_FINISHED );
    bson_destroy( &b );

    /* Test valid keys. */
    bson_init( &b );
    result = bson_append_string( &b , "a.b" , "17" );
    ASSERT( result == BSON_OK );

    ASSERT( b.err & BSON_FIELD_HAS_DOT );

    /* Don't set INIT dollar if deb ref fields are being used. */
    result = bson_append_string( &b , "$id" , "17" );
    ASSERT( result == BSON_OK );
    ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) );

    result = bson_append_string( &b , "$ref" , "17" );
    ASSERT( result == BSON_OK );
    ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) );

    result = bson_append_string( &b , "$db" , "17" );
    ASSERT( result == BSON_OK );
    ASSERT( !(b.err & BSON_FIELD_INIT_DOLLAR) );

    result = bson_append_string( &b , "$ab" , "17" );
    ASSERT( result == BSON_OK );
    ASSERT( b.err & BSON_FIELD_INIT_DOLLAR );

    result = bson_append_string( &b , "ab" , "this is valid utf8" );
    ASSERT( result == BSON_OK );
    ASSERT( ! ( b.err & BSON_NOT_UTF8 ) );

    result = bson_append_string( &b , ( const char * )not_utf8, "valid" );
    ASSERT( result == BSON_ERROR );
    ASSERT( b.err & BSON_NOT_UTF8 );

    ASSERT( bson_finish( &b ) == BSON_ERROR );
    ASSERT( b.err & BSON_FIELD_HAS_DOT );
    ASSERT( b.err & BSON_FIELD_INIT_DOLLAR );
    ASSERT( b.err & BSON_NOT_UTF8 );

    result = mongo_insert( conn, ns, &b, NULL );
    ASSERT( result == MONGO_ERROR );
    ASSERT( conn->err & MONGO_BSON_NOT_FINISHED );

    result = mongo_update( conn, ns, bson_empty( &empty ), &b, 0, NULL );
    ASSERT( result == MONGO_ERROR );
    ASSERT( conn->err & MONGO_BSON_NOT_FINISHED );

    mongo_cursor_init( cursor, conn, "test.cursors" );
    mongo_cursor_set_query( cursor, &b );
    result = mongo_cursor_next( cursor );
    ASSERT( result == MONGO_ERROR );
    ASSERT( cursor->err & MONGO_CURSOR_BSON_ERROR );
    ASSERT( cursor->conn->err & MONGO_BSON_NOT_FINISHED );

    bson_destroy( &b );
    mongo_cursor_destroy( cursor );

    /* Test valid strings. */
    bson_init( &b );
    result = bson_append_string( &b , "foo" , "bar" );
    ASSERT( result == BSON_OK );
    ASSERT( b.err == 0 );

    result = bson_append_string( &b , "foo" , ( const char * )not_utf8 );
    ASSERT( result == BSON_ERROR );
    ASSERT( b.err & BSON_NOT_UTF8 );

    b.err = 0;
    ASSERT( b.err == 0 );

    result = bson_append_regex( &b , "foo" , ( const char * )not_utf8, "s" );
    ASSERT( result == BSON_ERROR );
    ASSERT( b.err & BSON_NOT_UTF8 );

    for ( j=0; j < BATCH_SIZE; j++ )
        bp[j] = &bs[j];

    for ( j=0; j < BATCH_SIZE; j++ )
        make_small_invalid( &bs[j], i );

    result = mongo_insert_batch( conn, ns, (const bson **)bp, BATCH_SIZE, NULL, 0 );
    ASSERT( result == MONGO_ERROR );
    ASSERT( conn->err == MONGO_BSON_INVALID );

    for ( j=0; j < BATCH_SIZE; j++ )
        bson_destroy( &bs[j] );

    bson_destroy( &b );
    mongo_cmd_drop_db( conn, "test" );
    mongo_disconnect( conn );

    mongo_destroy( conn );

    return 0;
}
Exemplo n.º 6
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;
}
Exemplo n.º 7
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;
}
Exemplo n.º 8
0
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;
}
Exemplo n.º 9
0
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;
}