static void protocol_error(http_provider *http, lcb_error_t err)
{
int can_retry = 1;
lcb_log(LOGARGS(http, ERROR), "Got protocol-level error 0x%x", err);
PROVIDER_SET_ERROR(&http->base, err);
/**
* XXX: We only want to retry on some errors. Things which signify an
* obvious user error should be left out here; we only care about
* actual "network" errors
*/
if (err == LCB_AUTH_ERROR ||
err == LCB_PROTOCOL_ERROR ||
err == LCB_BUCKET_ENOENT) {
can_retry = 0;
}
if (http->retry_on_missing &&
(err == LCB_BUCKET_ENOENT || err == LCB_AUTH_ERROR)) {
LOG(http, INFO, "Retrying on AUTH||BUCKET_ENOENT");
can_retry = 1;
}
if (!can_retry) {
close_current(http);
lcb_confmon_provider_failed(&http->base, err);
} else {
io_error(http);
}
}
static lcb_error_t schedule_next_request(cccp_provider *cccp,
lcb_error_t err,
int can_rollover)
{
lcb_server_t *server = NULL;
lcb_size_t ii;
lcb_host_t *next_host = hostlist_shift_next(cccp->nodes, can_rollover);
if (!next_host) {
lcb_timer_disarm(cccp->timer);
lcb_confmon_provider_failed(&cccp->base, err);
cccp->server_active = 0;
return err;
}
/** See if we can find a server */
for (ii = 0; ii < cccp->instance->nservers; ii++) {
lcb_server_t *cur = cccp->instance->servers + ii;
if (lcb_host_equals(&cur->curhost, next_host)) {
server = cur;
break;
}
}
if (server) {
protocol_binary_request_get_cluster_config req;
cccp_cookie *cookie = calloc(1, sizeof(*cookie));
lcb_log(LOGARGS(cccp, INFO),
"Re-Issuing CCCP Command on server struct %p", server);
cookie->parent = cccp;
memset(&req, 0, sizeof(req));
req.message.header.request.magic = PROTOCOL_BINARY_REQ;
req.message.header.request.opcode = CMD_GET_CLUSTER_CONFIG;
req.message.header.request.opaque = ++cccp->instance->seqno;
lcb_server_start_packet(server, cookie, &req, sizeof(req.bytes));
lcb_server_end_packet(server);
lcb_server_send_packets(server);
lcb_timer_rearm(cccp->timer, PROVIDER_SETTING(&cccp->base,
config_node_timeout));
} else {
cccp->cur_connreq = calloc(1, sizeof(*cccp->cur_connreq));
connmgr_req_init(cccp->cur_connreq, next_host->host, next_host->port,
socket_connected);
cccp->cur_connreq->data = cccp;
connmgr_get(cccp->instance->memd_sockpool, cccp->cur_connreq,
PROVIDER_SETTING(&cccp->base, config_node_timeout));
}
cccp->server_active = 1;
return LCB_SUCCESS;
}
static lcb_error_t mcio_error(cccp_provider *cccp, lcb_error_t err)
{
lcb_log(LOGARGS(cccp, ERR), "Got I/O Error=0x%x", err);
if (err == LCB_AUTH_ERROR && cccp->base.parent->config == NULL) {
lcb_confmon_provider_failed(&cccp->base, err);
return err;
}
release_socket(cccp, err == LCB_NOT_SUPPORTED);
return schedule_next_request(cccp, err, 0);
}
static void async_callback(void *cookie)
{
time_t last_mtime;
file_provider *provider = (file_provider *)cookie;
last_mtime = provider->last_mtime;
if (load_cache(provider) == 0) {
if (last_mtime != provider->last_mtime) {
lcb_confmon_provider_success(&provider->base, provider->config);
return;
}
}
lcb_confmon_provider_failed(&provider->base, LCB_ERROR);
}
static void async_callback(lcb_timer_t timer,
lcb_t notused,
const void *cookie)
{
file_provider *provider = (file_provider *)cookie;
lcb_async_destroy(NULL, timer);
provider->async = NULL;
LOG(provider, TRACE, "Got async callback. Will load");
if (load_cache(provider) == 0) {
lcb_confmon_provider_success(&provider->base, provider->config);
} else {
lcb_confmon_provider_failed(&provider->base, LCB_ERROR);
}
(void)notused;
}
/**
* Call when there is an error in I/O. This includes read, write, connect
* and timeouts.
*/
static lcb_error_t io_error(http_provider *http)
{
lcb_error_t err;
lcb_conn_params params;
char *errinfo;
close_current(http);
params.timeout = PROVIDER_SETTING(&http->base, config_node_timeout);
params.handler = connect_done_handler;
err = lcb_connection_next_node(&http->connection,
http->nodes, ¶ms, &errinfo);
if (err != LCB_SUCCESS) {
lcb_confmon_provider_failed(&http->base, err);
lcb_timer_disarm(http->io_timer);
return err;
} else {
setup_request_header(http);
}
return LCB_SUCCESS;
}
/**
* Call when there is an error in I/O. This includes read, write, connect
* and timeouts.
*/
static lcb_error_t io_error(http_provider *http, lcb_error_t origerr)
{
lcb_error_t err;
lcb_conn_params params;
char *errinfo;
int can_retry = 0;
close_current(http);
params.timeout = PROVIDER_SETTING(&http->base, config_node_timeout);
params.handler = connect_done_handler;
if (http->base.parent->config) {
can_retry = 1;
} else if (origerr != LCB_AUTH_ERROR && origerr != LCB_BUCKET_ENOENT) {
can_retry = 1;
}
if (can_retry) {
err = lcb_connection_next_node(
&http->connection, http->nodes, ¶ms, &errinfo);
} else {
err = origerr;
}
if (err != LCB_SUCCESS) {
lcb_confmon_provider_failed(&http->base, origerr);
lcb_timer_disarm(http->io_timer);
if (is_v220_compat(http)) {
lcb_log(LOGARGS(http, INFO),
"HTTP node list finished. Looping again (disconn_tmo=-1)");
connect_next(http);
}
return origerr;
} else {
setup_request_header(http);
}
return LCB_SUCCESS;
}
static void delayed_schederr(lcb_timer_t tm, lcb_t instance, const void *cookie)
{
http_provider *http = (void *)cookie;
lcb_confmon_provider_failed(&http->base, http->as_errcode);
(void)tm; (void)instance;
}
