uint8_t inuse;
uint8_t outstanding_pings;
uint8_t flags; /* active, suspect, expired */
- uint8_t touched; /* did we ever get a touch */
+ uint8_t touched; /* did we ever get a touch */
} ks_dhtrt_bucket_entry_t;
typedef struct ks_dhtrt_bucket_s {
ks_dhtrt_bucket_entry_t entries[KS_DHT_BUCKETSIZE];
uint8_t count;
uint8_t expired_count;
- ks_rwl_t *lock; /* lock for safe traversal of the entry array */
+ ks_rwl_t *lock; /* lock for safe traversal of the entry array */
} ks_dhtrt_bucket_t;
struct ks_dhtrt_bucket_header_s * parent;
struct ks_dhtrt_bucket_header_s * left;
struct ks_dhtrt_bucket_header_s * right;
- struct ks_dhtrt_bucket_header_s * left1bit;
- struct ks_dhtrt_bucket_header_s * right1bit;
+ struct ks_dhtrt_bucket_header_s * left1bit;
+ struct ks_dhtrt_bucket_header_s * right1bit;
ks_dhtrt_bucket_t * bucket;
ks_time_t tyme; /* last processed time */
unsigned char mask[KS_DHT_NODEID_SIZE]; /* node id mask */
} ks_dhtrt_bucket_header_t;
typedef struct ks_dhtrt_deletednode_s {
- ks_dht_node_t* node;
- struct ks_dhtrt_deletednode_s *next;
+ ks_dht_node_t* node;
+ struct ks_dhtrt_deletednode_s *next;
} ks_dhtrt_deletednode_t;
typedef struct ks_dhtrt_internal_s {
uint8_t localid[KS_DHT_NODEID_SIZE];
ks_dhtrt_bucket_header_t *buckets; /* root bucketheader */
ks_dht_t *dht;
- ks_thread_pool_t *tpool;
+ ks_thread_pool_t *tpool;
ks_rwl_t *lock; /* lock for safe traversal of the tree */
ks_time_t last_process_table;
- ks_time_t next_process_table_delta;
- ks_mutex_t *deleted_node_lock;
- ks_dhtrt_deletednode_t *deleted_node;
- ks_dhtrt_deletednode_t *free_node_ex;
- uint32_t deleted_count;
+ ks_time_t next_process_table_delta;
+ ks_mutex_t *deleted_node_lock;
+ ks_dhtrt_deletednode_t *deleted_node;
+ ks_dhtrt_deletednode_t *free_node_ex;
+ uint32_t deleted_count;
} ks_dhtrt_internal_t;
typedef struct ks_dhtrt_xort_s {
static
ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t *table, ks_dht_node_t *node)
{
- if (!table || !table->internal) {
- return KS_STATUS_FAIL;
- }
+ if (!table || !table->internal) {
+ return KS_STATUS_FAIL;
+ }
- ks_dhtrt_internal_t* internal = table->internal;
- ks_dhtrt_bucket_t *bucket = 0;
+ ks_dhtrt_internal_t* internal = table->internal;
+ ks_dhtrt_bucket_t *bucket = 0;
int insanity = 0;
- ks_rwl_write_lock(internal->lock);
+ ks_rwl_write_lock(internal->lock);
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, node->nodeid.id);
- assert(header != NULL); /* should always find a header */
+ assert(header != NULL); /* should always find a header */
bucket = header->bucket;
if (bucket == 0) {
- ks_rwl_write_unlock(internal->lock);
- return KS_STATUS_FAIL; /* we were not able to find a bucket*/
- }
+ ks_rwl_write_unlock(internal->lock);
+ return KS_STATUS_FAIL; /* we were not able to find a bucket*/
+ }
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- char buf[100];
- ks_log(KS_LOG_DEBUG, "Insert node: LOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
+ char buf[100];
+ ks_log(KS_LOG_DEBUG, "Insert node: LOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
#endif
ks_rwl_write_lock(bucket->lock);
}
}
- /*
- todo: attempting a ping at at this point would require us
- to suspend this process ... tricky...assume right now we will go ahead and
- eject. Possibly add to a list to recheck
- */
-
if ( !(header->flags & BHF_LEFT) ) { /* only the left handside node can be split */
#ifdef KS_DHT_DEBUGPRINTF_
char bufx[100];
#ifdef KS_DHT_DEBUGLOCKPRINTF_
ks_log(KS_LOG_DEBUG, "Insert node: UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
#endif
- ks_rwl_write_unlock(bucket->lock);
- ks_rwl_write_unlock(internal->lock);
+ ks_rwl_write_unlock(bucket->lock);
+ ks_rwl_write_unlock(internal->lock);
return KS_STATUS_FAIL;
}
ks_log(KS_LOG_DEBUG," nodeid %s was not inserted\n", ks_dhtrt_printableid(node->nodeid.id, bufx));
#endif
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- ks_log(KS_LOG_DEBUG, "Insert node: UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
+ ks_log(KS_LOG_DEBUG, "Insert node: UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
#endif
ks_rwl_write_unlock(bucket->lock);
- ks_rwl_write_unlock(internal->lock);
+ ks_rwl_write_unlock(internal->lock);
return KS_STATUS_FAIL;
}
if (ks_dhtrt_ismasked(node->nodeid.id, newleft->mask)) {
bucket = newleft->bucket;
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- ks_log(KS_LOG_DEBUG, "Insert node: UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->right->mask, buf));
- ks_log(KS_LOG_DEBUG, "Insert node: LOCKING bucket %s\n", ks_dhtrt_printableid(newleft->mask, buf));
+ ks_log(KS_LOG_DEBUG, "Insert node: UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->right->mask, buf));
+ ks_log(KS_LOG_DEBUG, "Insert node: LOCKING bucket %s\n", ks_dhtrt_printableid(newleft->mask, buf));
#endif
- ks_rwl_write_lock(bucket->lock); /* lock new bucket */
- ks_rwl_write_unlock(header->right->bucket->lock); /* unlock old bucket */
+ ks_rwl_write_lock(bucket->lock); /* lock new bucket */
+ ks_rwl_write_unlock(header->right->bucket->lock); /* unlock old bucket */
header = newleft;
- } else {
+ }
+ else {
bucket = newright->bucket;
- /* note: we still hold a lock on the bucket */
+ /* note: we still hold a lock on the bucket */
header = newright;
}
++insanity;
#endif
ks_status_t s = ks_dhtrt_insert_id(bucket, node);
- ks_rwl_write_unlock(internal->lock);
+ ks_rwl_write_unlock(internal->lock);
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- ks_log(KS_LOG_DEBUG, "Insert node: UNLOCKING bucket %s\n",
- ks_dhtrt_printableid(header->mask, buf));
+ ks_log(KS_LOG_DEBUG, "Insert node: UNLOCKING bucket %s\n",
+ ks_dhtrt_printableid(header->mask, buf));
#endif
- ks_rwl_write_unlock(bucket->lock);
- return s;
+ ks_rwl_write_unlock(bucket->lock);
+ return s;
}
KS_DECLARE(ks_dht_node_t *) ks_dhtrt_find_node(ks_dhtrt_routetable_t *table, ks_dht_nodeid_t nodeid)
{
- if (!table || !table->internal) {
- return NULL;
- }
+ if (!table || !table->internal) {
+ return NULL;
+ }
- ks_dht_node_t* node = NULL;
- ks_dhtrt_internal_t* internal = table->internal;
+ ks_dht_node_t* node = NULL;
+ ks_dhtrt_internal_t* internal = table->internal;
- ks_rwl_read_lock(internal->lock); /* grab read lock */
+ ks_rwl_read_lock(internal->lock); /* grab read lock */
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, nodeid.id);
if (bucket != 0) { /* probably a logic error ?*/
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- char buf[100];
- ks_log(KS_LOG_DEBUG, "Find node: read LOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
+ char buf[100];
+ ks_log(KS_LOG_DEBUG, "Find node: read LOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
#endif
ks_rwl_read_lock(bucket->lock);
ks_rwl_read_lock(node->reflock);
}
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- ks_log(KS_LOG_DEBUG, "Find node: read UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
+ ks_log(KS_LOG_DEBUG, "Find node: read UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
#endif
ks_rwl_read_unlock(bucket->lock);
}
}
- ks_rwl_read_unlock(internal->lock);
+ ks_rwl_read_unlock(internal->lock);
return node;
}
KS_DECLARE(ks_status_t) ks_dhtrt_touch_node(ks_dhtrt_routetable_t *table, ks_dht_nodeid_t nodeid)
{
- if (!table || !table->internal) {
- return KS_STATUS_FAIL;
- }
+ if (!table || !table->internal) {
+ return KS_STATUS_FAIL;
+ }
- ks_status_t s = KS_STATUS_FAIL;
- ks_dhtrt_internal_t* internal = table->internal;
+ ks_status_t s = KS_STATUS_FAIL;
+ ks_dhtrt_internal_t* internal = table->internal;
ks_rwl_read_lock(internal->lock); /* grab read lock */
if (e != 0) {
e->tyme = ks_time_now_sec();
e->outstanding_pings = 0;
- e->touched = 1;
+ e->touched = 1;
if (e->flags == DHTPEER_EXPIRED) {
--header->bucket->expired_count;
}
e->flags = DHTPEER_ACTIVE;
- s = KS_STATUS_SUCCESS;
+ s = KS_STATUS_SUCCESS;
}
#ifdef KS_DHT_DEBUGLOCKPRINTF_
ks_log(KS_LOG_DEBUG, "Touch node: UNLOCKING bucket %s\n", ks_dhtrt_printableid(header->mask, buf));
KS_DECLARE(ks_status_t) ks_dhtrt_expire_node(ks_dhtrt_routetable_t *table, ks_dht_nodeid_t nodeid)
{
- if (!table || !table->internal) {
- return KS_STATUS_FAIL;
- }
+ if (!table || !table->internal) {
+ return KS_STATUS_FAIL;
+ }
- ks_status_t s = KS_STATUS_FAIL;
- ks_dhtrt_internal_t *internal = table->internal;
+ ks_status_t s = KS_STATUS_FAIL;
+ ks_dhtrt_internal_t *internal = table->internal;
ks_rwl_read_lock(internal->lock); /* grab read lock */
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, nodeid.id);
if (header != 0 && header->bucket != 0) {
- ks_rwl_write_lock(header->bucket->lock);
+ ks_rwl_write_lock(header->bucket->lock);
ks_dhtrt_bucket_entry_t *e = ks_dhtrt_find_bucketentry(header, nodeid.id);
if (e != 0) {
KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t *table, ks_dhtrt_querynodes_t *query)
{
- if (!table || !table->internal) {
- return KS_STATUS_FAIL;
+ if (!table || !table->internal) {
+ return KS_STATUS_FAIL;
query->count = 0;
- }
+ }
- uint8_t count = 0;
- ks_dhtrt_internal_t *internal = table->internal;
+ uint8_t count = 0;
+ ks_dhtrt_internal_t *internal = table->internal;
ks_rwl_read_lock(internal->lock); /* grab read lock */
count = ks_dhtrt_findclosest_locked_nodes(table, query);
uint8_t cnt;
if (query->max == 0) return 0; /* sanity checks */
- if (query->max > KS_DHTRT_MAXQUERYSIZE) { /* enforce the maximum */
- query->max = KS_DHTRT_MAXQUERYSIZE;
+ if (query->max > KS_DHTRT_MAXQUERYSIZE) { /* enforce the maximum */
+ query->max = KS_DHTRT_MAXQUERYSIZE;
}
query->count = 0;
/* step 1 - look at immediate bucket */
/* --------------------------------- */
- int max = query->max;
+ int max = query->max;
cnt = ks_dhtrt_findclosest_bucketnodes(query->nodeid.id, query->type, query->family, header, &xort0, initid ,max);
total += cnt;
#endif
if (total >= query->max ||
- !header->parent ) { /* is query answered ? */
+ !header->parent ) { /* is query answered ? */
return ks_dhtrt_load_query(query, &xort0);
}
}
}
- max = query->count - total;
+ max = query->count - total;
cnt = ks_dhtrt_findclosest_bucketnodes(query->nodeid.id, query->type, query->family, header, &xort1, initid ,max);
total += cnt;
int insanity = 0;
ks_dhtrt_bucket_header_t *lheader = 0;
ks_dhtrt_bucket_header_t *rheader = 0;
- ks_dhtrt_bucket_header_t *last_rheader = 0;
- ks_dhtrt_bucket_header_t *last_lheader = 0;
+ ks_dhtrt_bucket_header_t *last_rheader = 0;
+ ks_dhtrt_bucket_header_t *last_lheader = 0;
ks_dhtrt_sortedxors_t *prev = &xort1;
ks_dhtrt_sortedxors_t *tofree = 0;
ks_dhtrt_sortedxors_t *xortn;
ks_dhtrt_sortedxors_t *xortn1;
do {
- last_lheader = lheader;
+ last_lheader = lheader;
lheader = 0;
- last_rheader = rheader;
+ last_rheader = rheader;
rheader = 0;
xortn = 0;
xortn1 = 0;
ks_dhtrt_shiftleft(leftid);
- if (last_lheader && last_lheader->left1bit) {
+ if (last_lheader && last_lheader->left1bit) {
lheader = last_lheader->left1bit = ks_dhtrt_find_relatedbucketheader(last_lheader->left1bit, leftid);
}
- else {
+ else {
lheader = ks_dhtrt_find_bucketheader(table, leftid);
- if (last_lheader) {
+ if (last_lheader) {
last_lheader->left1bit = lheader; /* remember so we can take a shortcut next query */
}
}
max = query->max - total;
cnt = ks_dhtrt_findclosest_bucketnodes(query->nodeid.id, query->type, query->family,
lheader, xortn, leftid ,max);
- total += cnt;
+ total += cnt;
#ifdef KS_DHT_DEBUGPRINTF_
ks_log(KS_LOG_DEBUG," stage3: seaching left bucket header %s yielded %d nodes, total=%d\n",
ks_dhtrt_printableid(lheader->mask, buffer), cnt, total);
#endif
}
#ifdef KS_DHT_DEBUGPRINTF_
- else {
- ks_log(KS_LOG_DEBUG," stage3: failed to find left header %s\n",
- ks_dhtrt_printableid(leftid, buffer));
- }
+ else {
+ ks_log(KS_LOG_DEBUG," stage3: failed to find left header %s\n",
+ ks_dhtrt_printableid(leftid, buffer));
+ }
#endif
}
ks_dhtrt_shiftright(rightid);
- if (last_rheader && last_rheader->right1bit) {
- rheader = last_rheader->right1bit = ks_dhtrt_find_relatedbucketheader(last_rheader->right1bit, rightid);
- }
- else {
- rheader = ks_dhtrt_find_bucketheader(table, rightid);
+ if (last_rheader && last_rheader->right1bit) {
+ rheader = last_rheader->right1bit = ks_dhtrt_find_relatedbucketheader(last_rheader->right1bit, rightid);
+ }
+ else {
+ rheader = ks_dhtrt_find_bucketheader(table, rightid);
if (rheader == last_rheader) { /* did we get the same bucket header returned */
rheader = 0; /* yes: we are done on the left hand branch */
}
- else {
- if (last_rheader) {
- last_rheader->left1bit = rheader; /* remember so we can take a shortcut next query */
- }
+ else {
+ if (last_rheader) {
+ last_rheader->left1bit = rheader; /* remember so we can take a shortcut next query */
+ }
}
- }
+ }
if (rheader) {
xortn1 = ks_pool_alloc(table->pool, sizeof(ks_dhtrt_sortedxors_t));
- if (tofree == 0) {
- tofree = xortn1;
- }
+ if (tofree == 0) {
+ tofree = xortn1;
+ }
prev->next = xortn1;
prev = xortn1;
max = query->max - total;
cnt = ks_dhtrt_findclosest_bucketnodes(query->nodeid.id, query->type, query->family,
rheader, xortn1, rightid , max);
- total += cnt;
+ total += cnt;
#ifdef KS_DHT_DEBUGPRINTF_
ks_log(KS_LOG_DEBUG," stage3: seaching right bucket header %s yielded %d nodes, total=%d\n",
ks_dhtrt_printableid(rheader->mask, buffer), cnt, total);
#endif
}
#ifdef KS_DHT_DEBUGPRINTF_
- else {
- ks_log(KS_LOG_DEBUG," stage3: failed to find right header %s\n",
- ks_dhtrt_printableid(rightid, buffer));
- }
+ else {
+ ks_log(KS_LOG_DEBUG," stage3: failed to find right header %s\n",
+ ks_dhtrt_printableid(rightid, buffer));
+ }
#endif
}
KS_DECLARE(ks_status_t) ks_dhtrt_release_node(ks_dht_node_t* node)
{
- return ks_rwl_read_unlock(node->reflock);
+ return ks_rwl_read_unlock(node->reflock);
}
KS_DECLARE(ks_status_t) ks_dhtrt_sharelock_node(ks_dht_node_t* node)
{
- return ks_rwl_read_lock(node->reflock);
+ return ks_rwl_read_lock(node->reflock);
}
KS_DECLARE(ks_status_t) ks_dhtrt_release_querynodes(ks_dhtrt_querynodes_t *query)
{
- for(int ix=0; ix<query->count; ++ix) {
- ks_rwl_read_unlock(query->nodes[ix]->reflock);
- }
- return KS_STATUS_SUCCESS;
+ for(int ix=0; ix<query->count; ++ix) {
+ ks_rwl_read_unlock(query->nodes[ix]->reflock);
+ }
+ return KS_STATUS_SUCCESS;
}
KS_DECLARE(void) ks_dhtrt_process_table(ks_dhtrt_routetable_t *table)
/* inactive again it is considered inactive */
/* */
- if (!table || !table->internal) {
- return;
- }
+ if (!table || !table->internal) {
+ return;
+ }
- ks_dhtrt_internal_t *internal = table->internal;
- int ping_count = 0;
+ ks_dhtrt_internal_t *internal = table->internal;
+ int ping_count = 0;
- ks_time_t t0 = ks_time_now_sec();
+ ks_time_t t0 = ks_time_now_sec();
- /*
- printf("process_table: %" PRId64 " %" PRId64 "\n", t0 - internal->last_process_table, internal->next_process_table_delta);
- */
+ /*
+ printf("process_table: %" PRId64 " %" PRId64 "\n", t0 - internal->last_process_table, internal->next_process_table_delta);
+ */
- if (t0 - internal->last_process_table < internal->next_process_table_delta) {
+ if (t0 - internal->last_process_table < internal->next_process_table_delta) {
return;
- }
+ }
- internal->last_process_table = t0;
+ internal->last_process_table = t0;
- ks_log(KS_LOG_DEBUG,"process_table in progress\n");
+ ks_log(KS_LOG_DEBUG,"process_table in progress\n");
ks_rwl_read_lock(internal->lock); /* grab read lock */
/* more than n pings outstanding? */
- if (e->flags == DHTPEER_DUBIOUS) {
- continue;
- }
+ if (e->flags == DHTPEER_DUBIOUS) {
+ continue;
+ }
if ( e->flags != DHTPEER_EXPIRED &&
e->outstanding_pings >= KS_DHTRT_MAXPING ) {
#endif
e->flags = DHTPEER_EXPIRED;
++b->expired_count;
- e->outstanding_pings = 0; /* extinguish all hope: do not retry again */
+ e->outstanding_pings = 0; /* extinguish all hope: do not retry again */
continue;
}
/* if there are any outstanding pings - send another */
if (e->outstanding_pings > 0) {
- ks_dhtrt_ping(internal, e);
- ++ping_count;
- continue;
+ ks_dhtrt_ping(internal, e);
+ ++ping_count;
+ continue;
}
ks_time_t tdiff = t0 - e->tyme;
- if (tdiff > KS_DHTRT_EXPIREDTIME) {
- e->flags = DHTPEER_DUBIOUS; /* mark as dubious */
- ks_dhtrt_ping(internal, e); /* final effort to activate */
+ if (tdiff > KS_DHTRT_EXPIREDTIME) {
+ e->flags = DHTPEER_DUBIOUS; /* mark as dubious */
+ ks_dhtrt_ping(internal, e); /* final effort to activate */
continue;
- }
+ }
if (tdiff > KS_DHTRT_INACTIVETIME) { /* inactive for suspicious length */
ks_dhtrt_ping(internal, e); /* kick */
ks_rwl_write_unlock(b->lock);
} /* end of if trywrite_lock successful */
- else {
+ else {
#ifdef KS_DHT_DEBUGPRINTF_
char buf1[100];
ks_log(KS_LOG_DEBUG,"process_table: unble to LOCK bucket %s\n", ks_dhtrt_printableid(header->mask, buf1));
#endif
- }
+ }
}
header = header->left;
header = header->right;
}
}
- ks_rwl_read_unlock(internal->lock); /* release read lock */
+ ks_rwl_read_unlock(internal->lock); /* release read lock */
- ks_dhtrt_process_deleted(table, 0);
+ ks_dhtrt_process_deleted(table, 0);
- if (ping_count == 0) {
+ if (ping_count == 0) {
internal->next_process_table_delta = KS_DHTRT_PROCESSTABLE_INTERVAL;
}
- else {
+ else {
internal->next_process_table_delta = KS_DHTRT_PROCESSTABLE_SHORTINTERVAL;
}
- ks_log(KS_LOG_DEBUG,"process_table complete\n");
+ ks_log(KS_LOG_DEBUG,"process_table complete\n");
return;
}
ks_dhtrt_deletednode_t *prev = NULL, *temp=NULL;
#ifdef KS_DHT_DEBUGPRINTFX_
- ks_log(KS_LOG_DEBUG, "ALLOC process_deleted entry: internal->deleted_count %d\n", internal->deleted_count);
+ ks_log(KS_LOG_DEBUG, "ALLOC process_deleted entry: internal->deleted_count %d\n", internal->deleted_count);
#endif
- /* reclaim excess memory */
- uint32_t threshold = KS_DHTRT_RECYCLE_NODE_THRESHOLD;
+ /* reclaim excess memory */
+ uint32_t threshold = KS_DHTRT_RECYCLE_NODE_THRESHOLD;
if (all) {
threshold = 1;
ks_dht_node_t* node = deleted->node;
#ifdef KS_DHT_DEBUGPRINTFX_
- ks_log(KS_LOG_DEBUG, "ALLOC process_deleted entry: try write lock\n");
+ ks_log(KS_LOG_DEBUG, "ALLOC process_deleted entry: try write lock\n");
#endif
if (ks_rwl_try_write_lock(node->reflock) == KS_STATUS_SUCCESS) {
- ks_rwl_destroy(&(node->reflock));
- ks_pool_free(table->pool, &node);
- temp = deleted;
- deleted = deleted->next;
- ks_pool_free(table->pool, &temp);
- --internal->deleted_count;
+ ks_rwl_destroy(&(node->reflock));
+ ks_pool_free(table->pool, &node);
+ temp = deleted;
+ deleted = deleted->next;
+ ks_pool_free(table->pool, &temp);
+ --internal->deleted_count;
#ifdef KS_DHT_DEBUGPRINTF_
ks_log(KS_LOG_DEBUG, "ALLOC process_deleted: internal->deleted_count %d\n", internal->deleted_count);
#endif
if (prev != NULL) {
prev->next = deleted;
}
- else {
- internal->deleted_node = deleted;
- }
+ else {
+ internal->deleted_node = deleted;
+ }
}
- else {
+ else {
#ifdef KS_DHT_DEBUGPRINTFX_
- ks_log(KS_LOG_DEBUG, "ALLOC process_deleted entry: try write lock failed\n");
+ ks_log(KS_LOG_DEBUG, "ALLOC process_deleted entry: try write lock failed\n");
#endif
- prev = deleted;
- deleted = prev->next;
- }
+ prev = deleted;
+ deleted = prev->next;
+ }
}
#ifdef KS_DHT_DEBUGPRINTF_
- ks_log(KS_LOG_DEBUG, "ALLOC process_deleted exit: internal->deleted_count %d\n", internal->deleted_count);
+ ks_log(KS_LOG_DEBUG, "ALLOC process_deleted exit: internal->deleted_count %d\n", internal->deleted_count);
#endif
ks_mutex_unlock(internal->deleted_node_lock);
ks_dhtrt_bucket_header_t *stack[KS_DHT_NODEID_SIZE * 8];
int stackix = 0;
- ks_rwl_read_lock(internal->lock); /* grab read lock */
+ ks_rwl_read_lock(internal->lock); /* grab read lock */
while (header) {
stack[stackix++] = header;
/* walk and report left handsize */
for (int ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
memset(buffer, 0, 100);
if (b->entries[ix].inuse == 1) {
- ks_dhtrt_printableid(b->entries[ix].id, buffer);
- ks_dht_node_t *n = b->entries[ix].gptr;
- ks_log(KS_LOG_DEBUG, " slot %d: flags:%d %d type:%d family:%d %s\n", ix,
- b->entries[ix].flags,
- b->entries[ix].outstanding_pings,
- n->type,
- n->family,
- buffer);
+ ks_dhtrt_printableid(b->entries[ix].id, buffer);
+ ks_dht_node_t *n = b->entries[ix].gptr;
+ ks_log(KS_LOG_DEBUG, " slot %d: flags:%d %d type:%d family:%d %s\n", ix,
+ b->entries[ix].flags,
+ b->entries[ix].outstanding_pings,
+ n->type,
+ n->family,
+ buffer);
}
else {
ks_log(KS_LOG_DEBUG, " slot %d: <free>\n", ix);
header = header->right;
}
}
- ks_rwl_read_unlock(internal->lock); /* release read lock */
+ ks_rwl_read_unlock(internal->lock); /* release read lock */
return;
}
#ifdef KS_DHT_DEBUGPRINTF_
char buffer[100];
ks_log(KS_LOG_DEBUG, "creating bucket header for mask: %s\n", ks_dhtrt_printableid(mask, buffer));
- if (parent) ks_log(KS_LOG_DEBUG, " ... from parent mask: %s\n", ks_dhtrt_printableid(parent->mask, buffer));
+ if (parent) {
+ ks_log(KS_LOG_DEBUG, " ... from parent mask: %s\n", ks_dhtrt_printableid(parent->mask, buffer));
+ }
#endif
return header;
}
static
ks_dhtrt_bucket_header_t *ks_dhtrt_find_relatedbucketheader(ks_dhtrt_bucket_header_t *header, ks_dhtrt_nodeid_t id)
{
- /*
- using the passed bucket header as a starting point find the right bucket.
- This is a shortcut used in query to shorten the search path for queries extending beyond a single bucket.
- */
-
- while (header) {
- if ( header->bucket ) {
- return header;
- }
+ /*
+ using the passed bucket header as a starting point find the right bucket.
+ This is a shortcut used in query to shorten the search path for queries extending beyond a single bucket.
+ */
- /* left hand side is more restrictive (closer) so should be tried first */
- if (header->left != 0 && (ks_dhtrt_ismasked(id, header->left->mask))) {
- header = header->left;
- } else {
- header = header->right;
- }
- }
+ while (header) {
+ if ( header->bucket ) {
+ return header;
+ }
- return NULL;
+ /* left hand side is more restrictive (closer) so should be tried first */
+ if (header->left != 0 && (ks_dhtrt_ismasked(id, header->left->mask))) {
+ header = header->left;
+ } else {
+ header = header->right;
+ }
+ }
+ return NULL;
}
memcpy(dest->entries[lix].id, source->entries[rix].id, KS_DHT_NODEID_SIZE);
dest->entries[lix].gptr = source->entries[rix].gptr;
dest->entries[lix].family = source->entries[rix].family;
- dest->entries[lix].type = source->entries[rix].type;
+ dest->entries[lix].type = source->entries[rix].type;
dest->entries[lix].inuse = 1;
++lix;
++dest->count;
if ( free<KS_DHT_BUCKETSIZE ) {
bucket->entries[free].inuse = 1;
bucket->entries[free].gptr = node;
- bucket->entries[free].type = node->type;
- bucket->entries[free].family = node->family;
- bucket->entries[free].tyme = ks_time_now_sec();
- bucket->entries[free].flags = DHTPEER_DUBIOUS;
+ bucket->entries[free].type = node->type;
+ bucket->entries[free].family = node->family;
+ bucket->entries[free].tyme = ks_time_now_sec();
+ bucket->entries[free].flags = DHTPEER_DUBIOUS;
- if (free != expiredix) { /* are we are taking a free slot rather than replacing an expired node? */
+ if (free != expiredix) { /* are we are taking a free slot rather than replacing an expired node? */
++bucket->count; /* yes: increment total count */
}
char bufferx[100];
if ( bucket->entries[ix].inuse == 1 && bucket->entries[ix].flags == DHTPEER_ACTIVE ) {
ks_log(KS_LOG_DEBUG, "bucket->entries[%d].id = %s inuse=%x\n", ix,
- ks_dhtrt_printableid(bucket->entries[ix].id, bufferx),
- bucket->entries[ix].inuse );
+ ks_dhtrt_printableid(bucket->entries[ix].id, bufferx),
+ bucket->entries[ix].inuse );
}
#endif
if ( bucket->entries[ix].inuse == 1 &&
#ifdef KS_DHT_DEBUGPRINTFX_
char bufferx[100];
ks_log(KS_LOG_DEBUG, "bucket->entries[%d].id = %s inuse=%c\n", ix,
- ks_dhtrt_printableid(bucket->entries[ix].id, bufferx),
- bucket->entries[ix].inuse );
+ ks_dhtrt_printableid(bucket->entries[ix].id, bufferx),
+ bucket->entries[ix].inuse );
#endif
if ( bucket->entries[ix].inuse == 1 &&
(!memcmp(id, bucket->entries[ix].id, KS_DHT_NODEID_SIZE)) ) {
bucket->entries[ix].inuse = 0;
bucket->entries[ix].gptr = 0;
bucket->entries[ix].flags = 0;
- --bucket->count;
+ --bucket->count;
return KS_STATUS_SUCCESS;
}
}
static
uint8_t ks_dhtrt_findclosest_bucketnodes(ks_dhtrt_nodeid_t id,
- enum ks_dht_nodetype_t type,
- enum ks_afflags_t family,
- ks_dhtrt_bucket_header_t *header,
- ks_dhtrt_sortedxors_t *xors,
- unsigned char *hixor, /*todo: remove */
- unsigned int max) {
+ enum ks_dht_nodetype_t type,
+ enum ks_afflags_t family,
+ ks_dhtrt_bucket_header_t *header,
+ ks_dhtrt_sortedxors_t *xors,
+ unsigned char *hixor, /*todo: remove */
+ unsigned int max) {
uint8_t count = 0; /* count of nodes added this time */
xors->startix = KS_DHT_BUCKETSIZE;
#ifdef KS_DHT_DEBUGPRINTF_
char buf[100];
ks_log(KS_LOG_DEBUG, "closestbucketnodes: intermediate tree node found %s\n",
- ks_dhtrt_printableid(header->mask, buf));
+ ks_dhtrt_printableid(header->mask, buf));
#endif
}
- ks_rwl_read_lock(bucket->lock); /* get a read lock : released in load_query when the results are copied */
+ ks_rwl_read_lock(bucket->lock); /* get a read lock : released in load_query when the results are copied */
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- char buf[100];
- ks_log(KS_LOG_DEBUG, "closestbucketnodes: LOCKING bucket %s\n",
- ks_dhtrt_printableid(header->mask, buf));
+ char buf[100];
+ ks_log(KS_LOG_DEBUG, "closestbucketnodes: LOCKING bucket %s\n",
+ ks_dhtrt_printableid(header->mask, buf));
#endif
for (uint8_t ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
- if ( bucket->entries[ix].inuse == 1 && /* in use */
- bucket->entries[ix].flags == DHTPEER_ACTIVE && /* not dubious or expired */
- (family == ifboth || bucket->entries[ix].family == family) && /* match if family */
- (bucket->entries[ix].type & type) && /* match type */
- ks_dhtrt_isactive( &(bucket->entries[ix])) ) {
+ if ( bucket->entries[ix].inuse == 1 && /* in use */
+ bucket->entries[ix].flags == DHTPEER_ACTIVE && /* not dubious or expired */
+ (family == ifboth || bucket->entries[ix].family == family) && /* match if family */
+ (bucket->entries[ix].type & type) && /* match type */
+ ks_dhtrt_isactive( &(bucket->entries[ix])) ) {
/* calculate xor value */
ks_dhtrt_xor(bucket->entries[ix].id, id, xorvalue );
/* do we need to hold this one */
if ( count < max || /* yes: we have not filled the quota yet */
- (memcmp(xorvalue, hixor, KS_DHT_NODEID_SIZE) < 0)) { /* or is closer node than one already selected */
+ (memcmp(xorvalue, hixor, KS_DHT_NODEID_SIZE) < 0)) { /* or is closer node than one already selected */
/* now sort the new xorvalue into the results structure */
/* this now becomes worst case O(n*2) logic - is there a better way */
#ifdef KS_DHT_DEBUGPRINTF_
char buf[100];
ks_log(KS_LOG_DEBUG, " loadquery from bucket %s count %d\n",
- ks_dhtrt_printableid(current->bheader->mask,buf), current->count);
+ ks_dhtrt_printableid(current->bheader->mask,buf), current->count);
#endif
int xorix = current->startix;
++ix ) {
unsigned int z = current->xort[xorix].ix;
query->nodes[ix] = current->bheader->bucket->entries[z].gptr;
- xorix = current->xort[xorix].nextix;
+ xorix = current->xort[xorix].nextix;
++loaded;
}
#ifdef KS_DHT_DEBUGLOCKPRINTF_
- char buf1[100];
- ks_log(KS_LOG_DEBUG, "load_query: UNLOCKING bucket %s\n",
- ks_dhtrt_printableid(current->bheader->mask, buf1));
- fflush(stdout);
+ char buf1[100];
+ ks_log(KS_LOG_DEBUG, "load_query: UNLOCKING bucket %s\n",
+ ks_dhtrt_printableid(current->bheader->mask, buf1));
#endif
- ks_rwl_read_unlock(current->bheader->bucket->lock); /* release the read lock from findclosest_bucketnodes */
+ ks_rwl_read_unlock(current->bheader->bucket->lock); /* release the read lock from findclosest_bucketnodes */
if (loaded >= query->max) break;
current = current->next;
void ks_dhtrt_queue_node_fordelete(ks_dhtrt_routetable_t* table, ks_dht_node_t* node)
{
- ks_dhtrt_internal_t* internal = table->internal;
+ ks_dhtrt_internal_t* internal = table->internal;
ks_mutex_lock(internal->deleted_node_lock);
ks_dhtrt_deletednode_t* deleted = internal->free_node_ex; /* grab a free stub */
- if (deleted) {
- internal->free_node_ex = deleted->next;
- }
- else {
- deleted = ks_pool_alloc(table->pool, sizeof(ks_dhtrt_deletednode_t));
- }
+ if (deleted) {
+ internal->free_node_ex = deleted->next;
+ }
+ else {
+ deleted = ks_pool_alloc(table->pool, sizeof(ks_dhtrt_deletednode_t));
+ }
- deleted->node = node;
+ deleted->node = node;
deleted->next = internal->deleted_node;
internal->deleted_node = deleted; /* add to deleted queue */
++internal->deleted_count;
ks_dht_node_t* ks_dhtrt_make_node(ks_dhtrt_routetable_t* table)
{
- ks_dht_node_t *node = NULL;
+ ks_dht_node_t *node = NULL;
ks_dhtrt_internal_t *internal = table->internal;
ks_mutex_lock(internal->deleted_node_lock);
- /* to to reuse a deleted node */
+ /* to to reuse a deleted node */
if (internal->deleted_count) {
ks_dhtrt_deletednode_t *deleted = internal->deleted_node;
- node = deleted->node; /* take the node */
- memset(node, 0, sizeof(ks_dht_node_t));
- deleted->node = 0; /* avoid accidents */
- internal->deleted_node = deleted->next;
- deleted->next = internal->free_node_ex; /* save the stub for reuse */
- --internal->deleted_count;
+ node = deleted->node; /* take the node */
+ memset(node, 0, sizeof(ks_dht_node_t));
+ deleted->node = 0; /* avoid accidents */
+ internal->deleted_node = deleted->next;
+ deleted->next = internal->free_node_ex; /* save the stub for reuse */
+ --internal->deleted_count;
#ifdef KS_DHT_DEBUGPRINTFX_
- ks_log(KS_LOG_DEBUG, "ALLOC: Reusing a node struct %d\n", internal->deleted_count);
+ ks_log(KS_LOG_DEBUG, "ALLOC: Reusing a node struct %d\n", internal->deleted_count);
#endif
- }
- ks_mutex_unlock(internal->deleted_node_lock);
+ }
+ ks_mutex_unlock(internal->deleted_node_lock);
- if (!node) {
- node = ks_pool_alloc(table->pool, sizeof(ks_dht_node_t));
- }
+ if (!node) {
+ node = ks_pool_alloc(table->pool, sizeof(ks_dht_node_t));
+ }
- return node;
+ return node;
}
void ks_dhtrt_ping(ks_dhtrt_internal_t *internal, ks_dhtrt_bucket_entry_t *entry) {
#ifdef KS_DHT_DEBUGPRINTF_
char buf[100];
ks_log(KS_LOG_DEBUG, "Ping queued for nodeid %s count %d\n",
- ks_dhtrt_printableid(entry->id,buf), entry->outstanding_pings);
+ ks_dhtrt_printableid(entry->id,buf), entry->outstanding_pings);
#endif
- ks_dht_node_t* node = entry->gptr;
+ ks_dht_node_t* node = entry->gptr;
ks_log(KS_LOG_DEBUG, "Node addr %s %d\n", node->addr.host, node->addr.port);
- ks_dht_ping(internal->dht, &node->addr, NULL);
+ ks_dht_ping(internal->dht, &node->addr, NULL);
return;
}
//#include "ks.h"
#include "../src/dht/ks_dht.h"
-ks_dht_t* dht;
-ks_dhtrt_routetable_t* rt;
-ks_pool_t* pool;
-ks_thread_pool_t* tpool;
+ks_dht_t *dht;
+ks_dhtrt_routetable_t *rt;
+ks_pool_t *pool;
+ks_thread_pool_t *tpool;
static ks_thread_t *threads[10];
-int doquery(ks_dhtrt_routetable_t* rt, uint8_t* id, enum ks_dht_nodetype_t type, enum ks_afflags_t family)
+int doquery(ks_dhtrt_routetable_t *rt, uint8_t *id, enum ks_dht_nodetype_t type, enum ks_afflags_t family)
{
- ks_dhtrt_querynodes_t query;
- memset(&query, 0, sizeof(query));
- query.max = 30;
- memcpy(&query.nodeid.id, id, KS_DHT_NODEID_SIZE);
- query.family = family;
- query.type = type;
-
- return ks_dhtrt_findclosest_nodes(rt, &query);
+ ks_dhtrt_querynodes_t query;
+ memset(&query, 0, sizeof(query));
+ query.max = 30;
+ memcpy(&query.nodeid.id, id, KS_DHT_NODEID_SIZE);
+ query.family = family;
+ query.type = type;
+
+ return ks_dhtrt_findclosest_nodes(rt, &query);
}
void test01()
{
- printf("*** testbuckets - test01 start\n"); fflush(stdout);
+ printf("**** testbuckets - test01 start\n"); fflush(stdout);
- ks_dhtrt_routetable_t* rt;
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- ks_dhtrt_deinitroute(&rt);
+ ks_dhtrt_routetable_t *rt;
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ ks_dhtrt_deinitroute(&rt);
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- ks_dht_nodeid_t nodeid, homeid;
- memset(homeid.id, 0xdd, KS_DHT_NODEID_SIZE);
- homeid.id[19] = 0;
-
- char ip[] = "192.168.100.100";
- unsigned short port = 7000;
- ks_dht_node_t* peer;
- ks_dht_node_t* peer1;
-
- ks_status_t status;
- status = ks_dhtrt_create_node(rt, homeid, KS_DHT_LOCAL, ip, port, &peer);
- if (status == KS_STATUS_FAIL) {
- printf("*** ks_dhtrt_create_node test01 failed\n");
- exit(101);
- }
-
- peer = ks_dhtrt_find_node(rt, homeid);
- if (peer == 0) {
- printf("*** ks_dhtrt_find_node test01 failed \n"); fflush(stdout);
- exit(102);
- }
-
- status = ks_dhtrt_create_node(rt, homeid, KS_DHT_LOCAL, ip, port, &peer1);
- if (status == KS_STATUS_FAIL) {
- printf("*** ks_dhtrt_create_node test01 did allow duplicate createnodes!!\n");
- exit(103);
- }
- if (peer != peer1) {
- printf("*** ks_dhtrt_create_node duplicate createnode did not return the same node!\n");
- exit(104);
- }
-
- status = ks_dhtrt_delete_node(rt, peer);
- if (status == KS_STATUS_FAIL) {
- printf("*** ks_dhtrt_delete_node test01 failed\n");
- exit(104);
- }
-
- printf("*** testbuckets - test01 complete\n\n\n"); fflush(stdout);
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ ks_dht_nodeid_t nodeid, homeid;
+ memset(homeid.id, 0xdd, KS_DHT_NODEID_SIZE);
+ homeid.id[19] = 0;
+
+ char ip[] = "192.168.100.100";
+ unsigned short port = 7000;
+ ks_dht_node_t *peer;
+ ks_dht_node_t *peer1;
+
+ ks_status_t status;
+ status = ks_dhtrt_create_node(rt, homeid, KS_DHT_LOCAL, ip, port, &peer);
+ if (status == KS_STATUS_FAIL) {
+ printf("* **ks_dhtrt_create_node test01 failed\n");
+ exit(101);
+ }
+
+ peer = ks_dhtrt_find_node(rt, homeid);
+ if (peer == 0) {
+ printf("*** ks_dhtrt_find_node test01 failed \n"); fflush(stdout);
+ exit(102);
+ }
+
+ status = ks_dhtrt_create_node(rt, homeid, KS_DHT_LOCAL, ip, port, &peer1);
+ if (status == KS_STATUS_FAIL) {
+ printf("**** ks_dhtrt_create_node test01 did allow duplicate createnodes!!\n");
+ exit(103);
+ }
+ if (peer != peer1) {
+ printf("**** ks_dhtrt_create_node duplicate createnode did not return the same node!\n");
+ exit(104);
+ }
+
+ status = ks_dhtrt_delete_node(rt, peer);
+ if (status == KS_STATUS_FAIL) {
+ printf("**** ks_dhtrt_delete_node test01 failed\n");
+ exit(104);
+ }
+
+ printf("**** testbuckets - test01 complete\n\n\n"); fflush(stdout);
}
void test02()
{
- printf("*** testbuckets - test02 start\n"); fflush(stdout);
-
- ks_dht_node_t* peer;
- ks_dht_nodeid_t nodeid;
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
-
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
- enum ks_afflags_t both = ifboth;
-
- ks_status_t status;
-
- nodeid.id[0] = 1;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv6, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[0] = 2;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[0] = 3;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[0] = 4;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv6, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[1] = 1;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
-
-
- nodeid.id[19] = 1;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[19] = 2;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[19] = 3;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[19] = 4;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
-
- nodeid.id[19] = 5;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- nodeid.id[19] = 6;
- status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
-
- int qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
- printf("\n*** local query count expected 3, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, both);
- printf("\n*** remote query count expected 6, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, both);
- printf("\n*** both query count expected 9, actual %d\n", qcount); fflush(stdout);
-
- qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv4);
- printf("\n*** local AF_INET query count expected 1, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv6);
- printf("\n*** local AF_INET6 query count expected 2, actual %d\n", qcount); fflush(stdout);
-
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv6);
- printf("\n*** AF_INET6 count expected 5, actual %d\n", qcount); fflush(stdout);
-
- qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv4);
- printf("\n*** remote AF_INET query count expected 3, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv6);
- printf("\n*** remote AF_INET6 query count expected 3, actual %d\n", qcount); fflush(stdout);
-
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
- printf("\n*** AF_INET count expected 4, actual %d\n", qcount); fflush(stdout);
-
- nodeid.id[19] = 5;
- ks_dhtrt_touch_node(rt, nodeid);
- nodeid.id[19] = 6;
- ks_dhtrt_touch_node(rt, nodeid);
-
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
- printf("\n*** AF_INET (after touch) count expected 6, actual %d\n", qcount); fflush(stdout);
-
- printf("*** testbuckets - test02 finished\n"); fflush(stdout);
-
- return;
+ printf("**** testbuckets - test02 start\n"); fflush(stdout);
+
+ ks_dht_node_t *peer;
+ ks_dht_nodeid_t nodeid;
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
+ enum ks_afflags_t both = ifboth;
+
+ ks_status_t status;
+
+ nodeid.id[0] = 1;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv6, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[0] = 2;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[0] = 3;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[0] = 4;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv6, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[1] = 1;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+
+
+ nodeid.id[19] = 1;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[19] = 2;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[19] = 3;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[19] = 4;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+
+ nodeid.id[19] = 5;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ nodeid.id[19] = 6;
+ status = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
+
+ int qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
+ printf("\n* **local query count expected 3, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, both);
+ printf("\n* **remote query count expected 6, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, both);
+ printf("\n* **both query count expected 9, actual %d\n", qcount); fflush(stdout);
+
+ qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv4);
+ printf("\n* **local AF_INET query count expected 1, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv6);
+ printf("\n* **local AF_INET6 query count expected 2, actual %d\n", qcount); fflush(stdout);
+
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv6);
+ printf("\n* **AF_INET6 count expected 5, actual %d\n", qcount); fflush(stdout);
+
+ qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv4);
+ printf("\n* **remote AF_INET query count expected 3, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv6);
+ printf("\n* **remote AF_INET6 query count expected 3, actual %d\n", qcount); fflush(stdout);
+
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
+ printf("\n* **AF_INET count expected 4, actual %d\n", qcount); fflush(stdout);
+
+ nodeid.id[19] = 5;
+ ks_dhtrt_touch_node(rt, nodeid);
+ nodeid.id[19] = 6;
+ ks_dhtrt_touch_node(rt, nodeid);
+
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
+ printf("\n**** AF_INET (after touch) count expected 6, actual %d\n", qcount); fflush(stdout);
+
+ printf("**** testbuckets - test02 finished\n"); fflush(stdout);
+
+ return;
}
/* this is similar to test2 but after mutiple table splits. */
void test03()
{
- printf("*** testbuckets - test03 start\n"); fflush(stdout);
+ printf("**** testbuckets - test03 start\n"); fflush(stdout);
- ks_dht_node_t* peer;
- ks_dht_nodeid_t nodeid;
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+ ks_dht_node_t *peer;
+ ks_dht_nodeid_t nodeid;
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
- enum ks_afflags_t both = ifboth;
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
+ enum ks_afflags_t both = ifboth;
- ks_status_t status;
- int ipv4_remote = 0;
+ ks_status_t status;
+ int ipv4_remote = 0;
int ipv4_local = 0;
- for (int i=0; i<200; ++i) {
- if (i%10 == 0) {
- ++nodeid.id[0];
- nodeid.id[1] = 0;
- }
- else {
- ++nodeid.id[1];
- }
- ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- if (s0 == KS_STATUS_SUCCESS) {
- ks_dhtrt_touch_node(rt, nodeid);
- ++ipv4_remote;
- }
- }
+ for (int i=0; i<200; ++i) {
+ if (i%10 == 0) {
+ ++nodeid.id[0];
+ nodeid.id[1] = 0;
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ if (s0 == KS_STATUS_SUCCESS) {
+ ks_dhtrt_touch_node(rt, nodeid);
+ ++ipv4_remote;
+ }
+ }
- for (int i=0; i<2; ++i) {
- if (i%10 == 0) {
- ++nodeid.id[0];
- nodeid.id[1] = 0;
- }
- else {
- ++nodeid.id[1];
- }
-
- ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
- if (s0 == KS_STATUS_SUCCESS) {
- ks_dhtrt_touch_node(rt, nodeid);
- ++ipv4_local;
- }
- }
+ for (int i=0; i<2; ++i) {
+ if (i%10 == 0) {
+ ++nodeid.id[0];
+ nodeid.id[1] = 0;
+ }
+ else {
+ ++nodeid.id[1];
+ }
- for (int i=0; i<201; ++i) {
- if (i%10 == 0) {
- ++nodeid.id[0];
- nodeid.id[1] = 0;
- }
- else {
- ++nodeid.id[1];
- }
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- }
+ ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
+ if (s0 == KS_STATUS_SUCCESS) {
+ ks_dhtrt_touch_node(rt, nodeid);
+ ++ipv4_local;
+ }
+ }
+
+ for (int i=0; i<201; ++i) {
+ if (i%10 == 0) {
+ ++nodeid.id[0];
+ nodeid.id[1] = 0;
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ }
- ks_dhtrt_dump(rt, 7);
+ ks_dhtrt_dump(rt, 7);
- int qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
- printf("\n** local query count expected 2, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
+ int qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
+ printf("\n**** local query count expected 2, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, both);
- printf("\n*** remote query count expected 20, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, both);
- printf("\n*** both query count expected 20, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, both);
+ printf("\n**** remote query count expected 20, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, both);
+ printf("\n**** both query count expected 20, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv4);
- printf("\n*** local AF_INET query count expected 2, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv6);
- printf("\n*** local AF_INET6 query count expected 0, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv4);
+ printf("\n**** local AF_INET query count expected 2, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, ifv6);
+ printf("\n**** local AF_INET6 query count expected 0, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv6);
- printf("\n*** AF_INET6 count expected 20, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv6);
+ printf("\n**** AF_INET6 count expected 20, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv4);
- printf("\n*** remote AF_INET query count expected 20, actual %d max %d\n", qcount, ipv4_remote); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv6);
- printf("\n*** remote AF_INET6 query count expected 20, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv4);
+ printf("\n**** remote AF_INET query count expected 20, actual %d max %d\n", qcount, ipv4_remote); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_REMOTE, ifv6);
+ printf("\n**** remote AF_INET6 query count expected 20, actual %d\n", qcount); fflush(stdout);
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
- printf("\n*** AF_INET count expected 20, actual %d\n", qcount); fflush(stdout);
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
+ printf("\n**** AF_INET count expected 20, actual %d\n", qcount); fflush(stdout);
- printf("*** testbuckets - test03 finished\n\n\n"); fflush(stdout);
- return;
+ printf("**** testbuckets - test03 finished\n\n\n"); fflush(stdout);
+ return;
}
void test04()
{
- printf("*** testbuckets - test04 start\n"); fflush(stdout);
-
- ks_dht_node_t* peer;
- ks_dht_nodeid_t nodeid;
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
-
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
- enum ks_afflags_t both = ifboth;
-
- ks_status_t status;
-
- for (int i=0,i2=0,i3=0; i<10000; ++i, ++i2, ++i3) {
- if (i%20 == 0) {
- nodeid.id[0] = nodeid.id[0] / 2;
- if(i2%20 == 0) {
- nodeid.id[1] = nodeid.id[1] / 2;
- i2 = 0;
- if(i3%20 == 0) {
- nodeid.id[2] = nodeid.id[2] / 2;
- }
- }
- else {
- ++nodeid.id[3];
- }
- }
- else {
- ++nodeid.id[1];
- }
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- }
-
-
- memset(nodeid.id, 0x2f, KS_DHT_NODEID_SIZE);
- ks_time_t t0 = ks_time_now();
- int qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
- ks_time_t t1 = ks_time_now();
-
- int tx = t1 - t0;
- t1 /= 1000;
-
- printf("*** query on 10k nodes in %d ms\n", tx);
+ printf("**** testbuckets - test04 start\n"); fflush(stdout);
+
+ ks_dht_node_t *peer;
+ ks_dht_nodeid_t nodeid;
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
+ enum ks_afflags_t both = ifboth;
+
+ ks_status_t status;
+
+ for (int i=0,i2=0,i3=0; i<10000; ++i, ++i2, ++i3) {
+ if (i%20 == 0) {
+ nodeid.id[0] = nodeid.id[0] / 2;
+ if (i2%20 == 0) {
+ nodeid.id[1] = nodeid.id[1] / 2;
+ i2 = 0;
+ if (i3%20 == 0) {
+ nodeid.id[2] = nodeid.id[2] / 2;
+ }
+ }
+ else {
+ ++nodeid.id[3];
+ }
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ }
+
+
+ memset(nodeid.id, 0x2f, KS_DHT_NODEID_SIZE);
+ ks_time_t t0 = ks_time_now();
+ int qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, ifv4);
+ ks_time_t t1 = ks_time_now();
+
+ int tx = t1 - t0;
+ t1 /= 1000;
+
+ printf("**** query on 10k nodes in %d ms\n", tx);
- printf("*** testbuckets - test04 finished\n\n\n"); fflush(stdout);
+ printf("**** testbuckets - test04 finished\n\n\n"); fflush(stdout);
- return;
+ return;
}
/* test read/write node locking */
void test05()
{
- printf("*** testbuckets - test05 start\n"); fflush(stdout);
-
- ks_dht_node_t* peer, *peer1, *peer2;
- ks_dht_nodeid_t nodeid;
- ks_status_t s;
+ printf("**** testbuckets - test05 start\n"); fflush(stdout);
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+ ks_dht_node_t *peer, *peer1, *peer2;
+ ks_dht_nodeid_t nodeid;
+ ks_status_t s;
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7001;
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
-
- peer1 = ks_dhtrt_find_node(rt, nodeid);
- printf("test05 - first find compelete\n"); fflush(stdout);
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7001;
- peer2 = ks_dhtrt_find_node(rt, nodeid);
- printf("test05 - second find compelete\n"); fflush(stdout);
-
- ks_dhtrt_delete_node(rt, peer);
- printf("test05 - delete compelete\n"); fflush(stdout);
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+
+ peer1 = ks_dhtrt_find_node(rt, nodeid);
+ printf("test05 - first find compelete\n"); fflush(stdout);
- s = ks_dhtrt_release_node(peer1);
- if (s == KS_STATUS_FAIL) printf("release 1 failed\n"); fflush(stdout);
+ peer2 = ks_dhtrt_find_node(rt, nodeid);
+ printf("test05 - second find compelete\n"); fflush(stdout);
+ ks_dhtrt_delete_node(rt, peer);
+ printf("test05 - delete compelete\n"); fflush(stdout);
+ s = ks_dhtrt_release_node(peer1);
+ if (s == KS_STATUS_FAIL) printf("release 1 failed\n"); fflush(stdout);
- s = ks_dhtrt_release_node(peer2);
- if (s == KS_STATUS_FAIL) printf("release 1 failed\n");
+ s = ks_dhtrt_release_node(peer2);
+ if (s == KS_STATUS_FAIL) printf("release 1 failed\n");
- printf("*** testbuckets - test05 finished\n\n\n"); fflush(stdout);
+ printf("* **testbuckets - test05 finished\n\n\n"); fflush(stdout);
- return;
+ return;
}
-/* test06 */
-/* ------- */
+/* test06 */
+/* ------ */
ks_dht_nodeid_t g_nodeid1;
ks_dht_nodeid_t g_nodeid2;
-ks_dht_node_t* g_peer;
+ks_dht_node_t *g_peer;
static void *testnodelocking_ex1(ks_thread_t *thread, void *data)
{
- //lock=3 on entry
- ks_dhtrt_release_node(g_peer); //lock=2
- ks_dhtrt_release_node(g_peer); //lock=1
- ks_dhtrt_release_node(g_peer); //lock=0
- return NULL;
+ //lock=3 on entry
+ ks_dhtrt_release_node(g_peer); //lock=2
+ ks_dhtrt_release_node(g_peer); //lock=1
+ ks_dhtrt_release_node(g_peer); //lock=0
+ return NULL;
}
static void *testnodelocking_ex2(ks_thread_t *thread, void *data)
{
- // lock=4 on entry
- ks_dht_node_t* peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=5
- ks_dhtrt_release_node(peer2); //lock=4
- ks_dhtrt_sharelock_node(peer2); //lock=5
- ks_dhtrt_release_node(peer2); //lock=4
- ks_dhtrt_sharelock_node(peer2); //lock=5
- ks_dhtrt_release_node(peer2); //lock=4
- ks_dhtrt_release_node(peer2); //lock=3
- ks_dhtrt_find_node(rt, g_nodeid1); //lock=4
- ks_dhtrt_release_node(peer2); //lock=3
-
- return NULL;
+ // lock=4 on entry
+ ks_dht_node_t *peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=5
+ ks_dhtrt_release_node(peer2); //lock=4
+ ks_dhtrt_sharelock_node(peer2); //lock=5
+ ks_dhtrt_release_node(peer2); //lock=4
+ ks_dhtrt_sharelock_node(peer2); //lock=5
+ ks_dhtrt_release_node(peer2); //lock=4
+ ks_dhtrt_release_node(peer2); //lock=3
+ ks_dhtrt_find_node(rt, g_nodeid1); //lock=4
+ ks_dhtrt_release_node(peer2); //lock=3
+
+ return NULL;
}
void test06()
{
- printf("*** testbuckets - test06 start\n"); fflush(stdout);
+ printf("**** testbuckets - test06 start\n"); fflush(stdout);
- ks_dht_node_t* peer;
- memset(g_nodeid1.id, 0xef, KS_DHT_NODEID_SIZE);
- memset(g_nodeid2.id, 0x1f, KS_DHT_NODEID_SIZE);
+ ks_dht_node_t *peer;
+ memset(g_nodeid1.id, 0xef, KS_DHT_NODEID_SIZE);
+ memset(g_nodeid2.id, 0x1f, KS_DHT_NODEID_SIZE);
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
- ks_dhtrt_create_node(rt, g_nodeid1, KS_DHT_REMOTE, ipv4, port, &peer); // lock=1
- ks_dhtrt_touch_node(rt, g_nodeid1);
+ ks_dhtrt_create_node(rt, g_nodeid1, KS_DHT_REMOTE, ipv4, port, &peer); // lock=1
+ ks_dhtrt_touch_node(rt, g_nodeid1);
- ks_dht_node_t* peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=2
- peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=3
- peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=4
+ ks_dht_node_t *peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=2
+ peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=3
+ peer2 = ks_dhtrt_find_node(rt, g_nodeid1); //lock=4
- ks_dhtrt_release_node(peer2); //lock=3
+ ks_dhtrt_release_node(peer2); //lock=3
ks_dhtrt_sharelock_node(peer2); //lock=4
- g_peer = peer2;
+ g_peer = peer2;
- ks_thread_t* t0;
- ks_thread_create(&t0, testnodelocking_ex1, NULL, pool);
+ ks_thread_t *t0;
+ ks_thread_create(&t0, testnodelocking_ex1, NULL, pool);
- ks_thread_t* t1;
- ks_thread_create(&t1, testnodelocking_ex2, NULL, pool);
+ ks_thread_t *t1;
+ ks_thread_create(&t1, testnodelocking_ex2, NULL, pool);
- ks_thread_join(t1);
- ks_thread_join(t0);
+ ks_thread_join(t1);
+ ks_thread_join(t0);
- ks_dhtrt_delete_node(rt, peer2);
+ ks_dhtrt_delete_node(rt, peer2);
- printf("\n\n*** testbuckets - test06 -- check if the node gets deleted\n\n\n\n"); fflush(stdout);
+ printf("\n\n* **testbuckets - test06 -- check if the node gets deleted\n\n\n\n"); fflush(stdout);
- ks_dhtrt_process_table(rt);
+ ks_dhtrt_process_table(rt);
- printf("*** testbuckets - test06 start\n"); fflush(stdout);
+ printf("**** testbuckets - test06 start\n"); fflush(stdout);
- return;
+ return;
}
static void *test60ex1(ks_thread_t *thread, void *data)
{
- while(!gstop) {
- ks_dhtrt_process_table(rt);
- ks_sleep(100);
- }
- return NULL;
+ while(!gstop) {
+ ks_dhtrt_process_table(rt);
+ ks_sleep(100);
+ }
+ return NULL;
}
static void *test60ex2(ks_thread_t *thread, void *data)
{
- ks_dht_nodeid_t nodeid;
- ks_dhtrt_querynodes_t query;
+ ks_dht_nodeid_t nodeid;
+ ks_dhtrt_querynodes_t query;
- while(!gstop) {
+ while(!gstop) {
- memset(&query, 0, sizeof(query));
- memset(query.nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
- query.max = 30;
- query.family = ifv4;
- query.type = KS_DHT_REMOTE;
+ memset(&query, 0, sizeof(query));
+ memset(query.nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+ query.max = 30;
+ query.family = ifv4;
+ query.type = KS_DHT_REMOTE;
- ks_dhtrt_findclosest_nodes(rt, &query);
- ks_sleep(10000);
-
- for(int i=0; i<query.count; ++i) {
- ks_dhtrt_release_node(query.nodes[i]);
- ks_sleep(10000);
- }
- ks_sleep(2000000);
+ ks_dhtrt_findclosest_nodes(rt, &query);
+ ks_sleep(10000);
+
+ for (int i=0; i<query.count; ++i) {
+ ks_dhtrt_release_node(query.nodes[i]);
+ ks_sleep(10000);
+ }
+ ks_sleep(2000000);
+
+ }
- }
- return NULL;
+ return NULL;
}
static void *test60ex(ks_thread_t *thread, void *data)
{
- ks_dht_node_t* peer;
- ks_dht_nodeid_t nodeid;
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
+ ks_dht_node_t *peer;
+ ks_dht_nodeid_t nodeid;
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
- int *pi = data;
- int i = *pi;
- ks_mutex_lock(glock);
- nodeid.id[0] = ++gindex;
- ks_mutex_unlock(glock);
+ int *pi = data;
+ int i = *pi;
+ ks_mutex_lock(glock);
+ nodeid.id[0] = ++gindex;
+ ks_mutex_unlock(glock);
- printf("starting thread with i of %d\n", gindex); fflush(stdout);
+ printf("starting thread with i of %d\n", gindex); fflush(stdout);
- for(int loop=0; loop<test60loops; ++loop) {
+ for (int loop=0; loop<test60loops; ++loop) {
- for (int i=0; i<test60nodes; ++i) {
- ++nodeid.id[19];
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
- ks_sleep(1000);
- ks_dhtrt_touch_node(rt, nodeid);
- }
+ for (int i=0; i<test60nodes; ++i) {
+ ++nodeid.id[19];
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
+ ks_sleep(1000);
+ ks_dhtrt_touch_node(rt, nodeid);
+ }
- for (int i=0; i<test60nodes; ++i) {
- peer = ks_dhtrt_find_node(rt, nodeid);
- if (peer) {
- ks_dhtrt_delete_node(rt, peer);
- ks_sleep(400);
+ for (int i=0; i<test60nodes; ++i) {
+ peer = ks_dhtrt_find_node(rt, nodeid);
+ if (peer) {
+ ks_dhtrt_delete_node(rt, peer);
+ ks_sleep(400);
+ }
+ --nodeid.id[19];
}
- --nodeid.id[19];
- }
- }
+ }
- return 0;
-
+ return 0;
+
}
void test60()
{
- printf("**** test60: starting\n"); fflush(stdout);
- int i;
- ks_mutex_create(&glock, KS_MUTEX_FLAG_DEFAULT, pool);
+ printf("**** test60: starting\n"); fflush(stdout);
+ int i;
+ ks_mutex_create(&glock, KS_MUTEX_FLAG_DEFAULT, pool);
- ks_thread_t* t0;
- ks_thread_create(&t0, test60ex1, NULL, pool);
+ ks_thread_t *t0;
+ ks_thread_create(&t0, test60ex1, NULL, pool);
- ks_thread_t* t1;
- ks_thread_create(&t1, test60ex2, NULL, pool);
+ ks_thread_t *t1;
+ ks_thread_create(&t1, test60ex2, NULL, pool);
- for(i = 0; i < 10; i++) {
- ks_thread_create(&threads[i], test60ex, &i, pool);
- }
+ for (i = 0; i < 10; i++) {
+ ks_thread_create(&threads[i], test60ex, &i, pool);
+ }
- printf("all threads started\n"); fflush(stdout);
+ printf("all threads started\n"); fflush(stdout);
- for(i = 0; i < 10; i++) {
- ks_thread_join(threads[i]);
- }
- gstop = 1;
+ for (i = 0; i < 10; i++) {
+ ks_thread_join(threads[i]);
+ }
+ gstop = 1;
- ks_thread_join(t1);
+ ks_thread_join(t1);
- ks_thread_join(t0);
+ ks_thread_join(t0);
- printf("all threads completed\n"); fflush(stdout);
- ks_dhtrt_dump(rt, 7);
- printf("**** test60: completed\n"); fflush(stdout);
+ printf("all threads completed\n"); fflush(stdout);
+ ks_dhtrt_dump(rt, 7);
+ printf("**** test60: completed\n"); fflush(stdout);
- return;
+ return;
}
void test30()
{
- printf("*** testbuckets - test03 start\n"); fflush(stdout);
-
- ks_dht_node_t* peer;
- ks_dht_nodeid_t nodeid;
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
-
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
- enum ks_afflags_t both = ifboth;
-
- ks_status_t status;
- int ipv4_remote = 0;
- int ipv4_local = 0;
-
- for (int i=0; i<200; ++i) {
- if (i%10 == 0) {
- ++nodeid.id[0];
- nodeid.id[1] = 0;
- }
- else {
- ++nodeid.id[1];
- }
- ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- if (s0 == KS_STATUS_SUCCESS) {
- ks_dhtrt_touch_node(rt, nodeid);
- ++ipv4_remote;
- }
- }
-
- for (int i=0; i<2; ++i) {
- if (i%10 == 0) {
- ++nodeid.id[0];
- nodeid.id[1] = 0;
- }
- else {
- ++nodeid.id[1];
- }
-
- ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
- if (s0 == KS_STATUS_SUCCESS) {
- ks_dhtrt_touch_node(rt, nodeid);
- ++ipv4_local;
- }
- }
-
- for (int i=0; i<201; ++i) {
- if (i%10 == 0) {
- ++nodeid.id[0];
- nodeid.id[1] = 0;
- }
- else {
- ++nodeid.id[1];
- }
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- }
-
-
- ks_dhtrt_dump(rt, 7);
-
-
- int qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
- printf("\n** local query count expected 2, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
-
- qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
- printf("\n** local query count expected 2, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
-
- qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, both);
- printf("\n** local query count expected 20, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
-
- return;
+ printf("**** testbuckets - test03 start\n"); fflush(stdout);
+
+ ks_dht_node_t *peer;
+ ks_dht_nodeid_t nodeid;
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
+ enum ks_afflags_t both = ifboth;
+
+ ks_status_t status;
+ int ipv4_remote = 0;
+ int ipv4_local = 0;
+
+ for (int i=0; i<200; ++i) {
+ if (i%10 == 0) {
+ ++nodeid.id[0];
+ nodeid.id[1] = 0;
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ if (s0 == KS_STATUS_SUCCESS) {
+ ks_dhtrt_touch_node(rt, nodeid);
+ ++ipv4_remote;
+ }
+ }
+
+ for (int i=0; i<2; ++i) {
+ if (i%10 == 0) {
+ ++nodeid.id[0];
+ nodeid.id[1] = 0;
+ }
+ else {
+ ++nodeid.id[1];
+ }
+
+ ks_status_t s0 = ks_dhtrt_create_node(rt, nodeid, KS_DHT_LOCAL, ipv4, port, &peer);
+ if (s0 == KS_STATUS_SUCCESS) {
+ ks_dhtrt_touch_node(rt, nodeid);
+ ++ipv4_local;
+ }
+ }
+
+ for (int i=0; i<201; ++i) {
+ if (i%10 == 0) {
+ ++nodeid.id[0];
+ nodeid.id[1] = 0;
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv6, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ }
+
+
+ ks_dhtrt_dump(rt, 7);
+
+
+ int qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
+ printf("\n **** local query count expected 2, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
+
+ qcount = doquery(rt, nodeid.id, KS_DHT_LOCAL, both);
+ printf("\n **** local query count expected 2, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
+
+ qcount = doquery(rt, nodeid.id, KS_DHT_BOTH, both);
+ printf("\n **** local query count expected 20, actual %d, max %d\n", qcount, ipv4_local); fflush(stdout);
+
+ return;
}
/* test resue of node memory */
void test50()
{
- printf("*** testbuckets - test50 start\n"); fflush(stdout);
-
- ks_dht_node_t* peer;
- ks_dht_nodeid_t nodeid, nodeid2;
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
- memset(nodeid2.id, 0xef, KS_DHT_NODEID_SIZE);
-
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
- enum ks_afflags_t both = ifboth;
-
- ks_status_t status;
-
- for (int i=0,i2=0; i<200; ++i, ++i2) {
- if (i%20 == 0) {
- nodeid.id[0] = nodeid.id[0] / 2;
- if(i2%20 == 0) {
- i2 = 0;
- nodeid.id[1] = nodeid.id[1] / 2;
- }
- else {
- ++nodeid.id[2];
- }
- }
- else {
- ++nodeid.id[1];
- }
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- }
-
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
- for (int i=0,i2=0; i<200; ++i, ++i2) {
- if (i%20 == 0) {
- nodeid.id[0] = nodeid.id[0] / 2;
- if(i2%20 == 0) {
- i2 = 0;
- nodeid.id[1] = nodeid.id[1] / 2;
- }
- else {
- ++nodeid.id[2];
- }
- }
- else {
- ++nodeid.id[1];
- }
- ks_dht_node_t *n = ks_dhtrt_find_node(rt, nodeid);
- if (n != NULL) {
- ks_dhtrt_release_node(n);
- ks_dhtrt_delete_node(rt, n);
- }
- }
-
- ks_dhtrt_process_table(rt);
-
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
-
- for (int i=0,i2=0; i<200; ++i, ++i2) {
- if (i%20 == 0) {
- nodeid.id[0] = nodeid.id[0] / 2;
- if(i2%20 == 0) {
- i2 = 0;
- nodeid.id[1] = nodeid.id[1] / 2;
- }
- else {
- ++nodeid.id[2];
- }
- }
- else {
- ++nodeid.id[1];
- }
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- }
-
printf("*** testbuckets - test50 start\n"); fflush(stdout);
+
+ ks_dht_node_t *peer;
+ ks_dht_nodeid_t nodeid, nodeid2;
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+ memset(nodeid2.id, 0xef, KS_DHT_NODEID_SIZE);
+
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
+ enum ks_afflags_t both = ifboth;
+
+ ks_status_t status;
+
+ for (int i=0,i2=0; i<200; ++i, ++i2) {
+ if (i%20 == 0) {
+ nodeid.id[0] = nodeid.id[0] / 2;
+ if (i2%20 == 0) {
+ i2 = 0;
+ nodeid.id[1] = nodeid.id[1] / 2;
+ }
+ else {
+ ++nodeid.id[2];
+ }
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ }
+
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+ for (int i=0,i2=0; i<200; ++i, ++i2) {
+ if (i%20 == 0) {
+ nodeid.id[0] = nodeid.id[0] / 2;
+ if (i2%20 == 0) {
+ i2 = 0;
+ nodeid.id[1] = nodeid.id[1] / 2;
+ }
+ else {
+ ++nodeid.id[2];
+ }
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_dht_node_t *n = ks_dhtrt_find_node(rt, nodeid);
+ if (n != NULL) {
+ ks_dhtrt_release_node(n);
+ ks_dhtrt_delete_node(rt, n);
+ }
+ }
+
+ ks_dhtrt_process_table(rt);
+
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+
+ for (int i=0,i2=0; i<200; ++i, ++i2) {
+ if (i%20 == 0) {
+ nodeid.id[0] = nodeid.id[0] / 2;
+ if (i2%20 == 0) {
+ i2 = 0;
+ nodeid.id[1] = nodeid.id[1] / 2;
+ }
+ else {
+ ++nodeid.id[2];
+ }
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ }
+
+ printf("**** testbuckets - test50 start\n"); fflush(stdout);
return;
}
/* test process_table */
void test51()
{
- printf("*** testbuckets - test51 start\n"); fflush(stdout);
-
- ks_dht_node_t* peer;
- ks_dht_nodeid_t nodeid, nodeid2;
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
- memset(nodeid2.id, 0xef, KS_DHT_NODEID_SIZE);
-
- char ipv6[] = "1234:1234:1234:1234";
- char ipv4[] = "123.123.123.123";
- unsigned short port = 7000;
- enum ks_afflags_t both = ifboth;
-
- ks_status_t status;
-
- for (int i=0,i2=0; i<2; ++i, ++i2) {
- if (i%20 == 0) {
- nodeid.id[0] = nodeid.id[0] / 2;
- if(i2%20 == 0) {
- i2 = 0;
- nodeid.id[1] = nodeid.id[1] / 2;
- }
- else {
- ++nodeid.id[2];
- }
- }
- else {
- ++nodeid.id[1];
- }
- ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
- ks_dhtrt_touch_node(rt, nodeid);
- }
-
- for(int ix=0; ix<50; ++ix) {
+ printf("**** testbuckets - test51 start\n"); fflush(stdout);
+
+ ks_dht_node_t *peer;
+ ks_dht_nodeid_t nodeid, nodeid2;
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+ memset(nodeid2.id, 0xef, KS_DHT_NODEID_SIZE);
+
+ char ipv6[] = "1234:1234:1234:1234";
+ char ipv4[] = "123.123.123.123";
+ unsigned short port = 7000;
+ enum ks_afflags_t both = ifboth;
+
+ ks_status_t status;
+
+ for (int i=0,i2=0; i<2; ++i, ++i2) {
+ if (i%20 == 0) {
+ nodeid.id[0] = nodeid.id[0] / 2;
+ if (i2%20 == 0) {
+ i2 = 0;
+ nodeid.id[1] = nodeid.id[1] / 2;
+ }
+ else {
+ ++nodeid.id[2];
+ }
+ }
+ else {
+ ++nodeid.id[1];
+ }
+ ks_dhtrt_create_node(rt, nodeid, KS_DHT_REMOTE, ipv4, port, &peer);
+ ks_dhtrt_touch_node(rt, nodeid);
+ }
+
+ for (int ix=0; ix<50; ++ix) {
ks_dhtrt_process_table(rt);
- ks_sleep(1000 * 1000 * 120);
- printf("*** pulse ks_dhtrt_process_table\n");
- if ( ix%2 == 0) ks_dhtrt_dump(rt, 7);
- }
+ ks_sleep(1000 *1000 *120);
+ printf("* **pulse ks_dhtrt_process_table\n");
+ if ( ix%2 == 0) ks_dhtrt_dump(rt, 7);
+ }
+ printf("**** testbuckets - test51 complete\n"); fflush(stdout);
- printf("*** testbuckets - test51 complete\n"); fflush(stdout);
-
- return;
+ return;
}
-int main(int argc, char* argv[]) {
+int main(int argc, char *argv[]) {
- printf("testdhtbuckets - start\n");
+ printf("testdhtbuckets - start\n");
- int tests[100];
-
- if (argc == 0) {
- tests[0] = 1;
- tests[1] = 1;
- tests[2] = 1;
- tests[3] = 1;
- tests[4] = 1;
- }
+ int tests[100];
+ if (argc == 0) {
+ tests[0] = 1;
+ tests[1] = 2;
+ tests[2] = 3;
+ tests[3] = 4;
+ tests[4] = 5;
+ }
else {
for(int tix=1; tix<100 && tix<argc; ++tix) {
long i = strtol(argv[tix], NULL, 0);
}
}
- ks_init();
- ks_global_set_default_logger(7);
- ks_dht_create(&dht, NULL, NULL);
+ ks_init();
+ ks_global_set_default_logger(7);
+ ks_dht_create(&dht, NULL, NULL);
// ks_thread_pool_create(&tpool, 0, KS_DHT_TPOOL_MAX, KS_DHT_TPOOL_STACK, KS_PRI_NORMAL, KS_DHT_TPOOL_IDLE);
tpool = 0;
- ks_status_t status;
- char *str = NULL;
- int bytes = 1024;
- ks_dht_nodeid_t homeid;
- ks_dht_nodeid_t nodeid, nodeid1, nodeid2;
- ks_dht_node_t *peer, *peer1, *peer2;
-
- memset(homeid.id, 0xde, KS_DHT_NODEID_SIZE);
- memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
-
- ks_init();
- status = ks_pool_open(&pool);
-
- printf("init/deinit routeable\n"); fflush(stdout);
-
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- ks_dhtrt_deinitroute(&rt);
-
-
-
for(int tix=0; tix<argc; ++tix) {
-
- if (tests[tix] == 1) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test01();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 2) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test02();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 3) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test03();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 4) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test04();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 5) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test05();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 6) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test06();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
-
- if (tests[tix] == 30) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test30();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
-
- if (tests[tix] == 50) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test50();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 51) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test51();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 60) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- test60();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
- if (tests[tix] == 99) {
- ks_dhtrt_initroute(&rt, dht, pool, tpool);
- //testnodelocking();
- ks_dhtrt_deinitroute(&rt);
- continue;
- }
-
-
- }
-
-
-
- return 0;
+ ks_status_t status;
+ char *str = NULL;
+ int bytes = 1024;
+ ks_dht_nodeid_t homeid;
+ ks_dht_nodeid_t nodeid, nodeid1, nodeid2;
+ ks_dht_node_t *peer, *peer1, *peer2;
+
+ memset(homeid.id, 0xde, KS_DHT_NODEID_SIZE);
+ memset(nodeid.id, 0xef, KS_DHT_NODEID_SIZE);
+
+ ks_init();
+ status = ks_pool_open(&pool);
+
+ printf("init/deinit routeable\n"); fflush(stdout);
+
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ ks_dhtrt_deinitroute(&rt);
+
+
+
for (int tix=0; tix<argc; ++tix) {
+
+ if (tests[tix] == 1) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test01();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 2) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test02();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 3) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test03();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 4) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test04();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 5) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test05();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 6) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test06();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+
+ if (tests[tix] == 30) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test30();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+
+ if (tests[tix] == 50) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test50();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 51) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test51();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 60) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ test60();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+ if (tests[tix] == 99) {
+ ks_dhtrt_initroute(&rt, dht, pool, tpool);
+ //testnodelocking();
+ ks_dhtrt_deinitroute(&rt);
+ continue;
+ }
+
+
+ }
+
+
+
+ return 0;
}
projects / thirdparty / freeswitch.git / commitdiff
