int main() {
unsigned long one, two;
one = network_new(1);
two = network_new(0);
assert(network_nodes_number(one) == 0);
assert(network_nodes_number(two) == 0);
network_add_node(one, "1");
network_add_node(one, "2");
network_add_link(two, "1", "2");
assert(network_nodes_number(one) == 2);
assert(network_links_number(one) == 0);
assert(network_nodes_number(two) == 2);
assert(network_links_number(two) == 1);
network_add_link(one, "1", "2");
network_add_link(two, "2", "2");
assert(network_links_number(one) == 1);
assert(network_links_number(two) == 2);
network_remove_link(two, "2", "2");
assert(network_nodes_number(one) == 2);
assert(network_links_number(one) == 1);
assert(network_nodes_number(two) == 2);
assert(network_links_number(two) == 1);
assert(network_in_degree(543, "sadsa") == 0);
return 0;
}
// -----[ _ez_node_builder ]-----------------------------------------
static inline int _ez_node_builder(ez_topo_t * eztopo,
ez_node_t * eznode)
{
net_error_t error;
int options= 0;
if (!(eznode->options & EZ_NODE_OPT_NO_LOOPBACK))
options|= NODE_OPTIONS_LOOPBACK;
// Generate address ?
if (eznode->id.addr == NET_ADDR_ANY)
eznode->id.addr= ++(eztopo->addr);
// Create and add node
error= node_create(eznode->id.addr, &eznode->node, options);
if (error != ESUCCESS)
return error;
error= network_add_node(eztopo->network, eznode->node);
if (error != ESUCCESS) {
node_destroy(&eznode->node);
return error;
}
// Place in IGP domain ?
if (eznode->domain > 0) {
igp_domain_t * domain= network_find_igp_domain(eztopo->network,
eznode->domain);
if (domain == NULL) {
domain= igp_domain_create(eznode->domain, IGP_DOMAIN_IGP);
assert(network_add_igp_domain(eztopo->network, domain) == ESUCCESS);
}
error= igp_domain_add_router(domain, eznode->node);
if (error != ESUCCESS)
return error;
}
return error;
}
/**
* context: {}
* tokens : {addr}
* options: {no-loopback}
*/
int cli_net_add_node(cli_ctx_t * ctx, cli_cmd_t * cmd)
{
net_addr_t addr;
net_node_t * node;
int error;
int options= 0; // default is: create loopback with address = node ID
// Node address ?
if (str2address(cli_get_arg_value(cmd, 0), &addr)) {
cli_set_user_error(cli_get(), "could not add node (invalid address)");
return CLI_ERROR_COMMAND_FAILED;
}
// Option: no-loopback ?
if (!cli_opts_has_value(cmd->opts, "no-loopback")) {
options|= NODE_OPTIONS_LOOPBACK;
}
// Create new node
error= node_create(addr, &node, options);
if (error != ESUCCESS) {
cli_set_user_error(cli_get(), "could not add node (%s)",
network_strerror(error));
return CLI_ERROR_COMMAND_FAILED;
}
// Add node
error= network_add_node(network_get_default(), node);
if (error != ESUCCESS) {
node_destroy(&node);
cli_set_user_error(cli_get(), "could not add node (%s)",
network_strerror(error));
return CLI_ERROR_COMMAND_FAILED;
}
return CLI_SUCCESS;
}
/**
* Process an event from a local mailbox.
*
* \param[in,out] pi Ping info
*
* \return 1 if processed an event 0 if not, negative error code otherwise
*/
static int
local_mbox_event(ping_info_t *pi)
{
ExamsgMID mid;
static Examsg ev;
int ev_size;
int s;
ev_size = examsgRecv(local_mh, &mid, &ev, sizeof(ev));
if (ev_size <= 0)
return 0;
switch (ev.any.type)
{
case EXAMSG_EXIT:
{
exa_nodeset_t dest_nodes;
quit = true;
exa_nodeset_single(&dest_nodes, mid.netid.node);
examsgAckReply(local_mh, &ev, EXA_SUCCESS, mid.id, &dest_nodes);
}
/* Return 0 because, despite we received a message, we do not want the
* main loop to continue to process messages as it is asked to stop now.
* So returning 0 juste means here "no need to read anymore messages" */
return 0;
case EXAMSG_SUP_PING:
if (network_status() == 0)
network_special_send(&mid, &ev, ev_size);
break;
case EXAMSG_ADDNODE:
{
exa_nodeset_t dest_nodes;
examsg_node_info_msg_t *info = (examsg_node_info_msg_t *)&ev;
s = network_add_node(info->node_id, info->node_name);
exa_nodeset_single(&dest_nodes, mid.netid.node);
examsgAckReply(local_mh, &ev, s, mid.id, &dest_nodes);
}
break;
case EXAMSG_DELNODE:
{
exa_nodeset_t dest_nodes;
s = network_del_node(((examsg_node_info_msg_t *)&ev)->node_id);
exa_nodeset_single(&dest_nodes, mid.netid.node);
examsgAckReply(local_mh, &ev, s, mid.id, &dest_nodes);
}
break;
case EXAMSG_RETRANSMIT_REQ:
if (network_status() == 0)
{
ExamsgRetransmitReq *retreq = (ExamsgRetransmitReq *)&ev;
exalog_debug("will send a retransmit request for %d to %u",
retreq->count, retreq->node_id);
s = network_send_retransmit_req(retreq->node_id, retreq->count);
EXA_ASSERT(s == 0);
reset_ping(pi);
}
break;
case EXAMSG_RETRANSMIT:
if (network_status() == 0)
{
ExamsgRetransmit *retr = (ExamsgRetransmit *)&ev;
exalog_debug("will retransmit messages: %d", retr->count);
retransmit(retr->count);
reset_ping(pi);
}
break;
case EXAMSG_FENCE:
{
const examsgd_fencing_req_t *req =
&((examsgd_fencing_req_msg_t *)&ev)->request;
network_handle_fence_request(req);
}
break;
case EXAMSG_NEW_COMER:
reset_ping(pi);
break;
default:
{
exa_nodeset_t dest_nodes;
exa_nodeset_single(&dest_nodes, mid.netid.node);
examsgAckReply(local_mh, &ev, EINVAL, mid.id, &dest_nodes);
exalog_error("got unknown message (type %d)", ev.any.type);
EXA_ASSERT(false);
}
break;
}
return 1;
}
