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);
}
