int test_connect_deprecated( const char *set_name ) {
mongo conn[1];
int res;
INIT_SOCKETS_FOR_WINDOWS;
mongo_replset_init( conn, set_name );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT + 1 );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT );
res = mongo_replset_connect( conn );
/* mongo_replset_connect should print a warning to stderr that it is deprecated */
ASSERT( conn->write_concern == (void*)0 ); /* write_concern should be 0 for backwards compatibility */
if( res != MONGO_OK ) {
res = conn->err;
return res;
}
ASSERT( conn->primary->port == SEED_START_PORT ||
conn->primary->port == SEED_START_PORT + 1 ||
conn->primary->port == SEED_START_PORT + 2 );
mongo_destroy( conn );
return res;
}
int test_connect( const char *set_name ) {
mongo conn[1];
int res;
INIT_SOCKETS_FOR_WINDOWS;
mongo_replset_init( conn, set_name );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT + 1 );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT );
res = mongo_replset_connect( conn );
if( res != MONGO_OK ) {
res = conn->err;
return res;
}
ASSERT( conn->primary->port == SEED_START_PORT ||
conn->primary->port == SEED_START_PORT + 1 ||
conn->primary->port == SEED_START_PORT + 2 );
mongo_destroy( conn );
return res;
}
int test_insert_limits( const char *set_name ) {
char version[10];
mongo conn[1];
mongo_write_concern wc[1];
int i;
char key[10];
int res = 0;
bson b[1], b2[1];
bson *objs[2];
mongo_write_concern_init( wc );
wc->w = 1;
mongo_write_concern_finish( wc );
/* We'll perform the full test if we're running v2.0 or later. */
if( mongo_get_server_version( version ) != -1 && version[0] <= '1' )
return 0;
mongo_replset_init( conn, set_name );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT + 1 );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT );
res = mongo_replset_connect( conn );
if( res != MONGO_OK ) {
res = conn->err;
return res;
}
ASSERT( conn->max_bson_size > MONGO_DEFAULT_MAX_BSON_SIZE );
bson_init( b );
for(i=0; i<1200000; i++) {
sprintf( key, "%d", i + 10000000 );
bson_append_int( b, key, i );
}
bson_finish( b );
ASSERT( bson_size( b ) > conn->max_bson_size );
ASSERT( mongo_insert( conn, "test.foo", b, wc ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_BSON_TOO_LARGE );
mongo_clear_errors( conn );
ASSERT( conn->err == 0 );
bson_init( b2 );
bson_append_int( b2, "foo", 1 );
bson_finish( b2 );
objs[0] = b;
objs[1] = b2;
ASSERT( mongo_insert_batch( conn, "test.foo", (const bson**)objs, 2, wc, 0 ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_BSON_TOO_LARGE );
mongo_write_concern_destroy( wc );
return 0;
}
SEXP rmongo_connect(SEXP mongo_conn) {
mongo* conn = _checkMongo(mongo_conn);
mongo_host_port hp;
SEXP host = getAttrib(mongo_conn, sym_host);
int len = LENGTH(host);
int i;
if (len == 0)
error("No hosts defined\n");
const char* name = CHAR(STRING_ELT(getAttrib(mongo_conn, sym_name), 0));
if (name[0] == '\0') {
for (i = 0; i < len; i++) {
mongo_parse_host(CHAR(STRING_ELT(host, i)), &hp);
if (mongo_connect(conn, hp.host, hp.port) == MONGO_OK)
break;
}
if (i == len) {
if (len == 1)
Rprintf("Unable to connect to %s:%d, error code = %d\n", hp.host, hp.port, conn->err);
else
Rprintf("Unable to connect to any of the given hosts, error code = %d\n", conn->err);
return mongo_conn;
}
}
else {
mongo_replset_init(conn, name);
for (i = 0; i < len; i++) {
mongo_parse_host(CHAR(STRING_ELT(host, i)), &hp);
mongo_replset_add_seed(conn, hp.host, hp.port);
}
if (mongo_replset_connect(conn) != MONGO_OK)
Rprintf("Unable to connect to replset\n");
}
int timeout = asInteger(getAttrib(mongo_conn, sym_timeout));
if (timeout > 0)
mongo_set_op_timeout(conn, timeout);
SEXP username = getAttrib(mongo_conn, sym_username);
if (CHAR(STRING_ELT(username, 0))[0] != '\0') {
SEXP password = getAttrib(mongo_conn, install("password"));
SEXP db = getAttrib(mongo_conn, install("db"));
SEXP ret = mongo_authenticate(mongo_conn, username, password, db);
if (!LOGICAL(ret)[0]) {
mongo_disconnect(conn);
Rprintf("Authentication failed.\n");
}
}
return mongo_conn;
}
int test_reconnect( const char *set_name ) {
mongo conn[1];
int res = 0;
int e = 0;
bson b;
INIT_SOCKETS_FOR_WINDOWS;
mongo_replset_init( conn, set_name );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT );
mongo_replset_add_seed( conn, TEST_SERVER, SEED_START_PORT + 1 );
if( ( mongo_replset_connect( conn ) != MONGO_OK ) ) {
mongo_destroy( conn );
return MONGO_ERROR;
} else {
fprintf( stderr, "Disconnect now:\n" );
sleep( 10 );
e = 1;
do {
res = mongo_find_one( conn, "foo.bar", bson_empty( &b ), bson_empty( &b ), NULL );
if( res == MONGO_ERROR && conn->err == MONGO_IO_ERROR ) {
sleep( 2 );
if( e++ < 30 ) {
fprintf( stderr, "Attempting reconnect %d.\n", e );
mongo_reconnect( conn );
} else {
fprintf( stderr, "Fail.\n" );
return -1;
}
}
} while( 1 );
}
return 0;
}
static ngx_int_t ngx_http_mongo_add_connection(ngx_cycle_t* cycle, ngx_http_gridfs_loc_conf_t* gridfs_loc_conf) {
ngx_http_mongo_connection_t* mongo_conn;
int status;
ngx_http_mongod_server_t *mongods;
volatile ngx_uint_t i;
u_char host[255];
mongods = gridfs_loc_conf->mongods->elts;
mongo_conn = ngx_http_get_mongo_connection( gridfs_loc_conf->mongo );
if (mongo_conn != NULL) {
return NGX_OK;
}
mongo_conn = ngx_array_push(&ngx_http_mongo_connections);
if (mongo_conn == NULL) {
return NGX_ERROR;
}
mongo_conn->name = gridfs_loc_conf->mongo;
mongo_conn->auths = ngx_array_create(cycle->pool, 4, sizeof(ngx_http_mongo_auth_t));
if ( gridfs_loc_conf->mongods->nelts == 1 ) {
ngx_cpystrn( host, mongods[0].host.data, mongods[0].host.len + 1 );
status = mongo_connect( &mongo_conn->conn, (const char*)host, mongods[0].port );
} else if ( gridfs_loc_conf->mongods->nelts >= 2 && gridfs_loc_conf->mongods->nelts < 9 ) {
/* Initiate replica set connection. */
mongo_replset_init( &mongo_conn->conn, (const char *)gridfs_loc_conf->replset.data );
/* Add replica set seeds. */
for( i=0; i<gridfs_loc_conf->mongods->nelts; ++i ) {
ngx_cpystrn( host, mongods[i].host.data, mongods[i].host.len + 1 );
mongo_replset_add_seed( &mongo_conn->conn, (const char *)host, mongods[i].port );
}
status = mongo_replset_connect( &mongo_conn->conn );
} else {
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Nginx Exception: Too many strings provided in 'mongo' directive.");
return NGX_ERROR;
}
switch (status) {
case MONGO_CONN_SUCCESS:
break;
case MONGO_CONN_NO_SOCKET:
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Exception: No Socket");
return NGX_ERROR;
case MONGO_CONN_FAIL:
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Exception: Connection Failure.");
return NGX_ERROR;
case MONGO_CONN_ADDR_FAIL:
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Exception: getaddrinfo Failure.");
return NGX_ERROR;
case MONGO_CONN_NOT_MASTER:
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Exception: Not Master");
return NGX_ERROR;
case MONGO_CONN_BAD_SET_NAME:
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Exception: Replica set name %s does not match.", gridfs_loc_conf->replset.data);
return NGX_ERROR;
case MONGO_CONN_NO_PRIMARY:
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Exception: Cannot connect to primary node.");
return NGX_ERROR;
default:
ngx_log_error(NGX_LOG_ERR, cycle->log, 0,
"Mongo Exception: Unknown Error");
return NGX_ERROR;
}
return NGX_OK;
}
result_t MongoDB::open(exlib::string connString)
{
assert(!Isolate::check());
obj_ptr<Url> u = new Url();
int32_t result;
int32_t nPort;
result_t hr = u->parse(connString);
if (hr < 0)
return hr;
if (qstrchr(u->m_host.c_str(), ','))
{
const char *host = u->m_host.c_str();
mongo_replset_init(&m_conn, "");
while (true)
{
exlib::string hostname;
exlib::string port;
Url::parseHost(host, hostname, port);
nPort = 27017;
if (!port.empty())
nPort = atoi(port.c_str());
mongo_replset_add_seed(&m_conn, hostname.c_str(), nPort);
if (*host != ',')
break;
host++;
}
result = mongo_replset_connect(&m_conn);
}
else
{
nPort = 27017;
if (!u->m_port.empty())
nPort = atoi(u->m_port.c_str());
mongo_init(&m_conn);
result = mongo_client(&m_conn, u->m_hostname.c_str(), nPort);
}
if (result != MONGO_OK)
return CHECK_ERROR(error());
if (!u->m_pathname.empty())
m_ns = u->m_pathname.substr(1);
if (!u->m_username.empty())
if (mongo_cmd_authenticate(&m_conn, m_ns.c_str(), u->m_username.c_str(),
u->m_password.c_str()) != MONGO_OK)
return CHECK_ERROR(error());
return 0;
}