static bool is_defined(CppContext *ctx, Token *tok) {
if (!tok || tok->toktype != TOKTYPE_IDENT)
error_token(tok, "identifier expected, but got '%s'", token_to_string(tok));
return dict_has(ctx->defs, tok->val.str);
}
static rstatus_t
gossip_pool_each_init(void *elem, void *data)
{
rstatus_t status;
struct server_pool *sp = elem;
gn_pool.ctx = sp->ctx;
gn_pool.name = &sp->name;
gn_pool.idx = sp->idx;
gn_pool.g_interval = sp->g_interval;
//dictDisableResize();
gn_pool.dict_dc = dictCreate(&string_table_dict_type, NULL);
gossip_set_seeds_provider(&sp->seed_provider);
uint32_t n_dc = array_n(&sp->datacenters);
if (n_dc == 0)
return DN_OK;
if (n_dc > 0) {
status = array_init(&gn_pool.datacenters, n_dc, sizeof(struct gossip_dc));
if (status != DN_OK) {
return status;
}
}
//add racks and datacenters
uint32_t dc_cnt = array_n(&sp->datacenters);
uint32_t dc_index;
for(dc_index = 0; dc_index < dc_cnt; dc_index++) {
struct datacenter *dc = array_get(&sp->datacenters, dc_index);
uint32_t rack_cnt = array_n(&dc->racks);
uint32_t rack_index;
for(rack_index = 0; rack_index < rack_cnt; rack_index++) {
struct rack *rack = array_get(&dc->racks, rack_index);
if (dictFind(gn_pool.dict_dc, rack->dc) == NULL) {
struct gossip_dc *g_dc = array_push(&gn_pool.datacenters);
gossip_dc_init(g_dc, rack->dc);
dictAdd(gn_pool.dict_dc, &g_dc->name, g_dc);
}
struct gossip_dc *g_dc = dictFetchValue(gn_pool.dict_dc, rack->dc);
if (dictFind(g_dc->dict_rack, rack->name) == NULL) {
log_debug(LOG_VERB, "What?? No rack in Dict for rack : '%.*s'", g_dc->name);
struct gossip_rack *g_rack = array_push(&g_dc->racks);
gossip_rack_init(g_rack, rack->dc, rack->name);
dictAdd(g_dc->dict_rack, &g_rack->name, g_rack);
}
}
}
uint32_t i, nelem;
for (i = 0, nelem = array_n(&sp->peers); i < nelem; i++) {
struct server *peer = array_get(&sp->peers, i);
struct gossip_dc *g_dc = dictFetchValue(gn_pool.dict_dc, &peer->dc);
struct gossip_rack *g_rack = dictFetchValue(g_dc->dict_rack, &peer->rack);
struct node *gnode = array_push(&g_rack->nodes);
node_init(gnode);
string_copy(&gnode->dc, peer->dc.data, peer->dc.len);
string_copy(&gnode->rack, g_rack->name.data, g_rack->name.len);
string_copy(&gnode->name, peer->name.data, peer->name.len);
string_copy(&gnode->pname, peer->pname.data, peer->pname.len); //ignore the port for now
gnode->port = peer->port;
gnode->is_local = peer->is_local;
if (i == 0) { //Don't override its own state
gnode->state = sp->ctx->dyn_state; //likely it is JOINING state
gnode->ts = (uint64_t)time(NULL);
current_node = gnode;
char *b_address = get_broadcast_address(sp);
string_deinit(&gnode->name);
string_copy(&gnode->name, b_address, dn_strlen(b_address));
} else {
gnode->state = DOWN;
gnode->ts = 1010101; //make this to be a very aged ts
}
struct dyn_token *ptoken = array_get(&peer->tokens, 0);
copy_dyn_token(ptoken, &gnode->token);
//copy socket stuffs
g_rack->nnodes++;
//add into dicts
dictAdd(g_rack->dict_name_nodes, &gnode->name, gnode);
dictAdd(g_rack->dict_token_nodes, token_to_string(&gnode->token), gnode);
node_count++;
}
//gossip_debug();
status = gossip_start(sp);
if (status != DN_OK) {
goto error;
}
return DN_OK;
error:
gossip_destroy(sp);
return DN_OK;
}
void expect_newline(CppContext *ctx) {
Token *tok = read_cpp_token(ctx);
if (tok && tok->toktype != TOKTYPE_NEWLINE)
error_token(tok, "newline expected, but got '%s'", token_to_string(tok));
}
static rstatus_t
gossip_add_node_if_absent(struct server_pool *sp,
struct string *dc,
struct string *rack,
struct string *address,
struct string *ip,
struct string *port,
struct dyn_token *token,
uint8_t state,
uint64_t timestamp)
{
rstatus_t status;
bool rack_existed = false;
log_debug(LOG_VERB, "gossip_add_node_if_absent : '%.*s'", address->len, address->data);
struct gossip_dc * g_dc = dictFetchValue(gn_pool.dict_dc, dc);
if (g_dc == NULL) {
log_debug(LOG_VERB, "We don't have this datacenter? '%.*s' ", dc->len, dc->data);
g_dc = array_push(&gn_pool.datacenters);
gossip_dc_init(g_dc, dc);
dictAdd(gn_pool.dict_dc, &g_dc->name, g_dc);
} else {
log_debug(LOG_VERB, "We got a datacenter in dict for '%.*s' ", dc->len, dc->data);
}
struct gossip_rack *g_rack = dictFetchValue(g_dc->dict_rack, rack);
if (g_rack == NULL) {
log_debug(LOG_VERB, "We don't have this rack? '%.*s' ", rack->len, rack->data);
g_rack = array_push(&g_dc->racks);
gossip_rack_init(g_rack, dc, rack);
dictAdd(g_dc->dict_rack, &g_rack->name, g_rack);
} else {
log_debug(LOG_VERB, "We got a rack for '%.*s' ", rack->len, rack->data);
}
struct string *token_str = token_to_string(token);
struct node *g_node = dictFetchValue(g_rack->dict_token_nodes, token_str);
if (g_node == NULL) { //never existed
log_debug(LOG_VERB, "Node not found! We need to add it");
log_debug(LOG_VERB, "adding node : dc[%.*s]", dc->len, dc->data);
log_debug(LOG_VERB, "adding node : g_rack[%.*s]", g_rack->name.len, g_rack->name.data);
log_debug(LOG_VERB, "adding node : address[%.*s]", address->len, address->data);
log_debug(LOG_VERB, "adding node : ip[%.*s]", ip->len, ip->data);
log_debug(LOG_VERB, "adding node : port[%.*s]", port->len, port->data);
log_debug(LOG_VERB, "suggested state : %d", state);
//print_dyn_token(token, 6);
gossip_add_node(sp, dc, g_rack, address, ip, port, token, state);
} else if (dictFind(g_rack->dict_name_nodes, ip) != NULL) {
log_debug(LOG_VERB, "Node found");
if (!g_node->is_local) { //don't update myself here
if (string_compare(&g_node->name, ip) != 0) {
log_debug(LOG_WARN, "Replacing an existing token with new info");
gossip_replace_node(sp, g_node, address, ip, state);
} else { //update state
gossip_update_state(sp, g_node, state, timestamp);
}
}
} else {
log_debug(LOG_WARN, "Replacing an existing token with new IP or address");
gossip_replace_node(sp, g_node, address, ip, state);
dictAdd(g_rack->dict_name_nodes, &g_node->name, g_node);
}
//free token_str
string_deinit(token_str);
dn_free(token_str);
return 0;
}
