static void time_it( nullary func, const char *name, bson_bool_t gle ) {
double timer;
double ops;
#ifdef _WIN32
int64_t start, end;
start = GetTickCount64();
func();
if ( gle ) ASSERT( !mongo_cmd_get_last_error( conn, DB, NULL ) );
end = GetTickCount64();
timer = end - start;
#else
struct timeval start, end;
gettimeofday( &start, NULL );
func();
if ( gle ) ASSERT( !mongo_cmd_get_last_error( conn, DB, NULL ) );
gettimeofday( &end, NULL );
timer = end.tv_sec - start.tv_sec;
timer *= 1000000;
timer += end.tv_usec - start.tv_usec;
#endif
ops = PER_TRIAL / timer;
ops *= 1000000;
printf( "%-45s\t%15f\n", name, ops );
}
static void clean( void ) {
bson b;
if ( mongo_cmd_drop_db( conn, DB ) != MONGO_OK ) {
printf( "failed to drop db\n" );
exit( 1 );
}
/* create the db */
mongo_insert( conn, DB ".creation", bson_shared_empty(), NULL );
ASSERT( !mongo_cmd_get_last_error( conn, DB, NULL ) );
}
static void clean(){
bson b;
if (!mongo_cmd_drop_db(conn, DB)){
printf("failed to drop db\n");
exit(1);
}
/* create the db */
mongo_insert(conn, DB ".creation", bson_empty(&b));
ASSERT(!mongo_cmd_get_last_error(conn, DB, NULL));
}
QVariantMap TMongoDriver::getLastCommandStatus(const QString &db)
{
QVariantMap ret;
bson bs;
memset(&bs, 0, sizeof(bs));
if (mongo_cmd_get_last_error(mongoConnection, qPrintable(db), &bs) == MONGO_OK) {
ret = TBson::fromBson((TBsonObject *)&bs);
}
bson_destroy(&bs);
return ret;
}
SEXP mongo_get_last_err(SEXP mongo_conn, SEXP db) {
mongo* conn = _checkMongo(mongo_conn);
const char* _db = CHAR(STRING_ELT(db, 0));
bson out;
if (mongo_cmd_get_last_error(conn, _db, &out) == MONGO_OK) {
bson_destroy(&out);
return R_NilValue;
}
SEXP ret = _mongo_bson_create(&out);
bson_destroy(&out);
UNPROTECT(3);
return ret;
}
static ngx_int_t ngx_http_mongo_authenticate(ngx_log_t *log, ngx_http_gridfs_loc_conf_t *gridfs_loc_conf) {
ngx_http_mongo_connection_t* mongo_conn;
ngx_http_mongo_auth_t *mongo_auth;
mongo_cursor *cursor = NULL;
bson empty;
char *test;
int error;
mongo_conn = ngx_http_get_mongo_connection( gridfs_loc_conf->mongo );
if (mongo_conn == NULL) {
ngx_log_error(NGX_LOG_ERR, log, 0,
"Mongo Connection not found: \"%V\"", &gridfs_loc_conf->mongo);
}
// Authenticate
if (gridfs_loc_conf->user.data != NULL && gridfs_loc_conf->pass.data != NULL) {
if (mongo_cmd_authenticate( &mongo_conn->conn,
(const char*)gridfs_loc_conf->db.data,
(const char*)gridfs_loc_conf->user.data,
(const char*)gridfs_loc_conf->pass.data )
!= MONGO_OK) {
ngx_log_error(NGX_LOG_ERR, log, 0,
"Invalid mongo user/pass: %s/%s",
gridfs_loc_conf->user.data,
gridfs_loc_conf->pass.data);
return NGX_ERROR;
}
mongo_auth = ngx_array_push(mongo_conn->auths);
mongo_auth->db = gridfs_loc_conf->db;
mongo_auth->user = gridfs_loc_conf->user;
mongo_auth->pass = gridfs_loc_conf->pass;
}
// Run a test command to test authentication.
test = (char*)malloc( gridfs_loc_conf->db.len + sizeof(".test"));
ngx_cpystrn((u_char*)test, (u_char*)gridfs_loc_conf->db.data, gridfs_loc_conf->db.len+1);
ngx_cpystrn((u_char*)(test+gridfs_loc_conf->db.len),(u_char*)".test", sizeof(".test"));
bson_empty(&empty);
cursor = mongo_find(&mongo_conn->conn, test, &empty, NULL, 0, 0, 0);
error = mongo_cmd_get_last_error(&mongo_conn->conn, (char*)gridfs_loc_conf->db.data, NULL);
free(test);
mongo_cursor_destroy(cursor);
if (error) {
ngx_log_error(NGX_LOG_ERR, log, 0, "Authentication Required");
return NGX_ERROR;
}
return NGX_OK;
}
int mongo_create_index(mongo_connection * conn, const char * ns, bson * key, int options, bson * out){
bson_buffer bb;
bson b;
bson_iterator it;
char name[255] = {'_'};
int i = 1;
char idxns[1024];
bson_iterator_init(&it, key->data);
while(i < 255 && bson_iterator_next(&it)){
strncpy(name + i, bson_iterator_key(&it), 255 - i);
i += strlen(bson_iterator_key(&it));
}
name[254] = '\0';
bson_buffer_init(&bb);
bson_append_bson(&bb, "key", key);
bson_append_string(&bb, "ns", ns);
bson_append_string(&bb, "name", name);
if (options & MONGO_INDEX_UNIQUE)
bson_append_bool(&bb, "unique", 1);
if (options & MONGO_INDEX_DROP_DUPS)
bson_append_bool(&bb, "dropDups", 1);
if (options & MONGO_INDEX_BACKGROUND)
bson_append_bool(&bb, "background", 1);
if (options & MONGO_INDEX_SPARSE)
bson_append_bool(&bb, "sparse", 1);
bson_from_buffer(&b, &bb);
strncpy(idxns, ns, 1024-16);
strcpy(strchr(idxns, '.'), ".system.indexes");
mongo_insert(conn, idxns, &b);
bson_destroy(&b);
*strchr(idxns, '.') = '\0'; /* just db not ns */
return mongo_cmd_get_last_error(conn, idxns, out);
}
int main(){
bson obj;
INIT_SOCKETS_FOR_WINDOWS;
if (mongo_connect( conn , TEST_SERVER, 27017 )){
printf("failed to connect\n");
exit(1);
}
/*********************/
ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_OK);
ASSERT( conn->lasterrcode == 0 );
ASSERT( conn->lasterrstr == NULL );
ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_OK);
ASSERT( conn->lasterrcode == 0 );
ASSERT( conn->lasterrstr == NULL );
ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_OK);
bson_destroy(&obj);
ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_OK);
bson_destroy(&obj);
/*********************/
mongo_simple_int_command(conn, db, "forceerror", 1, NULL);
ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_ERROR);
ASSERT( conn->lasterrcode == 10038 );
ASSERT( strcmp( (const char*)conn->lasterrstr, "forced error" ) == 0 );
ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_ERROR);
ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_ERROR);
bson_destroy(&obj);
ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_ERROR);
bson_destroy(&obj);
/* should clear lasterror but not preverror */
mongo_find_one(conn, ns, bson_empty(&obj), bson_empty(&obj), NULL);
ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_ERROR);
ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_OK);
ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_ERROR);
bson_destroy(&obj);
ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_OK);
bson_destroy(&obj);
/*********************/
mongo_cmd_reset_error(conn, db);
ASSERT(mongo_cmd_get_prev_error(conn, db, NULL) == MONGO_OK);
ASSERT(mongo_cmd_get_last_error(conn, db, NULL) == MONGO_OK);
ASSERT(mongo_cmd_get_prev_error(conn, db, &obj) == MONGO_OK);
bson_destroy(&obj);
ASSERT(mongo_cmd_get_last_error(conn, db, &obj) == MONGO_OK);
bson_destroy(&obj);
mongo_cmd_drop_db(conn, db);
mongo_destroy(conn);
return 0;
}
int main(){
bson obj;
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);
}
/*********************/
ASSERT(!mongo_cmd_get_prev_error(conn, db, NULL));
ASSERT(!mongo_cmd_get_last_error(conn, db, NULL));
ASSERT(!mongo_cmd_get_prev_error(conn, db, &obj));
bson_destroy(&obj);
ASSERT(!mongo_cmd_get_last_error(conn, db, &obj));
bson_destroy(&obj);
/*********************/
mongo_simple_int_command(conn, db, "forceerror", 1, NULL);
ASSERT(mongo_cmd_get_prev_error(conn, db, NULL));
ASSERT(mongo_cmd_get_last_error(conn, db, NULL));
ASSERT(mongo_cmd_get_prev_error(conn, db, &obj));
bson_destroy(&obj);
ASSERT(mongo_cmd_get_last_error(conn, db, &obj));
bson_destroy(&obj);
/* should clear lasterror but not preverror */
mongo_find_one(conn, ns, bson_empty(&obj), bson_empty(&obj), NULL);
ASSERT(mongo_cmd_get_prev_error(conn, db, NULL));
ASSERT(!mongo_cmd_get_last_error(conn, db, NULL));
ASSERT(mongo_cmd_get_prev_error(conn, db, &obj));
bson_destroy(&obj);
ASSERT(!mongo_cmd_get_last_error(conn, db, &obj));
bson_destroy(&obj);
/*********************/
mongo_cmd_reset_error(conn, db);
ASSERT(!mongo_cmd_get_prev_error(conn, db, NULL));
ASSERT(!mongo_cmd_get_last_error(conn, db, NULL));
ASSERT(!mongo_cmd_get_prev_error(conn, db, &obj));
bson_destroy(&obj);
ASSERT(!mongo_cmd_get_last_error(conn, db, &obj));
bson_destroy(&obj);
return 0;
}
static ngx_int_t ngx_http_gridfs_mongod_connect(ngx_conf_t* directive, ngx_http_gridfs_loc_conf_t* gridfs_conf) {
mongo_connection_options options;
bson empty;
bson_bool_t error;
char* test;
if (gridfs_conf->mongod_conn->connected) {
ngx_conf_log_error(NGX_LOG_ERR, directive, 0,
"Mongo Connection is duplicate");
return NGX_ERROR;
}
/* Connect to a mongod */
ngx_cpystrn( (u_char*)options.host,
gridfs_conf->mongod_host.data,
gridfs_conf->mongod_host.len + 1 );
options.port = gridfs_conf->mongod_port;
switch (mongo_connect( gridfs_conf->mongod_conn, &options )) {
case mongo_conn_success:
break;
case mongo_conn_bad_arg:
ngx_conf_log_error(NGX_LOG_ERR, directive, 0,
"Mongo Exception: Bad Arguments");
return NGX_ERROR;
case mongo_conn_no_socket:
ngx_conf_log_error(NGX_LOG_ERR, directive, 0,
"Mongo Exception: No Socket");
return NGX_ERROR;
case mongo_conn_fail:
ngx_conf_log_error(NGX_LOG_ERR, directive, 0,
"Mongo Exception: Connection Failure %s:%i;",
options.host,options.port/*
gridfs_conf->mongod_port*/);
return NGX_ERROR;
case mongo_conn_not_master:
ngx_conf_log_error(NGX_LOG_ERR, directive, 0,
"Mongo Exception: Not Master");
return NGX_ERROR;
default:
ngx_conf_log_error(NGX_LOG_ERR, directive, 0,
"Mongo Exception: Unknown Error");
return NGX_ERROR;
}
/* Authenticate with the user and password */
if (gridfs_conf->mongod_user.data != NULL && gridfs_conf->mongod_pass.data != NULL) {
if (!mongo_cmd_authenticate(gridfs_conf->mongod_conn,
(const char*)gridfs_conf->gridfs_db.data,
(const char*)gridfs_conf->mongod_user.data,
(const char*)gridfs_conf->mongod_pass.data)) {
ngx_conf_log_error(NGX_LOG_ERR, directive, 0,
"Invalid mongo user/pass: %s/%s",
gridfs_conf->mongod_user.data,
gridfs_conf->mongod_pass.data);
return NGX_ERROR;
}
}
/* Run a test command to test authentication. */
test = (char*)malloc( gridfs_conf->gridfs_db.len + sizeof(".test"));
ngx_cpystrn((u_char*)test, (u_char*)gridfs_conf->gridfs_db.data, gridfs_conf->gridfs_db.len+1);
ngx_cpystrn((u_char*)(test+gridfs_conf->gridfs_db.len),(u_char*)".test", sizeof(".test"));
bson_empty(&empty);
mongo_find(gridfs_conf->mongod_conn, test, &empty, NULL, 0, 0, 0);
error = mongo_cmd_get_last_error(gridfs_conf->mongod_conn, (char*)gridfs_conf->gridfs_db.data, NULL);
free(test);
if (error) {
ngx_conf_log_error(NGX_LOG_ERR, directive, 0, "Authentication Required");
return NGX_ERROR;
}
return NGX_OK;
}
