MongodbClientInternalData()
{
connection = new mongo();
DVASSERT(connection);
Memset(connection, 0, sizeof(mongo));
mongo_init(connection);
}
MONGO_EXPORT void mongo_replset_init( mongo *conn, const char *name ) {
mongo_init( conn );
conn->replset = bson_malloc( sizeof( mongo_replset ) );
conn->replset->primary_connected = 0;
conn->replset->seeds = NULL;
conn->replset->hosts = NULL;
conn->replset->name = ( char * )bson_malloc( strlen( name ) + 1 );
memcpy( conn->replset->name, name, strlen( name ) + 1 );
conn->primary = bson_malloc( sizeof( mongo_host_port ) );
}
int test_insert_limits( void ) {
char version[10];
mongo conn[1];
int i;
char key[10];
bson b[1], b2[1];
bson *objs[2];
/* Test the default max BSON size. */
mongo_init( conn );
ASSERT( conn->max_bson_size == MONGO_DEFAULT_MAX_BSON_SIZE );
/* 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;
if ( mongo_connect( conn , TEST_SERVER, 27017 ) ) {
printf( "failed to connect\n" );
exit( 1 );
}
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, NULL ) == 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,
NULL, 0 ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_BSON_TOO_LARGE );
return 0;
}
int test_error_messages( void ) {
mongo conn[1];
bson b[1];
const char *ns = "test.foo";
mongo_init( conn );
bson_init( b );
bson_append_int( b, "foo", 17 );
bson_finish( b );
ASSERT( mongo_insert( conn, ns, b, NULL ) != MONGO_OK );
ASSERT( conn->err == MONGO_IO_ERROR );
ASSERT( conn->errcode == WSAENOTSOCK );
mongo_init( conn );
ASSERT( mongo_count( conn, "test", "foo", NULL ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_IO_ERROR );
ASSERT( conn->errcode == WSAENOTSOCK );
return 0;
}
int mongo_connect( mongo *conn , const char *host, int port ) {
conn->primary = bson_malloc( sizeof( mongo_host_port ) );
strncpy( conn->primary->host, host, strlen( host ) + 1 );
conn->primary->port = port;
conn->primary->next = NULL;
mongo_init( conn );
if( mongo_socket_connect( conn, host, port ) != MONGO_OK )
return MONGO_ERROR;
if( mongo_check_is_master( conn ) != MONGO_OK )
return MONGO_ERROR;
else
return MONGO_OK;
}
int main() {
/*
* We assume objects in the form of {_id:<any_id>, list:[{a:<int>,b:<int>}, ...]}
*/
mongo conn[1];
mongo_init(conn);
if(MONGO_OK != mongo_client(conn, "127.0.0.1", 27017))
return 1;
bson b[1], b_result[1];
/*create the aggregation command in bson*/
bson_init(b);
bson_append_string(b, "aggregate", "agg");
bson_append_start_array(b, "pipeline");
bson_append_start_object(b,"0");
bson_append_string(b, "$unwind", "$list");
bson_append_finish_object(b);
bson_append_start_object(b,"1");
bson_append_start_object(b,"$group");
bson_append_string(b,"_id", "$list");
bson_append_start_object(b, "distinct_count");
bson_append_int(b, "$sum", 1);
bson_append_finish_object(b);
bson_append_finish_object(b);
bson_append_finish_object(b);
bson_append_finish_array(b);
bson_finish(b);
/*So you can see your command*/
bson_print(b);
/*run the command*/
mongo_run_command(conn, "test", b, b_result);
/*command results*/
bson_print(b_result);
bson_destroy(b_result);
bson_destroy(b);
mongo_destroy(conn);
return 0;
}
TMongoDriver::TMongoDriver()
: mongoConnection(new mongo), mongoCursor(new TMongoCursor())
{
mongo_init(mongoConnection);
}
/* {{{ PHP_GINIT_FUNCTION
*/
static PHP_GINIT_FUNCTION(mongo)
{
/* On windows, the max length is 256. Linux doesn't have a limit, but it
* will fill in the first 256 chars of hostname even if the actual
* hostname is longer. If you can't get a unique character in the first
* 256 chars of your hostname, you're doing it wrong. */
int len, win_max = 256;
char *hostname, host_start[256];
register ulong hash;
mongo_globals->default_host = "localhost";
mongo_globals->default_port = 27017;
mongo_globals->request_id = 3;
mongo_globals->chunk_size = DEFAULT_CHUNK_SIZE;
mongo_globals->cmd_char = "$";
mongo_globals->inc = 0;
mongo_globals->response_num = 0;
mongo_globals->errmsg = 0;
mongo_globals->pool_size = -1;
hostname = host_start;
/* from the gnu manual:
* gethostname stores the beginning of the host name in name even if the
* host name won't entirely fit. For some purposes, a truncated host name
* is good enough. If it is, you can ignore the error code.
* So we'll ignore the error code.
* Returns 0-terminated hostname. */
gethostname(hostname, win_max);
len = strlen(hostname);
hash = 5381;
/* from zend_hash.h */
/* variant with the hash unrolled eight times */
for (; len >= 8; len -= 8) {
hash = ((hash << 5) + hash) + *hostname++;
hash = ((hash << 5) + hash) + *hostname++;
hash = ((hash << 5) + hash) + *hostname++;
hash = ((hash << 5) + hash) + *hostname++;
hash = ((hash << 5) + hash) + *hostname++;
hash = ((hash << 5) + hash) + *hostname++;
hash = ((hash << 5) + hash) + *hostname++;
hash = ((hash << 5) + hash) + *hostname++;
}
switch (len) {
case 7: hash = ((hash << 5) + hash) + *hostname++; /* fallthrough... */
case 6: hash = ((hash << 5) + hash) + *hostname++; /* fallthrough... */
case 5: hash = ((hash << 5) + hash) + *hostname++; /* fallthrough... */
case 4: hash = ((hash << 5) + hash) + *hostname++; /* fallthrough... */
case 3: hash = ((hash << 5) + hash) + *hostname++; /* fallthrough... */
case 2: hash = ((hash << 5) + hash) + *hostname++; /* fallthrough... */
case 1: hash = ((hash << 5) + hash) + *hostname++; break;
case 0: break;
}
mongo_globals->machine = hash;
mongo_globals->ts_inc = 0;
#if PHP_VERSION_ID >= 50300
mongo_globals->log_callback_info = empty_fcall_info;
mongo_globals->log_callback_info_cache = empty_fcall_info_cache;
#endif
mongo_globals->manager = mongo_init();
TSRMLS_SET_CTX(mongo_globals->manager->log_context);
mongo_globals->manager->log_function = php_mcon_log_wrapper;
#if MONGO_PHP_STREAMS
mongo_globals->manager->connect = php_mongo_io_stream_connect;
mongo_globals->manager->recv_header = php_mongo_io_stream_read;
mongo_globals->manager->recv_data = php_mongo_io_stream_read;
mongo_globals->manager->send = php_mongo_io_stream_send;
mongo_globals->manager->close = php_mongo_io_stream_close;
mongo_globals->manager->forget = php_mongo_io_stream_forget;
#endif
}
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;
}
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;
}
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);
}
/**
* \brief This function tries to connect to MongoDB server
*/
int vs_mongo_conn_init(struct VS_CTX *vs_ctx)
{
int status;
vs_ctx->mongo_conn = mongo_alloc();
mongo_init(vs_ctx->mongo_conn);
/* Set connection timeout */
mongo_set_op_timeout(vs_ctx->mongo_conn, 1000);
/* Connect to MongoDB server */
status = mongo_client(vs_ctx->mongo_conn,
vs_ctx->mongodb_server, vs_ctx->mongodb_port);
if( status != MONGO_OK ) {
switch ( vs_ctx->mongo_conn->err ) {
case MONGO_CONN_NO_SOCKET:
v_print_log(VRS_PRINT_ERROR,
"No MongoDB server %s:%d socket\n",
vs_ctx->mongodb_server, vs_ctx->mongodb_port);
break;
case MONGO_CONN_FAIL:
v_print_log(VRS_PRINT_ERROR,
"Connection to MongoDB server %s:%d failed\n",
vs_ctx->mongodb_server, vs_ctx->mongodb_port);
break;
case MONGO_CONN_NOT_MASTER:
v_print_log(VRS_PRINT_ERROR,
"MongoDB server %s:%d is not master\n",
vs_ctx->mongodb_server, vs_ctx->mongodb_port);
break;
default:
v_print_log(VRS_PRINT_ERROR,
"Failed to connect to MongoDB server %s:%d , error: %d\n",
vs_ctx->mongodb_server, vs_ctx->mongodb_port,
vs_ctx->mongo_conn->err);
break;
}
mongo_dealloc(vs_ctx->mongo_conn);
vs_ctx->mongo_conn = NULL;
return 0;
}
v_print_log(VRS_PRINT_DEBUG_MSG,
"Connection to MongoDB server %s:%d succeeded\n",
vs_ctx->mongodb_server, vs_ctx->mongodb_port);
/* There has to be some db name defined */
if(vs_ctx->mongodb_db_name == NULL) {
v_print_log(VRS_PRINT_ERROR,
"No database name defined\n");
mongo_dealloc(vs_ctx->mongo_conn);
vs_ctx->mongo_conn = NULL;
return 0;
}
/* Try to do when authentication is configured */
if(vs_ctx->mongodb_user != NULL &&
vs_ctx->mongodb_pass != NULL)
{
status = mongo_cmd_authenticate(vs_ctx->mongo_conn,
vs_ctx->mongodb_db_name,
vs_ctx->mongodb_user,
vs_ctx->mongodb_pass);
if(status != MONGO_OK) {
v_print_log(VRS_PRINT_ERROR,
"Authentication to %s database failed, error: %s\n",
vs_ctx->mongodb_db_name,
mongo_get_server_err_string(vs_ctx->mongo_conn));
mongo_dealloc(vs_ctx->mongo_conn);
vs_ctx->mongo_conn = NULL;
return 0;
}
v_print_log(VRS_PRINT_DEBUG_MSG,
"Authentication to %s database succeeded\n",
vs_ctx->mongodb_db_name);
} else {
v_print_log(VRS_PRINT_DEBUG_MSG,
"No MongoDB authentication required\n");
}
/* Namespace used for storing nodes */
vs_ctx->mongo_node_ns = (char*)malloc(sizeof(char) * (strlen(vs_ctx->mongodb_db_name) + 6 + 1));
strcpy(vs_ctx->mongo_node_ns, vs_ctx->mongodb_db_name);
strcat(vs_ctx->mongo_node_ns, ".nodes");
/* Namespace used for storing tag groups and tags */
vs_ctx->mongo_tg_ns = (char*)malloc(sizeof(char) * (strlen(vs_ctx->mongodb_db_name) + 11 + 1));
strcpy(vs_ctx->mongo_tg_ns, vs_ctx->mongodb_db_name);
strcat(vs_ctx->mongo_tg_ns, ".tag_groups");
/* Namespace used for storing layers */
vs_ctx->mongo_layer_ns = (char*)malloc(sizeof(char) * (strlen(vs_ctx->mongodb_db_name) + 7 + 1));
strcpy(vs_ctx->mongo_layer_ns, vs_ctx->mongodb_db_name);
strcat(vs_ctx->mongo_layer_ns, ".layers");
return 1;
}
static int wm_config_node (oconfig_item_t *ci) /* {{{ */
{
wm_node_t *node;
int status;
node = calloc (1, sizeof (*node));
if (node == NULL)
return (ENOMEM);
mongo_init (node->conn);
node->host = NULL;
node->store_rates = 1;
pthread_mutex_init (&node->lock, /* attr = */ NULL);
status = cf_util_get_string_buffer (ci, node->name, sizeof (node->name));
if (status != 0)
{
sfree (node);
return (status);
}
for (int i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Host", child->key) == 0)
status = cf_util_get_string (child, &node->host);
else if (strcasecmp ("Port", child->key) == 0)
{
status = cf_util_get_port_number (child);
if (status > 0)
{
node->port = status;
status = 0;
}
}
else if (strcasecmp ("Timeout", child->key) == 0)
status = cf_util_get_int (child, &node->timeout);
else if (strcasecmp ("StoreRates", child->key) == 0)
status = cf_util_get_boolean (child, &node->store_rates);
else if (strcasecmp ("Database", child->key) == 0)
status = cf_util_get_string (child, &node->db);
else if (strcasecmp ("User", child->key) == 0)
status = cf_util_get_string (child, &node->user);
else if (strcasecmp ("Password", child->key) == 0)
status = cf_util_get_string (child, &node->passwd);
else
WARNING ("write_mongodb plugin: Ignoring unknown config option \"%s\".",
child->key);
if (status != 0)
break;
} /* for (i = 0; i < ci->children_num; i++) */
if ((node->db != NULL) || (node->user != NULL) || (node->passwd != NULL))
{
if ((node->db == NULL) || (node->user == NULL) || (node->passwd == NULL))
{
WARNING ("write_mongodb plugin: Authentication requires the "
"\"Database\", \"User\" and \"Password\" options to be specified, "
"but at last one of them is missing. Authentication will NOT be "
"used.");
sfree (node->db);
sfree (node->user);
sfree (node->passwd);
}
}
if (status == 0)
{
char cb_name[DATA_MAX_NAME_LEN];
user_data_t ud;
ssnprintf (cb_name, sizeof (cb_name), "write_mongodb/%s", node->name);
ud.data = node;
ud.free_func = wm_config_free;
status = plugin_register_write (cb_name, wm_write, &ud);
INFO ("write_mongodb plugin: registered write plugin %s %d",cb_name,status);
}
if (status != 0)
wm_config_free (node);
return (status);
} /* }}} int wm_config_node */
int test_namespace_validation() {
mongo conn[1];
char longns[130] = "test.foo";
int i;
mongo_init( conn );
/* Test a few legal namespaces. */
ASSERT( mongo_validate_ns( conn, "test.foo" ) == MONGO_OK );
ASSERT( conn->err == 0 );
ASSERT( mongo_validate_ns( conn, "test.foo.bar" ) == MONGO_OK );
ASSERT( conn->err == 0 );
/* Test illegal namespaces. */
ASSERT( mongo_validate_ns( conn, ".test.foo" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "ns cannot start with", 20 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "test..foo" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "ns cannot start with", 20 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "test" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "ns cannot start with", 20 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "." ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "ns cannot start with", 20 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "tes t.foo" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Database name may not contain", 28 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "te$st.foo" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Database name may not contain", 28 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "te/st.foo" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Database name may not contain", 28 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "te\\st.foo" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Database name may not contain", 28 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "test.fo$o" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Collection may not contain '$'", 29 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "test.fo..o" ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Collection may not contain two consecutive '.'", 46 ) == 0 );
mongo_clear_errors( conn );
ASSERT( mongo_validate_ns( conn, "test.fo.o." ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Collection may not end with '.'", 30 ) == 0 );
mongo_clear_errors( conn );
for(i = 8; i < 129; i++ )
longns[i] = 'a';
longns[129] = '\0';
ASSERT( mongo_validate_ns( conn, longns ) == MONGO_ERROR );
ASSERT( conn->err == MONGO_NS_INVALID );
ASSERT( strncmp( conn->errstr, "Namespace too long; has 129 but must <= 128.", 32 ) == 0 );
mongo_clear_errors( conn );
return 0;
}
static int wm_config_node (oconfig_item_t *ci) /* {{{ */
{
wm_node_t *node;
int status;
int i;
node = malloc (sizeof (*node));
if (node == NULL)
return (ENOMEM);
memset (node, 0, sizeof (*node));
mongo_init (node->conn);
node->host = NULL;
node->store_rates = 1;
pthread_mutex_init (&node->lock, /* attr = */ NULL);
status = cf_util_get_string_buffer (ci, node->name, sizeof (node->name));
if (status != 0)
{
sfree (node);
return (status);
}
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *child = ci->children + i;
if (strcasecmp ("Host", child->key) == 0)
status = cf_util_get_string (child, &node->host);
else if (strcasecmp ("Port", child->key) == 0)
{
status = cf_util_get_port_number (child);
if (status > 0)
{
node->port = status;
status = 0;
}
}
else if (strcasecmp ("Timeout", child->key) == 0)
status = cf_util_get_int (child, &node->timeout);
else if (strcasecmp ("StoreRates", child->key) == 0)
status = cf_util_get_boolean (child, &node->store_rates);
else
WARNING ("write_mongodb plugin: Ignoring unknown config option \"%s\".",
child->key);
if (status != 0)
break;
} /* for (i = 0; i < ci->children_num; i++) */
if (status == 0)
{
char cb_name[DATA_MAX_NAME_LEN];
user_data_t ud;
ssnprintf (cb_name, sizeof (cb_name), "write_mongodb/%s", node->name);
ud.data = node;
ud.free_func = wm_config_free;
status = plugin_register_write (cb_name, wm_write, &ud);
INFO ("write_mongodb plugin: registered write plugin %s %d",cb_name,status);
}
if (status != 0)
wm_config_free (node);
return (status);
} /* }}} int wm_config_node */
MongoLink::MongoLink(const std::string& dbname)
: m_strDBName(dbname)
{
mongo_init(&m_mongo);
}
