Пример #1
0
static inline struct item *
_add_key(struct response *rsp, struct bstring *key)
{
    struct element *reply = (struct element *)array_get(rsp->token, 0);
    struct item *it;
    item_rstatus_e istatus;

    it = item_get(key);
    if (it != NULL) {
        rsp->type = reply->type = ELEM_ERR;
        reply->bstr = str2bstr(RSP_EXIST);
        INCR(process_metrics, list_create_exist);

        return NULL;
    } else {
        /* TODO: figure out a TTL story here */
        istatus = item_reserve(&it, key, NULL, ZIPLIST_HEADER_SIZE, 0, INT32_MAX);
        if (istatus != ITEM_OK) {
            rsp->type = reply->type = ELEM_ERR;
            reply->bstr = str2bstr(RSP_ERR_STORAGE);
            INCR(process_metrics, list_create_ex);
            INCR(process_metrics, process_ex);
        } else {
            INCR(process_metrics, list_create_stored);
        }

        return it;
    }
}
Пример #2
0
END_TEST

START_TEST(test_error)
{
#define ERR "something is wrong"
#define SERIALIZED "-" ERR "\r\n"

    struct element el_c, el_p;
    int ret;
    int len = sizeof(SERIALIZED) - 1;
    char *pos;

    test_reset();

    /* compose */
    el_c.type = ELEM_ERR;
    el_c.bstr = str2bstr(ERR);
    ret = compose_element(&buf, &el_c);
    ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret);
    ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0);

    /* parse */
    pos = buf->rpos + 1;
    ret = parse_element(&el_p, buf);
    ck_assert_int_eq(ret, PARSE_OK);
    ck_assert(buf->rpos == buf->wpos);
    ck_assert(el_p.type == ELEM_ERR);
    ck_assert(el_p.bstr.len == sizeof(ERR) - 1);
    ck_assert(el_p.bstr.data == pos);

#undef SERIALIZED
#undef ERR
}
Пример #3
0
void
cmd_list_create(struct response *rsp, struct request *req, struct command *cmd)
{
    struct item *it;
    struct bstring *key = _get_key(req);
    struct element *reply = (struct element *)array_push(rsp->token);

    INCR(process_metrics, list_create);

    it = _add_key(rsp, key);
    if (it == NULL) {
        log_debug("command '%.*s' '%.*s' failed: cannot store", cmd->bstr.len,
                cmd->bstr.data, key->len, key->data);
        return;
    }

    /* initialize data structure */
    ziplist_reset((ziplist_p)item_data(it));
    it->vlen = ZIPLIST_HEADER_SIZE;

    /* link into index */
    item_insert(it, key);

    rsp->type = reply->type = ELEM_STR;
    reply->bstr = str2bstr(RSP_OK);

    log_verb("command '%.*s' '%.*s' succeeded", cmd->bstr.len, cmd->bstr.data,
            key->len, key->data);
}
Пример #4
0
static void
_admin_version(struct response *rsp, struct request *req)
{
    INCR(admin_metrics, version);

    rsp->type = RSP_GENERIC;
    cc_snprintf(version_buf, VERSION_PRINT_LEN, VERSION_PRINT_FMT, VERSION_STRING);
    rsp->data = str2bstr(version_buf);
}
Пример #5
0
void
cmd_list_delete(struct response *rsp, struct request *req, struct command *cmd)
{
    struct bstring *key = _get_key(req);
    struct element *reply = (struct element *)array_push(rsp->token);

    INCR(process_metrics, list_delete);

    if (item_delete(key)) {
        reply->bstr = str2bstr(RSP_OK);
        INCR(process_metrics, list_delete_deleted);
        log_verb("command '%.*s' '%.*s' succeeded", cmd->bstr.len,
                cmd->bstr.data, key->len, key->data);
    } else {
        reply->bstr = str2bstr(RSP_NOTFOUND);
        INCR(process_metrics, list_delete_notfound);
        log_verb("command '%.*s' '%.*s' completed as no-op, key not found",
                cmd->bstr.len, cmd->bstr.data, key->len, key->data);
    }

}
Пример #6
0
void
admin_process_request(struct response *rsp, struct request *req)
{
    rsp->type = RSP_GENERIC;

    switch (req->type) {
    case REQ_STATS:
        _admin_stats(rsp, req);
        break;
    case REQ_VERSION:
        rsp->data = str2bstr(VERSION_PRINTED);
        break;
    default:
        rsp->type = RSP_INVALID;
        break;
    }
}
Пример #7
0
END_TEST

START_TEST(test_bulk_string)
{
#define BULK "foo bar\r\n"
#define SERIALIZED "$9\r\n" BULK "\r\n"
#define EMPTY "$0\r\n\r\n"

    struct element el_c, el_p;
    int ret;
    int len = sizeof(SERIALIZED) - 1;

    test_reset();

    /* compose */
    el_c.type = ELEM_BULK;
    el_c.bstr = str2bstr(BULK);
    ret = compose_element(&buf, &el_c);
    ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret);
    ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0);

    /* parse */
    ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK);
    ck_assert(buf->rpos == buf->wpos);
    ck_assert(el_p.type == ELEM_BULK);
    ck_assert(el_p.bstr.len == sizeof(BULK) - 1);
    ck_assert(el_p.bstr.data + el_p.bstr.len == buf->rpos - CRLF_LEN);
    ck_assert(buf->rpos == buf->wpos);

    /* empty string */
    buf_reset(buf);
    len = sizeof(EMPTY) - 1;
    el_c.bstr = null_bstring;
    ret = compose_element(&buf, &el_c);
    ck_assert_msg(ret == len, "bytes expected: %d, returned: %d", len, ret);
    ck_assert_int_eq(cc_bcmp(buf->rpos, EMPTY, ret), 0);
    ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK);
    ck_assert(el_p.bstr.len == 0);


#undef EMPTY
#undef SERIALIZED
#undef BULK
}