/* 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;
}
