testapp.c

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <stdint.h>
#include <ctype.h>
#include <dlfcn.h>
#include <arpa/inet.h>
#include <assert.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>

#include "bucket_engine.h"

#include "memcached/engine.h"
#include "memcached/util.h"

#define ENGINE_PATH ".libs/mock_engine.so"
#define DEFAULT_CONFIG "engine=.libs/mock_engine.so;default=true;admin=admin" \
    ";auto_create=false"
#define DEFAULT_CONFIG_NO_DEF "engine=.libs/mock_engine.so;default=false;admin=admin" \
    ";auto_create=false"
#define DEFAULT_CONFIG_AC "engine=.libs/mock_engine.so;default=true;admin=admin" \
    ";auto_create=true"

#define MOCK_CONFIG_NO_ALLOC "no_alloc"

#define CONN_MAGIC 16369814453946373207ULL

protocol_binary_response_status last_status = 0;
char *last_key = NULL;
char *last_body = NULL;

enum test_result {
    SUCCESS = 11,
    FAIL    = 13,
    DIED    = 14,
    CORE    = 15,
    PENDING = 19
};

struct test {
    const char *name;
    enum test_result (*tfun)(ENGINE_HANDLE *, ENGINE_HANDLE_V1 *);
    const char *cfg;
};

struct connstruct {
    uint64_t magic;
    const char *uname;
    const char *config;
    void *engine_data;
    bool connected;
    struct connstruct *next;
};

struct engine_event_handler {
    EVENT_CALLBACK cb;
    const void *cb_data;
    struct engine_event_handler *next;
};

static struct connstruct *connstructs;

static struct engine_event_handler *engine_event_handlers[MAX_ENGINE_EVENT_TYPE + 1];

static inline void perform_callbacks(ENGINE_EVENT_TYPE type,
                                     const void *data,
                                     const void *cookie) {
    struct connstruct *c = (struct connstruct*) cookie;
    for (struct engine_event_handler *h = engine_event_handlers[type];
         h; h = h->next) {
        h->cb(c, type, data, h->cb_data);
    }
}

static const char* get_server_version() {
    return "bucket mock";
}

static void get_auth_data(const void *cookie, auth_data_t *data) {
    struct connstruct *c = (struct connstruct *)cookie;
    if (c != NULL) {
        data->username = c->uname;
        data->config = c->config;
    }
}

static struct connstruct *mk_conn(const char *user, const char *config) {
    struct connstruct *rv = calloc(sizeof(struct connstruct), 1);
    auth_data_t ad;
    assert(rv);
    rv->magic = CONN_MAGIC;
    rv->uname = user ? strdup(user) : NULL;
    rv->config = config ? strdup(config) : NULL;
    rv->connected = true;
    rv->next = connstructs;
    connstructs = rv;
    perform_callbacks(ON_CONNECT, NULL, rv);
    if (rv->uname) {
        get_auth_data(rv, &ad);
        perform_callbacks(ON_AUTH, (const void*)&ad, rv);
    }
    return rv;
}

static void disconnect(struct connstruct *c) {
    c->connected = false;
    perform_callbacks(ON_DISCONNECT, NULL, c);
}

static void register_callback(ENGINE_HANDLE *eh,
                              ENGINE_EVENT_TYPE type,
                              EVENT_CALLBACK cb,
                              const void *cb_data) {
    struct engine_event_handler *h =
        calloc(sizeof(struct engine_event_handler), 1);
    assert(h);
    h->cb = cb;
    h->cb_data = cb_data;
    h->next = engine_event_handlers[type];
    engine_event_handlers[type] = h;
}

static void store_engine_specific(const void *cookie,
                                  void *engine_data) {
    if (cookie) {
        struct connstruct *c = (struct connstruct *)cookie;
        assert(c->magic == CONN_MAGIC);
        c->engine_data = engine_data;
    }
}

static void *get_engine_specific(const void *cookie) {
    struct connstruct *c = (struct connstruct *)cookie;
    assert(c == NULL || c->magic == CONN_MAGIC);
    return c ? c->engine_data : NULL;
}

static void *create_stats() {
    /* XXX: Not sure if ``big buffer'' is right in faking this part of
       the server. */
    void *s = calloc(1, 256);
    assert(s);
    return s;
}

static void destroy_stats(void *s) {
    assert(s);
    free(s);
}

/**
 * Callback the engines may call to get the public server interface
 * @param interface the requested interface from the server
 * @return pointer to a structure containing the interface. The client should
 *         know the layout and perform the proper casts.
 */
static SERVER_HANDLE_V1 *get_server_api(void)
{
    static SERVER_CORE_API core_api = {
        .get_auth_data = get_auth_data,
        .store_engine_specific = store_engine_specific,
        .get_engine_specific = get_engine_specific,
        // .get_socket_fd = get_socket_fd,
        .server_version = get_server_version,
        // .hash = hash,
        // .realtime = realtime,
        // .notify_io_complete = notify_io_complete,
        // .get_current_time = get_current_time,
        .parse_config = parse_config
    };

    static SERVER_STAT_API server_stat_api = {
        .new_stats = create_stats,
        .release_stats = destroy_stats
        // .evicting = count_eviction
    };

    static SERVER_EXTENSION_API extension_api = { 0 };
        // .register_extension = register_extension,
        // .unregister_extension = unregister_extension,
        // .get_extension = get_extension

    static SERVER_CALLBACK_API callback_api = {
        .register_callback = register_callback,
        .perform_callbacks = perform_callbacks,
    };

    static SERVER_HANDLE_V1 rv = {
        .interface = 1,
        .core = &core_api,
        .stat = &server_stat_api,
        .extension = &extension_api,
        .callback = &callback_api
    };

    return &rv;
}

bool add_response(const void *key, uint16_t keylen,
                  const void *ext, uint8_t extlen,
                  const void *body, uint32_t bodylen,
                  uint8_t datatype, uint16_t status,
                  uint64_t cas, const void *cookie) {
    last_status = status;
    if (last_body) {
        free(last_body);
        last_body = NULL;
    }
    if (bodylen > 0) {
        last_body = malloc(bodylen);
        assert(last_body);
        memcpy(last_body, body, bodylen);
    }
    if (last_key) {
        free(last_key);
        last_key = NULL;
    }
    if (keylen > 0) {
        last_key = malloc(keylen);
        assert(last_key);
        memcpy(last_key, key, keylen);
    }
    return true;
}

static ENGINE_HANDLE *load_engine(const char *soname, const char *config_str) {

    ENGINE_HANDLE *engine = NULL;
    /* Hack to remove the warning from C99 */
    union my_hack {
        CREATE_INSTANCE create;
        void* voidptr;
    } my_create = {.create = NULL };

    void *handle = dlopen(soname, RTLD_LAZY | RTLD_LOCAL);
    if (handle == NULL) {
        const char *msg = dlerror();
        fprintf(stderr, "Failed to open library \"%s\": %s\n",
                soname ? soname : "self",
                msg ? msg : "unknown error");
        return NULL;
    }

    void *symbol = dlsym(handle, "create_instance");
    if (symbol == NULL) {
        fprintf(stderr,
                "Could not find symbol \"create_instance\" in %s: %s\n",
                soname ? soname : "self",
                dlerror());
        return NULL;
    }
    my_create.voidptr = symbol;

    /* request a instance with protocol version 1 */
    ENGINE_ERROR_CODE error = (*my_create.create)(1, get_server_api, &engine);

    if (error != ENGINE_SUCCESS || engine == NULL) {
        fprintf(stderr, "Failed to create instance. Error code: %d\n", error);
        dlclose(handle);
        return NULL;
    }

    if (engine->interface == 1) {
        ENGINE_HANDLE_V1 *v1 = (ENGINE_HANDLE_V1*)engine;
        if (v1->initialize(engine, config_str) != ENGINE_SUCCESS) {
            v1->destroy(engine);
            fprintf(stderr, "Failed to initialize instance. Error code: %d\n",
                    error);
            dlclose(handle);
            return NULL;
        }
    } else {
        fprintf(stderr, "Unsupported interface level\n");
        dlclose(handle);
        return NULL;
    }

    return engine;
}

// ----------------------------------------------------------------------
// The actual test stuff...
// ----------------------------------------------------------------------

static bool item_eq(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1,
                    const void *c1, item *item1,
                    const void *c2, item *item2) {
    item_info i1 = { .nvalue = 1 };
    item_info i2 = { .nvalue = 1 };

    if (!h1->get_item_info(h, c1, item1, &i1) ||
        !h1->get_item_info(h, c2, item2, &i2))
        return false;

    return i1.exptime == i2.exptime
        && i1.flags == i2.flags
        && i1.nkey == i2.nkey
        && i1.nbytes == i2.nbytes
        && i1.nvalue == i2.nvalue
        && memcmp(i1.key, i2.key, i1.nkey) == 0
        && memcmp(i1.value[0].iov_base, i2.value[0].iov_base,
                  i1.nbytes) == 0;
}

static void assert_item_eq(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1,
                           const void *c1, item *i1,
                           const void *c2, item *i2) {
    assert(item_eq(h, h1, c1, i1, c2, i2));
}

/* Convenient storage abstraction */
static void store(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1,
                  const void *cookie,
                  const char *key, const char *value,
                  item **outitem) {

    item *item = NULL;

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->allocate(h, cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_SUCCESS);

    item_info info = { .nvalue = 1 };
    h1->get_item_info(h, cookie, item, &info);

    memcpy((char*)info.value[0].iov_base, value, strlen(value));

    rv = h1->store(h, cookie, item, 0, OPERATION_SET, 0);
    assert(rv == ENGINE_SUCCESS);

    if (outitem) {
        *outitem = item;
    }
}

static enum test_result test_default_storage(ENGINE_HANDLE *h,
                                             ENGINE_HANDLE_V1 *h1) {
    item *item = NULL, *fetched_item;
    const void *cookie = mk_conn(NULL, NULL);
    char *key = "somekey";
    char *value = "some value";

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->allocate(h, cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_SUCCESS);

    item_info info = { .nvalue = 1 };
    assert(h1->get_item_info(h, cookie, item, &info));

    memcpy((char*)info.value[0].iov_base, value, strlen(value));

    rv = h1->store(h, cookie, item, 0, OPERATION_SET, 0);
    assert(rv == ENGINE_SUCCESS);

    rv = h1->get(h, cookie, &fetched_item, key, strlen(key), 0);
    assert(rv == ENGINE_SUCCESS);

    assert_item_eq(h, h1, cookie, item, cookie, fetched_item);

    // no effect, but increases coverage.
    h1->reset_stats(h, cookie);

    return SUCCESS;
}

static enum test_result test_default_storage_key_overrun(ENGINE_HANDLE *h,
                                                         ENGINE_HANDLE_V1 *h1) {
    item *item = NULL, *fetched_item;
    const void *cookie = mk_conn(NULL, NULL);
    char *key = "somekeyx";
    char *value = "some value";

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->allocate(h, cookie, &item,
                      key, strlen(key)-1,
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_SUCCESS);

    item_info info = { .nvalue = 1 };
    h1->get_item_info(h, cookie, item, &info);

    memcpy((char*)info.value[0].iov_base, value, strlen(value));

    rv = h1->store(h, cookie, item, 0, OPERATION_SET, 0);
    assert(rv == ENGINE_SUCCESS);

    rv = h1->get(h, cookie, &fetched_item, "somekey", strlen("somekey"), 0);
    assert(rv == ENGINE_SUCCESS);

    assert_item_eq(h, h1, cookie, item, cookie, fetched_item);

    h1->get_item_info(h, cookie, fetched_item, &info);

    rv = h1->remove(h, cookie, info.key, info.nkey, info.cas, 0);
    assert(rv == ENGINE_SUCCESS);

    return SUCCESS;
}

static enum test_result test_default_unlinked_remove(ENGINE_HANDLE *h,
                                                     ENGINE_HANDLE_V1 *h1) {
    item *item = NULL;
    const void *cookie = mk_conn(NULL, NULL);
    char *key = "somekeyx";
    const char *value = "the value";

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->allocate(h, cookie, &item,
                      key, strlen(key)-1,
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_SUCCESS);
    rv = h1->remove(h, cookie, key, strlen(key), 0, 0);
    assert(rv == ENGINE_KEY_ENOENT);

    return SUCCESS;
}

static enum test_result test_two_engines_no_autocreate(ENGINE_HANDLE *h,
                                                       ENGINE_HANDLE_V1 *h1) {
    item *item = NULL, *fetched_item;
    const void *cookie = mk_conn("autouser", NULL);
    char *key = "somekey";
    char *value = "some value";
    uint64_t cas_out = 0, result = 0;

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->allocate(h, cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_DISCONNECT);

    rv = h1->store(h, cookie, item, 0, OPERATION_SET, 0);
    assert(rv == ENGINE_DISCONNECT);

    rv = h1->get(h, cookie, &fetched_item, key, strlen(key), 0);
    assert(rv == ENGINE_DISCONNECT);

    rv = h1->remove(h, cookie, key, strlen(key), 0, 0);
    assert(rv == ENGINE_DISCONNECT);

    rv = h1->arithmetic(h, cookie, key, strlen(key),
                        true, true, 1, 1, 0, &cas_out, &result, 0);
    assert(rv == ENGINE_DISCONNECT);

    // no effect, but increases coverage.
    h1->reset_stats(h, cookie);

    return SUCCESS;
}

static enum test_result test_no_default_storage(ENGINE_HANDLE *h,
                                                ENGINE_HANDLE_V1 *h1) {
    item *item = NULL, *fetched_item;
    const void *cookie = mk_conn(NULL, NULL);
    char *key = "somekey";
    char *value = "some value";

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->allocate(h, cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_DISCONNECT);

    rv = h1->get(h, cookie, &fetched_item, key, strlen(key), 0);
    assert(rv == ENGINE_DISCONNECT);


    return SUCCESS;
}

static enum test_result test_two_engines(ENGINE_HANDLE *h,
                                         ENGINE_HANDLE_V1 *h1) {
    item *item1, *item2, *fetched_item1 = NULL, *fetched_item2 = NULL;
    const void *cookie1 = mk_conn("user1", NULL), *cookie2 = mk_conn("user2", NULL);
    char *key = "somekey";
    char *value1 = "some value1", *value2 = "some value 2";

    store(h, h1, cookie1, key, value1, &item1);
    store(h, h1, cookie2, key, value2, &item2);

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->get(h, cookie1, &fetched_item1, key, strlen(key), 0);
    assert(rv == ENGINE_SUCCESS);
    rv = h1->get(h, cookie2, &fetched_item2, key, strlen(key), 0);
    assert(rv == ENGINE_SUCCESS);

    assert(!item_eq(h, h1, cookie1, fetched_item1, cookie2, fetched_item2));
    assert_item_eq(h, h1, cookie1, item1, cookie1, fetched_item1);
    assert_item_eq(h, h1, cookie2, item2, cookie2, fetched_item2);

    return SUCCESS;
}

static enum test_result test_two_engines_del(ENGINE_HANDLE *h,
                                             ENGINE_HANDLE_V1 *h1) {
    item *item1, *item2, *fetched_item1 = NULL, *fetched_item2 = NULL;
    const void *cookie1 = mk_conn("user1", NULL), *cookie2 = mk_conn("user2", NULL);
    char *key = "somekey";
    char *value1 = "some value1", *value2 = "some value 2";

    store(h, h1, cookie1, key, value1, &item1);
    store(h, h1, cookie2, key, value2, &item2);

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    // Delete an item
    rv = h1->remove(h, cookie1, key, strlen(key), 0, 0);
    assert(rv == ENGINE_SUCCESS);

    rv = h1->get(h, cookie1, &fetched_item1, key, strlen(key), 0);
    assert(rv == ENGINE_KEY_ENOENT);
    assert(fetched_item1 == NULL);
    rv = h1->get(h, cookie2, &fetched_item2, key, strlen(key), 0);
    assert(rv == ENGINE_SUCCESS);

    assert_item_eq(h, h1, cookie1, item2, cookie2, fetched_item2);

    return SUCCESS;
}

static enum test_result test_two_engines_flush(ENGINE_HANDLE *h,
                                               ENGINE_HANDLE_V1 *h1) {
    item *item1, *item2, *fetched_item1 = NULL, *fetched_item2 = NULL;
    const void *cookie1 = mk_conn("user1", NULL), *cookie2 = mk_conn("user2", NULL);
    char *key = "somekey";
    char *value1 = "some value1", *value2 = "some value 2";

    store(h, h1, cookie1, key, value1, &item1);
    store(h, h1, cookie2, key, value2, &item2);

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    // flush it
    rv = h1->flush(h, cookie1, 0);
    assert(rv == ENGINE_SUCCESS);

    rv = h1->get(h, cookie1, &fetched_item1, key, strlen(key), 0);
    assert(rv == ENGINE_KEY_ENOENT);
    assert(fetched_item1 == NULL);
    rv = h1->get(h, cookie2, &fetched_item2, key, strlen(key), 0);
    assert(rv == ENGINE_SUCCESS);

    assert_item_eq(h, h1, cookie2, item2, cookie2, fetched_item2);

    return SUCCESS;
}

static enum test_result test_arith(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
    const void *cookie1 = mk_conn("user1", NULL), *cookie2 = mk_conn("user2", NULL);
    char *key = "somekey";
    uint64_t result = 0, cas = 0;

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    // Initialize the first one.
    rv = h1->arithmetic(h, cookie1, key, strlen(key),
                        true, true, 1, 1, 0, &cas, &result, 0);
    assert(rv == ENGINE_SUCCESS);
    assert(cas == 0);
    assert(result == 1);

    // Fail an init of the second one.
    rv = h1->arithmetic(h, cookie2, key, strlen(key),
                        true, false, 1, 1, 0, &cas, &result, 0);
    assert(rv == ENGINE_KEY_ENOENT);

    // Update the first again.
    rv = h1->arithmetic(h, cookie1, key, strlen(key),
                        true, true, 1, 1, 0, &cas, &result, 0);
    assert(rv == ENGINE_SUCCESS);
    assert(cas == 0);
    assert(result == 2);

    return SUCCESS;
}

static enum test_result test_get_info(ENGINE_HANDLE *h, ENGINE_HANDLE_V1 *h1) {
    const engine_info* info = h1->get_info(h);
    return strncmp(info->description, "Bucket engine", 13) == 0 ? SUCCESS : FAIL;
}

static void* create_packet4(uint8_t opcode, const char *key, const char *val,
                            size_t vlen) {
    void *pkt_raw = calloc(1,
                           sizeof(protocol_binary_request_header)
                           + strlen(key)
                           + vlen);
    assert(pkt_raw);
    protocol_binary_request_header *req =
        (protocol_binary_request_header*)pkt_raw;
    req->request.opcode = opcode;
    req->request.bodylen = htonl(strlen(key) + vlen);
    req->request.keylen = htons(strlen(key));
    memcpy(pkt_raw + sizeof(protocol_binary_request_header),
           key, strlen(key));
    memcpy(pkt_raw + sizeof(protocol_binary_request_header) + strlen(key),
           val, vlen);
    return pkt_raw;
}

static void* create_packet(uint8_t opcode, const char *key, const char *val) {
    return create_packet4(opcode, key, val, strlen(val));
}

static void* create_create_bucket_pkt(const char *user, const char *path,
                                       const char *args) {
    char buf[strlen(path) + strlen(args) + 3];
    snprintf(buf, sizeof(buf), "%s%c%s", path, 0, args);
    return create_packet4(CREATE_BUCKET, user,
                          buf, strlen(path) + strlen(args) + 1);
}

static enum test_result test_create_bucket(ENGINE_HANDLE *h,
                                           ENGINE_HANDLE_V1 *h1) {
    const void *adm_cookie = mk_conn("admin", NULL);
    const char *key = "somekey";
    const char *value = "the value";
    item *item;

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;
    rv = h1->allocate(h, mk_conn("someuser", NULL), &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_DISCONNECT);

    void *pkt = create_create_bucket_pkt("someuser", ENGINE_PATH, "");
    rv = h1->unknown_command(h, adm_cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    rv = h1->allocate(h, mk_conn("someuser", NULL), &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_SUCCESS);

    return SUCCESS;
}

static enum test_result test_double_create_bucket(ENGINE_HANDLE *h,
                                                  ENGINE_HANDLE_V1 *h1) {
    const void *adm_cookie = mk_conn("admin", NULL);
    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_create_bucket_pkt("someuser", ENGINE_PATH, "");
    rv = h1->unknown_command(h, adm_cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    pkt = create_create_bucket_pkt("someuser", ENGINE_PATH, "");
    rv = h1->unknown_command(h, adm_cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == ENGINE_KEY_EEXISTS);

    return SUCCESS;
}

static enum test_result test_create_bucket_with_params(ENGINE_HANDLE *h,
                                                       ENGINE_HANDLE_V1 *h1) {
    const void *adm_cookie = mk_conn("admin", NULL), *other_cookie = mk_conn("someuser", NULL);
    const char *key = "somekey";
    const char *value = "the value";
    item *item;

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;
    rv = h1->allocate(h, adm_cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_DISCONNECT);

    void *pkt = create_create_bucket_pkt("someuser", ENGINE_PATH, "no_alloc");
    rv = h1->unknown_command(h, adm_cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    rv = h1->allocate(h, other_cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_DISCONNECT);

    return SUCCESS;
}

static enum test_result test_admin_user(ENGINE_HANDLE *h,
                                        ENGINE_HANDLE_V1 *h1) {
    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    // Test with no user.
    void *pkt = create_create_bucket_pkt("newbucket", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn(NULL, NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_ENOTSUP);

    // Test with non-admin
    pkt = create_create_bucket_pkt("newbucket", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn("notadmin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_ENOTSUP);

    // Test with admin
    pkt = create_create_bucket_pkt("newbucket", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    return SUCCESS;
}

static enum test_result test_delete_bucket(ENGINE_HANDLE *h,
                                           ENGINE_HANDLE_V1 *h1) {
    const void *adm_cookie = mk_conn("admin", NULL);
    const char *key = "somekey";
    const char *value = "the value";
    item *item;

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_create_bucket_pkt("someuser", ENGINE_PATH, "");
    rv = h1->unknown_command(h, adm_cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    const void *other_cookie = mk_conn("someuser", NULL);

    rv = h1->allocate(h, other_cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_SUCCESS);

    pkt = create_packet(DELETE_BUCKET, "someuser", "");
    rv = h1->unknown_command(h, adm_cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);

    pkt = create_packet(DELETE_BUCKET, "someuser", "");
    rv = h1->unknown_command(h, adm_cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == ENGINE_KEY_ENOENT);

    rv = h1->allocate(h, other_cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_DISCONNECT);

    return SUCCESS;
}

static enum test_result test_bucket_name_validation(ENGINE_HANDLE *h,
                                                    ENGINE_HANDLE_V1 *h1) {

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_create_bucket_pkt("bucket one", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == PROTOCOL_BINARY_RESPONSE_NOT_STORED);

    return SUCCESS;
}

static enum test_result test_list_buckets_none(ENGINE_HANDLE *h,
                                               ENGINE_HANDLE_V1 *h1) {

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    // Go find all the buckets.
    void *pkt = create_packet(LIST_BUCKETS, "", "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    // Now verify the body looks alright.
    assert(last_body == NULL);

    return SUCCESS;
}

static enum test_result test_list_buckets_one(ENGINE_HANDLE *h,
                                              ENGINE_HANDLE_V1 *h1) {

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    // Create a bucket first.

    void *pkt = create_create_bucket_pkt("bucket1", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    // Now go find all the buckets.
    pkt = create_packet(LIST_BUCKETS, "", "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    // Now verify the body looks alright.
    assert(strncmp(last_body, "bucket1", 7) == 0);

    return SUCCESS;
}

static enum test_result test_list_buckets_two(ENGINE_HANDLE *h,
                                              ENGINE_HANDLE_V1 *h1) {
    const void *cookie = mk_conn("admin", NULL);
    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    // Create two buckets first.

    void *pkt = create_create_bucket_pkt("bucket1", ENGINE_PATH, "");
    rv = h1->unknown_command(h, cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    pkt = create_create_bucket_pkt("bucket2", ENGINE_PATH, "");
    rv = h1->unknown_command(h, cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    // Now go find all the buckets.
    pkt = create_packet(LIST_BUCKETS, "", "");
    rv = h1->unknown_command(h, cookie, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    // Now verify the body looks alright.
    assert(strncmp(last_body, "bucket1 bucket2", 15) == 0
           || strncmp(last_body, "bucket2 bucket1", 15) == 0);

    return SUCCESS;
}

static enum test_result test_expand_bucket(ENGINE_HANDLE *h,
                                           ENGINE_HANDLE_V1 *h1) {

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_create_bucket_pkt("bucket1", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    pkt = create_packet(EXPAND_BUCKET, "bucket1", "1024");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    return SUCCESS;
}

static enum test_result test_expand_missing_bucket(ENGINE_HANDLE *h,
                                                   ENGINE_HANDLE_V1 *h1) {

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_packet(EXPAND_BUCKET, "bucket1", "1024");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == PROTOCOL_BINARY_RESPONSE_KEY_ENOENT);
    const char *exp = "Engine not found";
    assert(memcmp(last_key, exp, strlen(exp)) == 0);

    return SUCCESS;
}

static enum test_result test_unknown_call(ENGINE_HANDLE *h,
                                          ENGINE_HANDLE_V1 *h1) {

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_create_bucket_pkt("someuser", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    pkt = create_packet(0xfe, "somekey", "someval");
    rv = h1->unknown_command(h, mk_conn("someuser", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_ENOTSUP);

    return SUCCESS;
}

static enum test_result test_select_no_admin(ENGINE_HANDLE *h,
                                             ENGINE_HANDLE_V1 *h1) {
    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_create_bucket_pkt("someuser", ENGINE_PATH, "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    pkt = create_packet(SELECT_BUCKET, "stuff", "");
    rv = h1->unknown_command(h, mk_conn("notadmin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_ENOTSUP);

    return SUCCESS;
}

static enum test_result test_select_no_bucket(ENGINE_HANDLE *h,
                                              ENGINE_HANDLE_V1 *h1) {
    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_packet(SELECT_BUCKET, "stuff", "");
    rv = h1->unknown_command(h, mk_conn("admin", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == ENGINE_KEY_ENOENT);

    return SUCCESS;
}

static enum test_result test_select(ENGINE_HANDLE *h,
                                    ENGINE_HANDLE_V1 *h1) {
    item *item1, *fetched_item1 = NULL, *fetched_item2;
    const void *cookie1 = mk_conn("user1", NULL), *admin = mk_conn("admin", NULL);
    char *key = "somekey";
    char *value1 = "some value1";

    store(h, h1, cookie1, key, value1, &item1);

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->get(h, cookie1, &fetched_item1, key, strlen(key), 0);
    assert(rv == ENGINE_SUCCESS);
    rv = h1->get(h, admin, &fetched_item2, key, strlen(key), 0);
    assert(rv == ENGINE_KEY_ENOENT);

    assert_item_eq(h, h1, cookie1, item1, cookie1, fetched_item1);

    void *pkt = create_packet(SELECT_BUCKET, "user1", "");
    rv = h1->unknown_command(h, admin, pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_SUCCESS);
    assert(last_status == 0);

    rv = h1->get(h, admin, &fetched_item2, key, strlen(key), 0);
    assert(rv == ENGINE_SUCCESS);
    assert_item_eq(h, h1, cookie1, item1, admin, fetched_item2);

    return SUCCESS;
}

static enum test_result test_unknown_call_no_bucket(ENGINE_HANDLE *h,
                                                    ENGINE_HANDLE_V1 *h1) {

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    void *pkt = create_packet(0xfe, "somekey", "someval");
    rv = h1->unknown_command(h, mk_conn("someuser", NULL), pkt, add_response);
    free(pkt);
    assert(rv == ENGINE_DISCONNECT);

    return SUCCESS;
}

static enum test_result test_auto_config(ENGINE_HANDLE *h,
                                         ENGINE_HANDLE_V1 *h1) {
    item *item = NULL, *fetched_item;
    const void *cookie = mk_conn("someuser", MOCK_CONFIG_NO_ALLOC);
    char *key = "somekey";
    char *value = "some value";

    ENGINE_ERROR_CODE rv = ENGINE_SUCCESS;

    rv = h1->allocate(h, cookie, &item,
                      key, strlen(key),
                      strlen(value), 9258, 3600);
    assert(rv == ENGINE_ENOMEM);

    return SUCCESS;
}

static enum test_result test_get_tap_iterator(ENGINE_HANDLE *h,
                                              ENGINE_HANDLE_V1 *h1) {
    // This is run for its side effect of not crashing.
    TAP_ITERATOR ti = h1->get_tap_iterator(h, mk_conn("someuser", ""),
                                           NULL, 0, 0, NULL, 0);
    assert(ti == NULL);
    return SUCCESS;
}

static enum test_result test_tap_notify(ENGINE_HANDLE *h,
                                        ENGINE_HANDLE_V1 *h1) {
    ENGINE_ERROR_CODE ec = h1->tap_notify(h, mk_conn("someuser", ""),
                                          NULL, 0, 0, 0, TAP_MUTATION, 0,
                                          "akey", 4,
                                          0, 0, 0,
                                          "aval", 4, 0);
    assert(ec == ENGINE_SUCCESS);
    return SUCCESS;
}

static ENGINE_HANDLE_V1 *start_your_engines(const char *cfg) {
    ENGINE_HANDLE_V1 *h = (ENGINE_HANDLE_V1 *)load_engine(".libs/bucket_engine.so",
                                                          cfg);
    assert(h);
    // printf("Engine:  %s\n", h->get_info((ENGINE_HANDLE*)h));
    return h;
}

static int report_test(enum test_result r) {
    int rc = 0;
    char *msg = NULL;
    bool color_enabled = getenv("TESTAPP_ENABLE_COLOR") != NULL;
    int color = 0;
    char color_str[8] = { 0 };
    char *reset_color = "\033[m";
    switch(r) {
    case SUCCESS:
        msg="OK";
        color = 32;
        break;
    case FAIL:
        color = 31;
        msg="FAIL";
        rc = 1;
        break;
    case DIED:
        color = 31;
        msg = "DIED";
        rc = 1;
        break;
    case CORE:
        color = 31;
        msg = "CORE DUMPED";
        rc = 1;
        break;
    case PENDING:
        color = 33;
        msg = "PENDING";
        break;
    }
    assert(msg);
    if (color_enabled) {
        snprintf(color_str, sizeof(color_str), "\033[%dm", color);
    }
    printf("%s%s%s\n", color_str, msg, color_enabled ? reset_color : "");
    return rc;
}

static void disconnect_all_connections(struct connstruct *c) {
    if (c) {
        disconnect(c);
        disconnect_all_connections(c->next);
        free((void*)c->uname);
        free((void*)c->config);
        free(c);
    }
}

static void destroy_event_handlers_rec(struct engine_event_handler *h) {
    if (h) {
        destroy_event_handlers_rec(h->next);
        free(h);
    }
}

static void destroy_event_handlers() {
    int i = 0;
    for (i = 0; i < MAX_ENGINE_EVENT_TYPE; i++) {
        destroy_event_handlers_rec(engine_event_handlers[i]);
        engine_event_handlers[i] = NULL;
    }
}

static enum test_result run_test(struct test test) {
    enum test_result ret = PENDING;
    if (test.tfun != NULL) {
        last_status = 0xff;
#ifndef USE_GCOV
        pid_t pid = fork();
        if (pid == 0) {
#endif
            /* Start the engines and go */
            ENGINE_HANDLE_V1 *h = start_your_engines(test.cfg ?: DEFAULT_CONFIG);
            ret = test.tfun((ENGINE_HANDLE*)h, h);
            disconnect_all_connections(connstructs);
            destroy_event_handlers();
            connstructs = NULL;
            h->destroy((ENGINE_HANDLE*)h);
#ifndef USE_GCOV
            exit((int)ret);
        } else if (pid == (pid_t)-1) {
            ret = FAIL;
        } else {
            int rc;
            while (waitpid(pid, &rc, 0) == (pid_t)-1) {
                if (errno != EINTR) {
                    abort();
                }
            }

            if (WIFEXITED(rc)) {
                ret = (enum test_result)WEXITSTATUS(rc);
            } else if (WIFSIGNALED(rc) && WCOREDUMP(rc)) {
                ret = CORE;
            } else {
                ret = DIED;
            }
        }
#endif
    }

    return ret;
}

int main(int argc, char **argv) {
    int i = 0;
    int rc = 0;

    struct test tests[] = {
        {"get info", test_get_info},
        {"default storage", test_default_storage},
        {"default storage key overrun", test_default_storage_key_overrun},
        {"default unlinked remove", test_default_unlinked_remove},
        {"no default storage",
         test_no_default_storage,
         "engine=.libs/mock_engine.so;default=false"},
        {"user storage with no default",
         test_two_engines,
         "engine=.libs/mock_engine.so;default=false"},
        {"distinct storage", test_two_engines, DEFAULT_CONFIG_AC},
        {"distinct storage (no auto-create)", test_two_engines_no_autocreate,
         DEFAULT_CONFIG_NO_DEF},
        {"delete from one of two nodes", test_two_engines_del,
         DEFAULT_CONFIG_AC},
        {"flush from one of two nodes", test_two_engines_flush,
         DEFAULT_CONFIG_AC},
        {"isolated arithmetic", test_arith, DEFAULT_CONFIG_AC},
        {"create bucket", test_create_bucket, DEFAULT_CONFIG_NO_DEF},
        {"double create bucket", test_double_create_bucket,
         DEFAULT_CONFIG_NO_DEF},
        {"create bucket with params", test_create_bucket_with_params,
         DEFAULT_CONFIG_NO_DEF},
        {"bucket name verification", test_bucket_name_validation},
        {"delete bucket", test_delete_bucket,
         DEFAULT_CONFIG_NO_DEF},
        {"expand bucket", test_expand_bucket},
        {"expand missing bucket", test_expand_missing_bucket},
        {"list buckets with none", test_list_buckets_none},
        {"list buckets with one", test_list_buckets_one},
        {"list buckets", test_list_buckets_two},
        {"fail to select a bucket when not admin", test_select_no_admin},
        {"select a bucket as admin", test_select, DEFAULT_CONFIG_AC},
        {"fail to select non-existent bucket as admin", test_select_no_bucket},
        {"stats call"},
        {"release call"},
        {"unknown call delegation", test_unknown_call},
        {"unknown call delegation (no bucket)", test_unknown_call_no_bucket,
         DEFAULT_CONFIG_NO_DEF},
        {"admin verification", test_admin_user},
        {"auto create with config", test_auto_config,
         DEFAULT_CONFIG_AC},
        {"get tap iterator", test_get_tap_iterator},
        {"tap notify", test_tap_notify},
        {NULL, NULL}
    };

    for (i = 0; tests[i].name; i++) {
        printf("Running %s... ", tests[i].name);
        fflush(stdout);
        rc += report_test(run_test(tests[i]));
    }

    return rc;
}

static int read_config_file(const char *fname, struct config_item items[],
                            FILE *error);

/**
 * Copy a string and trim of leading and trailing white space characters.
 * Allow the user to escape out the stop character by putting a backslash before
 * the character.
 * @param dest where to store the result
 * @param size size of the result buffer
 * @param src where to copy data from
 * @param end the last character parsed is returned here
 * @param stop the character to stop copying.
 * @return 0 if success, -1 otherwise
 */
static int trim_copy(char *dest, size_t size, const char *src,
                     const char **end, char stop) {
   while (isspace(*src)) {
      ++src;
   }
   char *space = NULL;
   size_t n = 0;
   bool escape = false;
   int ret = 0;

   do {
      if ((*dest = *src) == '\\') {
         escape = true;
      } else {
         if (!escape) {
            if (space == NULL && isspace(*src)) {
               space = dest;
            }
         }
         escape = false;
         ++dest;
      }
      ++n;
      ++src;

   } while (!(n == size || ((*src == stop) && !escape) || *src == '\0'));
   *end = src;

   if (space) {
      *space = '\0';
   } else {
      if (n == size) {
         --dest;
         ret = -1;
      }
      *dest = '\0';
   }

   return ret;
}


int parse_config(const char *str, struct config_item *items, FILE *error) {
   int ret = 0;
   const char *ptr = str;

   while (*ptr != '\0') {
      while (isspace(*ptr)) {
         ++ptr;
      }
      if (*ptr == '\0') {
         /* end of parameters */
         return 0;
      }

      const char *end;
      char key[80];
      if (trim_copy(key, sizeof(key), ptr, &end, '=') == -1) {
         fprintf(error, "ERROR: Invalid key, starting at: <%s>\n", ptr);
         return -1;
      }

      ptr = end + 1;
      char value[80];
      if (trim_copy(value, sizeof(value), ptr, &end, ';') == -1) {
         fprintf(error, "ERROR: Invalid value, starting at: <%s>\n", ptr);
         return -1;
      }
      if (*end == ';') {
         ptr = end + 1;
      } else {
         ptr = end;
      }

      int ii = 0;
      while (items[ii].key != NULL) {
         if (strcmp(key, items[ii].key) == 0) {
            if (items[ii].found) {
               fprintf(error, "WARNING: Found duplicate entry for \"%s\"\n",
                       items[ii].key);
            }

            switch (items[ii].datatype) {
            case DT_SIZE:
               {
                  uint64_t val;
                  if (safe_strtoull(value, &val)) {
                     *items[ii].value.dt_size = (size_t)val;
                     items[ii].found = true;
                  } else {
                     ret = -1;
                  }
               }
               break;
            case DT_FLOAT:
               {
                  float val;
                  if (safe_strtof(value, &val)) {
                     *items[ii].value.dt_float = val;
                     items[ii].found = true;
                  } else {
                     ret = -1;
                  }
               }
               break;
            case DT_STRING:
               *items[ii].value.dt_string = strdup(value);
               items[ii].found = true;
               break;
            case DT_BOOL:
               if (strcasecmp(value, "true") == 0 || strcasecmp(value, "on") == 0) {
                  *items[ii].value.dt_bool = true;
                  items[ii].found = true;
               } else if (strcasecmp(value, "false") == 0 || strcasecmp(value, "off") == 0) {
                  *items[ii].value.dt_bool = false;
                  items[ii].found = true;
               } else {
                  ret = -1;
               }
               break;
            case DT_CONFIGFILE:
               {
                  int r = read_config_file(value, items, error);
                  if (r != 0) {
                     ret = r;
                  }
               }
               break;
            default:
               /* You need to fix your code!!! */
               abort();
            }
            if (ret == -1) {
               fprintf(error, "Invalid entry, Key: <%s> Value: <%s>\n",
                       key, value);
               return ret;
            }
            break;
         }
         ++ii;
      }

      if (items[ii].key == NULL) {
         fprintf(error, "Unsupported key: <%s>\n", key);
         ret = 1;
      }
   }
   return ret;
}

static int read_config_file(const char *fname, struct config_item items[],
                            FILE *error) {
   FILE *fp = fopen(fname, "r");
   if (fp == NULL) {
      (void)fprintf(error, "Failed to open file: %s\n", fname);
      return -1;
   }

   int ret = 0;
   char line[1024];
   while (fgets(line, sizeof(line), fp) != NULL && ret != -1L) {
      if (line[0] == '#') {
         /* Ignore comment line */
         continue;
      }

      int r = parse_config(line, items, error);
      if (r != 0) {
         ret = r;
      }
   }

   (void)fclose(fp);

   return ret;
}