topkeys_t *topkeys_init(int max_keys) {
topkeys_t *tk = calloc(sizeof(topkeys_t), 1);
if (tk == NULL) {
return NULL;
}
pthread_mutex_init(&tk->mutex, NULL);
tk->max_keys = max_keys;
tk->list.next = &tk->list;
tk->list.prev = &tk->list;
static struct hash_ops my_hash_ops = {
.hashfunc = genhash_string_hash,
.hasheq = my_hash_eq,
.dupKey = NULL,
.dupValue = NULL,
.freeKey = NULL,
.freeValue = NULL,
};
tk->hash = genhash_init(max_keys, my_hash_ops);
if (tk->hash == NULL) {
return NULL;
}
return tk;
}
void mcache_start(mcache *m, uint32_t max) {
assert(m);
if (m->lock) {
cb_mutex_enter(m->lock);
}
assert(m->funcs);
assert(m->map == NULL);
assert(m->max == 0);
assert(m->lru_head == NULL);
assert(m->lru_tail == NULL);
assert(m->oldest_live == 0);
struct hash_ops hops = skeyhash_ops;
hops.freeKey = m->key_alloc ? free : noop_free;
hops.freeValue = m->funcs->item_dec_ref;
m->map = genhash_init(128, hops);
if (m->map != NULL) {
m->max = max;
m->lru_head = NULL;
m->lru_tail = NULL;
m->oldest_live = 0;
}
if (m->lock) {
cb_mutex_exit(m->lock);
}
}
topkeys_t *topkeys_init(int max_keys) {
static struct hash_ops my_hash_ops;
topkeys_t *tk = calloc(sizeof(topkeys_t), 1);
if (tk == NULL) {
return NULL;
}
my_hash_ops.hashfunc = genhash_string_hash;
my_hash_ops.hasheq = my_hash_eq;
my_hash_ops.dupKey = NULL;
my_hash_ops.dupValue = NULL;
my_hash_ops.freeKey = NULL;
my_hash_ops.freeValue = NULL;
cb_mutex_initialize(&tk->mutex);
tk->max_keys = max_keys;
tk->list.next = &tk->list;
tk->list.prev = &tk->list;
tk->hash = genhash_init(max_keys, my_hash_ops);
if (tk->hash == NULL) {
return NULL;
}
return tk;
}
static void
test_construct()
{
genhash_t* h=NULL;
h=genhash_init(4, get_string_hash_ops());
genhash_free(h);
}
/*
* Set up a thread's information.
*/
static void setup_thread(LIBEVENT_THREAD *me) {
if (! me->base) {
me->base = event_init();
if (! me->base) {
moxi_log_write("Can't allocate event base\n");
exit(1);
}
}
/* Listen for notifications from other threads */
event_set(&me->notify_event, me->notify_receive_fd,
EV_READ | EV_PERSIST, thread_libevent_process, me);
event_base_set(me->base, &me->notify_event);
if (event_add(&me->notify_event, 0) == -1) {
moxi_log_write("Can't monitor libevent notify pipe\n");
exit(1);
}
me->new_conn_queue = malloc(sizeof(struct conn_queue));
if (me->new_conn_queue == NULL) {
perror("Failed to allocate memory for connection queue");
exit(EXIT_FAILURE);
}
cq_init(me->new_conn_queue);
// TODO: Merge new_conn_queue with work_queue.
//
me->work_queue = calloc(1, sizeof(work_queue));
if (me->work_queue == NULL) {
perror("Failed to allocate memory for work queue");
exit(EXIT_FAILURE);
}
work_queue_init(me->work_queue, me->base);
if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
perror("Failed to initialize mutex");
exit(EXIT_FAILURE);
}
me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
NULL, NULL);
if (me->suffix_cache == NULL) {
moxi_log_write("Failed to create suffix cache\n");
exit(EXIT_FAILURE);
}
me->conn_hash = genhash_init(512, strhash_ops);
if (me->conn_hash == NULL) {
moxi_log_write("Failed to create connection hash\n");
exit(EXIT_FAILURE);
}
}
static genhash_t*
get_test_hash()
{
genhash_t* h=NULL;
int i=0;
h=genhash_init(26, get_string_hash_ops());
for(i=0; i<26; i++) {
genhash_store(h, kvs[i], kvs[i]);
assert_hash_val(kvs[i], h, kvs[i]);
}
return h;
}
static ENGINE_ERROR_CODE mock_initialize(ENGINE_HANDLE* handle,
const char* config_str) {
struct mock_engine* se = get_handle(handle);
assert(my_hash_ops.dupKey);
if (strcmp(config_str, "no_alloc") != 0) {
se->hashtbl = genhash_init(1, my_hash_ops);
assert(se->hashtbl);
}
se->initialized = true;
return ENGINE_SUCCESS;
}
static ENGINE_ERROR_CODE mock_initialize(ENGINE_HANDLE* handle,
const char* config_str) {
struct mock_engine* se = get_handle(handle);
assert(!se->initialized);
assert(my_hash_ops.dupKey);
if (strcmp(config_str, "no_alloc") != 0) {
se->hashtbl = genhash_init(1, my_hash_ops);
assert(se->hashtbl);
}
se->server->callback->register_callback((ENGINE_HANDLE*)se, ON_DISCONNECT,
handle_disconnect, se);
se->initialized = true;
return ENGINE_SUCCESS;
}
static void
test_function_update()
{
genhash_t* h=genhash_init(4, get_string_hash_ops());
int type=0;
assert_hash_val(NULL, h, "x");
type=genhash_fun_update(h, "x", update_fun, free_str, NULL);
assert(type == NEW);
assert_hash_val("", h, "x");
type=genhash_fun_update(h, "x", update_fun, free_str, NULL);
assert(type == MODIFICATION);
assert_hash_val("x", h, "x");
type=genhash_fun_update(h, "x", update_fun, free_str, NULL);
assert(type == MODIFICATION);
assert_hash_val("xx", h, "x");
assert(genhash_size(h) == 1);
genhash_free(h);
}
static void
test_multiple_keys()
{
genhash_t* h=genhash_init(1, get_string_hash_ops());
int deleted = 0, i = 0;
/* Pollute the space to allow some hash collisions */
for(i=0; i<16000; i++) {
char key[8];
snprintf(key, sizeof(key), "k%d", i);
genhash_store(h, key, key);
assert_hash_val(key, h, key);
}
assert_hash_val(NULL, h, "x");
genhash_store(h, "x", "a");
genhash_store(h, "x", "b");
assert_hash_val("b", h, "x");
deleted=genhash_delete(h, "x");
assert(deleted == 1);
assert_hash_val("a", h, "x");
deleted=genhash_delete(h, "x");
assert(deleted == 1);
assert_hash_val(NULL, h, "x");
deleted=genhash_delete(h, "x");
assert(deleted == 0);
genhash_store(h, "x", "a");
genhash_store(h, "x", "b");
genhash_store(h, "y", "yz");
assert(genhash_size(h) == 16003);
assert(genhash_size_for_key(h, "x") == 2);
deleted=genhash_delete_all(h, "x");
assert(deleted == 2);
genhash_free(h);
}
static void
test_negative_size()
{
genhash_t* h=genhash_init(-827582, get_string_hash_ops());
assert(h == NULL);
}
/* Used for broadcast commands, like no-op, flush_all or stats.
*/
bool cproxy_broadcast_b2b_downstream(downstream *d, conn *uc) {
int nwrite = 0;
int nconns;
int i;
cb_assert(d != NULL);
cb_assert(d->ptd != NULL);
cb_assert(d->ptd->proxy != NULL);
cb_assert(d->downstream_conns != NULL);
cb_assert(uc != NULL);
cb_assert(uc->next == NULL);
cb_assert(uc->noreply == false);
nconns = mcs_server_count(&d->mst);
for (i = 0; i < nconns; i++) {
conn *c = d->downstream_conns[i];
if (c != NULL &&
c != NULL_CONN &&
b2b_forward_item_vbucket(uc, d, uc->item, c, -1) == true) {
nwrite++;
}
}
if (settings.verbose > 2) {
moxi_log_write("%d: b2b broadcast nwrite %d out of %d\n",
uc->sfd, nwrite, nconns);
}
if (nwrite > 0) {
/* TODO: Handle binary 'stats reset' sub-command. */
item *it;
if (uc->cmd == PROTOCOL_BINARY_CMD_STAT &&
d->merger == NULL) {
d->merger = genhash_init(128, skeyhash_ops);
}
it = item_alloc("h", 1, 0, 0,
sizeof(protocol_binary_response_header));
if (it != NULL) {
protocol_binary_response_header *header =
(protocol_binary_response_header *) ITEM_data(it);
memset(ITEM_data(it), 0, it->nbytes);
header->response.magic = (uint8_t) PROTOCOL_BINARY_RES;
header->response.opcode = uc->binary_header.request.opcode;
header->response.opaque = uc->opaque;
if (add_conn_item(uc, it)) {
d->upstream_suffix = ITEM_data(it);
d->upstream_suffix_len = it->nbytes;
d->upstream_status = PROTOCOL_BINARY_RESPONSE_SUCCESS;
d->target_host_ident = NULL;
if (settings.verbose > 2) {
moxi_log_write("%d: b2b broadcast upstream_suffix", uc->sfd);
cproxy_dump_header(uc->sfd, ITEM_data(it));
}
/* TODO: Handle FLUSHQ (quiet binary flush_all). */
d->downstream_used_start = nwrite;
d->downstream_used = nwrite;
cproxy_start_downstream_timeout(d, NULL);
return true;
}
item_remove(it);
}
}
return false;
}
genhash_t *lcb_hashtable_szt_new(lcb_size_t est)
{
return genhash_init(est, hashops_u32);
}
bool multiget_ascii_downstream(downstream *d, conn *uc,
int (*emit_start)(conn *c, char *cmd, int cmd_len),
int (*emit_skey)(conn *c, char *skey, int skey_len),
int (*emit_end)(conn *c),
mcache *front_cache) {
assert(d != NULL);
assert(d->downstream_conns != NULL);
assert(d->multiget == NULL);
assert(uc != NULL);
assert(uc->noreply == false);
proxy_td *ptd = d->ptd;
assert(ptd != NULL);
proxy_stats_cmd *psc_get =
&ptd->stats.stats_cmd[STATS_CMD_TYPE_REGULAR][STATS_CMD_GET];
proxy_stats_cmd *psc_get_key =
&ptd->stats.stats_cmd[STATS_CMD_TYPE_REGULAR][STATS_CMD_GET_KEY];
int nwrite = 0;
int nconns = mcs_server_count(&d->mst);
for (int i = 0; i < nconns; i++) {
if (d->downstream_conns[i] != NULL &&
cproxy_prep_conn_for_write(d->downstream_conns[i]) == false) {
d->ptd->stats.stats.err_downstream_write_prep++;
cproxy_close_conn(d->downstream_conns[i]);
return false;
}
}
if (uc->next != NULL) {
// More than one upstream conn, so we need a hashtable
// to track keys for de-deplication.
//
d->multiget = genhash_init(128, skeyhash_ops);
if (settings.verbose > 1) {
fprintf(stderr, "cproxy multiget hash table new\n");
}
}
// Snapshot the volatile only once.
//
uint32_t msec_current_time_snapshot = msec_current_time;
int uc_num = 0;
conn *uc_cur = uc;
while (uc_cur != NULL) {
assert(uc_cur->cmd == -1);
assert(uc_cur->item == NULL);
assert(uc_cur->state == conn_pause);
assert(IS_ASCII(uc_cur->protocol));
assert(IS_PROXY(uc_cur->protocol));
char *command = uc_cur->cmd_start;
assert(command != NULL);
char *space = strchr(command, ' ');
assert(space > command);
int cmd_len = space - command;
assert(cmd_len == 3 || cmd_len == 4); // Either get or gets.
int cas_emit = (command[3] == 's');
if (settings.verbose > 1) {
fprintf(stderr, "forward multiget %s (%d %d)\n",
command, cmd_len, uc_num);
}
while (space != NULL) {
char *key = space + 1;
char *next_space = strchr(key, ' ');
int key_len;
if (next_space != NULL) {
key_len = next_space - key;
} else {
key_len = strlen(key);
// We've reached the last key.
//
psc_get->read_bytes += (key - command + key_len);
}
// This key_len check helps skip consecutive spaces.
//
if (key_len > 0) {
ptd->stats.stats.tot_multiget_keys++;
psc_get_key->seen++;
psc_get_key->read_bytes += key_len;
// Update key-based statistics.
//
bool do_key_stats =
matcher_check(&ptd->key_stats_matcher,
key, key_len, true) == true &&
matcher_check(&ptd->key_stats_unmatcher,
key, key_len, false) == false;
if (do_key_stats) {
touch_key_stats(ptd, key, key_len,
msec_current_time_snapshot,
STATS_CMD_TYPE_REGULAR,
STATS_CMD_GET_KEY,
1, 0, 0,
key_len, 0);
}
// Handle a front cache hit by queuing response.
//
// Note, front cache stats are part of mcache.
//
if (!cas_emit) {
item *it = mcache_get(front_cache, key, key_len,
msec_current_time_snapshot);
if (it != NULL) {
assert(it->nkey == key_len);
assert(strncmp(ITEM_key(it), key, it->nkey) == 0);
cproxy_upstream_ascii_item_response(it, uc_cur, 0);
psc_get_key->hits++;
psc_get_key->write_bytes += it->nbytes;
if (do_key_stats) {
touch_key_stats(ptd, key, key_len,
msec_current_time_snapshot,
STATS_CMD_TYPE_REGULAR,
STATS_CMD_GET_KEY,
0, 1, 0,
0, it->nbytes);
}
// The refcount was inc'ed by mcache_get() for us.
//
item_remove(it);
goto loop_next;
}
}
bool self = false;
conn *c = cproxy_find_downstream_conn(d, key, key_len,
&self);
if (c != NULL) {
if (self) {
// Optimization for talking with ourselves,
// to avoid extra network hop.
//
ptd->stats.stats.tot_optimize_self++;
item *it = item_get(key, key_len);
if (it != NULL) {
cproxy_upstream_ascii_item_response(it, uc_cur,
cas_emit);
psc_get_key->hits++;
psc_get_key->write_bytes += it->nbytes;
if (do_key_stats) {
touch_key_stats(ptd, key, key_len,
msec_current_time_snapshot,
STATS_CMD_TYPE_REGULAR,
STATS_CMD_GET_KEY,
0, 1, 0,
0, it->nbytes);
}
// The refcount was inc'ed by item_get() for us.
//
item_remove(it);
if (settings.verbose > 1) {
fprintf(stderr,
"optimize self multiget hit: %s\n",
key);
}
} else {
psc_get_key->misses++;
if (do_key_stats) {
touch_key_stats(ptd, key, key_len,
msec_current_time_snapshot,
STATS_CMD_TYPE_REGULAR,
STATS_CMD_GET_KEY,
0, 0, 1,
0, 0);
}
if (settings.verbose > 1) {
fprintf(stderr,
"optimize self multiget miss: %s\n",
key);
}
}
goto loop_next;
}
// See if we've already requested this key via
// the multiget hash table, in order to
// de-deplicate repeated keys.
//
bool first_request = true;
if (d->multiget != NULL) {
// TODO: Use Trond's allocator here.
//
multiget_entry *entry =
calloc(1, sizeof(multiget_entry));
if (entry != NULL) {
entry->upstream_conn = uc_cur;
entry->opaque = 0;
entry->hits = 0;
entry->next = genhash_find(d->multiget, key);
genhash_update(d->multiget, key, entry);
if (entry->next != NULL) {
first_request = false;
}
} else {
// TODO: Handle out of multiget entry memory.
}
}
if (first_request) {
assert(c->item == NULL);
assert(c->state == conn_pause);
assert(IS_PROXY(c->protocol));
assert(c->ilist != NULL);
assert(c->isize > 0);
if (c->msgused <= 1 &&
c->msgbytes <= 0) {
emit_start(c, command, cmd_len);
}
// Provide the preceding space as optimization
// for ascii-to-ascii configuration.
//
emit_skey(c, key - 1, key_len + 1);
} else {
ptd->stats.stats.tot_multiget_keys_dedupe++;
if (settings.verbose > 1) {
char buf[KEY_MAX_LENGTH + 10];
memcpy(buf, key, key_len);
buf[key_len] = '\0';
fprintf(stderr,
"%d cproxy multiget dedpue: %s\n",
uc_cur->sfd, buf);
}
}
} else {
// TODO: Handle when downstream conn is down.
}
}
loop_next:
space = next_space;
}
uc_num++;
uc_cur = uc_cur->next;
}
for (int i = 0; i < nconns; i++) {
conn *c = d->downstream_conns[i];
if (c != NULL &&
(c->msgused > 1 ||
c->msgbytes > 0)) {
emit_end(c);
conn_set_state(c, conn_mwrite);
c->write_and_go = conn_new_cmd;
if (update_event(c, EV_WRITE | EV_PERSIST)) {
nwrite++;
if (uc->noreply) {
c->write_and_go = conn_pause;
}
} else {
if (settings.verbose > 1) {
fprintf(stderr,
"Couldn't update cproxy write event\n");
}
d->ptd->stats.stats.err_oom++;
cproxy_close_conn(c);
}
}
}
if (settings.verbose > 1) {
fprintf(stderr, "forward multiget nwrite %d out of %d\n",
nwrite, nconns);
}
d->downstream_used_start = nwrite;
d->downstream_used = nwrite;
if (cproxy_dettach_if_noreply(d, uc) == false) {
d->upstream_suffix = "END\r\n";
cproxy_start_downstream_timeout(d, NULL);
}
return nwrite > 0;
}
/* Forward a simple one-liner command downstream.
* For example, get, incr/decr, delete, etc.
* The response, though, might be a simple line or
* multiple VALUE+END lines.
*/
bool cproxy_forward_a2a_simple_downstream(downstream *d,
char *command, conn *uc) {
cb_assert(d != NULL);
cb_assert(d->ptd != NULL);
cb_assert(d->ptd->proxy != NULL);
cb_assert(d->downstream_conns != NULL);
cb_assert(command != NULL);
cb_assert(uc != NULL);
cb_assert(uc->item == NULL);
cb_assert(uc->cmd_curr != (protocol_binary_command) -1);
cb_assert(d->multiget == NULL);
cb_assert(d->merger == NULL);
/* Handles get and gets. */
if (uc->cmd_curr == PROTOCOL_BINARY_CMD_GETK ||
uc->cmd_curr == PROTOCOL_BINARY_CMD_GETKQ ||
uc->cmd_curr == PROTOCOL_BINARY_CMD_GETL) {
/* Only use front_cache for 'get', not for 'gets'. */
mcache *front_cache =
(command[3] == ' ') ? &d->ptd->proxy->front_cache : NULL;
return multiget_ascii_downstream(d, uc,
a2a_multiget_start,
a2a_multiget_skey,
a2a_multiget_end,
front_cache);
}
cb_assert(uc->next == NULL);
if (uc->cmd_curr == PROTOCOL_BINARY_CMD_FLUSH) {
return cproxy_broadcast_a2a_downstream(d, command, uc,
"OK\r\n");
}
if (uc->cmd_curr == PROTOCOL_BINARY_CMD_STAT) {
if (strncmp(command + 5, " reset", 6) == 0) {
return cproxy_broadcast_a2a_downstream(d, command, uc,
"RESET\r\n");
}
if (cproxy_broadcast_a2a_downstream(d, command, uc,
"END\r\n")) {
d->merger = genhash_init(512, skeyhash_ops);
return true;
} else {
return false;
}
}
/* TODO: Inefficient repeated scan_tokens. */
int cmd_len = 0;
token_t tokens[MAX_TOKENS];
size_t ntokens = scan_tokens(command, tokens, MAX_TOKENS, &cmd_len);
char *key = tokens[KEY_TOKEN].value;
int key_len = tokens[KEY_TOKEN].length;
if (ntokens <= 1) { /* This was checked long ago, while parsing */
cb_assert(false); /* the upstream conn. */
return false;
}
/* Assuming we're already connected to downstream. */
if (!strcmp(command, "version")) {
/* fake key for version command handling */
key = "v";
key_len = 1;
}
conn *c = cproxy_find_downstream_conn(d, key, key_len, NULL);
if (c != NULL) {
if (cproxy_prep_conn_for_write(c)) {
cb_assert(c->state == conn_pause);
out_string(c, command);
if (settings.verbose > 1) {
moxi_log_write("forwarding to %d, noreply %d\n",
c->sfd, uc->noreply);
}
if (update_event(c, EV_WRITE | EV_PERSIST)) {
d->downstream_used_start = 1;
d->downstream_used = 1;
if (cproxy_dettach_if_noreply(d, uc) == false) {
cproxy_start_downstream_timeout(d, c);
} else {
c->write_and_go = conn_pause;
/* Do mcache_delete() here only during a noreply, */
/* otherwise for with-reply requests, we could */
/* be in a race with other clients repopulating */
/* the front_cache. For with-reply requests, we */
/* clear the front_cache when we get a success reply. */
cproxy_front_cache_delete(d->ptd, key, key_len);
}
return true;
}
if (settings.verbose > 1) {
moxi_log_write("Couldn't update cproxy write event\n");
}
d->ptd->stats.stats.err_oom++;
cproxy_close_conn(c);
} else {
d->ptd->stats.stats.err_downstream_write_prep++;
cproxy_close_conn(c);
}
}
return false;
}
/* Forward a simple one-liner command downstream.
* For example, get, incr/decr, delete, etc.
* The response, though, might be a simple line or
* multiple VALUE+END lines.
*/
bool cproxy_forward_a2a_simple_downstream(downstream *d,
char *command, conn *uc) {
assert(d != NULL);
assert(d->ptd != NULL);
assert(d->ptd->proxy != NULL);
assert(d->downstream_conns != NULL);
assert(command != NULL);
assert(uc != NULL);
assert(uc->item == NULL);
assert(uc->cmd_curr != -1);
assert(d->multiget == NULL);
assert(d->merger == NULL);
// Handles get and gets.
//
if (uc->cmd_curr == PROTOCOL_BINARY_CMD_GET) {
// Only use front_cache for 'get', not for 'gets'.
//
mcache *front_cache =
(command[3] == ' ') ? &d->ptd->proxy->front_cache : NULL;
return multiget_ascii_downstream(d, uc,
a2a_multiget_start,
a2a_multiget_skey,
a2a_multiget_end,
front_cache);
}
assert(uc->next == NULL);
if (uc->cmd_curr == PROTOCOL_BINARY_CMD_FLUSH)
return cproxy_broadcast_a2a_downstream(d, command, uc,
"OK\r\n");
if (uc->cmd_curr == PROTOCOL_BINARY_CMD_STAT) {
if (strncmp(command + 5, " reset", 6) == 0)
return cproxy_broadcast_a2a_downstream(d, command, uc,
"RESET\r\n");
if (cproxy_broadcast_a2a_downstream(d, command, uc,
"END\r\n")) {
d->merger = genhash_init(512, skeyhash_ops);
return true;
} else {
return false;
}
}
// TODO: Inefficient repeated scan_tokens.
//
int cmd_len = 0;
token_t tokens[MAX_TOKENS];
size_t ntokens = scan_tokens(command, tokens, MAX_TOKENS, &cmd_len);
char *key = tokens[KEY_TOKEN].value;
int key_len = tokens[KEY_TOKEN].length;
if (ntokens <= 1) { // This was checked long ago, while parsing
assert(false); // the upstream conn.
return false;
}
// Assuming we're already connected to downstream.
//
bool self = false;
conn *c = cproxy_find_downstream_conn(d, key, key_len,
&self);
if (c != NULL) {
if (self) {
// TODO: This optimization could be done much earlier,
// even before the upstream conn was assigned
// to a downstream.
//
cproxy_optimize_to_self(d, uc, command);
process_command(uc, command);
return true;
}
if (cproxy_prep_conn_for_write(c)) {
assert(c->state == conn_pause);
out_string(c, command);
if (settings.verbose > 1)
fprintf(stderr, "forwarding to %d, noreply %d\n",
c->sfd, uc->noreply);
if (update_event(c, EV_WRITE | EV_PERSIST)) {
d->downstream_used_start = 1;
d->downstream_used = 1;
if (cproxy_dettach_if_noreply(d, uc) == false) {
cproxy_start_downstream_timeout(d, c);
} else {
c->write_and_go = conn_pause;
// Do mcache_delete() here only during a noreply,
// otherwise for with-reply requests, we could
// be in a race with other clients repopulating
// the front_cache. For with-reply requests, we
// clear the front_cache when we get a success reply.
//
mcache_delete(&d->ptd->proxy->front_cache, key, key_len);
}
return true;
}
if (settings.verbose > 1)
fprintf(stderr, "Couldn't update cproxy write event\n");
d->ptd->stats.stats.err_oom++;
cproxy_close_conn(c);
} else {
d->ptd->stats.stats.err_downstream_write_prep++;
cproxy_close_conn(c);
}
}
return false;
}
genhash_t *lcb_hashtable_nc_new(lcb_size_t est)
{
return genhash_init(est, hashops_nocopy);
}
