void testRemoveNode() { printf("Test removing a node...\n"); hash_ring_t *ring = hash_ring_create(1, HASH_FUNCTION_SHA1); hash_ring_node_t *node; char *mynode = "mynode"; char *mynode1 = "mynode1"; char *mynode2 = "mynode2"; char *mykey = "mykey"; assert(hash_ring_add_node(ring, (uint8_t*)mynode, strlen(mynode)) == HASH_RING_OK); assert(hash_ring_add_node(ring, (uint8_t*)mynode1, strlen(mynode2)) == HASH_RING_OK); assert(hash_ring_add_node(ring, (uint8_t*)mynode2, strlen(mynode2)) == HASH_RING_OK); assert(ring->numNodes == 3); node = hash_ring_find_node(ring, (uint8_t*)mykey, strlen(mykey)); assert(node != NULL && node->nameLen == strlen(mynode) && memcmp(mynode, node->name, node->nameLen) == 0); assert(hash_ring_remove_node(ring, (uint8_t*)mynode, strlen(mynode)) == HASH_RING_OK); assert(ring->numNodes == 2); assert(hash_ring_get_node(ring, (uint8_t*)mynode, strlen(mynode)) == NULL); // remove node1, and try to search for a key that went to it before, and verify it goes to node2 assert(hash_ring_remove_node(ring, (uint8_t*)mynode1, strlen(mynode1)) == HASH_RING_OK); assert(ring->numNodes == 1); node = hash_ring_find_node(ring, (uint8_t*)mykey, strlen(mykey)); assert(node != NULL && node->nameLen == strlen(mynode2) && memcmp(mynode2, node->name, node->nameLen) == 0); hash_ring_free(ring); }
void testKnownSlotsOnRing() { printf("Test getting known nodes on ring...\n"); hash_ring_t *ring = hash_ring_create(8, HASH_FUNCTION_SHA1); char *slotA = "slotA"; char *slotB = "slotB"; char *keyA = "keyA"; char *keyB = "keyBBBB"; char *keyC = "keyB_"; hash_ring_node_t *node; assert(hash_ring_add_node(ring, (uint8_t*)slotA, strlen(slotA)) == HASH_RING_OK); assert(hash_ring_add_node(ring, (uint8_t*)slotB, strlen(slotB)) == HASH_RING_OK); node = hash_ring_find_node(ring, (uint8_t*)keyA, strlen(keyA)); assert(node != NULL && node->nameLen == strlen(slotA) && memcmp(node->name, slotA, strlen(slotA)) == 0); node = hash_ring_find_node(ring, (uint8_t*)keyB, strlen(keyB)); assert(node != NULL && node->nameLen == strlen(slotA) && memcmp(node->name, slotA, strlen(slotA)) == 0); node = hash_ring_find_node(ring, (uint8_t*)keyC, strlen(keyC)); assert(node != NULL && node->nameLen == strlen(slotB) && memcmp(node->name, slotB, strlen(slotB)) == 0); hash_ring_free(ring); }
void testAddMultipleTimes() { printf("Test adding a node multiple times...\n"); hash_ring_t *ring = hash_ring_create(1, HASH_FUNCTION_SHA1); assert(ring != NULL); char *mynode = "mynode"; hash_ring_add_node(ring, (uint8_t*)mynode, strlen(mynode)); assert(ring->numNodes == 1); assert(hash_ring_add_node(ring, (uint8_t*)mynode, strlen(mynode)) == HASH_RING_ERR); assert(ring->numNodes == 1); hash_ring_free(ring); }
static void publisher_updater(void *args, zctx_t *ctx, void *pipe){ publishers_info *pub_interface = (struct publisher_list_struct*)args; void *publisher_updater_socket = create_socket(ctx, ZMQ_SUB, SOCK_CONNECT, DISPATCHER_NOTIFY_ADDR); zmq_setsockopt (publisher_updater_socket, ZMQ_SUBSCRIBE, "", strlen ("")); while(true) { int size; char *publisher_addr = _recv_buff(publisher_updater_socket, &size); char *publisher_addr_dup = to_c_string(publisher_addr, strlen(publisher_addr), strlen(publisher_addr)+1); hash_ring_add_node(pub_interface->publisher_ring, (uint8_t*)publisher_addr, strlen(publisher_addr)); void *dispatch_socket = create_socket(ctx, ZMQ_PUB, SOCK_CONNECT, publisher_addr); g_rw_lock_writer_lock (&lock); g_hash_table_insert(pub_interface->publisher_socks, publisher_addr, dispatch_socket); GMutex m; g_mutex_init (&m); g_hash_table_insert(pub_interface->publisher_socks_locks, publisher_addr_dup, &m); g_rw_lock_writer_unlock (&lock); fprintf(stderr, "New Publisher was added at %s", publisher_addr); //free(publisher_addr); } }
void addNodes(hash_ring_t *ring, int numNodes) { int x; uint8_t nodeName[16]; printf("generating and sorting %d nodes...", numNodes); fflush(stdout); for(x = 0; x < numNodes; x++) { fillRandomBytes(nodeName, sizeof(nodeName)); hash_ring_add_node(ring, nodeName, sizeof(nodeName)); } printf("done\n"); }
int main() { hash_ring_t *ring = hash_ring_create(8, HASH_FUNCTION_SHA1); char *slot = malloc(10); char *keyA = "keyA"; hash_ring_node_t *node; sprintf(slot, "%d", 12313); assert(hash_ring_add_node(ring, (uint8_t*)slot, strlen(slot)) == HASH_RING_OK); free(slot); node = hash_ring_find_node(ring, (uint8_t*)keyA, strlen(keyA)); assert(node != NULL && node->nameLen == strlen(slot) && memcmp(node->name, slot, strlen(slot)) == 0); }
void testKnownNextHighestItemOnRing() { printf("Test getting next highest item on ring...\n"); hash_ring_t *ring = hash_ring_create(8, HASH_FUNCTION_SHA1); char *slotA = "slotA"; char *slotB = "slotB"; assert(hash_ring_add_node(ring, (uint8_t*)slotA, strlen(slotA)) == HASH_RING_OK); assert(hash_ring_add_node(ring, (uint8_t*)slotB, strlen(slotB)) == HASH_RING_OK); // next highest for first item should yield the second assert(hash_ring_find_next_highest_item(ring, 2351641940735260693u)->number == 2584980261350711786u); // number less than the first should yield the first assert(hash_ring_find_next_highest_item(ring, 2351641940735260692u)->number == 2351641940735260693u); // number in the middle should yield the next assert(hash_ring_find_next_highest_item(ring, 5908063426886290069u)->number == 6065789416862870789u); // number equal to the last should wrap around to the first assert(hash_ring_find_next_highest_item(ring, 17675051572751928939u)->number == 2351641940735260693u); hash_ring_free(ring); }
void testRingSorting(int num) { printf("Test that the ring is sorted [%d item(s)]...\n", num); hash_ring_t *ring = hash_ring_create(num, HASH_FUNCTION_SHA1); char *slotA = "slotA"; assert(hash_ring_add_node(ring, (uint8_t*)slotA, strlen(slotA)) == HASH_RING_OK); int x; uint64_t cur = 0; for(x = 0; x < ring->numItems; x++) { assert(ring->items[x]->number > cur); cur = ring->items[x]->number; } hash_ring_free(ring); }
static void hash_ring_drv_output(ErlDrvData handle, char *buff, ErlDrvSizeT bufflen) { hash_ring_data* d = (hash_ring_data*)handle; char res = RETURN_ERR; // Check the command if(bufflen == 6 && buff[0] == COMMAND_CREATE_RING) { uint32_t numReplicas; memcpy(&numReplicas, &buff[1], 4); numReplicas = ntohl(numReplicas); int index = find_open_ring_space(d); if(index != -1) { d->ring_usage[index] = 1; d->rings[index] = hash_ring_create(numReplicas, buff[5]); index = htonl(index); driver_output(d->port, (char*)&index, 4); return; } } else if(bufflen == 5 && buff[0] == COMMAND_DELETE_RING) { uint32_t index; memcpy(&index, &buff[1], 4); index = ntohl(index); if(d->numRings > index) { if(d->ring_usage[index] == 1) { d->ring_usage[index] = 0; hash_ring_free(d->rings[index]); res = RETURN_OK; } } } else if(bufflen >= 9 && buff[0] == COMMAND_ADD_NODE) { uint32_t index = readUint32((unsigned char*)&buff[1]); uint32_t nodeLen = readUint32((unsigned char*)&buff[5]); if((bufflen - 9) == nodeLen && d->numRings > index && d->ring_usage[index] == 1) { hash_ring_add_node(d->rings[index], (unsigned char*)&buff[9], nodeLen); res = RETURN_OK; } } else if(bufflen >= 9 && buff[0] == COMMAND_REMOVE_NODE) { uint32_t index = readUint32((unsigned char*)&buff[1]); uint32_t nodeLen = readUint32((unsigned char*)&buff[5]); if((bufflen - 9) == nodeLen && d->numRings > index && d->ring_usage[index] == 1) { hash_ring_remove_node(d->rings[index], (unsigned char*)&buff[9], nodeLen); res = RETURN_OK; } } else if(bufflen >= 9 && buff[0] == COMMAND_FIND_NODE) { uint32_t index = readUint32((unsigned char*)&buff[1]); uint32_t keyLen = readUint32((unsigned char*)&buff[5]); if((bufflen - 9) == keyLen && d->numRings > index && d->ring_usage[index] == 1) { hash_ring_node_t *node = hash_ring_find_node(d->rings[index], (unsigned char*)&buff[9], keyLen); if(node != NULL) { driver_output(d->port, (char*)node->name, node->nameLen); return; } } } else if(bufflen == 6 && buff[0] == COMMAND_SET_MODE) { uint32_t index = readUint32((unsigned char*)&buff[1]); uint8_t mode = (uint8_t)buff[5]; if(d->numRings > index && d->ring_usage[index] == 1) { if(hash_ring_set_mode(d->rings[index], mode) == HASH_RING_OK) { res = RETURN_OK; } } } // default return driver_output(d->port, &res, 1); }
void testKnownMultipleSlotsOnRing() { printf("\n\nTest getting multiple known nodes on ring...\n\n"); hash_ring_t *ring = hash_ring_create(8, HASH_FUNCTION_SHA1); char *slotA = "slotA"; char *slotB = "slotB"; char *slotC = "slotC"; // hashes to a low number char *keyA = "keyA"; // hashes to high number char *keyB = "keyB*_*_*_"; int x; hash_ring_node_t *nodes[3]; assert(hash_ring_add_node(ring, (uint8_t*)slotA, strlen(slotA)) == HASH_RING_OK); assert(hash_ring_add_node(ring, (uint8_t*)slotB, strlen(slotB)) == HASH_RING_OK); x = hash_ring_find_nodes(ring, (uint8_t*)keyA, strlen(keyA), nodes, 3); assert( x == 2 && nodes[0] != NULL && nodes[0]->nameLen == strlen(slotA) && memcmp(nodes[0]->name, slotA, strlen(slotA)) == 0 && nodes[1] != NULL && nodes[1]->nameLen == strlen(slotB) && memcmp(nodes[1]->name, slotB, strlen(slotB)) == 0); x = hash_ring_find_nodes(ring, (uint8_t*)keyB, strlen(keyB), nodes, 3); assert( x == 2 && nodes[0] != NULL && nodes[0]->nameLen == strlen(slotB) && memcmp(nodes[0]->name, slotB, strlen(slotB)) == 0 && nodes[1] != NULL && nodes[1]->nameLen == strlen(slotA) && memcmp(nodes[1]->name, slotA, strlen(slotA)) == 0); assert(hash_ring_add_node(ring, (uint8_t*)slotC, strlen(slotC)) == HASH_RING_OK); x = hash_ring_find_nodes(ring, (uint8_t*)keyA, strlen(keyA), nodes, 3); assert( x == 3 && nodes[0] != NULL && nodes[0]->nameLen == strlen(slotC) && memcmp(nodes[0]->name, slotC, strlen(slotC)) == 0 && nodes[1] != NULL && nodes[1]->nameLen == strlen(slotA) && memcmp(nodes[1]->name, slotA, strlen(slotA)) == 0 && nodes[2] != NULL && nodes[2]->nameLen == strlen(slotB) && memcmp(nodes[2]->name, slotB, strlen(slotB)) == 0); x = hash_ring_find_nodes(ring, (uint8_t*)keyB, strlen(keyB), nodes, 3); assert( x == 3 && nodes[0] != NULL && nodes[0]->nameLen == strlen(slotC) && memcmp(nodes[0]->name, slotC, strlen(slotC)) == 0 && nodes[1] != NULL && nodes[1]->nameLen == strlen(slotB) && memcmp(nodes[1]->name, slotB, strlen(slotB)) == 0 && nodes[2] != NULL && nodes[2]->nameLen == strlen(slotA) && memcmp(nodes[2]->name, slotA, strlen(slotA)) == 0); hash_ring_free(ring); }