static void shutdown_http(clconfig_provider *provider)
{
http_provider *http = (http_provider *)provider;
reset_stream_state(http);
lcb_string_release(&http->stream.chunk);
lcb_string_release(&http->stream.input);
lcb_string_release(&http->stream.header);
lcb_connection_close(&http->connection);
lcb_connection_cleanup(&http->connection);
if (http->current_config) {
lcb_clconfig_decref(http->current_config);
}
if (http->disconn_timer) {
lcb_timer_destroy(NULL, http->disconn_timer);
}
if (http->io_timer) {
lcb_timer_destroy(NULL, http->io_timer);
}
if (http->as_schederr) {
lcb_timer_destroy(NULL, http->as_schederr);
}
if (http->nodes) {
hostlist_destroy(http->nodes);
}
free(http);
}
/**
* Release all allocated resources for this server instance
* @param server the server to destroy
*/
void lcb_server_destroy(lcb_server_t *server)
{
lcb_server_release_connection(server, LCB_SUCCESS);
/* Cancel all pending commands */
if (server->cmd_log.nbytes) {
lcb_server_purge_implicit_responses(server,
server->instance->seqno,
gethrtime(),
1);
}
if (server->io_timer) {
lcb_timer_destroy(NULL, server->io_timer);
}
lcb_connection_cleanup(&server->connection);
free(server->rest_api_server);
free(server->couch_api_base);
free(server->authority);
ringbuffer_destruct(&server->output_cookies);
ringbuffer_destruct(&server->cmd_log);
ringbuffer_destruct(&server->pending);
ringbuffer_destruct(&server->pending_cookies);
memset(server, 0xff, sizeof(*server));
}
/*
* Cancel the timer.
*
* @since 1.2.0.dp6
*
* This operation makes sense for periodic timers or if one need to cancel
* regular timer before it will be triggered.
*
* @example Cancel periodic timer
* n = 1
* c.run do
* tm = c.create_periodic_timer(500000) do
* c.incr("foo") do
* if n == 5
* tm.cancel
* else
* n += 1
* end
* end
* end
* end
*
* @return [String]
*/
VALUE
cb_timer_cancel(VALUE self)
{
struct timer_st *tm = DATA_PTR(self);
lcb_timer_destroy(tm->bucket->handle, tm->timer);
return self;
}
/**
* This function is where the configuration actually takes place. We ensure
* in other functions that this is only ever called directly from an event
* loop stack frame (or one of the small mini functions here) so that we
* don't accidentally end up destroying resources underneath us.
*/
static void config_callback(clconfig_listener *listener,
clconfig_event_t event,
clconfig_info *info)
{
struct lcb_bootstrap_st *bs = (struct lcb_bootstrap_st *)listener;
lcb_t instance = bs->parent;
if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) {
if (!instance->vbucket_config) {
initial_bootstrap_error(instance,
LCB_ERROR,
"No more bootstrap providers remain");
}
}
return;
}
instance->last_error = LCB_SUCCESS;
bs->active = 0;
/** Ensure we're not called directly twice again */
listener->callback = async_step_callback;
if (bs->timer) {
lcb_timer_destroy(instance, bs->timer);
bs->timer = NULL;
}
lcb_log(LOGARGS(instance, DEBUG), "Instance configured!");
if (instance->type != LCB_TYPE_CLUSTER) {
lcb_update_vbconfig(instance, info);
}
if (!bs->bootstrapped) {
bs->bootstrapped = 1;
if (instance->type == LCB_TYPE_BUCKET &&
instance->dist_type == VBUCKET_DISTRIBUTION_KETAMA) {
lcb_log(LOGARGS(instance, INFO),
"Reverting to HTTP Config for memcached buckets");
/** Memcached bucket */
lcb_clconfig_set_http_always_on(
lcb_confmon_get_provider(
instance->confmon, LCB_CLCONFIG_HTTP));
lcb_confmon_set_provider_active(instance->confmon,
LCB_CLCONFIG_HTTP, 1);
lcb_confmon_set_provider_active(instance->confmon,
LCB_CLCONFIG_CCCP, 0);
lcb_confmon_set_provider_active(instance->confmon,
LCB_CLCONFIG_CCCP, 0);
}
}
lcb_maybe_breakout(instance);
}
static void
timer_callback(lcb_timer_t timer, lcb_t instance,
const void *cookie)
{
struct timer_st *tm = (struct timer_st *)cookie;
int error = 0;
rb_protect(trigger_timer, tm->self, &error);
if (error) {
lcb_timer_destroy(instance, timer);
}
(void)cookie;
}
void lcb_bootstrap_destroy(lcb_t instance)
{
struct lcb_bootstrap_st *bs = instance->bootstrap;
if (!bs) {
return;
}
if (bs->timer) {
lcb_timer_destroy(instance, bs->timer);
}
lcb_confmon_remove_listener(instance->confmon, &bs->listener);
free(bs);
instance->bootstrap = NULL;
}
static void cccp_cleanup(clconfig_provider *pb)
{
cccp_provider *cccp = (cccp_provider *)pb;
release_socket(cccp, 0);
lcb_connection_cleanup(&cccp->connection);
if (cccp->config) {
lcb_clconfig_decref(cccp->config);
}
if (cccp->nodes) {
hostlist_destroy(cccp->nodes);
}
if (cccp->timer) {
lcb_timer_destroy(NULL, cccp->timer);
}
if (cccp->cmdcookie) {
cccp->cmdcookie->ignore_errors = 1;
}
free(cccp);
}
static void initial_bootstrap_error(lcb_t instance,
lcb_error_t err,
const char *errinfo)
{
instance->last_error = lcb_confmon_last_error(instance->confmon);
if (instance->last_error == LCB_SUCCESS) {
instance->last_error = err;
}
instance->bootstrap->active = 0 ;
lcb_error_handler(instance, instance->last_error, errinfo);
lcb_log(LOGARGS(instance, ERR),
"Failed to bootstrap client=%p. Code=0x%x, Message=%s",
(void *)instance, err, errinfo);
if (instance->bootstrap->timer) {
lcb_timer_destroy(instance, instance->bootstrap->timer);
instance->bootstrap->timer = NULL;
}
lcb_maybe_breakout(instance);
}
LIBCOUCHBASE_API
void lcb_destroy(lcb_t instance)
{
lcb_size_t ii;
lcb_settings *settings = &instance->settings;
if (instance->cur_configinfo) {
lcb_clconfig_decref(instance->cur_configinfo);
instance->cur_configinfo = NULL;
}
instance->vbucket_config = NULL;
lcb_bootstrap_destroy(instance);
lcb_confmon_destroy(instance->confmon);
hostlist_destroy(instance->usernodes);
if (instance->timers != NULL) {
for (ii = 0; ii < instance->timers->capacity; ++ii) {
if (instance->timers->items[ii] > 1) {
lcb_timer_destroy(instance,
(lcb_timer_t)instance->timers->items[ii]);
}
}
hashset_destroy(instance->timers);
}
if (instance->durability_polls) {
struct lcb_durability_set_st **dset_list;
lcb_size_t nitems = hashset_num_items(instance->durability_polls);
dset_list = (struct lcb_durability_set_st **)
hashset_get_items(instance->durability_polls, NULL);
if (dset_list) {
for (ii = 0; ii < nitems; ii++) {
lcb_durability_dset_destroy(dset_list[ii]);
}
free(dset_list);
}
hashset_destroy(instance->durability_polls);
}
for (ii = 0; ii < instance->nservers; ++ii) {
lcb_server_destroy(instance->servers + ii);
}
if (instance->http_requests) {
for (ii = 0; ii < instance->http_requests->capacity; ++ii) {
if (instance->http_requests->items[ii] > 1) {
lcb_http_request_t htreq =
(lcb_http_request_t)instance->http_requests->items[ii];
/**
* We don't want to invoke callbacks *or* remove it from our
* hash table
*/
htreq->status |= LCB_HTREQ_S_CBINVOKED | LCB_HTREQ_S_HTREMOVED;
/* we should figure out a better error code for this.. */
lcb_http_request_finish(instance, htreq, LCB_ERROR);
}
}
}
hashset_destroy(instance->http_requests);
free(instance->servers);
connmgr_destroy(instance->memd_sockpool);
if (settings->io && settings->io->v.v0.need_cleanup) {
lcb_destroy_io_ops(settings->io);
}
ringbuffer_destruct(&instance->purged_buf);
ringbuffer_destruct(&instance->purged_cookies);
free(instance->histogram);
free(instance->scratch);
free(settings->username);
free(settings->password);
free(settings->bucket);
free(settings->sasl_mech_force);
if (instance->cmdht) {
genhash_free(instance->cmdht);
instance->cmdht = NULL;
}
memset(instance, 0xff, sizeof(*instance));
free(instance);
}
