Exemplo n.º 1
0
def monkey_patch_pox():
    '''Override two key bits of POX functionality: the Timer class and
    the openflow connection class.  Other overrides are mainly to ensure
    that nothing unexpected happens, but are strictly not necessary at
    present (using betta branch of POX)'''
    get_logger().info("Monkeypatching POX for integration with fs")

    fakerlib = PoxLibPlug()
    import pox.lib.recoco as recoco
    setattr(recoco, "Timer", FakePoxTimer)

    import pox.lib
    setattr(pox.lib, "ioworker", fakerlib)
    setattr(pox.lib, "pxpcap", fakerlib)
    setattr(pox.lib, "socketcapture", fakerlib)

    import pox
    setattr(pox, "messenger", fakerlib)
    setattr(pox, "misc", fakerlib)

    setattr(ofcore, "Connection", FakeOpenflowConnection)
    setattr(ofcore, "OpenFlow_01_Task", fakerlib)

    import pox.core
    setattr(pox.core, "getLogger", get_pox_logger)
Exemplo n.º 2
0
    def parse_delay(delay):
        '''Parse config file delay, return delay as a float in seconds'''
        if isinstance(delay, (int,float)):
            return float(delay)
        elif isinstance(delay, (str, unicode)):
            if re.match('^(\d*\.?\d+)$', delay):
                return float(delay)

            # [sS]+anything assumed to be seconds
            mobj = re.match('^(\d*\.?\d+)s', delay, re.IGNORECASE)
            if mobj:
                return float(mobj.groups()[0]) 

            # [ms]+anything assumed to be milliseconds
            mobj = re.match('^(\d*\.?\d+)ms', delay, re.IGNORECASE)
            if mobj:
                return float(mobj.groups()[0]) / 1000.0

            # [us]+anything assumed to be microseconds
            mobj = re.match('^(\d*\.?\d+)us', delay, re.IGNORECASE)
            if mobj:
                return float(mobj.groups()[0]) / 1000000.0

        get_logger().error("Can't parse link delay: {}".format(delay))
        sys.exit(-1)
Exemplo n.º 3
0
def monkey_patch_pox():
    '''Override two key bits of POX functionality: the Timer class and
    the openflow connection class.  Other overrides are mainly to ensure
    that nothing unexpected happens, but are strictly not necessary at
    present (using betta branch of POX)'''
    get_logger().info("Monkeypatching POX for integration with fs")

    fakerlib = PoxLibPlug()
    import pox.lib.recoco as recoco
    setattr(recoco, "Timer", FakePoxTimer)

    import pox.lib
    setattr(pox.lib, "ioworker", fakerlib)
    setattr(pox.lib, "pxpcap", fakerlib)
    setattr(pox.lib, "socketcapture", fakerlib)

    import pox
    setattr(pox, "messenger", fakerlib)
    setattr(pox, "misc", fakerlib)

    setattr(ofcore, "Connection", FakeOpenflowConnection)
    setattr(ofcore, "OpenFlow_01_Task", fakerlib)

    import pox.core 
    setattr(pox.core, "getLogger", get_pox_logger)
Exemplo n.º 4
0
    def parse_delay(delay):
        '''Parse config file delay, return delay as a float in seconds'''
        if isinstance(delay, (int, float)):
            return float(delay)
        elif isinstance(delay, (str, unicode)):
            if re.match('^(\d*\.?\d+)$', delay):
                return float(delay)

            # [sS]+anything assumed to be seconds
            mobj = re.match('^(\d*\.?\d+)s', delay, re.IGNORECASE)
            if mobj:
                return float(mobj.groups()[0])

            # [ms]+anything assumed to be milliseconds
            mobj = re.match('^(\d*\.?\d+)ms', delay, re.IGNORECASE)
            if mobj:
                return float(mobj.groups()[0]) / 1000.0

            # [us]+anything assumed to be microseconds
            mobj = re.match('^(\d*\.?\d+)us', delay, re.IGNORECASE)
            if mobj:
                return float(mobj.groups()[0]) / 1000000.0

        get_logger().error("Can't parse link delay: {}".format(delay))
        sys.exit(-1)
Exemplo n.º 5
0
    def __init__(self,
                 timeToWake,
                 callback,
                 absoluteTime=False,
                 recurring=False,
                 args=(),
                 kw={},
                 scheduler=None,
                 started=True,
                 selfStoppable=True):

        if absoluteTime and recurring:
            raise RuntimeError(
                "Can't have a recurring timer for an absolute time!")

        if absoluteTime:
            raise RuntimeError("Can't have an absolute time in FakePoxTimer")

        self._self_stoppable = selfStoppable
        self._timeToWake = timeToWake

        self.id = "poxtimer{}".format(FakePoxTimer.timerid)
        FakePoxTimer.timerid += 1

        self._recurring = recurring
        self._callback = callback
        self._args = args
        self._kw = kw
        get_logger().debug("Setting fake pox timer callback {} {}".format(
            self._timeToWake, self._callback))
        fscore().after(self._timeToWake, self.id, self.docallback, None)
Exemplo n.º 6
0
def load_pox_component(name):
    '''Load a pox component by trying to import the named module and
       invoking launch().  Raise a runtime error if something goes wrong.'''

    log = get_logger()
    try:
        m = import_module(name)
        if 'launch' not in dir(m):
            log.error("Can't load POX module {}".format(name))
            raise RuntimeError('No launch function in module {}'.format(name))
        else:
            log.debug("Loading POX component {}".format(name))
            # FIXME: component launch needs some rework.
            # import pox.boot
            # pox.boot._do_launch([name])

            if m.launch.func_code.co_argcount == 0:
                m.launch()
            elif m.launch.func_code.co_argcount >= 1:
                m.launch(m.__dict__)

            log.debug("Loaded POX component {}".format(name))

    except ImportError,e:
        log.error("Error trying to import {} POX component".format(name))
        raise RuntimeError(str(e))
Exemplo n.º 7
0
    def __init__(self, gfunc, stime=0, emerge_profile=None, sustain_profile=None, withdraw_profile=None):
        self.generators = {}
        self.generator_generator = gfunc
        self.starttime = stime
        self.logger = get_logger("fslib.traffic")
        if isinstance(self.starttime, (int, float)):
            self.starttime = randomchoice(self.starttime)

        # profiles should be generators that return a list of tuples: (time, numsources)
        self.emerge = self.sustain = self.withdraw = None

        # print 'emerge',emerge_profile
        # print 'sustain',sustain_profile
        # print 'withdraw',withdraw_profile

        # examples:
        #    profile=((10,10,10,10,10,10),(1,2,3,4,5,6))"
        #    profile=((10,),(1,))"
        #    emerge=((1,),range(1,100,10)) sustain=((0,30),(100,100)) withdraw=((1,),range(100,1,10))"

        if emerge_profile:
            emerge = eval(emerge_profile)
            # print 'emerge',emerge
            self.emerge = zipit(emerge)

        if sustain_profile:
            sustain = eval(sustain_profile)
            # print 'sustain',sustain
            self.sustain = zipit(sustain)

        if withdraw_profile:
            withdraw = eval(withdraw_profile)
            print 'withdraw',withdraw
            self.withdraw = zipit(withdraw)
Exemplo n.º 8
0
def load_pox_component(name):
    '''Load a pox component by trying to import the named module and
       invoking launch().  Raise a runtime error if something goes wrong.'''

    log = get_logger()
    try:
        m = import_module(name)
        if 'launch' not in dir(m):
            log.error("Can't load POX module {}".format(name))
            raise RuntimeError('No launch function in module {}'.format(name))
        else:
            log.debug("Loading POX component {}".format(name))

            # FIXME: component launch needs some rework.
            # import pox.boot
            # pox.boot._do_launch([name])

            if m.launch.func_code.co_argcount == 0:
                m.launch()
            elif m.launch.func_code.co_argcount >= 1:
                m.launch(m.__dict__)

            log.debug("Loaded POX component {}".format(name))

    except ImportError, e:
        log.error("Error trying to import {} POX component".format(name))
        raise RuntimeError(str(e))
Exemplo n.º 9
0
    def __init__(self, interval, endtime=1.0, debug=0, progtick=0.05):
        if FsCore.inited:
            fscommon.get_logger().warn("Trying to initialize a new simulation object.")
            sys.exit(-1)

        FsCore.inited = True

        self.__debug = debug
        self.__interval = interval
        self.__now = 0.0
        self.__logger = fscommon.get_logger('fs.core')

        self.__heap = []
        self.endtime = endtime
        self.starttime = self.__now
        self.intr = False
        self.progtick = progtick
        self.__topology = NullTopology()
        self.monkeypatch()
        fscommon.set_fscore(self)
Exemplo n.º 10
0
    def __init__(self, interval, endtime=1.0, debug=0, progtick=0.05):
        if FsCore.inited:
            fscommon.get_logger().warn(
                "Trying to initialize a new simulation object.")
            sys.exit(-1)

        FsCore.inited = True

        self.__debug = debug
        self.__interval = interval
        self.__now = 0.0
        self.__logger = fscommon.get_logger('fs.core')

        self.__heap = []
        self.endtime = endtime
        self.starttime = self.__now
        self.intr = False
        self.progtick = progtick
        self.__topology = NullTopology()
        self.monkeypatch()
        fscommon.set_fscore(self)
Exemplo n.º 11
0
    def simrecv(self, msg):
        # print "Received message in FakeOpenflowConnection:", str(msg)
        # print "seq 3"
        if msg.version != oflib.OFP_VERSION:
            get_logger().debug("Bad OpenFlow version (0x%02x) on connection %s"
                % (ord(self.buf[offset]), self))
            return False # Throw connection away

        # don't need to pack/unpack because we control message send/recv
        # new_offset,msg = unpackers[ofp_type](self.buf, offset)
        ofp_type = msg.header_type

        try:
            from pox.openflow.of_01 import handlers
            h = handlers[ofp_type]
            h(self, msg)
        except:
            get_logger().debug("%s: Exception while handling OpenFlow message:\n" +
                      "%s %s", self,self,
                      ("\n" + str(self) + " ").join(str(msg).split('\n')))
        return True
Exemplo n.º 12
0
    def __init__ (self, timeToWake, callback, absoluteTime = False,
                recurring = False, args = (), kw = {}, scheduler = None,
                started = True, selfStoppable = True):

        if absoluteTime and recurring:
            raise RuntimeError("Can't have a recurring timer for an absolute time!")

        if absoluteTime:
            raise RuntimeError("Can't have an absolute time in FakePoxTimer")

        self._self_stoppable = selfStoppable
        self._timeToWake = timeToWake

        self.id = "poxtimer{}".format(FakePoxTimer.timerid)
        FakePoxTimer.timerid += 1

        self._recurring = recurring
        self._callback = callback
        self._args = args
        self._kw = kw
        get_logger().debug("Setting fake pox timer callback {} {}".format(self._timeToWake, self._callback))
        fscore().after(self._timeToWake, self.id, self.docallback, None)
Exemplo n.º 13
0
    def __init__(self, graph, nodes, links, traffic_modulators):
        self.logger = get_logger('fslib.config')
        self.__graph = graph
        self.nodes = nodes
        self.links = links
        self.traffic_modulators = traffic_modulators
        self.routing = {}
        self.ipdestlpm = None
        self.owdhash = {}
        self.__configure_routing()

        for a,b,d in self.graph.edges(data=True):
            if 'reliability' in d:
                self.__configure_edge_reliability(a,b,d['reliability'],d)
Exemplo n.º 14
0
    def parse_capacity(capacity):
        '''Parse config file capacity, return capacity as a float in bits/sec'''
        if isinstance(capacity, (int, float)):
            return float(capacity)
        elif isinstance(capacity, (str, unicode)):
            if re.match('^(\d+\.?\d*)$', capacity):
                return float(capacity)
            # [kK]+anything assumed to be kbit/sec
            mobj = re.match('^(\d+\.?\d*)[kK]', capacity)
            if mobj:
                return float(mobj.groups()[0]) * 1000.0

            # [mM]+anything assumed to be mbit/sec
            mobj = re.match('^(\d+\.?\d*)[mM]', capacity)
            if mobj:
                return float(mobj.groups()[0]) * 1000000.0

            # [gG]+anything assumed to be gbit/sec
            mobj = re.match('^(\d+\.?\d*)[gG]', capacity)
            if mobj:
                return float(mobj.groups()[0]) * 1000000000.0

        get_logger().error("Can't parse link capacity: {}".format(capacity))
        sys.exit(-1)
Exemplo n.º 15
0
    def parse_capacity(capacity):
        '''Parse config file capacity, return capacity as a float in bits/sec'''
        if isinstance(capacity, (int,float)):
            return float(capacity)
        elif isinstance(capacity, (str, unicode)):
            if re.match('^(\d+)$', capacity):
                return float(capacity)
            # [kK]+anything assumed to be kbit/sec
            mobj = re.match('^(\d+)[kK]', capacity)
            if mobj:
                return float(mobj.groups()[0]) * 1000.0

            # [mM]+anything assumed to be mbit/sec
            mobj = re.match('^(\d+)[mM]', capacity)
            if mobj:
                return float(mobj.groups()[0]) * 1000000.0

            # [gG]+anything assumed to be gbit/sec
            mobj = re.match('^(\d+)[gG]', capacity)
            if mobj:
                return float(mobj.groups()[0]) * 1000000000.0

        get_logger().error("Can't parse link capacity: {}".format(capacity))
        sys.exit(-1)
Exemplo n.º 16
0
 def __init__(self, capacity, delay, ingress_node, egress_node):
     self.capacity = Link.parse_capacity(capacity)/8.0 # bytes/sec
     self.delay = Link.parse_delay(delay)
     self.ingress_ip = 0
     self.egress_ip = 0
     self.egress_node = egress_node
     self.egress_name = Link.make_portname(self.egress_node.name, self.egress_ip)
     self.ingress_node = ingress_node
     self.ingress_name = Link.make_portname(self.ingress_node.name, self.ingress_ip)
     self.backlog = 0
     self.bdp = self.capacity * self.delay  # bytes
     self.queuealarm = 1.0
     self.lastalarm = -1
     self.alarminterval = 30
     self.doqdelay = True
     self.logger = get_logger("link {}->{}".format(self.ingress_node.name, self.egress_node.name))
Exemplo n.º 17
0
 def __init__(self, capacity, delay, ingress_node, egress_node):
     self.capacity = Link.parse_capacity(capacity)/8.0 # bytes/sec
     self.delay = Link.parse_delay(delay)
     self.ingress_ip = 0
     self.egress_ip = 0
     self.egress_node = egress_node
     self.egress_name = Link.make_portname(self.egress_node.name, self.egress_ip)
     self.ingress_node = ingress_node
     self.ingress_name = Link.make_portname(self.ingress_node.name, self.ingress_ip)
     self.backlog = 0
     self.bdp = self.capacity * self.delay  # bytes
     self.queuealarm = 1.0
     self.lastalarm = -1
     self.alarminterval = 30
     self.doqdelay = True
     self.logger = get_logger("link {}->{}".format(self.ingress_node.name, self.egress_node.name))
Exemplo n.º 18
0
def packet_to_flowlet(pkt):
    try:
        return getattr(pkt, "origflet")
    except AttributeError, e:
        log = get_logger()
        flet = None
        ip = pkt.find("ipv4")
        if ip is None:
            flet = PoxFlowlet(FlowIdent())
            log.debug(
                "Received non-IP packet {} from POX: there's no direct translation to fs".format(str(pkt.payload))
            )
        else:
            dport = sport = tcpflags = 0
            if ip.protocol == IPPROTO_TCP:
                tcp = ip.payload
                sport = tcp.srcport
                dport = tcp.dstport
                tcpflags = tcp.flags
                log.debug("Translating POX TCP packet to fs {}".format(tcp))
            elif ip.protocol == IPPROTO_UDP:
                udp = ip.payload
                sport = udp.srcport
                dport = udp.dstport
                log.debug("Translating POX UDP packet to fs {}".format(udp))
            elif ip.protocol == IPPROTO_ICMP:
                icmp = ip.payload
                dport = (icmp.type << 8) | icmp.code
                log.debug("Translating POX ICMP packet to fs {}".format(icmp))
            else:
                log.warn("Received unhandled IPv4 packet {} from POX: can't translate to fs".format(str(ip.payload)))

            flet = PoxFlowlet(FlowIdent(srcip=ip.srcip, dstip=ip.dstip, ipproto=ip.protocol, sport=sport, dport=dport))
            flet.tcpflags = tcpflags
            flet.iptos = ip.tos

        flet.srcmac = pkt.src
        flet.dstmac = pkt.dst
        flet.pkts = 1
        flet.bytes = len(pkt)
        flet.origpkt = pkt
        return flet
Exemplo n.º 19
0
def packet_to_flowlet(pkt):
    '''Translate a POX packet to an fs flowlet'''
    try:
        return getattr(pkt, "origflet")
    except AttributeError,e:
        log = get_logger()
        flet = None
        ip = pkt.find('ipv4')
        if ip is None:
            flet = PoxFlowlet(FlowIdent())
            log.debug("Received non-IP packet {} from POX: there's no direct translation to fs".format(str(pkt.payload)))
        else:
            dport = sport = tcpflags = 0
            if ip.protocol == IPPROTO_TCP:
                tcp = ip.payload
                sport = tcp.srcport
                dport = tcp.dstport
                tcpflags = tcp.flags
                log.debug("Translating POX TCP packet to fs {}".format(tcp))
            elif ip.protocol == IPPROTO_UDP:
                udp = ip.payload
                sport = udp.srcport
                dport = udp.dstport
                log.debug("Translating POX UDP packet to fs {}".format(udp))
            elif ip.protocol == IPPROTO_ICMP:
                icmp = ip.payload
                dport = (icmp.type << 8) | icmp.code
                log.debug("Translating POX ICMP packet to fs {}".format(icmp))
            else:
                log.warn("Received unhandled IPv4 packet {} from POX: can't translate to fs".format(str(ip.payload)))

            flet = PoxFlowlet(FlowIdent(srcip=ip.srcip, dstip=ip.dstip, ipproto=ip.protocol, sport=sport, dport=dport))
            flet.tcpflags = tcpflags
            flet.iptos = ip.tos

        flet.srcmac = pkt.src
        flet.dstmac = pkt.dst
        flet.pkts = 1
        flet.bytes = len(pkt)
        flet.origpkt = pkt
        return flet
Exemplo n.º 20
0
 def __init__(self, srcnode):
     self.srcnode = srcnode
     self.done = False
     self.logger = get_logger("tgen.{}".format(self.srcnode))
Exemplo n.º 21
0
    def __init__(self, srcnode, ipsrc='0.0.0.0', ipdst='0.0.0.0', sport=0, dport=0, flowsize=1500, pktsize=1500, flowstart=0, ipproto=socket.IPPROTO_TCP, lossrate=0.001, mss=1460, iptos=0x0, xopen=True, tcpmodel='csa00'):
        TrafficGenerator.__init__(self, srcnode)
        self.logger = get_logger('fs.harpoon')
        self.srcnet = ipaddr.IPNetwork(ipsrc)
        self.dstnet = ipaddr.IPNetwork(ipdst)
        if haveIPAddrGen:
            self.ipsrcgen = ipaddrgen.initialize_trie(int(self.srcnet), self.srcnet.prefixlen, 0.61)
            self.ipdstgen = ipaddrgen.initialize_trie(int(self.dstnet), self.dstnet.prefixlen, 0.61)

        if isinstance(ipproto, (str,unicode)):
            self.ipproto = eval(ipproto)
        else: 
            self.ipproto = randomchoice(ipproto)

        if isinstance(sport, (str,unicode)):
            self.srcports = eval(sport)
        else:
            self.srcports = randomchoice(sport)

        if isinstance(dport, (str,unicode)):
            self.dstports = eval(dport)
        else:
            self.dstports = randomchoice(dport)

        if isinstance(flowsize, (str,unicode)):
            self.flowsizerv = eval(flowsize)
        else:
            self.flowsizerv = randomchoice(flowsize)

        if isinstance(pktsize, (str,unicode)):
            self.pktsizerv = eval(pktsize)
        else:
            self.pktsizerv = randomchoice(pktsize)

        if isinstance(flowstart, (str,unicode)):
            self.flowstartrv = eval(flowstart)
        else:
            self.flowstartrv = randomchoice(flowstart)

        if isinstance(lossrate, (str,unicode)):
            self.lossraterv = eval(lossrate)
        else:
            self.lossraterv = randomchoice(lossrate)

        if isinstance(mss, (str,unicode)):
            self.mssrv = eval(mss)
        else:
            self.mssrv = randomchoice(mss)

        if isinstance(iptos, (str,unicode)):
            self.iptosrv = eval(iptos)
        else:
            self.iptosrv = randomchoice(iptos)

        self.xopen = xopen
        self.activeflows = {}

        try:
            self.tcpmodel = import_module("tcpmodels.{}".format(tcpmodel))
        except ImportError,e:
            raise InvalidFlowConfiguration('Unrecognized tcp model for harpoon: {} (Error on import: {})'.format(tcpmodel, str(e)))
Exemplo n.º 22
0
    def __init__(self, srcnode, ipsrc='0.0.0.0', ipdst='0.0.0.0', sport=0, dport=0, flowsize=1500, pktsize=1500, flowstart=0, ipproto=socket.IPPROTO_TCP, lossrate=0.001, mss=1460, iptos=0x0, xopen=True, tcpmodel='csa00'):
        TrafficGenerator.__init__(self, srcnode)
        self.logger = get_logger('fs.harpoon')
        self.srcnet = ipaddr.IPNetwork(ipsrc)
        self.dstnet = ipaddr.IPNetwork(ipdst)
        if haveIPAddrGen:
            self.ipsrcgen = ipaddrgen.initialize_trie(int(self.srcnet), self.srcnet.prefixlen, 0.61)
            self.ipdstgen = ipaddrgen.initialize_trie(int(self.dstnet), self.dstnet.prefixlen, 0.61)

        if isinstance(ipproto, (str,unicode)):
            self.ipproto = eval(ipproto)
        else: 
            self.ipproto = randomchoice(ipproto)

        if isinstance(sport, (str,unicode)):
            self.srcports = eval(sport)
        else:
            self.srcports = randomchoice(sport)

        if isinstance(dport, (str,unicode)):
            self.dstports = eval(dport)
        else:
            self.dstports = randomchoice(dport)

        if isinstance(flowsize, (str,unicode)):
            self.flowsizerv = eval(flowsize)
        else:
            self.flowsizerv = randomchoice(flowsize)

        if isinstance(pktsize, (str,unicode)):
            self.pktsizerv = eval(pktsize)
        else:
            self.pktsizerv = randomchoice(pktsize)

        if isinstance(flowstart, (str,unicode)):
            self.flowstartrv = eval(flowstart)
        else:
            self.flowstartrv = randomchoice(flowstart)

        if isinstance(lossrate, (str,unicode)):
            self.lossraterv = eval(lossrate)
        else:
            self.lossraterv = randomchoice(lossrate)

        if isinstance(mss, (str,unicode)):
            self.mssrv = eval(mss)
        else:
            self.mssrv = randomchoice(mss)

        if isinstance(iptos, (str,unicode)):
            self.iptosrv = eval(iptos)
        else:
            self.iptosrv = randomchoice(iptos)

        self.xopen = xopen
        self.activeflows = {}

        try:
            self.tcpmodel = import_module("tcpmodels.{}".format(tcpmodel))
        except ImportError,e:
            raise InvalidFlowConfiguration('Unrecognized tcp model for harpoon: {} (Error on import: {})'.format(tcpmodel, str(e)))
Exemplo n.º 23
0
        if 'launch' not in dir(m):
            log.error("Can't load POX module {}".format(name))
            raise RuntimeError('No launch function in module {}'.format(name))
        else:
            log.debug("Loading POX component {}".format(name))

            # FIXME: component launch needs some rework.
            # import pox.boot
            # pox.boot._do_launch([name])

            if m.launch.func_code.co_argcount == 0:
                m.launch()
            elif m.launch.func_code.co_argcount >= 1:
                m.launch(m.__dict__)

            log.debug("Loaded POX component {}".format(name))

    except ImportError, e:
        log.error("Error trying to import {} POX component".format(name))
        raise RuntimeError(str(e))


monkey_patch_pox()
load_pox_component("pox.openflow")

get_logger().debug("Kicking POX Up")
pox.core.core.goUp()
get_logger().debug("POX components: {}".format(pox.core.core.components))

from pox_bridge import *
Exemplo n.º 24
0
    def __init__(self, srcnode, ipsrc='0.0.0.0', ipdst='0.0.0.0', sport=0, dport=0, flowstarttime=0, flowsize=1500, pktsize=1500, flowstart=0, ipproto=socket.IPPROTO_TCP, lossrate=0.0045, mss=1460, iptos=0x0, xopen=True, tcpmodel='csa00',matrix='../conf/input.matrix'):
        TrafficGenerator.__init__(self, srcnode)
        self.logger = get_logger('fs.matrix')

        trafficmatrix = open(matrix, 'r')
        flowList = []
        flowStartList = []
        srcipList = []
        dstipList = []
        flowSizeList = []

        for line in trafficmatrix:
            if line.strip()!= "":
                flowList.append(line.strip().split(" "))

        for item in  flowList:
            try:
                if nodename_to_ipaddr(srcnode)==item[1]:
                    flowStartList.append(item[0])
                    srcipList.append(item[1])
                    dstipList.append(item[2])
                    #srcipList.append(nodename_to_ipaddr(item[1]))
                    #dstipList.append(nodename_to_ipaddr(item[2]))
                    flowSizeList.append(item[3])
            except:
                print "Invalid Flow"
                print item
                pass

        self.srcipList=srcipList

        self.srcnet = eval('sequentialchoice(srcipList)')
        self.dstnet = eval('sequentialchoice(dstipList)')
        self.flowstarttimerv = eval('sequentialchoice(flowStartList)')
        self.flowsizerv = eval('sequentialchoice(flowSizeList)')

        if haveIPAddrGen:
            self.ipsrcgen = ipaddrgen.initialize_trie(int(self.srcnet), self.srcnet.prefixlen, 0.61)
            self.ipdstgen = ipaddrgen.initialize_trie(int(self.dstnet), self.dstnet.prefixlen, 0.61)

        if isinstance(ipproto, (str,unicode)):
            #print eval(ipproto)
            self.ipproto = eval(ipproto)
        else: 
            self.ipproto = randomchoice(ipproto)

        if isinstance(sport, (str,unicode)):
            self.srcports = eval(sport)
        else:
            self.srcports = randomchoice(sport)

        if isinstance(dport, (str,unicode)):
            self.dstports = eval(dport)
        else:
            self.dstports = randomchoice(dport)

        if isinstance(pktsize, (str,unicode)):
            self.pktsizerv = eval(pktsize)
        else:
            self.pktsizerv = randomchoice(pktsize)

        if isinstance(flowstart, (str,unicode)):
            self.flowstartrv = eval(flowstart)
        else:
            self.flowstartrv = randomchoice(flowstart)

        if isinstance(lossrate, (str,unicode)):
            self.lossraterv = eval(lossrate)
        else:
            self.lossraterv = randomchoice(lossrate)

        if isinstance(mss, (str,unicode)):
            self.mssrv = eval(mss)
        else:
            self.mssrv = randomchoice(mss)

        if isinstance(iptos, (str,unicode)):
            self.iptosrv = eval(iptos)
        else:
            self.iptosrv = randomchoice(iptos)

        self.xopen = xopen
        self.activeflows = {}

        try:
            self.tcpmodel = import_module("tcpmodels.{}".format(tcpmodel))
        except ImportError,e:
            raise InvalidFlowConfiguration('Unrecognized tcp model for matrix: {} (Error on import: {})'.format(tcpmodel, str(e)))
Exemplo n.º 25
0
 def cancel(self):
     get_logger().debug("Attempting to cancel fake POX timer {}".format(
         self.id))
     fscore().cancel(self.id)
Exemplo n.º 26
0
def get_pox_logger(*args, **kwargs):
    return get_logger()
Exemplo n.º 27
0
 def cancel(self):
     get_logger().debug("Attempting to cancel fake POX timer {}".format(self.id))
     fscore().cancel(self.id)
Exemplo n.º 28
0
 def docallback(self, *args):
     get_logger().debug("In fake pox timer callback {} {}".format(self._timeToWake, self._callback))
     rv = self._callback(*self._args, **self._kw)
     if rv and self._recurring:
         fscore().after(self._timeToWake, self.id, self.docallback, None)
Exemplo n.º 29
0
 def docallback(self, *args):
     get_logger().debug("In fake pox timer callback {} {}".format(
         self._timeToWake, self._callback))
     rv = self._callback(*self._args, **self._kw)
     if rv and self._recurring:
         fscore().after(self._timeToWake, self.id, self.docallback, None)
Exemplo n.º 30
0
 def send(self, ofmessage):
     get_logger().debug(
         "Doing callback in OF connection from controller->switch {}".
         format(ofmessage))
     self.sendfn(self.switchname, ofmessage)
Exemplo n.º 31
0
def get_pox_logger(*args, **kwargs):
    return get_logger()
Exemplo n.º 32
0
 def __init__(self, srcnode):
     self.srcnode = srcnode
     self.done = False
     self.logger = get_logger("tgen {}".format(self.srcnode))
Exemplo n.º 33
0
 def __init__(self, node):
     ControllerModule.__init__(self)
     self.logger = get_logger()
     self.graph = None
     self.node = node
Exemplo n.º 34
0
 def __init__(self):
     self.logger = get_logger('fslib.config')
     # FIXME: let this be configurable
     FsConfigurator.link_subnetter = fsutil.subnet_generator("172.16.0.0/12", 2) 
Exemplo n.º 35
0
 def send(self, ofmessage):
     get_logger().debug("Doing callback in OF connection from controller->switch {}".format(ofmessage)) 
     # print "unknown", self.switchname
     self.sendfn(self.switchname, ofmessage)
Exemplo n.º 36
0
 def __init__(self, node):
     ControllerModule.__init__(self)
     self.logger = get_logger()
     self.graph = None
     self.node = node
Exemplo n.º 37
0
        if 'launch' not in dir(m):
            log.error("Can't load POX module {}".format(name))
            raise RuntimeError('No launch function in module {}'.format(name))
        else:
            log.debug("Loading POX component {}".format(name))

            # FIXME: component launch needs some rework.
            # import pox.boot
            # pox.boot._do_launch([name])

            if m.launch.func_code.co_argcount == 0:
                m.launch()
            elif m.launch.func_code.co_argcount >= 1:
                m.launch(m.__dict__)

            log.debug("Loaded POX component {}".format(name))

    except ImportError,e:
        log.error("Error trying to import {} POX component".format(name))
        raise RuntimeError(str(e))


monkey_patch_pox()
load_pox_component("pox.openflow")

get_logger().debug("Kicking POX Up")
pox.core.core.goUp()
get_logger().debug("POX components: {}".format(pox.core.core.components))

from pox_bridge import *