libcouchbase 0.0.1

data/ext/libcouchbase/src/bucketconfig/confmon.c

@@ -0,0 +1,474 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "internal.h"
+#include "clconfig.h"
+#define LOGARGS(mon, lvlbase) mon->settings, "confmon", LCB_LOG_##lvlbase, __FILE__, __LINE__
+#define LOG(mon, lvlbase, msg) lcb_log(mon->settings, "confmon", LCB_LOG_##lvlbase, __FILE__, __LINE__, msg)
+
+static void async_stop(void *);
+static void async_start(void *);
+static int do_next_provider(lcb_confmon *mon);
+static void invoke_listeners(lcb_confmon *mon,
+                             clconfig_event_t event,
+                             clconfig_info *info);
+
+#define IS_REFRESHING(mon) ((mon)->state & CONFMON_S_ACTIVE)
+
+static clconfig_provider *next_active(lcb_confmon *mon, clconfig_provider *cur)
+{
+    if (!LCB_LIST_HAS_NEXT((lcb_list_t *)&mon->active_providers, &cur->ll)) {
+        return NULL;
+    }
+    return LCB_LIST_ITEM(cur->ll.next, clconfig_provider, ll);
+}
+static clconfig_provider *first_active(lcb_confmon *mon)
+{
+    if (LCB_LIST_IS_EMPTY((lcb_list_t *)&mon->active_providers)) {
+        return NULL;
+    }
+    return LCB_LIST_ITEM(mon->active_providers.next, clconfig_provider, ll);
+}
+
+static const char *
+provider_string(clconfig_method_t type) {
+    if (type == LCB_CLCONFIG_HTTP) { return "HTTP"; }
+    if (type == LCB_CLCONFIG_CCCP) { return "CCCP"; }
+    if (type == LCB_CLCONFIG_FILE) { return "FILE"; }
+    if (type == LCB_CLCONFIG_MCRAW) { return "MCRAW"; }
+    if (type == LCB_CLCONFIG_USER) { return "USER"; }
+    return "";
+}
+
+lcb_confmon* lcb_confmon_create(lcb_settings *settings, lcbio_pTABLE iot)
+{
+    int ii;
+    lcb_confmon * mon = calloc(1, sizeof(*mon));
+    mon->settings = settings;
+    mon->iot = iot;
+    lcb_list_init(&mon->listeners);
+    lcb_clist_init(&mon->active_providers);
+    lcbio_table_ref(mon->iot);
+    lcb_settings_ref(mon->settings);
+
+    mon->all_providers[LCB_CLCONFIG_FILE] = lcb_clconfig_create_file(mon);
+    mon->all_providers[LCB_CLCONFIG_CCCP] = lcb_clconfig_create_cccp(mon);
+    mon->all_providers[LCB_CLCONFIG_HTTP] = lcb_clconfig_create_http(mon);
+    mon->all_providers[LCB_CLCONFIG_USER] = lcb_clconfig_create_user(mon);
+    mon->all_providers[LCB_CLCONFIG_MCRAW] = lcb_clconfig_create_mcraw(mon);
+
+    for (ii = 0; ii < LCB_CLCONFIG_MAX; ii++) {
+        mon->all_providers[ii]->parent = mon;
+    }
+    mon->as_stop = lcbio_timer_new(iot, mon, async_stop);
+    mon->as_start = lcbio_timer_new(iot, mon, async_start);
+    return mon;
+}
+
+void lcb_confmon_prepare(lcb_confmon *mon)
+{
+    int ii;
+
+    memset(&mon->active_providers, 0, sizeof(mon->active_providers));
+    lcb_clist_init(&mon->active_providers);
+
+    lcb_log(LOGARGS(mon, DEBUG), "Preparing providers (this may be called multiple times)");
+
+    for (ii = 0; ii < LCB_CLCONFIG_MAX; ii++) {
+        clconfig_provider *cur = mon->all_providers[ii];
+        if (cur) {
+            if (cur->enabled) {
+                lcb_clist_append(&mon->active_providers, &cur->ll);
+                lcb_log(LOGARGS(mon, DEBUG), "Provider %s is ENABLED", provider_string(cur->type));
+            } else if (cur->pause){
+                cur->pause(cur);
+                lcb_log(LOGARGS(mon, DEBUG), "Provider %s is DISABLED", provider_string(cur->type));
+            }
+        }
+    }
+
+    lcb_assert(LCB_CLIST_SIZE(&mon->active_providers));
+    mon->cur_provider = first_active(mon);
+}
+
+void lcb_confmon_destroy(lcb_confmon *mon)
+{
+    unsigned int ii;
+
+    if (mon->as_start) {
+        lcbio_timer_destroy(mon->as_start);
+    }
+
+    if (mon->as_stop) {
+        lcbio_timer_destroy(mon->as_stop);
+    }
+
+    mon->as_start = NULL;
+    mon->as_stop = NULL;
+
+    if (mon->config) {
+        lcb_clconfig_decref(mon->config);
+        mon->config = NULL;
+    }
+
+    for (ii = 0; ii < LCB_CLCONFIG_MAX; ii++) {
+        clconfig_provider *provider = mon->all_providers[ii];
+        if (provider == NULL) {
+            continue;
+        }
+
+        provider->shutdown(provider);
+        mon->all_providers[ii] = NULL;
+    }
+
+    lcbio_table_unref(mon->iot);
+    lcb_settings_unref(mon->settings);
+
+    free(mon);
+}
+
+static int do_set_next(lcb_confmon *mon, clconfig_info *info, int notify_miss)
+{
+    unsigned ii;
+
+    if (mon->config) {
+        lcbvb_CHANGETYPE chstatus = LCBVB_NO_CHANGES;
+        lcbvb_CONFIGDIFF *diff = lcbvb_compare(mon->config->vbc, info->vbc);
+
+        if (!diff) {
+            lcb_log(LOGARGS(mon, DEBUG), "Couldn't create vbucket diff");
+            return 0;
+        }
+
+        chstatus = lcbvb_get_changetype(diff);
+        lcbvb_free_diff(diff);
+
+        if (chstatus == 0 || lcb_clconfig_compare(mon->config, info) >= 0) {
+            const lcbvb_CONFIG *ca, *cb;
+
+            ca = mon->config->vbc;
+            cb = info->vbc;
+
+            lcb_log(LOGARGS(mon, INFO), "Not applying configuration received via %s. No changes detected. A.rev=%d, B.rev=%d", provider_string(info->origin), ca->revid, cb->revid);
+            if (notify_miss) {
+                invoke_listeners(mon, CLCONFIG_EVENT_GOT_ANY_CONFIG, info);
+            }
+            return 0;
+        }
+    }
+
+    lcb_log(LOGARGS(mon, INFO), "Setting new configuration. Received via %s", provider_string(info->origin));
+
+    if (mon->config) {
+        /** DECREF the old one */
+        lcb_clconfig_decref(mon->config);
+    }
+
+    for (ii = 0; ii < LCB_CLCONFIG_MAX; ii++) {
+        clconfig_provider *cur = mon->all_providers[ii];
+        if (cur && cur->enabled && cur->config_updated) {
+            cur->config_updated(cur, info->vbc);
+        }
+    }
+
+    lcb_clconfig_incref(info);
+    mon->config = info;
+    lcb_confmon_stop(mon);
+
+    invoke_listeners(mon, CLCONFIG_EVENT_GOT_NEW_CONFIG, info);
+
+    return 1;
+}
+
+void lcb_confmon_provider_failed(clconfig_provider *provider,
+                                 lcb_error_t reason)
+{
+    lcb_confmon *mon = provider->parent;
+
+    lcb_log(LOGARGS(mon, INFO), "Provider '%s' failed", provider_string(provider->type));
+
+    if (provider != mon->cur_provider) {
+        lcb_log(LOGARGS(mon, TRACE), "Ignoring failure. Current=%p (%s)", (void*)mon->cur_provider, provider_string(mon->cur_provider->type));
+        return;
+    }
+    if (!lcb_confmon_is_refreshing(mon)) {
+        lcb_log(LOGARGS(mon, DEBUG), "Ignoring failure. Refresh not active");
+    }
+
+    if (reason != LCB_SUCCESS) {
+        if (mon->settings->detailed_neterr && mon->last_error != LCB_SUCCESS) {
+            /* Filter out any artificial 'connect error' or 'network error' codes */
+            if (reason != LCB_CONNECT_ERROR && reason != LCB_NETWORK_ERROR) {
+                mon->last_error = reason;
+            }
+        } else {
+            mon->last_error = reason;
+        }
+    }
+
+    mon->cur_provider = next_active(mon, mon->cur_provider);
+
+    if (!mon->cur_provider) {
+        LOG(mon, TRACE, "Maximum provider reached. Resetting index");
+        invoke_listeners(mon, CLCONFIG_EVENT_PROVIDERS_CYCLED, NULL);
+        mon->cur_provider = first_active(mon);
+        lcb_confmon_stop(mon);
+    } else {
+        uint32_t interval = 0;
+        if (mon->config) {
+            /* Not first */
+            interval = PROVIDER_SETTING(provider, grace_next_provider);
+        }
+        lcb_log(LOGARGS(mon, DEBUG), "Will try next provider in %uus", interval);
+        mon->state |= CONFMON_S_ITERGRACE;
+        lcbio_timer_rearm(mon->as_start, interval);
+    }
+}
+
+void lcb_confmon_provider_success(clconfig_provider *provider,
+                                  clconfig_info *config)
+{
+    do_set_next(provider->parent, config, 1);
+    lcb_confmon_stop(provider->parent);
+}
+
+
+static int do_next_provider(lcb_confmon *mon)
+{
+    lcb_list_t *ii;
+    mon->state &= ~CONFMON_S_ITERGRACE;
+
+    LCB_LIST_FOR(ii, (lcb_list_t *)&mon->active_providers) {
+        clconfig_info *info;
+        clconfig_provider *cached_provider;
+
+        cached_provider = LCB_LIST_ITEM(ii, clconfig_provider, ll);
+        info = cached_provider->get_cached(cached_provider);
+        if (!info) {
+            continue;
+        }
+
+        if (do_set_next(mon, info, 0)) {
+            LOG(mon, DEBUG, "Using cached configuration");
+            return 1;
+        }
+    }
+
+    lcb_log(LOGARGS(mon, TRACE), "Current provider is %s", provider_string(mon->cur_provider->type));
+
+    mon->cur_provider->refresh(mon->cur_provider);
+    return 0;
+}
+
+static void async_start(void *arg)
+{
+    do_next_provider(arg);
+}
+
+lcb_error_t lcb_confmon_start(lcb_confmon *mon)
+{
+    lcb_U32 tmonext = 0;
+
+    lcbio_async_cancel(mon->as_stop);
+    if (IS_REFRESHING(mon)) {
+        LOG(mon, DEBUG, "Refresh already in progress...");
+        return LCB_SUCCESS;
+    }
+
+    LOG(mon, TRACE, "Start refresh requested");
+    lcb_assert(mon->cur_provider);
+    mon->state = CONFMON_S_ACTIVE|CONFMON_S_ITERGRACE;
+
+    if (mon->last_stop_us > 0) {
+        lcb_U32 diff = LCB_NS2US(gethrtime()) - mon->last_stop_us;
+        if (diff <= mon->settings->grace_next_cycle) {
+            tmonext = mon->settings->grace_next_cycle - diff;
+        }
+    }
+
+    lcbio_timer_rearm(mon->as_start, tmonext);
+    return LCB_SUCCESS;
+}
+
+static void async_stop(void *arg)
+{
+    lcb_confmon *mon = arg;
+    lcb_list_t *ii;
+
+    LCB_LIST_FOR(ii, (lcb_list_t *)&mon->active_providers) {
+        clconfig_provider *provider = LCB_LIST_ITEM(ii, clconfig_provider, ll);
+        if (!provider->pause) {
+            continue;
+        }
+        provider->pause(provider);
+    }
+
+    mon->last_stop_us = LCB_NS2US(gethrtime());
+    invoke_listeners(mon, CLCONFIG_EVENT_MONITOR_STOPPED, NULL);
+}
+
+lcb_error_t lcb_confmon_stop(lcb_confmon *mon)
+{
+    if (!IS_REFRESHING(mon)) {
+        return LCB_SUCCESS;
+    }
+    lcbio_timer_disarm(mon->as_start);
+    lcbio_async_signal(mon->as_stop);
+    mon->state = CONFMON_S_INACTIVE;
+    return LCB_SUCCESS;
+}
+
+void lcb_clconfig_decref(clconfig_info *info)
+{
+    lcb_assert(info->refcount);
+
+    if (--info->refcount) {
+        return;
+    }
+
+    if (info->vbc) {
+        lcbvb_destroy(info->vbc);
+    }
+
+    free(info);
+}
+
+int lcb_clconfig_compare(const clconfig_info *a, const clconfig_info *b)
+{
+    /** First check if both have revisions */
+    int rev_a, rev_b;
+    rev_a = lcbvb_get_revision(a->vbc);
+    rev_b = lcbvb_get_revision(b->vbc);
+    if (rev_a >= 0  && rev_b >= 0) {
+        return rev_a - rev_b;
+    }
+
+    if (a->cmpclock == b->cmpclock) {
+        return 0;
+
+    } else if (a->cmpclock < b->cmpclock) {
+        return -1;
+    }
+
+    return 1;
+}
+
+clconfig_info *
+lcb_clconfig_create(lcbvb_CONFIG* config, clconfig_method_t origin)
+{
+    clconfig_info *info = calloc(1, sizeof(*info));
+    if (!info) {
+        return NULL;
+    }
+    info->refcount = 1;
+    info->vbc = config;
+    info->origin = origin;
+    return info;
+}
+
+void lcb_confmon_add_listener(lcb_confmon *mon, clconfig_listener *listener)
+{
+    listener->parent = mon;
+    lcb_list_append(&mon->listeners, &listener->ll);
+}
+
+void lcb_confmon_remove_listener(lcb_confmon *mon, clconfig_listener *listener)
+{
+    lcb_list_delete(&listener->ll);
+    (void)mon;
+}
+
+static void invoke_listeners(lcb_confmon *mon,
+                             clconfig_event_t event,
+                             clconfig_info *info)
+{
+    lcb_list_t *ll, *ll_next;
+    LCB_LIST_SAFE_FOR(ll, ll_next, &mon->listeners) {
+        clconfig_listener *lsn = LCB_LIST_ITEM(ll, clconfig_listener, ll);
+        lsn->callback(lsn, event, info);
+    }
+}
+
+static void generic_shutdown(clconfig_provider *provider)
+{
+    free(provider);
+}
+
+clconfig_provider * lcb_clconfig_create_user(lcb_confmon *mon)
+{
+    clconfig_provider *provider = calloc(1, sizeof(*provider));
+    provider->type = LCB_CLCONFIG_USER;
+    provider->shutdown = generic_shutdown;
+
+    (void)mon;
+    return provider;
+}
+
+LCB_INTERNAL_API
+int lcb_confmon_is_refreshing(lcb_confmon *mon)
+{
+    return IS_REFRESHING(mon);
+}
+
+LCB_INTERNAL_API
+void
+lcb_confmon_set_provider_active(lcb_confmon *mon,
+    clconfig_method_t type, int enabled)
+{
+    clconfig_provider *provider = mon->all_providers[type];
+    if (provider->enabled == enabled) {
+        return;
+    } else {
+        provider->enabled = enabled;
+    }
+    lcb_confmon_prepare(mon);
+}
+
+void
+lcb_confmon_dump(lcb_confmon *mon, FILE *fp)
+{
+    unsigned ii;
+    fprintf(fp, "CONFMON=%p\n", (void*)mon);
+    fprintf(fp, "STATE= (0x%x)", mon->state);
+    if (mon->state & CONFMON_S_ACTIVE) {
+        fprintf(fp, "ACTIVE|");
+    }
+    if (mon->state == CONFMON_S_INACTIVE) {
+        fprintf(fp, "INACTIVE/IDLE");
+    }
+    if (mon->state & CONFMON_S_ITERGRACE) {
+        fprintf(fp, "ITERGRACE");
+    }
+    fprintf(fp, "\n");
+    fprintf(fp, "LAST ERROR: 0x%x\n", mon->last_error);
+
+
+    for (ii = 0; ii < LCB_CLCONFIG_MAX; ii++) {
+        clconfig_provider *cur = mon->all_providers[ii];
+        if (!cur) {
+            continue;
+        }
+
+        fprintf(fp, "** PROVIDER: 0x%x (%s) %p\n", cur->type, provider_string(cur->type), (void*)cur);
+        fprintf(fp, "** ENABLED: %s\n", cur->enabled ? "YES" : "NO");
+        fprintf(fp, "** CURRENT: %s\n", cur == mon->cur_provider ? "YES" : "NO");
+        if (cur->dump) {
+            cur->dump(cur, fp);
+        }
+        fprintf(fp, "\n");
+    }
+}