NePA TesT: Community Network Emulator

import glob

import json

from pprint import pprint

import sys

import os

import numpy as np

import matplotlib

matplotlib.use('Agg')

from matplotlib import pyplot as plt

from pprint import pprint

import code

from multiprocessing import Process, Manager

class MyTime:

        string = "0:0:0.0"

        @classmethod

        def vecToString(cls, vec):

                mus=vec[-1]

                highORlow="high"

                if (mus<0.5):

                        highORlow="low"

                return str(vec[0])+":"+str(vec[1])+":"+str(vec[2])+"-"+highORlow

        def __init__(self, timestring="0:0:0.0"):

                self.string=timestring

                spl=self.string.split(':')

                self.mh=int(spl[-3])

                self.mm=int(spl[-2])

                self.ms=int(spl[-1].split('.')[0])

                self.mus=int(spl[-1].split('.')[1]) * (10**-6)

                self.time=self.mh *60 * 60 + self.mm * 60 + self.ms + self.mus

        def asHMSUVector(self):

                if (self.mus<0.5):

                        retmus=0

                else:

                        retmus=5

                #print "\t\tmus="+str(self.mus)+", retmus="+str(retmus)

                return (self.mh,self.mm,self.ms,retmus)

        def asHMSVector(self):

                return (self.mh,self.mm,self.ms)

        def toString(self):

                return self.string

        def toFloat(self):

                return self.time

        #se self e' piu' tardi ritorna 1, -1 altrimenti

        #si assume che i log siano stati fatti nella stessa ora!

        def vecCompare(self,v2):

                h1,m1,s1,hl1=self.asHMSUVector()

                h2,m2,s2,hl2=v2

                if (h2 != h1):

                        if (h2>h1):

                                return -1

                        else:

                                return 1

                if (m2 != m1):

                        if (m2>m1):

                                return -1

                        else:

                                return 1

                if (s2 != s1):

                        if (s2>s1):

                                return -1

                        else:

                                return 1

                if (hl2 != hl1):

                        if (hl2>hl1):

                                return -1

                        else:

                                return 1

                return 0

        def __cmp__(self,obj):

                return self.vecCompare(obj.asHMSUVector())

        #return 1 if self older than other

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 entry in rt.keys():

                if entry.startswith(dest):

                        return rt[entry]

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

#time2N2RT: <secondo, N2RT>

time2N2RT={}

#N2RT: <node_id, RT>

#N2RT = {}

#RT: <dest, next_hop>

#ip2node: <ip, node_id>

def navigateRoutingTable(node2rt,ip2node,node2ips,sec,failedNodesId):

        ips=ip2node.keys()

        #remove ips of failed_nodes, given we want to check how many routes among ips of active nodes pass trough the dead node

        remIps=node2ips[failedNodesId]

        ips = list(set(ips) - set(remIps))

        black_holes=0

        loops=0

        routes=[]

        for s in ips:

                for d in ips:

                        #print "\t\tlooking for route from "+str(s)+"..->.."+str(d)

                        #r=route->list of IPs crossed

                        r = []

                        nr = []

                        r.append(s)

                        source_node=ip2node[s]

                        nr.append(source_node)

                        target_node=ip2node[d]

                        try:

                                nexthop=longestPrefixMatchNextHop(node2rt[source_node],d)

                        except DestNotFound as dnf:

                                print dnf, "probably alredy flushed"

                                break;

                        except KeyError as e:

                                print e

                                #print "Unexpected error:", sys.exc_info()[0], "\n\t Actually this concludes log analysis," \

                                # "when stop logging\n\tsome nodes terminates before others and some RT misses"

                                #pass

                                return ()

                                #break;

                        target=ip2node[nexthop]

                        while(target!=target_node):

                                r.append(nexthop)

                                source_node=ip2node[nexthop]

                                if (source_node not in nr):

                                        nr.append(source_node)

                                else:

                                        #print "\t\t\t\tLoooooooop!!!!!"

                                        loops+=1

                                        break;

                                try:

                                        nexthop=longestPrefixMatchNextHop(node2rt[source_node],d)

                                except KeyError:

                                        black_holes+=1

                                        '''print "\t\tNode "+str(ip2node[nexthop])+" owning "+str(nexthop)+" is dead"

                                        sys.stdout.write("\t\t\t\t")

                                        for i in range(len(r)):

                                                if (i!=0):

                                                        sys.stdout.write("->")

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

                                        print ""'''

                                        break;

                                except:

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

                                        break;

                                target=ip2node[nexthop]

                        r.append(d)

                        routes.append(r)

        print "\t#loops: "+str(loops)+", blackholes: "+str(black_holes)

        return (black_holes,loops,)

#the folder where to look for dumps and logs

folder=sys.argv[1]

print folder

'''t1=MyTime("12:00:01.200000")

t2=MyTime("12:00:01.700000")

print t1.vecCompare(t2.asHMSUVector())

print t2.vecCompare(t1.asHMSUVector())

print t1.vecCompare(t1.asHMSUVector())

code.interact(local=locals())'''

ip2node={}

node2ips={}

print "###########\n\n\n\n"

#Ricostruzione RT indicizzate per tempo

#bisogna anche salvarsi il tempo di rottura del nodo che e' morto

minDumpsLength=sys.maxint

failedNodesId=""

fail_time=MyTime()

stopTimes=[]

stopTimes2n={}

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

        print "Loading json from " + fname

        f=open(fname, "r")

        jtimedroutes=json.load(f)

        del(jtimedroutes[0]) #the first dummy entry always put in Babel dumps

        #identifyinf failed node as the one with minimun number of dumps

        '''if (len(jtimedroutes)<minDumpsLength):

                minDumpsLength=len(jtimedroutes)

                lastDump=jtimedroutes[-1]

                failedNodesId=lastDump['router_id']

                fail_time=MyTime(lastDump['topology_id'])

                print "\tFAILURE NEWS: "+failedNodesId+" stopped working at "+fail_time.toString()'''

        #put stopTime in a vector to see which is the first correct node that stopped logging

        lastDump=jtimedroutes[-1]

        router_id=lastDump['router_id']

        stopTime=MyTime(lastDump['topology_id'])

        stopTimes.append(stopTime)

        stopTimes2n[stopTime.asHMSUVector()]=router_id

        #pprint(time2N2RT)

        #Retrieving RTs dumped by this node

        slasttime=MyTime().toString

        for jtimedRT in jtimedroutes:

                router_id=jtimedRT['router_id']

                stime=jtimedRT['topology_id']

                routes=jtimedRT['routes']

                #print "\tAt time: "+stime+" we have an RT for node: "+router_id

                time=MyTime(stime)

                tk=time.asHMSUVector()

                #tk=tk[0]*60*60+tk[1]*60+tk[2]

                if (not time2N2RT or tk not in time2N2RT):

                        time2N2RT[tk]={}

                        #print "New second",router_id,tk

                if (not time2N2RT[tk] or router_id not in time2N2RT[tk]):

                        time2N2RT[tk][router_id]={}

                        #print "\tNew router for ",router_id,tk

                thisnodeIPs=[]

                for r in routes:

                        #RT=time2N2RT[tk][router_id]

                        dest=r['destination']

                        nexthop=r['next']

                        if(float(r['cost'])==0):

                                nexthop=dest.split('/')[0]

                                thisnodeIPs.append(nexthop)

                                ip2node[nexthop]=router_id

                        time2N2RT[tk][router_id][dest]=nexthop

                node2ips[router_id]=thisnodeIPs

                #N2RT[router_id]=RT

        f.close()

#code.interact(local=locals())

stopTimes=sorted(stopTimes)

fail_time=stopTimes[0]

failedNodesId=stopTimes2n[fail_time.asHMSUVector()]

stopLogTime=stopTimes[1] #[0] -> fail node stop

print "According to data read from json it seems that"

print "Failure at: "+fail_time.toString()

print "Stop log at: "+stopLogTime.toString()

'''print "ip2node"

pprint(ip2node)

print "node2ips"

pprint(node2ips)

print "#################\n\n\n\n"

pprint(time2N2RT)'''

print "#################\n\n\n\n"

srtsec=sorted(time2N2RT.keys())

#print "Times"

#pprint(srtsec)

#print "\n\n"

'''for sec in srtsec:

        print "Al secondo: "+ MyTime.vecToString(sec)

        for node in time2N2RT[sec]:

                print "\t\tRT("+str(node)+")={"

                for dest in time2N2RT[sec][node]:

                        print "\t\t\t\t"+str(dest)+" via "+str(time2N2RT[sec][node][dest])

                print "\t\t}"

        print "\n"'''

def broken_paths_discoverer(N2RT, ip2node, node2ips,sec, failedNodesId, res):

        print "\nProblems at time: "+MyTime.vecToString(sec)+"?"

        #da tenere conto di nodo_fallito e fail_time

        #non analizziamo i log precedenti a fail_time

        if (fail_time.vecCompare(sec)>0):

                print "\t"+MyTime.vecToString(sec) + " prior than fail_time: "+fail_time.toString()

                res[sec]=(-1,-1)

        elif (stopLogTime.vecCompare(sec)<0):

                print "\t"+MyTime.vecToString(sec) + " after than stopLogTime: "+stopLogTime.toString()

                res[sec]=(-1,-1)

        #"else" failTime < sec < StopLogTime ==> it is worth to navigate RTs

        else:

                res[sec]=navigateRoutingTable(time2N2RT[sec],ip2node,node2ips,sec,failedNodesId)

print "#################\n\n\n\n"

#Navigazione e conteggio disagi:

manager = Manager()

results = manager.dict()

#results={} #<time,vettore risultati>: disagi per secondo

print "Looking for problems in network for each period"

jobs=[]

for sec in srtsec:

        procs = len(srtsec)

        for i in range(0, procs):

                process = Process(target=broken_paths_discoverer, 

                                                                                  args=(time2N2RT[sec],ip2node,node2ips,sec,failedNodesId,results))

                jobs.append(process)

for j in jobs:

        j.start()

for j in jobs:

        j.join()

print "#######\n\n\n"

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

#Visualiza data in pretty table

from prettytable import PrettyTable

t = PrettyTable(['Time', '#loops','#blackholes'])

#sava data in csv file

fldname=folder.strip("/")

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

f.write("Time,loops,blackholes\n")

for sec in srtsec:

        if (sec in results):

                if (bool(results[sec])):

                        #print "At sec: "+MyTime.vecToString(sec)+" #loops: "+str(results[sec][1]) + " #blackholes: "+str(results[sec][0])

                        t.add_row([ MyTime.vecToString(sec), str(results[sec][1]), str(results[sec][0])])

                        f.write(MyTime.vecToString(sec) +","+ str(results[sec][1])+","+ str(results[sec][0])+"\n")

f.close()

print t