void
hashmap_add(hashmap *map, const char *key, void *data, boolean is_alias)
{
hashnode *node;
uint16_t bucket;
assert(map);
assert(key);
assert(data);
if ((node = malloc(sizeof(hashnode))) == NULL)
{
quit_error(POUTOFMEM);
}
node->key = key;
node->data = data;
node->hash = hashmap_hash(key);
node->is_alias = is_alias;
bucket = node->hash % map->buckets;
if (!map->data[bucket])
{
map->data[bucket] = darray_create();
darray_push(map->data[bucket], node);
}
else
{
darray_push(map->data[bucket], node);
}
}
void Server_queue_cleanup()
{
if(darray_end(SERVER_QUEUE) < SERVER_ACTIVE) {
// skip it, not enough to care about
return;
}
// pop the last one off to make sure it's never deleted
Server *cur_srv = darray_pop(SERVER_QUEUE);
uint32_t too_old = time(NULL) - SERVER_TTL;
int i = 0;
// TODO: kind of a dumb way to do this since it reorders the list
// go through all but the max we want to keep
for(i = 0; i < darray_end(SERVER_QUEUE) - SERVER_ACTIVE; i++) {
Server *srv = darray_get(SERVER_QUEUE, i);
if(srv->created_on < too_old) {
Server *replace = darray_pop(SERVER_QUEUE);
darray_set(SERVER_QUEUE, i, replace);
srv->listen_fd = -1; // don't close it
Server_destroy(srv);
}
}
// put the sacred server back on the end
darray_push(SERVER_QUEUE, cur_srv);
return;
}
static int simple_set_session( ssl_context *ssl )
{
time_t t = THE_CURRENT_TIME_IS;
int i = 0;
ssl_session *cur = NULL;
int make_new = 1;
check(setup_ssl_session_cache() == 0, "Failed to initialize SSL session cache.");
for(i = 0; i < darray_end(SSL_SESSION_CACHE); i++) {
cur = darray_get(SSL_SESSION_CACHE, i);
if( ssl->timeout != 0 && t - cur->start > ssl->timeout ) {
make_new = 0;
break; /* expired, reuse this slot */
}
if( memcmp( ssl->session->id, cur->id, cur->length ) == 0 ) {
make_new = 0;
break; /* client reconnected */
}
}
if(make_new) {
cur = (ssl_session *) darray_new(SSL_SESSION_CACHE);
check_mem(cur);
darray_push(SSL_SESSION_CACHE, cur);
}
*cur = *ssl->session;
return 0;
error:
return 1;
}
int
master_init(vr_conf *conf)
{
rstatus_t status;
uint32_t j;
sds *host, listen_str;
vr_listen **vlisten;
int threads_num;
int filelimit;
master.cbsul = NULL;
pthread_mutex_init(&master.cbsullock, NULL);
conf_server_get(CONFIG_SOPN_THREADS,&threads_num);
filelimit = threads_num*2+CONFIG_MIN_RESERVED_FDS;
vr_eventloop_init(&master.vel,filelimit);
master.vel.thread.fun_run = master_thread_run;
darray_init(&master.listens,darray_n(&cserver->binds),sizeof(vr_listen*));
for (j = 0; j < darray_n(&cserver->binds); j ++) {
host = darray_get(&cserver->binds,j);
listen_str = sdsdup(*host);
listen_str = sdscatfmt(listen_str, ":%i", cserver->port);
vlisten = darray_push(&master.listens);
*vlisten = vr_listen_create(listen_str);
if (*vlisten == NULL) {
darray_pop(&master.listens);
log_error("Create listen %s failed", listen_str);
sdsfree(listen_str);
return VR_ERROR;
}
sdsfree(listen_str);
}
for (j = 0; j < darray_n(&master.listens); j ++) {
vlisten = darray_get(&master.listens, j);
status = vr_listen_begin(*vlisten);
if (status != VR_OK) {
log_error("Begin listen to %s failed", (*vlisten)->name);
return VR_ERROR;
}
}
master.cbsul = dlistCreate();
if (master.cbsul == NULL) {
log_error("Create list failed: out of memory");
return VR_ENOMEM;
}
setup_master();
return VR_OK;
}
int hashmap_set(Hashmap *map, void *key, void *data) {
uint32_t hash = 0;
DArray *bucket = hashmap_find_bucket(map, key, 1, &hash);
check(bucket, "error: can't create bucket");
HashmapNode *node = hashmap_node_create(hash, key, data);
check_mem(node);
darray_push(bucket, node);
return 0;
error:
return -1;
}
DArray * darray_radix_sort(DArray *array) {
DArray *buckets, *bucket;
int *val, i, j, cur, mask, sortval, sorted;
buckets = darray_init();
mask = 1;
do {
sorted = 1;
// reset the buckets
for (i = 0; i < 10; i++) {
darray_set(buckets, i, darray_init());
}
// sort the values into buckets
for (i = 0; i <= (array->last); i++) {
val = (int*)darray_get(array, i);
sortval = (*val / mask) % 10;
if (sortval > 0) { sorted = 0; }
darray_push((PDArray)darray_get(buckets, sortval), val);
}
// rebuild array
cur = 0;
for (i = 0; i < 10; i++) {
bucket = (PDArray)darray_get(buckets, i);
for (j = 0; j <= (bucket->last); j++) {
darray_set(array,
cur++,
darray_get(bucket, j));
}
}
mask *= 10;
} while (!sorted);
return array;
}
char *test_push_pop()
{
int i = 0;
for(i=0; i<1000; i++) {
int *val = darray_new(array);
*val = i*333;
darray_push(array, val);
}
mu_assert(array->max==1300, "Wrong max size");
for(i=999; i>=0; i--) {
int *val = darray_pop(array);
mu_assert(val!=NULL, "Shouldn't get a NULL.");
mu_assert(*val==i*333, "Wrong value.");
free(val);
}
return NULL;
}
int vrt_dispatch_data_init(int threads_count, char *test_target_groups, int connections)
{
int j;
dispatch_data_threads_count = threads_count;
dispatch_data_threads = darray_create(threads_count, sizeof(dispatch_data_thread));
if (dispatch_data_threads == NULL) {
return VRT_ERROR;
}
for (j = 0; j < threads_count; j ++) {
dispatch_data_thread *ddt = darray_push(dispatch_data_threads);
if (dispatch_data_thread_init(ddt, test_target_groups, connections) != VRT_OK) {
return VRT_ERROR;
}
ddt->id = j;
}
return VRT_OK;
}
int Filter_add(StateEvent state, filter_cb cb, bstring load_path, tns_value_t *config)
{
darray_t *filters = Filter_lookup_create(state);
check(filters != NULL, "Invalid filter state: %d given for filter %s",
state, bdata(load_path));
Filter *filter = darray_new(filters);
check_mem(filter);
filter->state = state;
filter->cb = cb;
filter->load_path = bstrcpy(load_path);
filter->config = config;
darray_attach(filters, filter);
darray_push(filters, filter);
return 0;
error:
return -1;
}
void Server_queue_push(Server *srv)
{
Server_queue_cleanup();
darray_push(SERVER_QUEUE, srv);
hattach(srv, SERVER_QUEUE);
}
int main(void) {
darray(long) arr = darray_new();
darray_char str = darray_new();
darray(long*) arrp = darray_new();
arrp.onFree = _arr_free_handler;
#define reset(arr) do {darray_free(arr); darray_init(arr);} while(0)
size_t i;
trace("Generating amalgams (internal)");
generateAmalgams();
plan_tests(54);
testLits();
testing(darray_pushptr);
{
int vMaxCount = 10;//ARRAY_SIZE(lotsOfNumbers);
for (int k=0; k < vMaxCount; k++) {
long* p = malloc(sizeof(long));
*p = lotsOfNumbers[k];
darray_push(arrp, p);
}
ok1(darray_size(arrp) == vMaxCount);
ok1(darray_alloc(arrp) >= darray_size(arrp));
long **i;
size_t j = 0;
darray_foreach(i, arrp) {
if (i - arrp.item != j)
break;
if (**i != (long)lotsOfNumbers[j])
break;
j++;
};
ok1(j == vMaxCount);
darray_free_all(arrp);
ok1(_free_count == vMaxCount);
}
testing(darray_push);
{
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++)
darray_push(arr, lotsOfNumbers[i]);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(darray_alloc(arr) >= darray_size(arr));
ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)));
}
testing(darray_insert);
{
darray_insert(arr, 0, 123456);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)+1);
ok1(!memcmp(arr.item+1, lotsOfNumbers, sizeof(lotsOfNumbers)));
ok1(darray_item(arr, 0) == 123456);
darray_insert(arr, 15, 0x112233);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers)+2);
ok1(darray_item(arr, 15) == 0x112233);
ok1(!memcmp(arr.item+1, lotsOfNumbers, 14*sizeof(long)));
ok1(!memcmp(arr.item+16, &lotsOfNumbers[14], ARRAY_SIZE(lotsOfNumbers)-(15*sizeof(long))));
}
testing(darray_del);
{
darray_del(arr, 15);
darray_del(arr, 0);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)));
}
reset(arr);
testing(darray_prepend, darray_pop);
{
for (i = ARRAY_SIZE(lotsOfNumbers); i;)
darray_prepend(arr, lotsOfNumbers[--i]);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(darray_alloc(arr) >= darray_size(arr));
ok1(!memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)));
for (i = ARRAY_SIZE(lotsOfNumbers); i;) {
if (darray_pop(arr) != (long)lotsOfNumbers[--i]) {
i++;
break;
}
}
ok1(i==0);
ok1(darray_size(arr) == 0);
}
reset(arr);
testing(darray_from_c, darray_foreach, darray_foreach_reverse);
{
long *i;
size_t j;
darray_from_c(arr, lotsOfNumbers);
ok1(darray_size(arr) == ARRAY_SIZE(lotsOfNumbers));
ok1(darray_alloc(arr) >= darray_size(arr));
ok1(memcmp(arr.item, lotsOfNumbers, sizeof(lotsOfNumbers)) == 0);
j = 0;
darray_foreach(i, arr) {
if (i - arr.item != j)
break;
if (*i != (long)lotsOfNumbers[j])
break;
j++;
};
ok1(j == ARRAY_SIZE(lotsOfNumbers));
j = 0;
darray_foreach_reverse(i, arr) {
if (i - arr.item != darray_size(arr)-j-1)
break;
if (*i != (long)lotsOfNumbers[darray_size(arr)-j-1])
break;
j++;
};
ok1(j == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_append_string);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++)
darray_append_string(str, lotsOfStrings[i]);
ok1(str.size == amalgams.stringsSize);
ok1(str.alloc > str.size);
ok1(str.item[str.size] == 0);
ok1(!strcmp(str.item, amalgams.stringsF));
}
reset(str);
testing(darray_prepend_string);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++)
darray_prepend_string(str, lotsOfStrings[i]);
ok1(str.size == amalgams.stringsSize);
ok1(str.alloc > str.size);
ok1(str.item[str.size] == 0);
ok1(!strcmp(str.item, amalgams.stringsB));
}
reset(str);
testing(darray_from_string);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) {
darray_from_string(str, lotsOfStrings[i]);
if (str.size != strlen(lotsOfStrings[i]))
break;
if (str.alloc < strlen(lotsOfStrings[i])+1)
break;
if (strcmp(str.item, lotsOfStrings[i]))
break;
}
ok1(i == ARRAY_SIZE(lotsOfStrings));
}
reset(str);
testing(darray_resize0);
{
size_t prevSize=0, size;
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++, prevSize=size) {
size = lotsOfNumbers[i] & 0xFFFF;
darray_resize0(arr, size);
if (darray_size(arr) != size)
break;
if (darray_alloc(arr) < size)
break;
if (size>prevSize) {
if (!isZeros(arr.item+prevSize, (size-prevSize)*sizeof(*arr.item)))
break;
}
//fill the darray with lotsOfNumbers garbage
memtile(arr.item, darray_size(arr)*sizeof(*arr.item), lotsOfNumbers, sizeof(lotsOfNumbers));
}
ok1(i == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_realloc);
{
size_t s,a;
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++) {
arr.size = (s = lotsOfNumbers[i] >> 16);
//give size a nonsense value to make sure darray_realloc doesn't care about it
a = amalgams.stringsSize/sizeof(*arr.item)+2;
darray_realloc(arr, a = lotsOfNumbers[i] % ((amalgams.stringsSize/sizeof(*arr.item))+1));
if (a*sizeof(*arr.item) > amalgams.stringsSize)
break;
if (darray_alloc(arr) != a)
break;
if (darray_size(arr) != s)
break;
memtile(arr.item, a*sizeof(*arr.item), amalgams.stringsF, a*sizeof(*arr.item));
if (memcmp(arr.item, amalgams.stringsF, a*sizeof(*arr.item)))
break;
}
ok1(i == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_growalloc);
{
size_t prevA, s, a;
for (i=0; i < ARRAY_SIZE(lotsOfNumbers); i++) {
arr.size = (s = lotsOfNumbers[i] >> 16);
//give size a nonsense value to make sure darray_growalloc doesn't care about it
a = amalgams.stringsSize/sizeof(*arr.item)+2;
prevA = darray_alloc(arr);
darray_growalloc(arr, a = lotsOfNumbers[i] % ((amalgams.stringsSize/sizeof(*arr.item))+1));
if (a*sizeof(*arr.item) > amalgams.stringsSize)
break;
if (darray_alloc(arr) < a)
break;
if (darray_alloc(arr) < prevA)
break;
if (darray_size(arr) != s)
break;
memtile(arr.item, a*sizeof(*arr.item), amalgams.stringsF, a*sizeof(*arr.item));
if (memcmp(arr.item, amalgams.stringsF, a*sizeof(*arr.item)))
break;
//clear the darray every now and then
if (!(lotsOfNumbers[i] & 15)) {
reset(arr);
}
}
ok1(i == ARRAY_SIZE(lotsOfNumbers));
}
reset(arr);
testing(darray_make_room);
{
for (i=0; i < ARRAY_SIZE(lotsOfStrings); i++) {
char *dest = darray_make_room(str, strlen(lotsOfStrings[i]));
if (str.alloc < str.size+strlen(lotsOfStrings[i]))
break;
if (dest != str.item+str.size)
break;
memcpy(dest, lotsOfStrings[i], strlen(lotsOfStrings[i]));
str.size += strlen(lotsOfStrings[i]);
}
ok1(i == ARRAY_SIZE(lotsOfStrings));
ok1(str.size == amalgams.stringsSize);
darray_append(str, 0);
ok1(!strcmp(str.item, amalgams.stringsF));
}
reset(str);
testing(darray_appends, darray_prepends, darray_pop_check);
{
darray(const char*) arr = darray_new();
const char *n[9] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight"};
#if HAVE_TYPEOF
darray_appends(arr, n[5], n[6], n[7], n[8]);
#else
darray_appends_t(arr, const char *, n[5], n[6], n[7], n[8]);
#endif
ok1(darray_size(arr)==4 && darray_alloc(arr)>=4);
#if HAVE_TYPEOF
darray_prepends(arr, n[0], n[1], n[2], n[3], n[4]);
#else
darray_prepends_t(arr, const char *, n[0], n[1], n[2], n[3], n[4]);
#endif
ok1(darray_size(arr)==9 && darray_alloc(arr)>=9);
ok1(arr.item[0]==n[0] &&
arr.item[1]==n[1] &&
arr.item[2]==n[2] &&
arr.item[3]==n[3] &&
arr.item[4]==n[4] &&
arr.item[5]==n[5] &&
arr.item[6]==n[6] &&
arr.item[7]==n[7] &&
arr.item[8]==n[8]);
ok1(darray_pop_check(arr)==n[8] &&
darray_pop_check(arr)==n[7] &&
darray_pop_check(arr)==n[6] &&
darray_pop_check(arr)==n[5] &&
darray_pop_check(arr)==n[4] &&
darray_pop_check(arr)==n[3] &&
darray_pop_check(arr)==n[2] &&
darray_pop_check(arr)==n[1] &&
darray_pop_check(arr)==n[0]);
ok1(darray_size(arr)==0);
ok1(darray_pop_check(arr)==NULL && darray_pop_check(arr)==NULL && darray_pop_check(arr)==NULL);
darray_free(arr);
}
trace("Freeing amalgams (internal)");
freeAmalgams();
return exit_status();
}
void MemoryAllocation_PushA(DArray *array, MemoryAllocation *s) { darray_push(array, s); }
char *test_darray_operations()
{
darray_t *array = darray_create(sizeof(int), 100);
mu_assert(array != NULL, "darray_create failed.");
mu_assert(array->contents != NULL, "contents are wrong in darray");
mu_assert(array->end == 0, "end isn't at the right spot");
mu_assert(array->element_size == sizeof(int), "element size is wrong.");
mu_assert(array->max == 100, "wrong max length on initial size");
int *val1 = darray_new(array);
mu_assert(val1 != NULL, "failed to make a new element");
int *val2 = darray_new(array);
mu_assert(val2 != NULL, "failed to make a new element");
darray_set(array, 0, val1);
darray_set(array, 1, val2);
mu_assert(darray_get(array, 0) == val1, "Wrong first value.");
mu_assert(darray_get(array, 1) == val2, "Wrong second value.");
int *val_check = darray_remove(array, 0);
mu_assert(val_check != NULL, "Should not get NULL.");
mu_assert(*val_check == *val1, "Should get the first value.");
mu_assert(darray_get(array, 0) == NULL, "Should be gone.");
darray_free(val_check);
val_check = darray_remove(array, 1);
mu_assert(val_check != NULL, "Should not get NULL.");
mu_assert(*val_check == *val2, "Should get the first value.");
mu_assert(darray_get(array, 1) == NULL, "Should be gone.");
darray_free(val_check);
int old_max = array->max;
darray_expand(array);
mu_assert(array->max == old_max + array->expand_rate, "Wrong size after expand.");
darray_contract(array);
mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
darray_contract(array);
mu_assert(array->max == array->expand_rate + 1, "Should stay at the expand_rate at least.");
int i = 0;
for(i = 0; i < 1000; i++) {
int *val = darray_new(array);
darray_attach(array, val);
*val = i * 333;
darray_push(array, val);
}
mu_assert(array->max == 1201, "Wrong max size.");
for(i = 999; i > 0; i--) {
int *val = darray_pop(array);
mu_assert(val != NULL, "Shouldn't get a NULL.");
mu_assert(*val == i * 333, "Wrong value.");
darray_free(val);
}
darray_destroy(array);
return NULL;
}
static int dispatch_data_thread_init(dispatch_data_thread *ddt, char *test_target_groups, int connections)
{
int i, j, k;
ddt->id = 0;
ddt->thread_id = 0;
ddt->el = NULL;
ddt->hz = 10;
ddt->cronloops = 0;
ddt->datas = NULL;
ddt->rdatas = NULL;
ddt->abgs = NULL;
ddt->pause = 0;
ddt->count_wait_for_reply = 0;
ddt->reply_total_count_per_cycle = 0;
ddt->reply_type_err_count_per_cycle = 0;
ddt->el = aeCreateEventLoop(200);
if (ddt->el == NULL) {
return VRT_ERROR;
}
ddt->datas = dmtqueue_create();
if (ddt->datas == NULL) {
return VRT_ERROR;
}
if (dmtqueue_init_with_lockqueue(ddt->datas, NULL) != 0) {
return VRT_ERROR;
}
ddt->rdatas = dlistCreate();
if (ddt->rdatas == NULL) {
return VRT_ERROR;
}
ddt->abgs = abtest_groups_create(test_target_groups);
if (ddt->abgs == NULL) {
return VRT_ERROR;
}
/* Init connection context for each server */
for (i = 0; i < darray_n(ddt->abgs); i ++) {
abtest_group *abg = darray_get(ddt->abgs, i);
for (j = 0; j < darray_n(&abg->abtest_servers); j ++) {
abtest_server *abs = darray_get(&abg->abtest_servers, j);
abs->conn_contexts = darray_create(connections, sizeof(conn_context));
for (k = 0; k < connections; k ++) {
conn_context *cc = darray_push(abs->conn_contexts);
if (dispatch_conn_context_init(cc,abs->host,abs->port) != VRT_OK) {
return VRT_ERROR;
}
cc->actx->data = ddt;
redisAeAttach(ddt->el, cc->actx);
redisAsyncSetConnectCallback(cc->actx,connect_callback);
redisAsyncSetDisconnectCallback(cc->actx,disconnect_callback);
}
}
}
if (aeCreateTimeEvent(ddt->el, 1, dispatch_data_thread_cron, ddt, NULL) == AE_ERR) {
return VRT_ERROR;
}
return VRT_OK;
}
