static void event_complete_common(lcb_server_t *c, lcb_error_t rc) { lcb_t instance = c->instance; if (rc != LCB_SUCCESS) { lcb_failout_server(c, rc); } else { if (instance->bootstrap.type == LCB_CONFIG_TRANSPORT_HTTP && c->is_config_node) { c->instance->bootstrap.via.http.weird_things = 0; } lcb_sockrw_apply_want(&c->connection); c->inside_handler = 0; } if (instance->compat.type == LCB_CACHED_CONFIG && instance->compat.value.cached.needs_update) { lcb_refresh_config_cache(instance); } else if (instance->bootstrap.type == LCB_CONFIG_TRANSPORT_CCCP && instance->bootstrap.via.cccp.next_config) { lcb_update_vbconfig(instance, instance->bootstrap.via.cccp.next_config); instance->bootstrap.via.cccp.next_config = NULL; } lcb_maybe_breakout(instance); lcb_error_handler(instance, rc, NULL); }
static void config_callback(lcb_server_t *server, lcb_error_t error, const char *json) { VBUCKET_CONFIG_HANDLE config; lcb_t instance = server->instance; server->connection.timeout.usec = 0; lcb_connection_cancel_timer(&server->connection); if (error != LCB_SUCCESS) { lcb_error_handler(instance, error, "Failed to receive configration"); return; } config = vbucket_config_create(); if (config == NULL) { lcb_error_handler(instance, LCB_CLIENT_ENOMEM, "Failed to allocate memory for configuration"); return; } if (vbucket_config_parse2(config, LIBVBUCKET_SOURCE_MEMORY, json, server->connection.host)) { vbucket_config_destroy(config); lcb_error_handler(instance, LCB_PROTOCOL_ERROR, vbucket_get_error_message(config)); return; } lcb_update_vbconfig(instance, config); }
/** * 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); }
/** * 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 *bs = (struct lcb_BOOTSTRAP *)listener; lcb_t instance = bs->parent; if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) { if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) { if (!LCBT_VBCONFIG(instance)) { initial_bootstrap_error( instance, LCB_ERROR, "No more bootstrap providers remain"); } } return; } instance->last_error = LCB_SUCCESS; /** Ensure we're not called directly twice again */ listener->callback = async_step_callback; lcbio_timer_disarm(bs->tm); lcb_log(LOGARGS(instance, DEBUG), "Instance configured!"); if (info->origin != LCB_CLCONFIG_FILE) { /* Set the timestamp for the current config to control throttling, * but only if it's not an initial file-based config. See CCBC-482 */ bs->last_refresh = gethrtime(); bs->errcounter = 0; } if (info->origin == LCB_CLCONFIG_CCCP) { /* Disable HTTP provider if we've received something via CCCP */ if (instance->cur_configinfo == NULL || instance->cur_configinfo->origin != LCB_CLCONFIG_HTTP) { /* Never disable HTTP if it's still being used */ lcb_confmon_set_provider_active( instance->confmon, LCB_CLCONFIG_HTTP, 0); } } if (instance->type != LCB_TYPE_CLUSTER) { lcb_update_vbconfig(instance, info); } if (!bs->bootstrapped) { bs->bootstrapped = 1; lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL); if (instance->type == LCB_TYPE_BUCKET && LCBVB_DISTTYPE(LCBT_VBCONFIG(instance)) == LCBVB_DIST_KETAMA && instance->cur_configinfo->origin != LCB_CLCONFIG_MCRAW) { lcb_log(LOGARGS(instance, INFO), "Reverting to HTTP Config for memcached buckets"); instance->settings->bc_http_stream_time = -1; lcb_confmon_set_provider_active( instance->confmon, LCB_CLCONFIG_HTTP, 1); lcb_confmon_set_provider_active( instance->confmon, LCB_CLCONFIG_CCCP, 0); } instance->callbacks.bootstrap(instance, LCB_SUCCESS); } lcb_maybe_breakout(instance); }