clusterer_node_t* get_clusterer_nodes(int cluster_id)
{
clusterer_node_t *ret_nodes = NULL;
node_info_t *node;
cluster_info_t *cl;
lock_start_read(cl_list_lock);
cl = get_cluster_by_id(cluster_id);
if (!cl) {
LM_ERR("cluster id: %d not found!\n", cluster_id);
lock_stop_read(cl_list_lock);
return NULL;
}
for (node = cl->node_list; node; node = node->next)
if (get_next_hop(node) > 0)
if (add_clusterer_node(&ret_nodes, node) < 0) {
lock_stop_read(cl_list_lock);
LM_ERR("Unable to add node: %d to the returned list of reachable nodes\n",
node->node_id);
free_clusterer_nodes(ret_nodes);
return NULL;
}
lock_stop_read(cl_list_lock);
return ret_nodes;
}
int cl_get_my_index(int cluster_id, str *capability, int *nr_nodes)
{
int i, j, tmp;
int sorted[MAX_NO_NODES];
node_info_t *node;
cluster_info_t *cl;
struct remote_cap *cap;
lock_start_read(cl_list_lock);
cl = get_cluster_by_id(cluster_id);
if (!cl) {
LM_ERR("cluster id: %d not found!\n", cluster_id);
lock_stop_read(cl_list_lock);
return -1;
}
*nr_nodes = 0;
for (node = cl->node_list; node; node = node->next)
if (get_next_hop(node) > 0) {
lock_get(node->lock);
for (cap = node->capabilities; cap; cap = cap->next)
if (!str_strcmp(capability, &cap->name))
break;
if (cap && cap->flags & CAP_STATE_OK)
sorted[(*nr_nodes)++] = node->node_id;
lock_release(node->lock);
}
lock_stop_read(cl_list_lock);
/* sort array of reachable node ids */
for (i = 1; i < *nr_nodes; i++) {
tmp = sorted[i];
for (j = i - 1; j >= 0 && sorted[j] > tmp; j = j - 1)
sorted[j+1] = sorted[j];
sorted[j+1] = tmp;
}
for (i = 0; i < *nr_nodes && sorted[i] < current_id; i++) ;
(*nr_nodes)++;
return i;
}
clusterer_node_t *api_get_next_hop(int cluster_id, int node_id)
{
clusterer_node_t *ret = NULL;
node_info_t *dest_node;
cluster_info_t *cluster;
int rc;
lock_start_read(cl_list_lock);
cluster = get_cluster_by_id(cluster_id);
if (!cluster) {
LM_DBG("Cluster id: %d not found!\n", cluster_id);
return NULL;
}
dest_node = get_node_by_id(cluster, node_id);
if (!dest_node) {
LM_DBG("Node id: %d no found!\n", node_id);
return NULL;
}
rc = get_next_hop(dest_node);
if (rc < 0)
return NULL;
else if (rc == 0) {
LM_DBG("No other path to node: %d\n", node_id);
return NULL;
}
lock_get(dest_node->lock);
if (add_clusterer_node(&ret, dest_node->next_hop) < 0) {
LM_ERR("Failed to allocate next hop\n");
return NULL;
}
lock_release(dest_node->lock);
lock_stop_read(cl_list_lock);
return ret;
}
void query_tx (long long new_qid, long long qid, struct process_id *pid, long long cluster_id, double timeout, int size, const int *data) {
struct rpc_query_type qt;
CC = get_cluster_by_id (cluster_id);
qt.on_answer = CC->methods.funs + CC->methods.fun_pos[RPC_FUN_QUERY_ON_ANSWER];
qt.on_alarm = CC->methods.funs + CC->methods.fun_pos[RPC_FUN_QUERY_ON_ALARM];
qt.on_free = CC->methods.funs + CC->methods.fun_pos[RPC_FUN_QUERY_ON_FREE];
struct rpc_query *q = create_rpc_query (new_qid, *pid, qid, tl_type_none, qt, timeout);
assert (q);
struct secure_send_extra *E = zmalloc (sizeof (*E));
E->state = 0;
E->data_size = size;
E->data = malloc (E->data_size);
memcpy (E->data, data, E->data_size);
E->pid = *pid;
E->timeout = timeout;
E->binlog = 1;
q->extra = E;
secure_send_s0 ++;
insert_binlog_pos (log_cur_pos (), 1);
E->binlog_pos = log_cur_pos ();
}
int cl_get_my_sip_addr(int cluster_id, str *out_addr)
{
cluster_info_t *cl;
int rc;
if (!cl_list_lock) {
LM_ERR("cluster shutdown\n");
memset(out_addr, 0, sizeof *out_addr);
return -1;
}
lock_start_read(cl_list_lock);
cl = get_cluster_by_id(cluster_id);
if (!cl) {
LM_ERR("unknown cluster id: %d\n", cluster_id);
lock_stop_read(cl_list_lock);
memset(out_addr, 0, sizeof *out_addr);
return -1;
}
lock_get(cl->current_node->lock);
if (ZSTR(cl->current_node->sip_addr)) {
memset(out_addr, 0, sizeof *out_addr);
rc = 0;
} else {
if (pkg_str_dup(out_addr, &cl->current_node->sip_addr) != 0) {
LM_ERR("oom\n");
memset(out_addr, 0, sizeof *out_addr);
rc = -1;
} else {
rc = 0;
}
}
lock_release(cl->current_node->lock);
lock_stop_read(cl_list_lock);
return rc;
}
