/*
* Reads input from a particular node and ships it off to
* the "handle_event()"
*/
int net_input(int sd, int io_evt, void *node_)
{
merlin_event *pkt;
merlin_node *node = (merlin_node *)node_;
int len, events = 0;
errno = 0;
ldebug("NETINPUT from %p (%s)", node, node ? node->name : "oops");
len = node_recv(node);
if (len < 0) {
return 0;
}
node->stats.bytes.read += len;
node->last_recv = time(NULL);
while ((pkt = node_get_event(node))) {
events++;
handle_event(node, pkt);
free(pkt);
}
ldebug("Read %d events in %s from %s node %s",
events, human_bytes(len), node_type(node), node->name);
return events;
}
int distribute_thr(int recvSock)
{
char *p, buf[2048], *url;
URLNODE_T *urlNode;
urlNode = (URLNODE_T *) buf;
url = buf + sizeof(URLNODE_T);
while (1)
{
node_recv(recvSock, buf, 2048);
assert(urlNode->urlLen + sizeof(URLNODE_T) < 2048);
*(url + urlNode->urlLen) = 0;
printf("recv: %s urlLen: %d", url, urlNode->urlLen);
if (link_filter(url) == 0)
continue;
node_send(urlNode, url);
printf("send (%s) to center\n", links->links[i]);
}
return 0;
}
int process_epidemic_cnt_event(struct Simulator *aSim, struct Node *aNode, struct Node *bNode)
{
struct Item *aItem, *temp;
struct Pkg *aPkg, *newPkg;
/* update neighborhood */
node_met_a_node(aNode, bNode, aSim->oracle->neighborThreshold);
node_met_a_node(bNode, aNode, aSim->oracle->neighborThreshold);
aItem = aNode->storage->pkgs.head;
while(aItem != NULL) {
aPkg = (struct Pkg*)aItem->datap;
newPkg = pkg_copy_func(aPkg);
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else {
node_recv(aSim, bNode, newPkg);
aItem = aItem->next;
}
}
aItem = bNode->storage->pkgs.head;
while(aItem != NULL) {
aPkg = (struct Pkg*)aItem->datap;
newPkg = pkg_copy_func(aPkg);
if(strcmp(aPkg->dst, aNode->name)==0) {
newPkg->endAt = aSim->clock;
node_recv(aSim, aNode, newPkg);
temp = aItem->next;
storage_remove_pkg(bNode->storage, aPkg->id);
aItem = temp;
continue;
} else {
node_recv(aSim, aNode, newPkg);
aItem = aItem->next;
}
}
return 0;
}
static int ipc_reap_events(void)
{
int len, events = 0;
merlin_event *pkt;
node_log_event_count(&ipc, 0);
len = node_recv(&ipc);
if (len < 0)
return len;
while ((pkt = node_get_event(&ipc))) {
events++;
handle_ipc_event(pkt);
}
ldebug("Read %d events in %s from %s", events, human_bytes(len), ipc.name);
return 0;
}
void cache_work_thr()
{
unsigned ret;
char buf[2048], url[MAX_URL_LEN];
URLNODE_T *urlNode;
urlNode = (URLNODE_T *) buf;
while (1)
{
node_recv(buf, 2048);
if (urlNode->urlLen > MAX_URL_LEN)
{
printf("urlNode->urlLen error.\n");
continue;
}
*(buf + sizeof(URLNODE_T) + urlNode->urlLen) = 0;
snprintf(url, MAX_URL_LEN, "%s", buf + sizeof(URLNODE_T));
if ((ret = NEO_cache_check(g_domainRBdict, url)) > 100000)
{
printf("this domain save too many (%d) url.\n", ret);
continue;
}
//本机url, 直接更新, 同时发送到radar记录
guide_send(urlNode, url);
if (urlNode->updateTime > 0)
{
pthread_mutex_lock(&cache_mutex);
NEO_cache_url(g_domainRBdict, url, urlNode);
pthread_mutex_unlock(&cache_mutex);
}
}
return;
}
/*
* Reads input from a particular node and ships it off to
* the "handle_network_event()" routine up above
*/
static int net_input(merlin_node *node)
{
merlin_event *pkt;
int len, events = 0;
errno = 0;
len = node_recv(node);
if (len < 0) {
return 0;
}
node->stats.bytes.read += len;
node->last_recv = time(NULL);
while ((pkt = node_get_event(node))) {
events++;
handle_network_event(node, pkt);
}
ldebug("Read %d events in %s from %s node %s",
events, human_bytes(len), node_type(node), node->name);
return events;
}
void social_check_for_relaying_pkgs(struct Simulator *aSim, struct Node *aNode, struct Node *bNode)
{
struct Pairwise *aPairwise, *bPairwise;
struct Item *aItem, *temp;
struct Pkg *aPkg, *newPkg;
char cond1, cond2, cond3, cond4, doFwd;
aItem = aNode->storage->pkgs.head;
while(aItem != NULL) {
aPkg = (struct Pkg*)aItem->datap;
aPairwise = lookup_pairwise_in_oracle(aSim->oracle, aNode->name, aPkg->dst);
bPairwise = lookup_pairwise_in_oracle(aSim->oracle, bNode->name, aPkg->dst);
cond1 = ((aPairwise && aPairwise->estimation==-1)||aPairwise==NULL) && bPairwise && bPairwise->estimation!=-1;
cond2 = aPairwise && aPairwise->estimation!=-1 && bPairwise && bPairwise->estimation!=-1 && aPairwise->estimation>bPairwise->estimation;
cond3 = ((aPairwise && aPairwise->estimation==-1)||aPairwise==NULL) && ((bPairwise && bPairwise->estimation==-1)||bPairwise==NULL) && (aNode->betweenness<bNode->betweenness);
cond4 = aNode->betweenness<bNode->betweenness;
if(aSim->oracle->onlySocial)
doFwd = cond4;
else
doFwd = cond1 || cond2 || cond3;
if(aSim->fwdMethod == NO_REPLICA_FWD) {
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if(doFwd) {
newPkg = pkg_copy_func(aPkg);
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
}
} else if(aSim->fwdMethod == BETTER_ESTIMATE_FWD) {
if ( strcmp(aPkg->dst, bNode->name)==0 ) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if( doFwd) {
newPkg = pkg_copy_func(aPkg);
node_recv(aSim, bNode, newPkg);
}
} else if(aSim->fwdMethod == EVERBEST_ESTIMATE_FWD) {
if ( strcmp(aPkg->dst, bNode->name)==0 ) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if( (aPkg->value==-1 && doFwd)
|| (aPkg->value!=-1 && bPairwise && bPairwise->estimation!=-1 && aPkg->value>bPairwise->estimation)) {
newPkg = pkg_copy_func(aPkg);
aPkg->value = bPairwise->estimation;
newPkg->value = bPairwise->estimation;
node_recv(aSim, bNode, newPkg);
}
}
aItem = aItem->next;
}
}
void simbet_check_for_relaying_pkgs(struct Simulator *aSim, struct Node *aNode, struct Node *bNode)
{
struct Item *aItem, *temp;
struct Pkg *aPkg, *newPkg;
struct Node *dstNode;
double sim_aNode_dst, sim_bNode_dst, SimUtil_aNode, SimUtil_bNode, BetUtil_aNode, BetUtil_bNode, SimBetUtil_aNode, SimBetUtil_bNode;
aItem = aNode->storage->pkgs.head;
while(aItem != NULL) {
aPkg = (struct Pkg*)aItem->datap;
dstNode = lookup_node(&aSim->vnodes, aPkg->dst);
/* calculate the similarity between aNode and the dest*/
sim_aNode_dst = calculate_similarity(aNode, dstNode);
/* calculate the similarity between bNode and the dest*/
sim_bNode_dst = calculate_similarity(bNode, dstNode);
if(sim_aNode_dst+sim_bNode_dst == 0) {
SimUtil_aNode = 0;
SimUtil_bNode = 0;
} else {
SimUtil_aNode = sim_aNode_dst/(sim_aNode_dst+sim_bNode_dst);
SimUtil_bNode = sim_bNode_dst/(sim_aNode_dst+sim_bNode_dst);
}
if(aNode->betweenness+bNode->betweenness == 0) {
BetUtil_aNode = 0;
BetUtil_bNode = 0;
} else {
BetUtil_aNode = aNode->betweenness/(aNode->betweenness+bNode->betweenness);
BetUtil_bNode = bNode->betweenness/(aNode->betweenness+bNode->betweenness);
}
SimBetUtil_aNode = aSim->oracle->alfar*SimUtil_aNode + aSim->oracle->beta*BetUtil_aNode;
SimBetUtil_bNode = aSim->oracle->alfar*SimUtil_bNode + aSim->oracle->beta*BetUtil_bNode;
if(aSim->fwdMethod == NO_REPLICA_FWD) {
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if( SimBetUtil_aNode < SimBetUtil_bNode ) {
newPkg = pkg_copy_func(aPkg);
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
}
} else if(aSim->fwdMethod == BETTER_ESTIMATE_FWD) {
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if( SimBetUtil_aNode < SimBetUtil_bNode ) {
newPkg = pkg_copy_func(aPkg);
node_recv(aSim, bNode, newPkg);
}
} else if(aSim->fwdMethod == EVERBEST_ESTIMATE_FWD) {
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if ((aPkg->value==-1 && SimBetUtil_aNode < SimBetUtil_bNode)
|| (aPkg->value!=-1 && SimBetUtil_bNode > aPkg->value)) {
newPkg = pkg_copy_func(aPkg);
aPkg->value = SimBetUtil_bNode;
newPkg->value = SimBetUtil_bNode;
node_recv(aSim, bNode, newPkg);
}
}
aItem = aItem->next;
}
}
void bubble_check_for_relaying_pkgs(struct Simulator *aSim, struct Node *aNode, struct Node *bNode)
{
struct Item *aItem, *temp;
struct Pkg *aPkg, *newPkg;
aItem = aNode->storage->pkgs.head;
while(aItem != NULL) {
aPkg = (struct Pkg*)aItem->datap;
if(aSim->fwdMethod == NO_REPLICA_FWD) {
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if( aNode->neighbors.count < bNode->neighbors.count ) {
newPkg = pkg_copy_func(aPkg);
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
}
} else if(aSim->fwdMethod == BETTER_ESTIMATE_FWD) {
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if ( aNode->neighbors.count < bNode->neighbors.count ) {
newPkg = pkg_copy_func(aPkg);
node_recv(aSim, bNode, newPkg);
}
} else if(aSim->fwdMethod == EVERBEST_ESTIMATE_FWD) {
if(strcmp(aPkg->dst, bNode->name)==0) {
newPkg = pkg_copy_func(aPkg);
newPkg->endAt = aSim->clock;
node_recv(aSim, bNode, newPkg);
temp = aItem->next;
storage_remove_pkg(aNode->storage, aPkg->id);
aItem = temp;
continue;
} else if ((aPkg->value==-1 && aNode->neighbors.count < bNode->neighbors.count)
|| (aPkg->value!=-1 && bNode->neighbors.count > aPkg->value)) {
newPkg = pkg_copy_func(aPkg);
aPkg->value = bNode->neighbors.count;
newPkg->value = bNode->neighbors.count;
node_recv(aSim, bNode, newPkg);
}
}
aItem = aItem->next;
}
}
