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; }