static bool
_get_key(struct response *rsp, struct bstring *key)
{
struct item *it;
struct val val;
it = cuckoo_get(key);
if (it != NULL) {
rsp->type = RSP_VALUE;
rsp->key = *key;
rsp->flag = item_flag(it);
rsp->vcas = item_cas(it);
item_val(&val, it);
if (val.type == VAL_TYPE_INT) {
rsp->num = 1;
rsp->vint = val.vint;
} else {
rsp->vstr = val.vstr;
}
log_verb("found key at %p, location %p", key, it);
return true;
} else {
log_verb("key at %p not found", key);
return false;
}
}
void
test_cas(uint32_t policy)
{
#define KEY "key"
#define VAL "value"
#define VAL2 "value2"
struct bstring key;
struct val val;
rstatus_i status;
struct item *it;
uint64_t cas1, cas2;
test_reset(policy, true);
key.data = KEY;
key.len = sizeof(KEY) - 1;
val.type = VAL_TYPE_STR;
val.vstr.data = VAL;
val.vstr.len = sizeof(VAL) - 1;
time_update();
status = cuckoo_insert(&key, &val, UINT32_MAX - 1);
ck_assert_msg(status == CC_OK, "cuckoo_insert not OK - return status %d",
status);
it = cuckoo_get(&key);
cas1 = item_cas(it);
ck_assert_uint_ne(cas1, 0);
val.vstr.data = VAL2;
val.vstr.len = sizeof(VAL2) - 1;
status = cuckoo_update(it, &val, UINT32_MAX - 1);
ck_assert_msg(status == CC_OK, "cuckoo_update not OK - return status %d",
status);
it = cuckoo_get(&key);
cas2 = item_cas(it);
ck_assert_uint_ne(cas2, 0);
ck_assert_uint_ne(cas1, cas2);
#undef KEY
#undef VAL
#undef VAL2
}
/*
* Build the response. Each hit adds three elements to the outgoing
* reponse vector, viz:
* "VALUE "
* key
* " " + flags + " " + data length + "\r\n" + data (with \r\n)
*/
static rstatus_t
asc_respond_get(struct conn *c, unsigned valid_key_iter, struct item *it,
bool return_cas)
{
rstatus_t status;
char *cas_suffix = NULL;
int cas_suffix_len = 0;
int total_len = it->nkey + it->nsuffix + it->nbyte;
if (return_cas) {
status = asc_create_cas_suffix(c, valid_key_iter, &cas_suffix);
if (status != MC_OK) {
return status;
}
cas_suffix_len = snprintf(cas_suffix, CAS_SUFFIX_SIZE, " %"PRIu64,
item_cas(it));
}
status = conn_add_iov(c, "VALUE ", sizeof("VALUE ") - 1);
if (status != MC_OK) {
return status;
}
status = conn_add_iov(c, item_key(it), it->nkey);
if (status != MC_OK) {
return status;
}
status = conn_add_iov(c, item_suffix(it), it->nsuffix - CRLF_LEN);
if (status != MC_OK) {
return status;
}
if (return_cas) {
status = conn_add_iov(c, cas_suffix, cas_suffix_len);
if (status != MC_OK) {
return status;
}
total_len += cas_suffix_len;
}
status = conn_add_iov(c, CRLF, CRLF_LEN);
if (status != MC_OK) {
return status;
}
status = conn_add_iov(c, item_data(it), it->nbyte);
if (status != MC_OK) {
return status;
}
klog_write(c->peer, c->req_type, item_key(it), it->nkey, 0, total_len);
return MC_OK;
}
/*
* Build the response. Each hit adds three elements to the outgoing
* reponse vector, viz:
* "VALUE "
* key
* " " + flags + " " + data length + "\r\n" + data (with \r\n)
*/
static rstatus_t
asc_respond_get(struct conn *c, unsigned valid_key_iter, struct item *it,
bool return_cas)
{
rstatus_t status;
char *cas_suffix = NULL;
char suffix[SUFFIX_MAX_LEN];
int sz;
int total_len = 0;
status = conn_add_iov(c, "VALUE ", sizeof("VALUE ") - 1);
if (status != MC_OK) {
return status;
}
status = conn_add_iov(c, item_key(it), it->nkey);
if (status != MC_OK) {
return status;
}
total_len += it->nkey;
sz = snprintf(suffix, SUFFIX_MAX_LEN, " %"PRIu32" %"PRIu32, it->dataflags,
it->nbyte);
if (sz < 0) {
return MC_ERROR;
}
ASSERT(sz < SUFFIX_MAX_LEN); /* or we have a corrupted item */
status = conn_add_iov(c, suffix, sz);
if (status != MC_OK) {
return status;
}
total_len += sz;
if (return_cas) {
status = asc_create_cas_suffix(c, valid_key_iter, &cas_suffix);
if (status != MC_OK) {
return status;
}
sz = snprintf(cas_suffix, CAS_SUFFIX_SIZE, " %"PRIu64, item_cas(it));
if (sz < 0) {
return MC_ERROR;
}
ASSERT(sz < CAS_SUFFIX_SIZE);
status = conn_add_iov(c, cas_suffix, sz);
if (status != MC_OK) {
return status;
}
total_len += sz;
}
status = conn_add_iov(c, CRLF, CRLF_LEN);
if (status != MC_OK) {
return status;
}
total_len += CRLF_LEN;
status = conn_add_iov(c, item_data(it), it->nbyte);
if (status != MC_OK) {
return status;
}
total_len += it->nbyte;
status = conn_add_iov(c, CRLF, CRLF_LEN);
if (status != MC_OK) {
return status;
}
total_len += CRLF_LEN;
klog_write(c->peer, c->req_type, item_key(it), it->nkey, 0, total_len);
return MC_OK;
}
/*
* Build the response. Each hit adds three elements to the outgoing
* reponse vector, viz:
* "VALUE "
* key
* " " + flags + " " + data length + "\r\n" + data (with \r\n)
*/
static rstatus_t
asc_respond_get(struct conn *c, unsigned valid_key_iter, struct item *it,
bool return_cas)
{
rstatus_t status;
char *suffix = NULL;
int sz;
int total_len = 0;
uint32_t nbyte = it->nbyte;
char *data = item_data(it);
status = conn_add_iov(c, VALUE, VALUE_LEN);
if (status != MC_OK) {
return status;
}
total_len += VALUE_LEN;
status = conn_add_iov(c, item_key(it), it->nkey);
if (status != MC_OK) {
return status;
}
total_len += it->nkey;
status = asc_create_suffix(c, valid_key_iter, &suffix);
if (status != MC_OK) {
return status;
}
if (return_cas) {
sz = mc_snprintf(suffix, SUFFIX_MAX_LEN, " %"PRIu32" %"PRIu32" %"PRIu64,
it->dataflags, nbyte, item_cas(it));
ASSERT(sz <= SUFFIX_SIZE + CAS_SUFFIX_SIZE);
} else {
sz = mc_snprintf(suffix, SUFFIX_MAX_LEN, " %"PRIu32" %"PRIu32,
it->dataflags, nbyte);
ASSERT(sz <= SUFFIX_SIZE);
}
if (sz < 0) {
return MC_ERROR;
}
status = conn_add_iov(c, suffix, sz);
if (status != MC_OK) {
return status;
}
total_len += sz;
status = conn_add_iov(c, CRLF, CRLF_LEN);
if (status != MC_OK) {
return status;
}
total_len += CRLF_LEN;
status = conn_add_iov(c, data, nbyte);
if (status != MC_OK) {
return status;
}
total_len += nbyte;
status = conn_add_iov(c, CRLF, CRLF_LEN);
if (status != MC_OK) {
return status;
}
total_len += CRLF_LEN;
klog_write(c->peer, c->req_type, item_key(it), it->nkey, 0, total_len);
return MC_OK;
}
