/**
* 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);
}
lcb_error_t lcb_init_providers(lcb_t obj,
const struct lcb_create_st2 *e_options)
{
hostlist_t mc_nodes;
lcb_error_t err;
const char *hosts;
int http_enabled = 1;
int cccp_enabled = 1;
clconfig_provider *http =
lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_HTTP);
clconfig_provider *cccp =
lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_CCCP);
if (e_options->transports) {
int cccp_found = 0;
int http_found = 0;
const lcb_config_transport_t *cur;
for (cur = e_options->transports;
*cur != LCB_CONFIG_TRANSPORT_LIST_END; cur++) {
if (*cur == LCB_CONFIG_TRANSPORT_CCCP) {
cccp_found = 1;
} else if (*cur == LCB_CONFIG_TRANSPORT_HTTP) {
http_found = 1;
} else {
return LCB_EINVAL;
}
}
if (http_found || cccp_found) {
cccp_enabled = cccp_found;
http_enabled = http_found;
}
}
if (lcb_getenv_boolean("LCB_NO_CCCP")) {
cccp_enabled = 0;
}
if (lcb_getenv_boolean("LCB_NO_HTTP")) {
http_enabled = 0;
}
/** The only way we can get to here is if one of the vars are set */
if (cccp_enabled == 0 && http_enabled == 0) {
return LCB_BAD_ENVIRONMENT;
}
if (http_enabled) {
lcb_clconfig_http_enable(http);
lcb_clconfig_http_set_nodes(http, obj->usernodes);
} else {
lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_HTTP, 0);
}
if (!cccp_enabled) {
lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_CCCP, 0);
return LCB_SUCCESS;
}
hosts = get_nonempty_string(e_options->mchosts);
mc_nodes = hostlist_create();
if (!mc_nodes) {
return LCB_CLIENT_ENOMEM;
}
if (hosts) {
err = hostlist_add_stringz(mc_nodes, hosts, LCB_CONFIG_MCD_PORT);
if (err != LCB_SUCCESS) {
hostlist_destroy(mc_nodes);
return err;
}
} else {
lcb_size_t ii;
for (ii = 0; ii < obj->usernodes->nentries; ii++) {
lcb_host_t *cur = obj->usernodes->entries + ii;
hostlist_add_stringz(mc_nodes, cur->host, LCB_CONFIG_MCD_PORT);
}
}
lcb_clconfig_cccp_enable(cccp, obj);
lcb_clconfig_cccp_set_nodes(cccp, mc_nodes);
hostlist_destroy(mc_nodes);
return LCB_SUCCESS;
}
/**
* 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);
}
