NePA TesT: Community Network Emulator

import glob

import json

from pprint import pprint

import sys, select

import os

import numpy as np

import matplotlib

matplotlib.use('Agg')

from matplotlib import pyplot as plt

import code

import pdb

import networkx as nx

def outputTopologyGraph(noderoutes,node2RT):

        print "You have 5 seconds to write a filename!"

        fn="out"

        i, o, e = select.select( [sys.stdin], [], [], 5 )

        if (i):

                fn = sys.stdin.readline().strip()

        else:

                print "You said nothing! I choose \'out\' as filename for you"

        #map nodeid to numbers...

        nid2int={}

        v=0

        for k in node2RT:

                nid2int[k]=v

                v+=1

        G=nx.Graph()

        for path in noderoutes:

                mypath=[]

                for nid in path:

                        mypath.append(nid2int[nid])

                G.add_path(mypath)

        nx.write_edgelist(G, fn+".edges", data=False)

#the folder where to look for dumps and logs

folder=sys.argv[1]

print folder

#ROUTE CALCULATOR BASED ON R.TABLE DUMPS PROVIDED BY BABEL

node2RT={}#keys are node_ids, values their RT. Each RT has as keys destinations, as values related NHs

ip2node={}#map between ip addr and nodeid of node_owner

nodes2counter={}

rid2hanme={}

for fname in glob.glob(folder+'topo*'):

        print "Loading json from " + fname

        f=open(fname, "r")

        j=json.load(f)

        #we choose the last routes dump for each node

        ld=j[1]

        routes=ld['routes']

        router_id=ld['router_id']

        nodes2counter[router_id]=0.0

        hname=fname.split("/")[-1].strip("topo").strip(".json")

        rid2hanme[router_id]=hname

        rt={}

        for r in routes:

                nh=r['next']

                dest=r['destination']

                rt[dest]=nh

        node2RT[router_id]=rt

        for r in routes:

                if (r['next']=="me"):

                        ip=r['destination'].split("/")[0]

                        ip2node[ip]=router_id

        f.close()

ips=ip2node.keys()

class DestNotFound(Exception):

        def __init__(self, value):

                self.value = value

        def __str__(self):

                return repr(self.value)

#ok, let me call this function like this...

#currently works only because ALL routes are \32 addresses

def longestPrefixMatchNextHop(rt,dest):

        for d in rt.keys():

                if d.startswith(dest):

                        return rt[d]

        raise DestNotFound("DEST 404: "+str(dest))

routes=[]

for s in ips:

        for d in ips:

                #print "looking for route from "+str(s)+"..->.."+str(d)

                #r=route->list of IPs crossed

                source_node=ip2node[s]

                target_node=ip2node[d]

                if(source_node==target_node):

                        continue

                r = []

                r.append(s)

                try:

                        target_ip=longestPrefixMatchNextHop(node2RT[ip2node[s]],d)

                        target=ip2node[target_ip]

                except:

                        print "Unexpected error:", sys.exc_info()[0], target_ip

                        code.interact(local=dict(globals(), **locals()))

                        continue

                while(target!=target_node):

                        r.append(target_ip)

                        target_ip=longestPrefixMatchNextHop(node2RT[ip2node[target_ip]],d)

                        target=ip2node[target_ip]

                r.append(d)

                routes.append(r)

                '''for i in range(len(r)):

                        if (i!=0):

                                sys.stdout.write("->")

                        sys.stdout.write("c"+str(r[i]))

                print ""'''

#print all routes for offline analysis

'''for r in routes:

        for i in range(len(r)):

                if (i!=0):

                        sys.stdout.write("->")

                sys.stdout.write(str(r[i]))

        print ""'''

#nrs=NodeRoutes, where a NodeRoute is a list of node crossed in a route

nrs = [] 

print "Transform routes from IPlist to NodeList"

for r in routes:

        nr = []

        for crossed in r:

                node_owner=ip2node[crossed]

                nr.append(node_owner)

        nrs.append(nr)

        '''for i in range(len(nr)):

                if (i!=0):

                        sys.stdout.write("->")

                sys.stdout.write("c"+str(nr[i]))

        print ""'''

#There are lot of identical NodeRoute, because routes comes from the combination of all IPs in the network

# but we want only routes between each pair of node, so we remove duplicates

noderoutes=set()

for nr in nrs:

        noderoutes.add(tuple(nr))

#NB: noderoutes includes all the selfNodeRoutes (e.g. A->A)

print "#routes="+str(len(routes))+" #noderoutes="+str(len(noderoutes))

print "Different node routes"

for nr in noderoutes:

        for i in range(len(nr)):

                if (i!=0):

                        sys.stdout.write(" -> ")

                sys.stdout.write(str(nr[i]))

        print ""

#outputTopologyGraph(noderoutes,node2RT)

#Computing how many routes cross each node, endpoint are not considered

for nr in noderoutes:

        nr=list(nr)

        del nr[0]

        del nr[-1]

        for crossed in nr:

                c=nodes2counter[crossed]

                nodes2counter[crossed]=c+1.0

tot=0

for n in nodes2counter:

        tot=tot+nodes2counter[n]

        print "Centrality of "+str(n)+" = "+str(nodes2counter[n])

print "tot="+str(tot)

#Now nodes2counter store reference results from Routing Table dumps provided by Babel

#Now results from distributed proto are collected from csv dumps and finally they will be compared with just computed reference values

import csv

res={}

tot=0

for fname in glob.glob(folder+'*_cdump.csv'):

        text=os.popen("tail -n 30 "+fname).read()

        f=fname.split("/")[-1]

        f=f.split("_")

        nodename=f[0]

        lines=text.splitlines()

        csum = 0

        for l in lines:

                csum += int(l.split(",")[-1])

        avgc = csum / 30.0

        res[nodename] = avgc

        #print "Node ",n,":",cent

        tot = tot + avgc

for k in res:

        print "Node",k,":",res[k]

print "tot =",tot

#Merging results in a single dict before writing to file for later elaboration/plotting

towrite={}

for k in nodes2counter:

        v=nodes2counter[k]

        toAdd=(v,)

        towrite[rid2hanme[k]]=toAdd

#code.interact(local=dict(globals(), **locals()))

for k in res:

        v=res[k]

        toAdd=(v,)

        towrite[k]+=toAdd

for k in towrite:

        cent=towrite[k]

        print "Node: "+str(k)+ "\t(theoric = "+str(cent[0])+", proto = "+str(cent[1])+")"

import operator

sorted_by_theor_centr = sorted(towrite.items(), key=operator.itemgetter(1), reverse=True)

pprint(sorted_by_theor_centr)

#write sorted results to file to plot later

fldname=folder.strip("/")

file = open(folder+fldname+"-results.csv", "w")

file.write("NodeID,theoric,proto\n")

for el in sorted_by_theor_centr:

        file.write(str(el[0])+","+str(el[1][0])+","+str(el[1][1])+"\n")

file.close()

xticks = []

y1 = []

y2 = []

for el in sorted_by_theor_centr:

        xticks.append(el[0])

        y1.append(el[1][0])

        y2.append(el[1][1])

x = np.arange(len(sorted_by_theor_centr))

plt.plot(x, y1, 'ro', label="theoric")

plt.plot(x, y2, 'b*', label="proto")

plt.xticks(x, xticks, rotation='vertical', fontsize=8)

plt.xlabel('Nodes by id')

plt.ylabel('Babel Centrality index')

plt.legend(loc='upper right', fontsize=10, numpoints=1)

# Pad margins so that markers don't get clipped by the axes

plt.margins(0.2)

# Tweak spacing to prevent clipping of tick-labels

plt.subplots_adjust(bottom=0.3)

#fig = plt.gcf()

#plt.show()

fldname=folder.strip("/")

plt.savefig(folder+fldname+"plot.pdf")