/**
* Actually free the resources allocated by the dset (and all its entries).
* Called by some other functions in libcouchbase
*/
void lcb_durability_dset_destroy(lcb_durability_set_t *dset)
{
lcb_size_t ii;
lcb_t instance = dset->instance;
if (dset->timer) {
lcb_io_opt_t io = instance->settings.io;
io->v.v0.delete_timer(io, dset->timer);
io->v.v0.destroy_timer(io, dset->timer);
dset->timer = NULL;
}
for (ii = 0; ii < dset->nentries; ii++) {
lcb_durability_entry_t *ent = dset->entries + ii;
free((void *)REQFLD(ent, key));
}
hashset_remove(dset->instance->durability_polls, dset);
if (dset->nentries > 1) {
if (dset->ht) {
genhash_free(dset->ht);
}
free(dset->entries);
free(dset->valid_entries);
}
free(dset);
lcb_maybe_breakout(instance);
}
void mcache_stop(mcache *m) {
assert(m);
if (m->lock) {
cb_mutex_enter(m->lock);
}
genhash_t *x = m->map;
m->map = NULL;
m->max = 0;
m->lru_head = NULL;
m->lru_tail = NULL;
m->oldest_live = 0;
if (m->lock) {
cb_mutex_exit(m->lock);
}
/* Destroying hash table outside the lock. */
if (x != NULL) {
genhash_free(x);
}
}
static void
test_construct()
{
genhash_t* h=NULL;
h=genhash_init(4, get_string_hash_ops());
genhash_free(h);
}
static void
test_clear()
{
genhash_t* h=get_test_hash();
assert(genhash_size(h) == 26);
genhash_clear(h);
assert(genhash_size(h) == 0);
genhash_free(h);
}
static void mock_destroy(ENGINE_HANDLE* handle) {
struct mock_engine* se = get_handle(handle);
if (se->initialized) {
se->initialized = false;
genhash_free(se->hashtbl);
free(se);
}
}
void topkeys_free(topkeys_t *tk) {
pthread_mutex_destroy(&tk->mutex);
genhash_free(tk->hash);
dlist_t *p = tk->list.next;
while (p != &tk->list) {
dlist_t *tmp = p->next;
free(p);
p = tmp;
}
}
static void
test_update()
{
genhash_t* h=get_test_hash();
int type=0, i=0;
for(i=0; i<26; i++) {
assert_hash_val(kvs[i], h, kvs[i]);
type=genhash_update(h, kvs[i], "updated");
assert(type == MODIFICATION);
assert_hash_val("updated", h, kvs[i]);
}
type=genhash_update(h, "newtest", "new");
assert(type == NEW);
assert_hash_val("new", h, "newtest");
genhash_free(h);
}
static void
test_simple()
{
genhash_t* h=get_test_hash();
int i=0;
for(i=0; i<13; i++) {
int deleted=genhash_delete(h, kvs[i*2]);
assert(deleted == 1);
deleted=genhash_delete(h, kvs[i*2]);
assert(deleted == 0);
}
for(i=0; i<26; i++) {
if(i % 2 == 0) {
assert_hash_val(NULL, h, kvs[i]);
} else {
assert_hash_val(kvs[i], h, kvs[i]);
}
}
genhash_free(h);
}
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);
}
/**
* Actually free the resources allocated by the dset (and all its entries).
* Called by some other functions in libcouchbase
*/
void lcb_durability_dset_destroy(lcb_DURSET *dset)
{
lcb_t instance = dset->instance;
if (dset->timer) {
lcbio_TABLE *io = instance->iotable;
io->timer.cancel(io->p, dset->timer);
io->timer.destroy(io->p, dset->timer);
dset->timer = NULL;
}
lcb_aspend_del(&dset->instance->pendops, LCB_PENDTYPE_DURABILITY, dset);
if (dset->nentries > 1) {
if (dset->ht) {
genhash_free(dset->ht);
}
free(dset->entries);
}
lcb_string_release(&dset->kvbufs);
free(dset);
lcb_maybe_breakout(instance);
}
static void
test_free_null()
{
genhash_free(NULL);
}
LIBCOUCHBASE_API
void lcb_destroy(lcb_t instance)
{
lcb_size_t ii;
lcb_settings *settings = &instance->settings;
if (instance->cur_configinfo) {
lcb_clconfig_decref(instance->cur_configinfo);
instance->cur_configinfo = NULL;
}
instance->vbucket_config = NULL;
lcb_bootstrap_destroy(instance);
lcb_confmon_destroy(instance->confmon);
hostlist_destroy(instance->usernodes);
if (instance->timers != NULL) {
for (ii = 0; ii < instance->timers->capacity; ++ii) {
if (instance->timers->items[ii] > 1) {
lcb_timer_destroy(instance,
(lcb_timer_t)instance->timers->items[ii]);
}
}
hashset_destroy(instance->timers);
}
if (instance->durability_polls) {
struct lcb_durability_set_st **dset_list;
lcb_size_t nitems = hashset_num_items(instance->durability_polls);
dset_list = (struct lcb_durability_set_st **)
hashset_get_items(instance->durability_polls, NULL);
if (dset_list) {
for (ii = 0; ii < nitems; ii++) {
lcb_durability_dset_destroy(dset_list[ii]);
}
free(dset_list);
}
hashset_destroy(instance->durability_polls);
}
for (ii = 0; ii < instance->nservers; ++ii) {
lcb_server_destroy(instance->servers + ii);
}
if (instance->http_requests) {
for (ii = 0; ii < instance->http_requests->capacity; ++ii) {
if (instance->http_requests->items[ii] > 1) {
lcb_http_request_t htreq =
(lcb_http_request_t)instance->http_requests->items[ii];
/**
* We don't want to invoke callbacks *or* remove it from our
* hash table
*/
htreq->status |= LCB_HTREQ_S_CBINVOKED | LCB_HTREQ_S_HTREMOVED;
/* we should figure out a better error code for this.. */
lcb_http_request_finish(instance, htreq, LCB_ERROR);
}
}
}
hashset_destroy(instance->http_requests);
free(instance->servers);
connmgr_destroy(instance->memd_sockpool);
if (settings->io && settings->io->v.v0.need_cleanup) {
lcb_destroy_io_ops(settings->io);
}
ringbuffer_destruct(&instance->purged_buf);
ringbuffer_destruct(&instance->purged_cookies);
free(instance->histogram);
free(instance->scratch);
free(settings->username);
free(settings->password);
free(settings->bucket);
free(settings->sasl_mech_force);
if (instance->cmdht) {
genhash_free(instance->cmdht);
instance->cmdht = NULL;
}
memset(instance, 0xff, sizeof(*instance));
free(instance);
}
