/* 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; }
static void make_small(bson * out, int i){ bson_buffer bb; bson_buffer_init(&bb); bson_append_new_oid(&bb, "_id"); bson_append_int(&bb, "x", i); bson_from_buffer(out, &bb); }
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 ); }
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] ); } }
int main() { mongo conn[1]; bson b; const char *sock_path = "/tmp/mongodb-27017.sock"; const char *ns = "test.c.unix_socket"; const char *col = "c.unix_socket"; ASSERT( mongo_client( conn, sock_path, -1 ) == MONGO_OK ); mongo_cmd_drop_collection( conn, "test", col, NULL ); bson_init( &b ); bson_append_new_oid( &b, "_id" ); bson_append_string( &b, "foo", "bar" ); bson_append_int( &b, "x", 1); bson_finish( &b ); ASSERT( mongo_insert( conn, ns, &b, NULL ) == MONGO_OK ); mongo_cmd_drop_collection( conn, "test", col, NULL ); bson_destroy( &b ); mongo_destroy( conn ); 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 ); }
static void make_medium(bson * out, int i){ bson_buffer bb; bson_buffer_init(&bb); bson_append_new_oid(&bb, "_id"); bson_append_int(&bb, "x", i); bson_append_int(&bb, "integer", 5); bson_append_double(&bb, "number", 5.05); bson_append_bool(&bb, "boolean", 0); bson_append_start_array(&bb, "array"); bson_append_string(&bb, "0", "test"); bson_append_string(&bb, "1", "benchmark"); bson_append_finish_object(&bb); bson_from_buffer(out, &bb); }
static void test_write_concern_input( mongo *conn ) { mongo_write_concern wc[1], wcbad[1]; bson b[1]; mongo_cmd_drop_collection( conn, TEST_DB, TEST_COL, NULL ); bson_init( b ); bson_append_new_oid( b, "_id" ); bson_finish( b ); mongo_write_concern_init( wc ); mongo_write_concern_set_w( wc, 1 ); /* Failure to finish write concern object. */ ASSERT( mongo_insert( conn, TEST_NS, b, wc ) != MONGO_OK ); ASSERT( conn->err == MONGO_WRITE_CONCERN_INVALID ); ASSERT_EQUAL_STRINGS( conn->errstr, "Must call mongo_write_concern_finish() before using *write_concern." ); mongo_write_concern_finish( wc ); /* Use a bad write concern. */ mongo_clear_errors( conn ); mongo_write_concern_init( wcbad ); mongo_write_concern_set_w( wcbad, 2 ); mongo_write_concern_finish( wcbad ); mongo_set_write_concern( conn, wcbad ); ASSERT( mongo_insert( conn, TEST_NS, b, NULL ) != MONGO_OK ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "norepl" ); /* Ensure that supplied write concern overrides default. */ mongo_clear_errors( conn ); ASSERT( mongo_insert( conn, TEST_NS, b, wc ) != MONGO_OK ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->errstr, "See conn->lasterrstr for details." ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "E11000 duplicate key error index" ); ASSERT( conn->lasterrcode == 11000 ); conn->write_concern = NULL; mongo_write_concern_destroy( wc ); mongo_write_concern_destroy( wcbad ); bson_destroy( b ); }
/* Add a new DLR entry to MongoDB */ static void dlr_mongodb_add(struct dlr_entry *entry) { DBPoolConn *pconn; bson b; bson_buffer buf; mongo_connection *conn = NULL; pconn = dbpool_conn_consume(pool); if (pconn == NULL) { dlr_entry_destroy(entry); return; } conn = (mongo_connection*)pconn->conn; bson_buffer_init(&buf); bson_append_new_oid(&buf, "_id"); bson_append_string(&buf, octstr_get_cstr(fields->field_smsc), octstr_get_cstr(entry->smsc)); bson_append_string(&buf, octstr_get_cstr(fields->field_ts), octstr_get_cstr(entry->timestamp)); bson_append_string(&buf, octstr_get_cstr(fields->field_src), octstr_get_cstr(entry->source)); bson_append_string(&buf, octstr_get_cstr(fields->field_dst), octstr_get_cstr(entry->destination)); bson_append_string(&buf, octstr_get_cstr(fields->field_serv), octstr_get_cstr(entry->service)); bson_append_string(&buf, octstr_get_cstr(fields->field_url), octstr_get_cstr(entry->url)); bson_append_string(&buf, octstr_get_cstr(fields->field_account), octstr_get_cstr(entry->account)); bson_append_string(&buf, octstr_get_cstr(fields->field_binfo), octstr_get_cstr(entry->binfo)); bson_append_int(&buf, octstr_get_cstr(fields->field_mask), entry->mask); bson_append_string(&buf, octstr_get_cstr(fields->field_boxc), octstr_get_cstr(entry->boxc_id)); bson_append_int(&buf, octstr_get_cstr(fields->field_status), 0); bson_from_buffer(&b, &buf); /* TODO: namespace support */ MONGO_TRY { mongo_insert(conn, mongodb_namespace, &b); } MONGO_CATCH { mongodb_error("dlr_mongodb_insert", conn->exception.type); } dbpool_conn_produce(pconn); bson_destroy(&b); dlr_entry_destroy(entry); }
int main() { mongo conn[1]; int status = mongo_client( conn, "127.0.0.1", 27017 ); if( status != MONGO_OK ) { switch ( conn->err ) { case MONGO_CONN_NO_SOCKET: printf( "no socket\n" ); return 1; case MONGO_CONN_FAIL: printf( "connection failed\n" ); return 1; case MONGO_CONN_NOT_MASTER: printf( "not master\n" ); return 1; } } bson b[1]; bson_init( b ); bson_append_new_oid( b, "_id" ); bson_append_string( b, "name", "Joe" ); bson_append_int( b, "age", 33 ); bson_finish( b ); mongo_insert( conn, "tutorial.persons", b, 0 ); bson_destroy( b ); tutorial_insert_batch(conn); tutorial_empty_query(conn); tutorial_simple_query(conn); tutorial_update(conn); tutorial_index(conn); mongo_destroy( conn ); return 0; }
int main(){ mongo_connection conn[1]; mongo_connection_options opts; bson_buffer bb; bson b; mongo_cursor * cursor; int i; char hex_oid[25]; const char * col = "c.simple"; const char * ns = "test.c.simple"; INIT_SOCKETS_FOR_WINDOWS; strncpy(opts.host, TEST_SERVER, 255); opts.host[254] = '\0'; opts.port = 27017; if (mongo_connect( conn , &opts )){ printf("failed to connect\n"); exit(1); } /* if the collection doesn't exist dropping it will fail */ if (!mongo_cmd_drop_collection(conn, "test", col, NULL) && mongo_find_one(conn, ns, bson_empty(&b), bson_empty(&b), NULL)){ printf("failed to drop collection\n"); exit(1); } for(i=0; i< 5; i++){ bson_buffer_init( & bb ); bson_append_new_oid( &bb, "_id" ); bson_append_double( &bb , "a" , 17 ); bson_append_int( &bb , "b" , 17 ); bson_append_string( &bb , "c" , "17" ); { bson_buffer * sub = bson_append_start_object( &bb , "d" ); bson_append_int( sub, "i", 71 ); bson_append_finish_object(sub); } { bson_buffer * arr = bson_append_start_array( &bb , "e" ); bson_append_int( arr, "0", 71 ); bson_append_string( arr, "1", "71" ); bson_append_finish_object(arr); } bson_from_buffer(&b, &bb); mongo_insert( conn , ns , &b ); bson_destroy(&b); } cursor = mongo_find( conn , ns , bson_empty(&b) , 0 , 0 , 0 , 0 ); while (mongo_cursor_next(cursor)){ bson_iterator it; bson_iterator_init(&it, cursor->current.data); while(bson_iterator_next(&it)){ fprintf(stderr, " %s: ", bson_iterator_key(&it)); switch(bson_iterator_type(&it)){ case bson_double: fprintf(stderr, "(double) %e\n", bson_iterator_double(&it)); break; case bson_int: fprintf(stderr, "(int) %d\n", bson_iterator_int(&it)); break; case bson_string: fprintf(stderr, "(string) \"%s\"\n", bson_iterator_string(&it)); break; case bson_oid: bson_oid_to_string(bson_iterator_oid(&it), hex_oid); fprintf(stderr, "(oid) \"%s\"\n", hex_oid); break; case bson_object: fprintf(stderr, "(subobject) {...}\n"); break; case bson_array: fprintf(stderr, "(array) [...]\n"); break; default: fprintf(stderr, "(type %d)\n", bson_iterator_type(&it)); break; } } fprintf(stderr, "\n"); } mongo_cursor_destroy(cursor); mongo_cmd_drop_db(conn, "test"); mongo_destroy( conn ); return 0; }
static void make_small_invalid( bson *out, int i ) { bson_init( out ); bson_append_new_oid( out, "$_id" ); bson_append_int( out, "x.foo", i ); bson_finish( out ); }
static void make_small( bson *out, int i ) { bson_init( out ); bson_append_new_oid( out, "_id" ); bson_append_int( out, "x", i ); bson_finish( out ); }
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; }
static int mongodb_log(struct ast_cdr *cdr) { const char * ns; mongo conn[1]; ast_debug(1, "mongodb: Starting mongodb_log.\n"); mongo_init( &conn ); if (mongo_connect( &conn , ast_str_buffer(hostname), dbport ) != MONGO_OK){ mongo_destroy( &conn ); ast_log(LOG_ERROR, "Method: mongodb_log, MongoDB failed to connect.\n"); connected = 0; records = 0; return -1; } if (ast_str_strlen(dbuser) != 0 && (mongo_cmd_authenticate(&conn, ast_str_buffer(dbname), ast_str_buffer(dbuser), ast_str_buffer(password)) != MONGO_OK)) { mongo_destroy( &conn ); ast_log(LOG_ERROR, "Method: mongodb_log, MongoDB failed to authenticate to do %s with username %s!\n", ast_str_buffer(dbname), ast_str_buffer(dbuser)); connected = 0; records = 0; return -1; } ast_debug(1, "mongodb: Locking mongodb_lock.\n"); ast_mutex_lock(&mongodb_lock); ast_debug(1, "mongodb: Got connection, Preparing record.\n"); bson b[1]; ast_debug(1, "mongodb: Init bson.\n"); bson_init( &b ); bson_append_new_oid( &b, "_id" ); ast_debug(1, "mongodb: accountcode.\n"); bson_append_string( &b , "accountcode", cdr->accountcode); ast_debug(1, "mongodb: src.\n"); bson_append_string( &b , "src", cdr->src); ast_debug(1, "mongodb: dst.\n"); bson_append_string( &b, "dst" , cdr->dst ); ast_debug(1, "mongodb: dcontext.\n"); bson_append_string( &b, "dcontext" , cdr->dcontext ); ast_debug(1, "mongodb: clid.\n"); bson_append_string( &b, "clid" , cdr->clid ); ast_debug(1, "mongodb: channel.\n"); bson_append_string( &b, "channel" , cdr->channel ); ast_debug(1, "mongodb: dstchannel.\n"); bson_append_string( &b, "dstchannel" , cdr->dstchannel ); ast_debug(1, "mongodb: lastapp.\n"); bson_append_string( &b, "lastapp" , cdr->lastapp ); ast_debug(1, "mongodb: lastdata.\n"); bson_append_string( &b, "lastdata" , cdr->lastdata ); ast_debug(1, "mongodb: start.\n"); bson_append_date( &b, "start", (bson_date_t)cdr->start.tv_sec*1000); ast_debug(1, "mongodb: answer.\n"); bson_append_date( &b, "answer", (bson_date_t)cdr->answer.tv_sec*1000); ast_debug(1, "mongodb: end.\n"); bson_append_date( &b, "end" , (bson_date_t)cdr->end.tv_sec*1000); ast_debug(1, "mongodb: duration.\n"); bson_append_int( &b, "duration" , cdr->duration ); ast_debug(1, "mongodb: billsec.\n"); bson_append_int( &b, "billsec" , cdr->billsec ); ast_debug(1, "mongodb: disposition.\n"); bson_append_string( &b, "disposition" , ast_cdr_disp2str(cdr->disposition) ); ast_debug(1, "mongodb: amaflags.\n"); bson_append_string( &b, "amaflags" , ast_cdr_flags2str(cdr->amaflags) ); ast_debug(1, "mongodb: uniqueid.\n"); bson_append_string( &b, "uniqueid" , cdr->uniqueid ); ast_debug(1, "mongodb: userfield.\n"); bson_append_string( &b, "userfield" , cdr->userfield ); bson_finish(&b); ast_debug(1, "mongodb: Inserting a CDR record.\n"); mongo_insert( &conn , ast_str_buffer(dbnamespace) , &b ); bson_destroy(&b); mongo_destroy( &conn ); connected = 1; records++; totalrecords++; ast_debug(1, "Unlocking mongodb_lock.\n"); ast_mutex_unlock(&mongodb_lock); return 0; }
static void ngx_wirte_tracking_into_mongodb(ngx_http_request_t *r, ngx_http_vesb_aio_log_main_conf_t *valcf,ngx_http_vesb_aio_log_loc_conf_t *vallcf,int timeuse) { mongo conn[1]; char *conn_str; int port,status,insertstatus; time_t timenow; ngx_list_part_t *part = &r->headers_in.headers.part; ngx_table_elt_t *header = part->elts; ngx_uint_t i; if(r->headers_out.status == NGX_HTTP_OK) { conn_str = (char *)valcf->mongodb_conn_str.data; port = (int)valcf->mongodb_conn_port; status = mongo_client( conn, conn_str, port ); if( status == MONGO_OK ) { mongo_set_op_timeout( conn, 10000 );//time oust 10000 ms time ( &timenow ); bson b[1]; bson_init( b ); bson_append_new_oid( b, "_id" ); if( r->headers_in.x_forwarded_for == NULL ) { bson_append_string_n( b, "realclientip" , (char *)r->connection->addr_text.data, r->connection->addr_text.len); } else { bson_append_string_n( b, "realclientip" , (char *)r->headers_in.x_forwarded_for->value.data,r->headers_in.x_forwarded_for->value.len); } bson_append_int( b,"statuscode",r->headers_out.status); bson_append_int( b,"usetime",timeuse); bson_append_long( b,"requestsize",r->request_length); bson_append_long( b,"responsesize",r->headers_out.content_length_n); bson_append_time_t( b,"invoketime",timenow ); if(vallcf->app_name.data != NULL) { bson_append_string_n( b,"appname",(char *)vallcf->app_name.data,vallcf->app_name.len); } else { bson_append_string( b,"appname","undefine"); } /*get method name*/ for(i=0;/* void */; ++i) { if(i >= part->nelts) { if(part->next == NULL) { break; } part = part->next; header = part->elts; i=0; } if(header[i].hash == 0) { continue; } if(ngx_strstr(header[i].key.data,"SOAPAction") != NULL) { bson_append_string_n( b,"SOAPAction",(char *)header[i].value.data,header[i].value.len); } else if(ngx_strstr(header[i].key.data,"Content-Type") != NULL) { bson_append_string_n( b,"Content-Type",(char *)header[i].value.data,header[i].value.len); } } bson_finish( b ); insertstatus = mongo_insert( conn,"vesb.tracking", b , NULL ); if( insertstatus != MONGO_OK ) { ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0, "insert tracking log in mongodb is failed!(error:%d)",conn[0].err); } bson_destroy( b ); } else { ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0, "mongodb is unconnection!(error:%d)",status); } mongo_destroy( conn ); } }
static void test_insert( mongo *conn ) { mongo_write_concern wc0[1], wc1[1]; bson b[1], b2[1], b3[1], b4[1]; bson *objs[2]; mongo_cmd_drop_collection( conn, TEST_DB, TEST_COL, NULL ); mongo_write_concern_init( wc0 ); mongo_write_concern_set_w( wc0, 0 ); mongo_write_concern_finish( wc0 ); mongo_write_concern_init( wc1 ); mongo_write_concern_set_w( wc1, 1 ); mongo_write_concern_finish( wc1 ); bson_init( b4 ); bson_append_string( b4, "foo", "bar" ); bson_finish( b4 ); ASSERT( mongo_insert( conn, TEST_NS, b4, wc1 ) == MONGO_OK ); ASSERT( mongo_remove( conn, TEST_NS, bson_shared_empty( ), wc1 ) == MONGO_OK ); bson_init( b ); bson_append_new_oid( b, "_id" ); bson_finish( b ); ASSERT( mongo_insert( conn, TEST_NS, b, NULL ) == MONGO_OK ); /* This fails but returns OK with write concern w = 0 */ ASSERT( mongo_insert( conn, TEST_NS, b, wc0 ) == MONGO_OK ); /* no getLastError request */ ASSERT( mongo_insert( conn, TEST_NS, b, wc1 ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->errstr, "See conn->lasterrstr for details." ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "E11000 duplicate key error index" ); ASSERT( conn->lasterrcode == 11000 ); mongo_clear_errors( conn ); /* Still fails but returns OK with write concern w = 0 */ ASSERT( mongo_insert( conn, TEST_NS, b, wc0 ) == MONGO_OK ); /* But not when we set a default write concern on the conn. */ mongo_set_write_concern( conn, wc1 ); ASSERT( mongo_insert( conn, TEST_NS, b, NULL ) != MONGO_OK ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->errstr, "See conn->lasterrstr for details." ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "E11000 duplicate key error index" ); ASSERT( conn->lasterrcode == 11000 ); /* Now test batch insert. */ bson_init( b2 ); bson_append_new_oid( b2, "_id" ); bson_finish( b2 ); bson_init( b3 ); bson_append_new_oid( b3, "_id" ); bson_finish( b3 ); objs[0] = b2; objs[1] = b3; /* Insert two new documents by insert_batch. */ conn->write_concern = NULL; ASSERT( mongo_count( conn, TEST_DB, TEST_COL, bson_shared_empty( ) ) == 1 ); ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs, 2, NULL, 0 ) == MONGO_OK ); ASSERT( mongo_count( conn, TEST_DB, TEST_COL, bson_shared_empty( ) ) == 3 ); /* This should definitely fail if we try again with write concern. */ mongo_clear_errors( conn ); ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs, 2, wc1, 0 ) == MONGO_ERROR ); ASSERT( conn->err == MONGO_WRITE_ERROR ); ASSERT_EQUAL_STRINGS( conn->errstr, "See conn->lasterrstr for details." ); ASSERT_EQUAL_STRINGS( conn->lasterrstr, "E11000 duplicate key error index" ); ASSERT( conn->lasterrcode == 11000 ); /* But it will succeed without the write concern set. */ ASSERT( mongo_insert_batch( conn, TEST_NS, (const bson **)objs, 2, NULL, 0 ) == MONGO_OK ); bson_destroy( b ); bson_destroy( b2 ); bson_destroy( b3 ); bson_destroy( b4 ); mongo_write_concern_destroy( wc0 ); mongo_write_concern_destroy( wc1 ); }
int main(int argc, char **argv) { bson b, sub; bson_iterator it; /* 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 ); bson_finish( &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 */ bson_print( &sub ); bson_destroy( &b ); return 0; }
int flush_to_mongo(st_http_request * p, int counter) { mongo conn; mongo_init(&conn); mongo_set_op_timeout(&conn, 10000); int status = mongo_client(&conn, globalArgs.host, globalArgs.port); if (status != MONGO_OK) { switch (conn.err) { case MONGO_CONN_SUCCESS: printf("Connected to mongo\n"); case MONGO_CONN_NO_SOCKET: printf("FAIL: Could not create a socket!\n"); break; case MONGO_CONN_ADDR_FAIL: printf("FAIL: MONGO_CONN_ADDR_FAIL: %s\n", globalArgs.host); break; case MONGO_CONN_NOT_MASTER: printf("FAIL: MONGO_CONN_NOT_MASTER\n"); break; case MONGO_CONN_BAD_SET_NAME: printf("FAIL: MONGO_CONN_BAD_SET_NAME\n"); break; case MONGO_CONN_NO_PRIMARY: printf("FAIL: MONGO_CONN_NO_PRIMARY\n"); break; case MONGO_IO_ERROR: printf("FAIL: MONGO_IO_ERROR\n"); break; case MONGO_SOCKET_ERROR: printf("FAIL: MONGO_SOCKET_ERROR\n"); break; case MONGO_READ_SIZE_ERROR: printf("FAIL: MONGO_READ_SIZE_ERROR\n"); break; case MONGO_COMMAND_FAILED: printf("FAIL: MONGO_COMMAND_FAILED\n"); break; case MONGO_WRITE_ERROR: printf("FAIL: MONGO_WRITE_ERROR\n"); break; case MONGO_NS_INVALID: printf("FAIL: MONGO_NS_INVALID\n"); break; case MONGO_BSON_INVALID: printf("FAIL: MONGO_BSON_INVALIDr\n"); break; case MONGO_BSON_NOT_FINISHED: printf("FAIL: MONGO_BSON_NOT_FINISHED\n"); break; case MONGO_BSON_TOO_LARGE: printf("FAIL: MONGO_BSON_TOO_LARGEr\n"); break; case MONGO_WRITE_CONCERN_INVALID: printf("FAIL: Mongo write concern invalid\n"); break; case MONGO_CONN_FAIL: printf ("FAIL: Mongo connection fail. Make sure it's listening at %s:%d\n", globalArgs.host, globalArgs.port); break; } exit(EXIT_FAILURE); } bson **bps; bps = (bson **) malloc(sizeof(bson *) * counter); char *fields = globalArgs.fields; int i = 0; for (i = 0; i < counter; i++) { bson *bp = (bson *) malloc(sizeof(bson)); bson_init(bp); bson_append_new_oid(bp, "_id"); if (fields == NULL || strstr(fields, "req_ip") != NULL) bson_append_string(bp, "req_ip", p[i].req_ip); if (fields == NULL || strstr(fields, "req_ident") != NULL) bson_append_string(bp, "req_ident", p[i].req_ident); if (fields == NULL || strstr(fields, "req_user") != NULL) bson_append_string(bp, "req_user", p[i].req_user); if (fields == NULL || strstr(fields, "req_datetime") != NULL) bson_append_string(bp, "req_datetime", p[i].req_datetime); if (fields == NULL || strstr(fields, "req_method") != NULL) bson_append_string(bp, "req_method", p[i].req_method); if (fields == NULL || strstr(fields, "req_uri") != NULL) bson_append_string(bp, "req_uri", p[i].req_uri); if (fields == NULL || strstr(fields, "req_proto") != NULL) bson_append_string(bp, "req_proto", p[i].req_proto); if (fields == NULL || strstr(fields, "resp_code") != NULL) bson_append_int(bp, "resp_code", p[i].resp_code); if (fields == NULL || strstr(fields, "resp_bytes") != NULL) bson_append_int(bp, "resp_bytes", atoi(p[i].resp_bytes)); if (fields == NULL || strstr(fields, "req_referer") != NULL) bson_append_string(bp, "req_referer", p[i].req_referer); if (fields == NULL || strstr(fields, "req_agent") != NULL) bson_append_string(bp, "req_agent", p[i].req_agent); bson_finish(bp); bps[i] = bp; } mongo_insert_batch(&conn, globalArgs.collection, (const bson **) bps, counter, 0, MONGO_CONTINUE_ON_ERROR); mongo_destroy(&conn); int j = 0; for (j = 0; j < counter; j++) { bson_destroy(bps[j]); free(bps[j]); } free(bps); return (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; }