switch_status_t mongo_connection_pool_put(mongo_connection_pool_t *conn_pool, DBClientBase *conn, switch_bool_t destroy) { switch_status_t status = SWITCH_STATUS_SUCCESS; switch_assert(conn_pool != NULL); switch_assert(conn != NULL); switch_mutex_lock(conn_pool->mutex); if (destroy || conn_pool->size > conn_pool->max_connections) { #ifdef MONGO_POOL_DEBUG switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "POOL: Destroy connection %p\n", conn); #endif mongo_connection_destroy(&conn); conn_pool->size--; } else { #ifdef MONGO_POOL_DEBUG switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "POOL: push connection %p\n", conn); #endif status = switch_queue_push(conn_pool->connections, conn); } switch_mutex_unlock(conn_pool->mutex); #ifdef MONGO_POOL_DEBUG switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "POOL: put size %d conn: %p\n", (int) switch_queue_size(conn_pool->connections), conn); #endif return status; }
void mongo_connection_pool_destroy(mongo_connection_pool_t **conn_pool) { mongo_connection_pool_t *cpool = *conn_pool; void *data = NULL; switch_assert(cpool != NULL); while (switch_queue_trypop(cpool->connections, &data) == SWITCH_STATUS_SUCCESS) { mongo_connection_destroy((DBClientBase **)&data); } switch_mutex_destroy(cpool->mutex); switch_core_destroy_memory_pool(&cpool->pool); *conn_pool = NULL; }
/* Helpers */ static mongo_connection *mongo_get_connection_single(mongo_con_manager *manager, mongo_server_def *server, mongo_server_options *options, int connection_flags, char **error_message) { char *hash; mongo_connection *con = NULL; mongo_connection_blacklist *blacklist = NULL; hash = mongo_server_create_hash(server); /* See if a connection is in our blacklist to short-circut trying to * connect to a node that is known to be down. This is done so we don't * waste precious time in connecting to unreachable nodes */ blacklist = mongo_manager_blacklist_find_by_hash(manager, hash); if (blacklist) { struct timeval start; /* It is blacklisted, but it may have been a long time again and * chances are we should give it another try */ if (mongo_connection_ping_check(manager, blacklist->last_ping, &start)) { /* The connection is blacklisted, but we've reached our ping * interval so lets remove the blacklisting and pretend we didn't * know about it */ mongo_manager_blacklist_deregister(manager, blacklist, hash); } else { /* Otherwise short-circut the connection attempt, and say we failed * right away */ free(hash); *error_message = strdup("Previous connection attempts failed, server blacklisted"); return NULL; } } con = mongo_manager_connection_find_by_hash(manager, hash); /* If we aren't about to (re-)connect then all we care about if it was a * known connection or not */ if (connection_flags & MONGO_CON_FLAG_DONT_CONNECT) { free(hash); return con; } /* If we found a valid connection check if we need to ping it */ if (con) { /* Do the ping, if needed */ if (!mongo_connection_ping(manager, con, options, error_message)) { /* If the ping failed, deregister the connection */ mongo_manager_connection_deregister(manager, con); /* Set the return value to NULL, as the connection is broken and * has been removed */ con = NULL; } free(hash); return con; } /* Since we didn't find an existing connection, lets make one! */ con = mongo_connection_create(manager, hash, server, options, error_message); if (con) { /* When we make a connection, we need to figure out the server version it is */ if (!mongo_connection_get_server_version(manager, con, options, error_message)) { mongo_manager_log(manager, MLOG_CON, MLOG_WARN, "server_version: error while getting the server version %s:%d: %s", server->host, server->port, *error_message); mongo_connection_destroy(manager, con, MONGO_CLOSE_BROKEN); free(hash); return NULL; } /* Do authentication if requested */ /* Note: Arbiters don't contain any data, including auth stuff, so you cannot authenticate on an arbiter */ if (con->connection_type != MONGO_NODE_ARBITER) { if (!manager->authenticate(manager, con, options, server, error_message)) { mongo_connection_destroy(manager, con, MONGO_CLOSE_BROKEN); free(hash); return NULL; } } /* Do the first-time ping to record the latency of the connection */ if (mongo_connection_ping(manager, con, options, error_message)) { /* Register the connection on successful pinging */ mongo_manager_connection_register(manager, con); } else { /* Or kill it and reset the return value if the ping somehow failed */ mongo_connection_destroy(manager, con, MONGO_CLOSE_BROKEN); con = NULL; } } free(hash); return con; }
static mongo_connection *mongo_get_connection_multiple(mongo_con_manager *manager, mongo_servers *servers, int connection_flags, char **error_message) { mongo_connection *con = NULL; mongo_connection *tmp; mcon_collection *collection = NULL; mongo_read_preference tmp_rp; /* We only support NEAREST for MULTIPLE right now */ int i; int found_connected_server = 0; mcon_str *messages; int found_supported_wire_version = 1; mcon_str_ptr_init(messages); /* Create a connection to every of the servers in the seed list */ for (i = 0; i < servers->count; i++) { int ismaster_error = 0; char *con_error_message = NULL; tmp = mongo_get_connection_single(manager, servers->server[i], &servers->options, connection_flags, (char **) &con_error_message); if (tmp) { found_connected_server++; /* Run ismaster, if needed, to extract server flags */ ismaster_error = mongo_connection_ismaster(manager, tmp, &servers->options, NULL, NULL, NULL, &con_error_message, NULL); switch (ismaster_error) { case 1: /* Run just fine */ case 2: /* ismaster() skipped due to interval */ break; case 0: /* Some error */ case 3: /* Run just fine, but hostname didn't match what we expected */ case 4: /* Danger danger, reported wire version does not overlap what we support */ default: mongo_manager_log(manager, MLOG_CON, MLOG_WARN, "server_flags: error while getting the server configuration %s:%d: %s", servers->server[i]->host, servers->server[i]->port, con_error_message); /* If it failed because of wire version, we have to bail out completely * later on, but we should continue to aggregate the errors in case more * servers are unsupported */ if (ismaster_error == 4) { mongo_manager_connection_deregister(manager, tmp); found_supported_wire_version = 0; } else { mongo_connection_destroy(manager, tmp, MONGO_CLOSE_BROKEN); } tmp = NULL; found_connected_server--; } } if (!tmp) { if (!(connection_flags & MONGO_CON_FLAG_DONT_CONNECT)) { mongo_manager_log(manager, MLOG_CON, MLOG_WARN, "Couldn't connect to '%s:%d': %s", servers->server[i]->host, servers->server[i]->port, con_error_message); if (messages->l) { mcon_str_addl(messages, "; ", 2, 0); } mcon_str_add(messages, "Failed to connect to: ", 0); mcon_str_add(messages, servers->server[i]->host, 0); mcon_str_addl(messages, ":", 1, 0); mcon_str_add_int(messages, servers->server[i]->port); mcon_str_addl(messages, ": ", 2, 0); mcon_str_add(messages, con_error_message, 1); /* Also frees con_error_message */ } else { free(con_error_message); } } } if (!found_supported_wire_version) { *error_message = strdup("Found a server running unsupported wire version. Please upgrade the driver, or take the server out of rotation"); mcon_str_ptr_dtor(messages); return NULL; } /* If we don't have a connected server then there is no point in continueing */ if (!found_connected_server && (connection_flags & MONGO_CON_FLAG_DONT_CONNECT)) { mcon_str_ptr_dtor(messages); return NULL; } /* When selecting a *mongos* node, readPreferences make no sense as we * don't have a "primary" or "secondary" mongos. The mongos nodes aren't * tagged either. To pick a mongos we therefore simply pick the "nearest" * mongos node. */ tmp_rp.type = MONGO_RP_NEAREST; tmp_rp.tagsets = NULL; tmp_rp.tagset_count = 0; collection = mongo_find_candidate_servers(manager, &tmp_rp, servers); if (!collection || collection->count == 0) { if (messages->l) { *error_message = strdup(messages->d); } else { *error_message = strdup("No candidate servers found"); } goto bailout; } collection = mongo_sort_servers(manager, collection, &servers->read_pref); collection = mongo_select_nearest_servers(manager, collection, &servers->options, &servers->read_pref); if (!collection) { *error_message = strdup("No server near us"); goto bailout; } con = mongo_pick_server_from_set(manager, collection, &servers->read_pref); bailout: /* Cleaning up */ mcon_str_ptr_dtor(messages); if (collection) { mcon_collection_free(collection); } return con; }
static mongo_connection *mongo_get_connection_single(mongo_con_manager *manager, mongo_server_def *server, mongo_server_options *options, int connection_flags, char **error_message) { char *hash; mongo_connection *con = NULL; mongo_connection_blacklist *blacklist = NULL; hash = mongo_server_create_hash(server); /* See if a connection is in our blacklist to short-circut trying to connect * to a node that is known to be down. This is done so we don't waste * precious time in connecting to unreachable nodes */ blacklist = mongo_manager_blacklist_find_by_hash(manager, hash); if (blacklist) { struct timeval start; /* It is blacklisted, but it may have been a long time again and chances are * we should give it another try */ if (mongo_connection_ping_check(manager, blacklist->last_ping, &start)) { /* The connection is blacklisted, but we've reached our ping interval * so lets remove the blacklisting and pretend we didn't know about it */ mongo_manager_blacklist_deregister(manager, blacklist, hash); con = NULL; } else { /* Otherwise short-circut the connection attempt, and say we failed right away */ free(hash); return NULL; } } con = mongo_manager_connection_find_by_hash(manager, hash); /* If we aren't about to (re-)connect then all we care about if it was a known connection or not */ if (connection_flags & MONGO_CON_FLAG_DONT_CONNECT) { free(hash); return con; } /* If we found a valid connection check if we need to ping it */ if (con) { /* Do the ping, if needed */ if (!mongo_connection_ping(manager, con, options, error_message)) { /* If the ping failed, deregister the connection */ mongo_manager_connection_deregister(manager, con); /* Set the return value to NULL, as the connection is broken and has been removed */ con = NULL; } free(hash); return con; } /* Since we didn't find an existing connection, lets make one! */ con = mongo_connection_create(manager, hash, server, options, error_message); if (con) { /* Do authentication if requested */ if (server->db && server->username && server->password) { mongo_manager_log(manager, MLOG_CON, MLOG_INFO, "get_connection_single: authenticating %s", hash); if (!authenticate_connection(manager, con, options, server->authdb ? server->authdb : server->db, server->username, server->password, error_message)) { mongo_connection_destroy(manager, con, MONGO_CLOSE_BROKEN); free(hash); return NULL; } } /* Do the first-time ping to record the latency of the connection */ if (mongo_connection_ping(manager, con, options, error_message)) { /* Register the connection on successful pinging */ mongo_manager_connection_register(manager, con); } else { /* Or kill it and reset the return value if the ping somehow failed */ mongo_connection_destroy(manager, con, MONGO_CLOSE_BROKEN); con = NULL; } } free(hash); return con; }
static mongo_connection *mongo_get_connection_multiple(mongo_con_manager *manager, mongo_servers *servers, int connection_flags, char **error_message) { mongo_connection *con = NULL; mongo_connection *tmp; mcon_collection *collection = NULL; mongo_read_preference tmp_rp; /* We only support NEAREST for MULTIPLE right now */ int i; int found_connected_server = 0; mcon_str *messages; mcon_str_ptr_init(messages); /* Create a connection to every of the servers in the seed list */ for (i = 0; i < servers->count; i++) { char *con_error_message = NULL; tmp = mongo_get_connection_single(manager, servers->server[i], &servers->options, connection_flags, (char **) &con_error_message); if (tmp) { found_connected_server++; /* Run ismaster, if needed, to extract server flags */ if (!mongo_connection_get_server_flags(manager, tmp, &servers->options, &con_error_message)) { mongo_manager_log(manager, MLOG_CON, MLOG_WARN, "server_flags: error while getting the server configuration %s:%d: %s", &servers->server[i]->host, &servers->server[i]->port, con_error_message); mongo_connection_destroy(manager, tmp, MONGO_CLOSE_BROKEN); tmp = NULL; found_connected_server--; } } if (!tmp && !(connection_flags & MONGO_CON_FLAG_DONT_CONNECT)) { mongo_manager_log(manager, MLOG_CON, MLOG_WARN, "Couldn't connect to '%s:%d': %s", servers->server[i]->host, servers->server[i]->port, con_error_message); if (messages->l) { mcon_str_addl(messages, "; ", 2, 0); } mcon_str_add(messages, "Failed to connect to: ", 0); mcon_str_add(messages, servers->server[i]->host, 0); mcon_str_addl(messages, ":", 1, 0); mcon_str_add_int(messages, servers->server[i]->port); mcon_str_addl(messages, ": ", 2, 0); mcon_str_add(messages, con_error_message, 1); /* Also frees con_error_message */ } } /* If we don't have a connected server then there is no point in continueing */ if (!found_connected_server && (connection_flags & MONGO_CON_FLAG_DONT_CONNECT)) { mcon_str_ptr_dtor(messages); return NULL; } /* When selecting a *mongos* node, readPreferences make no sense as we * don't have a "primary" or "secondary" mongos. The mongos nodes aren't * tagged either. To pick a mongos we therefore simply pick the "nearest" * mongos node. */ tmp_rp.type = MONGO_RP_NEAREST; tmp_rp.tagsets = NULL; tmp_rp.tagset_count = 0; collection = mongo_find_candidate_servers(manager, &tmp_rp, servers); if (!collection || collection->count == 0) { if (messages->l) { *error_message = strdup(messages->d); } else { *error_message = strdup("No candidate servers found"); } goto bailout; } collection = mongo_sort_servers(manager, collection, &servers->read_pref); collection = mongo_select_nearest_servers(manager, collection, &servers->options, &servers->read_pref); if (!collection) { *error_message = strdup("No server near us"); goto bailout; } con = mongo_pick_server_from_set(manager, collection, &servers->read_pref); bailout: /* Cleaning up */ mcon_str_ptr_dtor(messages); if (collection) { mcon_collection_free(collection); } return con; }