libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/src/bucketconfig/bc_cccp.cc

@@ -24,54 +24,36 @@
 #include "internal.h"
 #include "clconfig.h"
 #include "packetutils.h"
+#include "simplestring.h"
 #include <mcserver/negotiate.h>
 #include <lcbio/lcbio.h>
-#include <lcbio/timer-cxx.h>
+#include <lcbio/timer-ng.h>
 #include <lcbio/ssl.h>
 #include "ctx-log-inl.h"
 #define LOGARGS(cccp, lvl) cccp->parent->settings, "cccp", LCB_LOG_##lvl, __FILE__, __LINE__
 #define LOGFMT "<%s:%s> "
 #define LOGID(cccp) get_ctx_host(cccp->ioctx), get_ctx_port(cccp->ioctx)
 
-struct CccpCookie;
+#define PROVIDER_SETTING_T(fld) PROVIDER_SETTING(this, fld)
 
-using namespace lcb::clconfig;
+struct CccpCookie;
 
-struct CccpProvider : public Provider {
-    CccpProvider(Confmon *);
+struct CccpProvider : public clconfig_provider {
+    CccpProvider(lcb_confmon *);
     ~CccpProvider();
 
     void release_socket(bool can_reuse);
     lcb_error_t schedule_next_request(lcb_error_t why, bool can_rollover);
     lcb_error_t mcio_error(lcb_error_t why);
-    void on_timeout() { mcio_error(LCB_ETIMEDOUT); }
     lcb_error_t update(const char *host, const char* data);
     void request_config();
+    void on_config_updated(lcbvb_CONFIG *vbc);
     void on_io_read();
 
-    bool pause(); // Override
-    void configure_nodes(const lcb::Hostlist&); // Override
-    void config_updated(lcbvb_CONFIG *); // Override;
-    void dump(FILE*) const; // Override
-    lcb_error_t refresh(); // Override
-
-    ConfigInfo *get_cached() /* Override */ {
-        return config;
-    }
-
-    const lcb::Hostlist* get_nodes() const /* Override */ {
-        return nodes;
-    }
-
-    void enable(void *arg) {
-        instance = reinterpret_cast<lcb_t>(arg);
-        Provider::enable();
-    }
-
     lcb::Hostlist *nodes;
-    ConfigInfo *config;
+    clconfig_info *config;
     bool server_active;
-    lcb::io::Timer<CccpProvider, &CccpProvider::on_timeout> timer;
+    lcbio_pTIMER timer;
     lcb_t instance;
     lcbio_CONNREQ creq;
     lcbio_CTX *ioctx;
@@ -124,19 +106,19 @@ CccpProvider::schedule_next_request(lcb_error_t err, bool can_rollover)
     lcb::Server *server;
     lcb_host_t *next_host = nodes->next(can_rollover);
     if (!next_host) {
-        timer.cancel();
-        parent->provider_failed(this, err);
+        lcbio_timer_disarm(timer);
+        lcb_confmon_provider_failed(this, err);
         server_active = false;
         return err;
     }
 
-    server = instance->find_server(*next_host);
+    server = lcb_find_server_by_host(instance, next_host);
     if (server) {
         CccpCookie *cookie = new CccpCookie(this);
         cmdcookie = cookie;
         lcb_log(LOGARGS(this, INFO), "Re-Issuing CCCP Command on server struct %p (%s:%s)", (void*)server, next_host->host, next_host->port);
-        timer.rearm(settings().config_node_timeout);
-        instance->request_config(cookie, server);
+        lcbio_timer_rearm(timer, PROVIDER_SETTING_T(config_node_timeout));
+        return lcb_getconfig(instance, cookie, server);
 
     } else {
         lcbio_pMGRREQ preq;
@@ -144,7 +126,7 @@ CccpProvider::schedule_next_request(lcb_error_t err, bool can_rollover)
         lcb_log(LOGARGS(this, INFO), "Requesting connection to node %s:%s for CCCP configuration", next_host->host, next_host->port);
         preq = lcbio_mgr_get(
                 instance->memd_sockpool, next_host,
-                settings().config_node_timeout,
+                PROVIDER_SETTING_T(config_node_timeout),
                 on_connected, this);
         LCBIO_CONNREQ_MKPOOLED(&creq, preq);
     }
@@ -157,16 +139,32 @@ lcb_error_t
 CccpProvider::mcio_error(lcb_error_t err)
 {
     if (err != LCB_NOT_SUPPORTED && err != LCB_UNKNOWN_COMMAND) {
-        lcb_log(LOGARGS(this, ERR), LOGFMT "Could not get configuration: %s", LOGID(this), lcb_strerror_short(err));
+        lcb_log(LOGARGS(this, ERR), LOGFMT "Got I/O Error=0x%x", LOGID(this), err);
     }
 
     release_socket(err == LCB_NOT_SUPPORTED);
     return schedule_next_request(err, false);
 }
 
+static void socket_timeout(void *arg) {
+    reinterpret_cast<CccpProvider*>(arg)->mcio_error(LCB_ETIMEDOUT);
+}
+
+void lcb_clconfig_cccp_enable(clconfig_provider *pb, lcb_t instance)
+{
+    CccpProvider *cccp = static_cast<CccpProvider*>(pb);
+    lcb_assert(pb->type == LCB_CLCONFIG_CCCP);
+    cccp->instance = instance;
+    pb->enabled = true;
+}
+
+static hostlist_t get_nodes(const clconfig_provider *pb) {
+    return static_cast<const CccpProvider*>(pb)->nodes;
+}
+
 /** Update the configuration from a server. */
 lcb_error_t
-lcb::clconfig::cccp_update(Provider *provider, const char *host, const char *data) {
+lcb_cccp_update(clconfig_provider *provider, const char *host, const char *data) {
     return static_cast<CccpProvider*>(provider)->update(host, data);
 }
 
@@ -176,7 +174,7 @@ CccpProvider::update(const char *host, const char *data)
     /** TODO: replace this with lcbvb_ names */
     lcbvb_CONFIG* vbc;
     int rv;
-    ConfigInfo *new_config;
+    clconfig_info *new_config;
     vbc = lcbvb_create();
 
     if (!vbc) {
@@ -192,7 +190,7 @@ CccpProvider::update(const char *host, const char *data)
     }
 
     lcbvb_replace_host(vbc, host);
-    new_config = ConfigInfo::create(vbc, CLCONFIG_CCCP);
+    new_config = lcb_clconfig_create(vbc, LCB_CLCONFIG_CCCP);
 
     if (!new_config) {
         lcbvb_destroy(vbc);
@@ -200,24 +198,25 @@ CccpProvider::update(const char *host, const char *data)
     }
 
     if (config) {
-        config->decref();
+        lcb_clconfig_decref(config);
     }
 
     /** TODO: Figure out the comparison vector */
+    new_config->cmpclock = gethrtime();
     config = new_config;
-    parent->provider_got_config(this, new_config);
+    lcb_confmon_provider_success(this, new_config);
     return LCB_SUCCESS;
 }
 
-void lcb::clconfig::cccp_update(
-    const void *cookie, lcb_error_t err,
-    const void *bytes, size_t nbytes, const lcb_host_t *origin)
+void lcb_cccp_update2(const void *cookie, lcb_error_t err,
+                      const void *bytes, lcb_size_t nbytes,
+                      const lcb_host_t *origin)
 {
     CccpCookie *ck = reinterpret_cast<CccpCookie*>(const_cast<void*>(cookie));
     CccpProvider *cccp = ck->parent;
 
     if (ck == cccp->cmdcookie) {
-        cccp->timer.cancel();
+        lcbio_timer_disarm(cccp->timer);
         cccp->cmdcookie = NULL;
     }
 
@@ -264,53 +263,70 @@ on_connected(lcbio_SOCKET *sock, void *data, lcb_error_t err, lcbio_OSERR)
     cccp->request_config();
 }
 
-lcb_error_t CccpProvider::refresh() {
-    if (creq.u.p_generic || server_active || cmdcookie) {
+static lcb_error_t cccp_get(clconfig_provider *pb)
+{
+    CccpProvider *cccp = static_cast<CccpProvider *>(pb);
+    if (cccp->creq.u.p_generic || cccp->server_active || cccp->cmdcookie) {
         return LCB_BUSY;
     }
 
-    return schedule_next_request(LCB_SUCCESS, true);
+    return cccp->schedule_next_request(LCB_SUCCESS, true);
 }
 
-bool
-CccpProvider::pause()
+static clconfig_info *cccp_get_cached(clconfig_provider *pb) {
+    return static_cast<CccpProvider *>(pb)->config;
+}
+
+static lcb_error_t cccp_pause(clconfig_provider *pb)
 {
-    if (!server_active) {
-        return true;
+    CccpProvider *cccp = static_cast<CccpProvider *>(pb);
+    if (!cccp->server_active) {
+        return LCB_SUCCESS;
     }
 
-    server_active = 0;
-    release_socket(false);
-    timer.cancel();
-    return true;
+    cccp->server_active = 0;
+    cccp->release_socket(false);
+    lcbio_timer_disarm(cccp->timer);
+    return LCB_SUCCESS;
+}
+
+static void cccp_cleanup(clconfig_provider *pb) {
+    delete static_cast<CccpProvider*>(pb);
 }
 
 CccpProvider::~CccpProvider() {
     release_socket(false);
 
     if (config) {
-        config->decref();
+        lcb_clconfig_decref(config);
     }
     if (nodes) {
         delete nodes;
     }
-    timer.release();
+    if (timer) {
+        lcbio_timer_destroy(timer);
+    }
     if (cmdcookie) {
         cmdcookie->ignore_errors = 1;
     }
 }
 
-void
-CccpProvider::configure_nodes(const lcb::Hostlist& nodes_)
+static void
+configure_nodes(clconfig_provider *pb, const hostlist_t nodes)
 {
-    nodes->assign(nodes_);
-    if (parent->settings->randomize_bootstrap_nodes) {
-        nodes->randomize();
+    CccpProvider *cccp = static_cast<CccpProvider *>(pb);
+    cccp->nodes->assign(*nodes);
+    if (PROVIDER_SETTING(pb, randomize_bootstrap_nodes)) {
+        cccp->nodes->randomize();
     }
 }
 
+static void config_updated(clconfig_provider *provider, lcbvb_CONFIG* vbc) {
+    static_cast<CccpProvider*>(provider)->on_config_updated(vbc);
+}
+
 void
-CccpProvider::config_updated(lcbvb_CONFIG *vbc)
+CccpProvider::on_config_updated(lcbvb_CONFIG *vbc)
 {
     lcbvb_SVCMODE mode;
     if (LCBVB_NSERVERS(vbc) < 1) {
@@ -318,7 +334,7 @@ CccpProvider::config_updated(lcbvb_CONFIG *vbc)
     }
 
     nodes->clear();
-    if (settings().sslopts & LCB_SSL_ENABLED) {
+    if (PROVIDER_SETTING_T(sslopts) & LCB_SSL_ENABLED) {
         mode = LCBVB_SVCMODE_SSL;
     } else {
         mode = LCBVB_SVCMODE_PLAIN;
@@ -333,7 +349,7 @@ CccpProvider::config_updated(lcbvb_CONFIG *vbc)
         nodes->add(mcaddr, LCB_CONFIG_MCD_PORT);
     }
 
-    if (settings().randomize_bootstrap_nodes) {
+    if (PROVIDER_SETTING_T(randomize_bootstrap_nodes)) {
         nodes->randomize();
     }
 }
@@ -395,7 +411,7 @@ CccpProvider::on_io_read()
     lcb_error_t err = update(hoststr.c_str(), jsonstr.c_str());
 
     if (err == LCB_SUCCESS) {
-        timer.cancel();
+        lcbio_timer_disarm(timer);
         server_active = false;
     } else {
         schedule_next_request(LCB_PROTOCOL_ERROR, 0);
@@ -411,45 +427,62 @@ void CccpProvider::request_config()
     lcbio_ctx_put(ioctx, req.data(), req.size());
     lcbio_ctx_rwant(ioctx, 24);
     lcbio_ctx_schedule(ioctx);
-    timer.rearm(settings().config_node_timeout);
+    lcbio_timer_rearm(timer, PROVIDER_SETTING(this, config_node_timeout));
 }
 
-void CccpProvider::dump(FILE *fp) const {
-    if (!enabled) {
+static void do_dump(clconfig_provider *pb, FILE *fp)
+{
+    CccpProvider *cccp = (CccpProvider *)pb;
+
+    if (!cccp->enabled) {
         return;
     }
 
     fprintf(fp, "## BEGIN CCCP PROVIDER DUMP ##\n");
-    fprintf(fp, "TIMER ACTIVE: %s\n", timer.is_armed() ? "YES" : "NO");
-    fprintf(fp, "PIPELINE RESPONSE COOKIE: %p\n", (void*)cmdcookie);
-    if (ioctx) {
+    fprintf(fp, "TIMER ACTIVE: %s\n", lcbio_timer_armed(cccp->timer) ? "YES" : "NO");
+    fprintf(fp, "PIPELINE RESPONSE COOKIE: %p\n", (void*)cccp->cmdcookie);
+    if (cccp->ioctx) {
         fprintf(fp, "CCCP Owns connection:\n");
-        lcbio_ctx_dump(ioctx, fp);
-    } else if (creq.u.p_generic) {
+        lcbio_ctx_dump(cccp->ioctx, fp);
+    } else if (cccp->creq.u.p_generic) {
         fprintf(fp, "CCCP Is connecting\n");
     } else {
         fprintf(fp, "CCCP does not have a dedicated connection\n");
     }
 
-    for (size_t ii = 0; ii < nodes->size(); ii++) {
-        const lcb_host_t &curhost = (*nodes)[ii];
+    for (size_t ii = 0; ii < cccp->nodes->size(); ii++) {
+        const lcb_host_t &curhost = (*cccp->nodes)[ii];
         fprintf(fp, "CCCP NODE: %s:%s\n", curhost.host, curhost.port);
     }
     fprintf(fp, "## END CCCP PROVIDER DUMP ##\n");
 }
 
-CccpProvider::CccpProvider(Confmon *mon)
-    : Provider(mon, CLCONFIG_CCCP),
-      nodes(new lcb::Hostlist()),
+clconfig_provider * lcb_clconfig_create_cccp(lcb_confmon *mon)
+{
+    return new CccpProvider(mon);
+}
+
+CccpProvider::CccpProvider(lcb_confmon *mon)
+    : nodes(new lcb::Hostlist()),
       config(NULL),
       server_active(false),
-      timer(mon->iot, this),
+      timer(NULL),
       instance(NULL),
       ioctx(NULL),
-      cmdcookie(NULL) {
+      cmdcookie(NULL)
+{
+    clconfig_provider::type = LCB_CLCONFIG_CCCP;
+    clconfig_provider::refresh = cccp_get;
+    clconfig_provider::get_cached = cccp_get_cached;
+    clconfig_provider::pause = cccp_pause;
+    clconfig_provider::shutdown = cccp_cleanup;
+    clconfig_provider::config_updated = ::config_updated;
+    clconfig_provider::configure_nodes = ::configure_nodes;
+    clconfig_provider::get_nodes = ::get_nodes;
+    clconfig_provider::dump = do_dump;
+    clconfig_provider::parent = mon;
+    clconfig_provider::enabled = 0;
+
+    timer = lcbio_timer_new(mon->iot, this, socket_timeout);
     std::memset(&creq, 0, sizeof creq);
 }
-
-Provider* lcb::clconfig::new_cccp_provider(Confmon *mon) {
-    return new CccpProvider(mon);
-}

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

@@ -0,0 +1,347 @@
+/* -*- 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"
+#include "simplestring.h"
+#include <lcbio/lcbio.h>
+#include <lcbio/timer-ng.h>
+
+#define CONFIG_CACHE_MAGIC "{{{fb85b563d0a8f65fa8d3d58f1b3a0708}}}"
+
+#define LOGARGS(pb, lvl) pb->base.parent->settings, "bc_file", LCB_LOG_##lvl, __FILE__, __LINE__
+#define LOGFMT "(cache=%s) "
+#define LOGID(fb) fb->filename
+
+typedef struct {
+    clconfig_provider base;
+    char *filename;
+    clconfig_info *config;
+    time_t last_mtime;
+    int last_errno;
+    int ro_mode; /* Whether the config cache should _not_ overwrite the file */
+    lcbio_pTIMER timer;
+    clconfig_listener listener;
+} file_provider;
+
+static int load_cache(file_provider *provider)
+{
+    lcb_string str;
+    char line[1024];
+    lcb_ssize_t nr;
+    int fail;
+    FILE *fp = NULL;
+    lcbvb_CONFIG *config = NULL;
+    char *end;
+    struct stat st;
+    int status = -1;
+
+    lcb_string_init(&str);
+
+    if (provider->filename == NULL) {
+        return -1;
+    }
+
+    fp = fopen(provider->filename, "r");
+    if (fp == NULL) {
+        int save_errno = errno;
+        lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't open for reading: %s", LOGID(provider), strerror(save_errno));
+        return -1;
+    }
+
+    if (fstat(fileno(fp), &st)) {
+        provider->last_errno = errno;
+        goto GT_DONE;
+    }
+
+    if (provider->last_mtime == st.st_mtime) {
+        lcb_log(LOGARGS(provider, WARN), LOGFMT "Modification time too old", LOGID(provider));
+        goto GT_DONE;
+    }
+
+    config = lcbvb_create();
+    if (config == NULL) {
+        goto GT_DONE;
+    }
+
+    lcb_string_init(&str);
+
+    while ((nr = fread(line, 1, sizeof(line), fp)) > 0) {
+        if (lcb_string_append(&str, line, nr)) {
+            goto GT_DONE;
+        }
+    }
+
+    if (ferror(fp)) {
+        goto GT_DONE;
+    }
+
+    fclose(fp);
+    fp = NULL;
+
+    if (!str.nused) {
+        status = -1;
+        goto GT_DONE;
+    }
+
+    end = strstr(str.base, CONFIG_CACHE_MAGIC);
+    if (end == NULL) {
+        lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't find magic", LOGID(provider));
+        if (!provider->ro_mode) {
+            remove(provider->filename);
+        }
+        status = -1;
+        goto GT_DONE;
+    }
+
+    fail = lcbvb_load_json(config, str.base);
+    if (fail) {
+        status = -1;
+        lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't parse configuration", LOGID(provider));
+        lcb_log_badconfig(LOGARGS(provider, ERROR), config, str.base);
+        if (!provider->ro_mode) {
+            remove(provider->filename);
+        }
+        goto GT_DONE;
+    }
+
+    if (lcbvb_get_distmode(config) != LCBVB_DIST_VBUCKET) {
+        status = -1;
+        lcb_log(LOGARGS(provider, ERROR), LOGFMT "Not applying cached memcached config", LOGID(provider));
+        goto GT_DONE;
+    }
+
+    if (strcmp(config->bname, PROVIDER_SETTING(&provider->base, bucket)) != 0) {
+        status = -1;
+        lcb_log(LOGARGS(provider, ERROR), LOGFMT "Bucket name in file is different from the one requested", LOGID(provider));
+    }
+
+    if (provider->config) {
+        lcb_clconfig_decref(provider->config);
+    }
+
+    provider->config = lcb_clconfig_create(config, LCB_CLCONFIG_FILE);
+    provider->config->cmpclock = gethrtime();
+    provider->config->origin = provider->base.type;
+    provider->last_mtime = st.st_mtime;
+    status = 0;
+    config = NULL;
+
+    GT_DONE:
+    if (fp != NULL) {
+        fclose(fp);
+    }
+
+    if (config != NULL) {
+        lcbvb_destroy(config);
+    }
+
+    lcb_string_release(&str);
+    return status;
+}
+
+static void
+write_to_file(file_provider *provider, lcbvb_CONFIG *cfg)
+{
+    FILE *fp;
+
+    if (provider->filename == NULL || provider->ro_mode) {
+        return;
+    }
+
+    fp = fopen(provider->filename, "w");
+    if (fp) {
+        char *json = lcbvb_save_json(cfg);
+        lcb_log(LOGARGS(provider, INFO), LOGFMT "Writing configuration to file", LOGID(provider));
+        fprintf(fp, "%s%s", json, CONFIG_CACHE_MAGIC);
+        fclose(fp);
+        free(json);
+    } else {
+        int save_errno = errno;
+        lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't open file for writing: %s", LOGID(provider), strerror(save_errno));
+    }
+}
+
+static clconfig_info * get_cached(clconfig_provider *pb)
+{
+    file_provider *provider = (file_provider *)pb;
+    if (!provider->filename) {
+        return NULL;
+    }
+
+    return provider->config;
+}
+
+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 lcb_error_t refresh_file(clconfig_provider *pb)
+{
+    file_provider *provider = (file_provider *)pb;
+    if (lcbio_timer_armed(provider->timer)) {
+        return LCB_SUCCESS;
+    }
+
+    lcbio_async_signal(provider->timer);
+    return LCB_SUCCESS;
+}
+
+static lcb_error_t pause_file(clconfig_provider *pb)
+{
+    (void)pb;
+    return LCB_SUCCESS;
+}
+
+static void shutdown_file(clconfig_provider *pb)
+{
+    file_provider *provider = (file_provider *)pb;
+    free(provider->filename);
+    if (provider->timer) {
+        lcbio_timer_destroy(provider->timer);
+    }
+    if (provider->config) {
+        lcb_clconfig_decref(provider->config);
+    }
+    free(provider);
+}
+
+static void config_listener(clconfig_listener *lsn, clconfig_event_t event,
+                            clconfig_info *info)
+{
+    file_provider *provider;
+
+    if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+        return;
+    }
+
+    provider = (file_provider *) (void*)(((char *)lsn) - offsetof(file_provider, listener));
+    if (!provider->base.enabled) {
+        return;
+    }
+
+    if (info->origin == LCB_CLCONFIG_PHONY || info->origin == LCB_CLCONFIG_FILE) {
+        lcb_log(LOGARGS(provider, TRACE), "Not writing configuration originating from PHONY or FILE to cache");
+        return;
+    }
+
+    write_to_file(provider, info->vbc);
+}
+
+static void
+do_file_dump(clconfig_provider *pb, FILE *fp)
+{
+    file_provider *pr = (file_provider *)pb;
+
+    fprintf(fp, "## BEGIN FILE PROVIEDER DUMP ##\n");
+    if (pr->filename) {
+        fprintf(fp, "FILENAME: %s\n", pr->filename);
+    }
+    fprintf(fp, "LAST SYSTEM ERRNO: %d\n", pr->last_errno);
+    fprintf(fp, "LAST MTIME: %lu\n", (unsigned long)pr->last_mtime);
+    fprintf(fp, "## END FILE PROVIDER DUMP ##\n");
+
+}
+
+clconfig_provider * lcb_clconfig_create_file(lcb_confmon *parent)
+{
+    file_provider *provider = calloc(1, sizeof(*provider));
+
+    if (!provider) {
+        return NULL;
+    }
+
+    provider->base.get_cached = get_cached;
+    provider->base.refresh = refresh_file;
+    provider->base.pause = pause_file;
+    provider->base.shutdown = shutdown_file;
+    provider->base.dump = do_file_dump;
+    provider->base.type = LCB_CLCONFIG_FILE;
+    provider->listener.callback = config_listener;
+    provider->timer = lcbio_timer_new(parent->iot, provider, async_callback);
+
+    lcb_confmon_add_listener(parent, &provider->listener);
+
+    return &provider->base;
+}
+
+
+static char *mkcachefile(const char *name, const char *bucket)
+{
+    if (name != NULL) {
+        return strdup(name);
+    } else {
+        char buffer[1024];
+        const char *tmpdir = lcb_get_tmpdir();
+
+        snprintf(buffer, sizeof(buffer),
+                 "%s/%s", tmpdir ? tmpdir : ".", bucket);
+        return strdup(buffer);
+    }
+}
+
+int lcb_clconfig_file_set_filename(clconfig_provider *p, const char *f, int ro)
+{
+    file_provider *provider = (file_provider *)p;
+    lcb_assert(provider->base.type == LCB_CLCONFIG_FILE);
+    provider->base.enabled = 1;
+
+    if (provider->filename) {
+        free(provider->filename);
+    }
+
+    provider->filename = mkcachefile(f, p->parent->settings->bucket);
+
+    if (ro) {
+        FILE *fp_tmp;
+        provider->ro_mode = 1;
+
+        fp_tmp = fopen(provider->filename, "r");
+        if (!fp_tmp) {
+            lcb_log(LOGARGS(provider, ERROR), LOGFMT "Couldn't open for reading: %s", LOGID(provider), strerror(errno));
+            return -1;
+        } else {
+            fclose(fp_tmp);
+        }
+    }
+
+    return 0;
+}
+
+const char *
+lcb_clconfig_file_get_filename(clconfig_provider *p)
+{
+    file_provider *fp = (file_provider *)p;
+    return fp->filename;
+}
+
+void
+lcb_clconfig_file_set_readonly(clconfig_provider *p, int val)
+{
+    ((file_provider *)p)->ro_mode = val;
+}