src/emuvim/dcemulator/net.py

   1 """
   2 Copyright (c) 2015 SONATA-NFV and Paderborn University
   3 ALL RIGHTS RESERVED.
   4
   5 Licensed under the Apache License, Version 2.0 (the "License");
   6 you may not use this file except in compliance with the License.
   7 You may obtain a copy of the License at
   8
   9     http://www.apache.org/licenses/LICENSE-2.0
  10
  11 Unless required by applicable law or agreed to in writing, software
  12 distributed under the License is distributed on an "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 See the License for the specific language governing permissions and
  15 limitations under the License.
  16
  17 Neither the name of the SONATA-NFV [, ANY ADDITIONAL AFFILIATION]
  18 nor the names of its contributors may be used to endorse or promote
  19 products derived from this software without specific prior written
  20 permission.
  21
  22 This work has been performed in the framework of the SONATA project,
  23 funded by the European Commission under Grant number 671517 through
  24 the Horizon 2020 and 5G-PPP programmes. The authors would like to
  25 acknowledge the contributions of their colleagues of the SONATA
  26 partner consortium (www.sonata-nfv.eu).
  27 """
  28 import logging
  29
  30 import site
  31 import time
  32 from subprocess import Popen
  33 import re
  34 import requests
  35 import os
  36
  37 from mininet.net import Containernet
  38 from mininet.node import Controller, DefaultController, OVSSwitch, OVSKernelSwitch, Docker, RemoteController
  39 from mininet.cli import CLI
  40 from mininet.link import TCLink
  41 from mininet.clean import cleanup
  42 import networkx as nx
  43 from emuvim.dcemulator.monitoring import DCNetworkMonitor
  44 from emuvim.dcemulator.node import Datacenter, EmulatorCompute
  45 from emuvim.dcemulator.resourcemodel import ResourceModelRegistrar
  46
  47 LOG = logging.getLogger("dcemulator.net")
  48 LOG.setLevel(logging.DEBUG)
  49
  50 # default CPU period used for cpu percentage-based cfs values (microseconds)
  51 CPU_PERIOD = 1000000
  52
  53 class DCNetwork(Containernet):
  54     """
  55     Wraps the original Mininet/Containernet class and provides
  56     methods to add data centers, switches, etc.
  57
  58     This class is used by topology definition scripts.
  59     """
  60
  61     def __init__(self, controller=RemoteController, monitor=False,
  62                  enable_learning=False, # learning switch behavior of the default ovs switches icw Ryu controller can be turned off/on, needed for E-LAN functionality
  63                  dc_emulation_max_cpu=1.0,  # fraction of overall CPU time for emulation
  64                  dc_emulation_max_mem=512,  # emulation max mem in MB
  65                  **kwargs):
  66         """
  67         Create an extended version of a Containernet network
  68         :param dc_emulation_max_cpu: max. CPU time used by containers in data centers
  69         :param kwargs: path through for Mininet parameters
  70         :return:
  71         """
  72         # members
  73         self.dcs = {}
  74         self.ryu_process = None
  75         #list of deployed nsds.E_Lines and E_LANs (uploaded from the dummy gatekeeper)
  76         self.deployed_nsds = []
  77         self.deployed_elines = []
  78         self.deployed_elans = []
  79         self.installed_chains = []
  80
  81
  82         # always cleanup environment before we start the emulator
  83         self.killRyu()
  84         cleanup()
  85
  86         # call original Docker.__init__ and setup default controller
  87         Containernet.__init__(
  88             self, switch=OVSKernelSwitch, controller=controller, **kwargs)
  89
  90         # default switch configuration
  91         enable_ryu_learning = False
  92         if enable_learning :
  93             self.failMode = 'standalone'
  94             enable_ryu_learning = True
  95         else:
  96             self.failMode = 'secure'
  97
  98         # Ryu management
  99         if controller == RemoteController:
 100             # start Ryu controller
 101             self.startRyu(learning_switch=enable_ryu_learning)
 102
 103         # add the specified controller
 104         self.addController('c0', controller=controller)
 105
 106         # graph of the complete DC network
 107         self.DCNetwork_graph = nx.MultiDiGraph()
 108
 109         # initialize pool of vlan tags to setup the SDN paths
 110         self.vlans = range(4096)[::-1]
 111
 112         # link to Ryu REST_API
 113         ryu_ip = 'localhost'
 114         ryu_port = '8080'
 115         self.ryu_REST_api = 'http://{0}:{1}'.format(ryu_ip, ryu_port)
 116         self.RyuSession = requests.Session()
 117
 118         # monitoring agent
 119         if monitor:
 120             self.monitor_agent = DCNetworkMonitor(self)
 121         else:
 122             self.monitor_agent = None
 123
 124         # initialize resource model registrar
 125         self.rm_registrar = ResourceModelRegistrar(
 126             dc_emulation_max_cpu, dc_emulation_max_mem)
 127         self.cpu_period = CPU_PERIOD
 128
 129     def addDatacenter(self, label, metadata={}, resource_log_path=None):
 130         """
 131         Create and add a logical cloud data center to the network.
 132         """
 133         if label in self.dcs:
 134             raise Exception("Data center label already exists: %s" % label)
 135         dc = Datacenter(label, metadata=metadata, resource_log_path=resource_log_path)
 136         dc.net = self  # set reference to network
 137         self.dcs[label] = dc
 138         dc.create()  # finally create the data center in our Mininet instance
 139         LOG.info("added data center: %s" % label)
 140         return dc
 141
 142     def addLink(self, node1, node2, **params):
 143         """
 144         Able to handle Datacenter objects as link
 145         end points.
 146         """
 147         assert node1 is not None
 148         assert node2 is not None
 149
 150         # ensure type of node1
 151         if isinstance( node1, basestring ):
 152             if node1 in self.dcs:
 153                 node1 = self.dcs[node1].switch
 154         if isinstance( node1, Datacenter ):
 155             node1 = node1.switch
 156         # ensure type of node2
 157         if isinstance( node2, basestring ):
 158             if node2 in self.dcs:
 159                 node2 = self.dcs[node2].switch
 160         if isinstance( node2, Datacenter ):
 161             node2 = node2.switch
 162         # try to give containers a default IP
 163         if isinstance( node1, Docker ):
 164             if "params1" not in params:
 165                 params["params1"] = {}
 166             if "ip" not in params["params1"]:
 167                 params["params1"]["ip"] = self.getNextIp()
 168         if isinstance( node2, Docker ):
 169             if "params2" not in params:
 170                 params["params2"] = {}
 171             if "ip" not in params["params2"]:
 172                 params["params2"]["ip"] = self.getNextIp()
 173         # ensure that we allow TCLinks between data centers
 174         # TODO this is not optimal, we use cls=Link for containers and TCLink for data centers
 175         # see Containernet issue: https://github.com/mpeuster/containernet/issues/3
 176         if "cls" not in params:
 177             params["cls"] = TCLink
 178
 179         link = Containernet.addLink(self, node1, node2, **params)
 180
 181         # try to give container interfaces a default id
 182         node1_port_id = node1.ports[link.intf1]
 183         if isinstance(node1, Docker):
 184             if "id" in params["params1"]:
 185                 node1_port_id = params["params1"]["id"]
 186         node1_port_name = link.intf1.name
 187
 188         node2_port_id = node2.ports[link.intf2]
 189         if isinstance(node2, Docker):
 190             if "id" in params["params2"]:
 191                 node2_port_id = params["params2"]["id"]
 192         node2_port_name = link.intf2.name
 193
 194
 195         # add edge and assigned port number to graph in both directions between node1 and node2
 196         # port_id: id given in descriptor (if available, otherwise same as port)
 197         # port: portnumber assigned by Containernet
 198
 199         attr_dict = {}
 200         # possible weight metrics allowed by TClink class:
 201         weight_metrics = ['bw', 'delay', 'jitter', 'loss']
 202         edge_attributes = [p for p in params if p in weight_metrics]
 203         for attr in edge_attributes:
 204             # if delay: strip ms (need number as weight in graph)
 205             match = re.search('([0-9]*\.?[0-9]+)', params[attr])
 206             if match:
 207                 attr_number = match.group(1)
 208             else:
 209                 attr_number = None
 210             attr_dict[attr] = attr_number
 211
 212
 213         attr_dict2 = {'src_port_id': node1_port_id, 'src_port_nr': node1.ports[link.intf1],
 214                       'src_port_name': node1_port_name,
 215                      'dst_port_id': node2_port_id, 'dst_port_nr': node2.ports[link.intf2],
 216                       'dst_port_name': node2_port_name}
 217         attr_dict2.update(attr_dict)
 218         self.DCNetwork_graph.add_edge(node1.name, node2.name, attr_dict=attr_dict2)
 219
 220         attr_dict2 = {'src_port_id': node2_port_id, 'src_port_nr': node2.ports[link.intf2],
 221                       'src_port_name': node2_port_name,
 222                      'dst_port_id': node1_port_id, 'dst_port_nr': node1.ports[link.intf1],
 223                       'dst_port_name': node1_port_name}
 224         attr_dict2.update(attr_dict)
 225         self.DCNetwork_graph.add_edge(node2.name, node1.name, attr_dict=attr_dict2)
 226
 227         LOG.debug("addLink: n1={0} intf1={1} -- n2={2} intf2={3}".format(
 228             str(node1),node1_port_name, str(node2), node2_port_name))
 229
 230         return link
 231
 232     def addDocker( self, label, **params ):
 233         """
 234         Wrapper for addDocker method to use custom container class.
 235         """
 236         self.DCNetwork_graph.add_node(label)
 237         return Containernet.addDocker(self, label, cls=EmulatorCompute, **params)
 238
 239     def removeDocker( self, label, **params ):
 240         """
 241         Wrapper for removeDocker method to update graph.
 242         """
 243         self.DCNetwork_graph.remove_node(label)
 244         return Containernet.removeDocker(self, label, **params)
 245
 246     def addSwitch( self, name, add_to_graph=True, **params ):
 247         """
 248         Wrapper for addSwitch method to store switch also in graph.
 249         """
 250
 251         # add this switch to the global topology overview
 252         if add_to_graph:
 253             self.DCNetwork_graph.add_node(name)
 254
 255         # set the learning switch behavior
 256         if 'failMode' in params :
 257             failMode = params['failMode']
 258         else :
 259             failMode = self.failMode
 260
 261         s = Containernet.addSwitch(self, name, protocols='OpenFlow10,OpenFlow12,OpenFlow13', failMode=failMode, **params)
 262
 263         # set flow entry that enables learning switch behavior (needed to enable E-LAN functionality)
 264         #LOG.info('failmode {0}'.format(failMode))
 265         #if failMode == 'standalone' :
 266         #    LOG.info('add NORMAL')
 267         #    s.dpctl('add-flow', 'actions=NORMAL')
 268
 269         return s
 270
 271     def getAllContainers(self):
 272         """
 273         Returns a list with all containers within all data centers.
 274         """
 275         all_containers = []
 276         for dc in self.dcs.itervalues():
 277             all_containers += dc.listCompute()
 278         return all_containers
 279
 280     def start(self):
 281         # start
 282         for dc in self.dcs.itervalues():
 283             dc.start()
 284         Containernet.start(self)
 285
 286     def stop(self):
 287
 288         # stop the monitor agent
 289         if self.monitor_agent is not None:
 290             self.monitor_agent.stop()
 291
 292         # stop emulator net
 293         Containernet.stop(self)
 294
 295         # stop Ryu controller
 296         self.killRyu()
 297
 298
 299     def CLI(self):
 300         CLI(self)
 301
 302     def setLAN(self, vnf_list):
 303         """
 304         setup an E-LAN network by assigning the same VLAN tag to each DC interface of the VNFs in the E-LAN
 305
 306         :param vnf_list: names of the VNFs in this E-LAN  [{name:,interface:},...]
 307         :return:
 308         """
 309         src_sw = None
 310         src_sw_inport_nr = 0
 311         src_sw_inport_name = None
 312
 313         # get a vlan tag for this E-LAN
 314         vlan = self.vlans.pop()
 315
 316         for vnf in vnf_list:
 317             vnf_src_name = vnf['name']
 318             vnf_src_interface = vnf['interface']
 319
 320             # check if port is specified (vnf:port)
 321             if vnf_src_interface is None:
 322                 # take first interface by default
 323                 connected_sw = self.DCNetwork_graph.neighbors(vnf_src_name)[0]
 324                 link_dict = self.DCNetwork_graph[vnf_src_name][connected_sw]
 325                 vnf_src_interface = link_dict[0]['src_port_id']
 326
 327             for connected_sw in self.DCNetwork_graph.neighbors(vnf_src_name):
 328                 link_dict = self.DCNetwork_graph[vnf_src_name][connected_sw]
 329                 for link in link_dict:
 330                     if (link_dict[link]['src_port_id'] == vnf_src_interface or
 331                                 link_dict[link]['src_port_name'] == vnf_src_interface):  # Fix: we might also get interface names, e.g, from a son-emu-cli call
 332                         # found the right link and connected switch
 333                         src_sw = connected_sw
 334                         src_sw_inport_nr = link_dict[link]['dst_port_nr']
 335                         src_sw_inport_name = link_dict[link]['dst_port_name']
 336                         break
 337
 338             # set the tag on the dc switch interface
 339             LOG.debug('set E-LAN: vnf name: {0} interface: {1} tag: {2}'.format(vnf_src_name, vnf_src_interface,vlan))
 340             switch_node = self.getNodeByName(src_sw)
 341             self._set_vlan_tag(switch_node, src_sw_inport_name, vlan)
 342
 343     def _addMonitorFlow(self, vnf_src_name, vnf_dst_name, vnf_src_interface=None, vnf_dst_interface=None,
 344                        tag=None, **kwargs):
 345         """
 346         Add a monitoring flow entry that adds a special flowentry/counter at the begin or end of a chain.
 347         So this monitoring flowrule exists on top of a previously defined chain rule and uses the same vlan tag/routing.
 348         :param vnf_src_name:
 349         :param vnf_dst_name:
 350         :param vnf_src_interface:
 351         :param vnf_dst_interface:
 352         :param tag: vlan tag to be used for this chain (same tag as existing chain)
 353         :param monitor_placement: 'tx' or 'rx' indicating to place the extra flowentry resp. at the beginning or end of the chain
 354         :return:
 355         """
 356
 357         src_sw = None
 358         src_sw_inport_nr = 0
 359         src_sw_inport_name = None
 360         dst_sw = None
 361         dst_sw_outport_nr = 0
 362         dst_sw_outport_name = None
 363
 364         LOG.debug("call AddMonitorFlow vnf_src_name=%r, vnf_src_interface=%r, vnf_dst_name=%r, vnf_dst_interface=%r",
 365                   vnf_src_name, vnf_src_interface, vnf_dst_name, vnf_dst_interface)
 366
 367         #check if port is specified (vnf:port)
 368         if vnf_src_interface is None:
 369             # take first interface by default
 370             connected_sw = self.DCNetwork_graph.neighbors(vnf_src_name)[0]
 371             link_dict = self.DCNetwork_graph[vnf_src_name][connected_sw]
 372             vnf_src_interface = link_dict[0]['src_port_id']
 373
 374         for connected_sw in self.DCNetwork_graph.neighbors(vnf_src_name):
 375             link_dict = self.DCNetwork_graph[vnf_src_name][connected_sw]
 376             for link in link_dict:
 377                 if (link_dict[link]['src_port_id'] == vnf_src_interface or
 378                         link_dict[link]['src_port_name'] == vnf_src_interface):  # Fix: we might also get interface names, e.g, from a son-emu-cli call
 379                     # found the right link and connected switch
 380                     src_sw = connected_sw
 381                     src_sw_inport_nr = link_dict[link]['dst_port_nr']
 382                     src_sw_inport_name = link_dict[link]['dst_port_name']
 383                     break
 384
 385         if vnf_dst_interface is None:
 386             # take first interface by default
 387             connected_sw = self.DCNetwork_graph.neighbors(vnf_dst_name)[0]
 388             link_dict = self.DCNetwork_graph[connected_sw][vnf_dst_name]
 389             vnf_dst_interface = link_dict[0]['dst_port_id']
 390
 391         vnf_dst_name = vnf_dst_name.split(':')[0]
 392         for connected_sw in self.DCNetwork_graph.neighbors(vnf_dst_name):
 393             link_dict = self.DCNetwork_graph[connected_sw][vnf_dst_name]
 394             for link in link_dict:
 395                 if link_dict[link]['dst_port_id'] == vnf_dst_interface or \
 396                         link_dict[link]['dst_port_name'] == vnf_dst_interface:  # Fix: we might also get interface names, e.g, from a son-emu-cli call
 397                     # found the right link and connected switch
 398                     dst_sw = connected_sw
 399                     dst_sw_outport_nr = link_dict[link]['src_port_nr']
 400                     dst_sw_outport_name = link_dict[link]['src_port_name']
 401                     break
 402
 403         if not tag >= 0:
 404             LOG.exception('tag not valid: {0}'.format(tag))
 405
 406         # get shortest path
 407         try:
 408             # returns the first found shortest path
 409             # if all shortest paths are wanted, use: all_shortest_paths
 410             path = nx.shortest_path(self.DCNetwork_graph, src_sw, dst_sw, weight=kwargs.get('weight'))
 411         except:
 412             LOG.exception("No path could be found between {0} and {1} using src_sw={2} and dst_sw={3}".format(
 413                 vnf_src_name, vnf_dst_name, src_sw, dst_sw))
 414             LOG.debug("Graph nodes: %r" % self.DCNetwork_graph.nodes())
 415             LOG.debug("Graph edges: %r" % self.DCNetwork_graph.edges())
 416             for e, v in self.DCNetwork_graph.edges():
 417                 LOG.debug("%r" % self.DCNetwork_graph[e][v])
 418             return "No path could be found between {0} and {1}".format(vnf_src_name, vnf_dst_name)
 419
 420         LOG.info("Path between {0} and {1}: {2}".format(vnf_src_name, vnf_dst_name, path))
 421
 422         current_hop = src_sw
 423         switch_inport_nr = src_sw_inport_nr
 424
 425         cmd = kwargs.get('cmd')
 426
 427         #iterate through the path to install the flow-entries
 428         for i in range(0,len(path)):
 429             current_node = self.getNodeByName(current_hop)
 430
 431             if path.index(current_hop) < len(path)-1:
 432                 next_hop = path[path.index(current_hop)+1]
 433             else:
 434                 #last switch reached
 435                 next_hop = vnf_dst_name
 436
 437             next_node = self.getNodeByName(next_hop)
 438
 439             if next_hop == vnf_dst_name:
 440                 switch_outport_nr = dst_sw_outport_nr
 441                 LOG.info("end node reached: {0}".format(vnf_dst_name))
 442             elif not isinstance( next_node, OVSSwitch ):
 443                 LOG.info("Next node: {0} is not a switch".format(next_hop))
 444                 return "Next node: {0} is not a switch".format(next_hop)
 445             else:
 446                 # take first link between switches by default
 447                 index_edge_out = 0
 448                 switch_outport_nr = self.DCNetwork_graph[current_hop][next_hop][index_edge_out]['src_port_nr']
 449
 450
 451            # set of entry via ovs-ofctl
 452             if isinstance( current_node, OVSSwitch ):
 453                 kwargs['vlan'] = tag
 454                 kwargs['path'] = path
 455                 kwargs['current_hop'] = current_hop
 456                 kwargs['switch_inport_name'] = src_sw_inport_name
 457                 kwargs['switch_outport_name'] = dst_sw_outport_name
 458                 kwargs['skip_vlan_tag'] = True
 459
 460                 monitor_placement = kwargs.get('monitor_placement').strip()
 461                 # put monitor flow at the dst switch
 462                 insert_flow = False
 463                 if monitor_placement == 'tx' and path.index(current_hop) == 0:  # first node:
 464                     insert_flow = True
 465                 # put monitoring flow at the src switch
 466                 elif monitor_placement == 'rx' and path.index(current_hop) == len(path) - 1:  # last node:
 467                     insert_flow = True
 468                 elif monitor_placement not in ['rx', 'tx']:
 469                     LOG.exception('invalid monitor command: {0}'.format(monitor_placement))
 470
 471
 472                 if self.controller == RemoteController and insert_flow:
 473                     ## set flow entry via ryu rest api
 474                     self._set_flow_entry_ryu_rest(current_node, switch_inport_nr, switch_outport_nr, **kwargs)
 475                     break
 476                 elif insert_flow:
 477                     ## set flow entry via ovs-ofctl
 478                     self._set_flow_entry_dpctl(current_node, switch_inport_nr, switch_outport_nr, **kwargs)
 479                     break
 480
 481             # take first link between switches by default
 482             if isinstance( next_node, OVSSwitch ):
 483                 switch_inport_nr = self.DCNetwork_graph[current_hop][next_hop][0]['dst_port_nr']
 484                 current_hop = next_hop
 485
 486         return "path {2} between {0} and {1}".format(vnf_src_name, vnf_dst_name, cmd)
 487
 488
 489     def setChain(self, vnf_src_name, vnf_dst_name, vnf_src_interface=None, vnf_dst_interface=None, **kwargs):
 490         """
 491         Chain 2 vnf interfaces together by installing the flowrules in the switches along their path.
 492         Currently the path is found using the default networkx shortest path function.
 493         Each chain gets a unique vlan id , so different chains wil not interfere.
 494
 495         :param vnf_src_name: vnf name (string)
 496         :param vnf_dst_name: vnf name (string)
 497         :param vnf_src_interface: source interface name  (string)
 498         :param vnf_dst_interface: destination interface name  (string)
 499         :param cmd: 'add-flow' (default) to add a chain, 'del-flows' to remove a chain
 500         :param cookie: cookie for the installed flowrules (can be used later as identifier for a set of installed chains)
 501         :param match: custom match entry to be added to the flowrules (default: only in_port and vlan tag)
 502         :param priority: custom flowrule priority
 503         :param monitor: boolean to indicate whether this chain is a monitoring chain
 504         :param tag: vlan tag to be used for this chain (pre-defined or new one if none is specified)
 505         :return: output log string
 506         """
 507
 508         # special procedure for monitoring flows
 509         if kwargs.get('monitor'):
 510
 511             # check if chain already exists
 512             found_chains = [chain_dict for chain_dict in self.installed_chains if
 513              (chain_dict['vnf_src_name'] == vnf_src_name and chain_dict['vnf_src_interface'] == vnf_src_interface
 514              and chain_dict['vnf_dst_name'] == vnf_dst_name and chain_dict['vnf_dst_interface'] == vnf_dst_interface)]
 515
 516             if len(found_chains) > 0:
 517                 # this chain exists, so need an extra monitoring flow
 518                 # assume only 1 chain per vnf/interface pair
 519                 LOG.debug('*** installing monitoring chain on top of pre-defined chain from {0}:{1} -> {2}:{3}'.
 520                             format(vnf_src_name, vnf_src_interface, vnf_dst_name, vnf_dst_interface))
 521                 tag = found_chains[0]['tag']
 522                 ret = self._addMonitorFlow(vnf_src_name, vnf_dst_name, vnf_src_interface, vnf_dst_interface,
 523                                      tag=tag, table_id=0, **kwargs)
 524                 return ret
 525             else:
 526                 # no chain existing (or E-LAN) -> install normal chain
 527                 LOG.warning('*** installing monitoring chain without pre-defined NSD chain from {0}:{1} -> {2}:{3}'.
 528                             format(vnf_src_name, vnf_src_interface, vnf_dst_name, vnf_dst_interface))
 529                 pass
 530
 531
 532         cmd = kwargs.get('cmd')
 533         if cmd == 'add-flow' or cmd == 'del-flows':
 534             ret = self._chainAddFlow(vnf_src_name, vnf_dst_name, vnf_src_interface, vnf_dst_interface, **kwargs)
 535             if kwargs.get('bidirectional'):
 536                 ret = ret +'\n' + self._chainAddFlow(vnf_dst_name, vnf_src_name, vnf_dst_interface, vnf_src_interface, **kwargs)
 537
 538         else:
 539             ret = "Command unknown"
 540
 541         return ret
 542
 543
 544     def _chainAddFlow(self, vnf_src_name, vnf_dst_name, vnf_src_interface=None, vnf_dst_interface=None, **kwargs):
 545
 546         src_sw = None
 547         src_sw_inport_nr = 0
 548         src_sw_inport_name = None
 549         dst_sw = None
 550         dst_sw_outport_nr = 0
 551         dst_sw_outport_name = None
 552
 553         LOG.debug("call chainAddFlow vnf_src_name=%r, vnf_src_interface=%r, vnf_dst_name=%r, vnf_dst_interface=%r",
 554                   vnf_src_name, vnf_src_interface, vnf_dst_name, vnf_dst_interface)
 555
 556         #check if port is specified (vnf:port)
 557         if vnf_src_interface is None:
 558             # take first interface by default
 559             connected_sw = self.DCNetwork_graph.neighbors(vnf_src_name)[0]
 560             link_dict = self.DCNetwork_graph[vnf_src_name][connected_sw]
 561             vnf_src_interface = link_dict[0]['src_port_id']
 562
 563         for connected_sw in self.DCNetwork_graph.neighbors(vnf_src_name):
 564             link_dict = self.DCNetwork_graph[vnf_src_name][connected_sw]
 565             for link in link_dict:
 566                 if (link_dict[link]['src_port_id'] == vnf_src_interface or
 567                         link_dict[link]['src_port_name'] == vnf_src_interface):  # Fix: we might also get interface names, e.g, from a son-emu-cli call
 568                     # found the right link and connected switch
 569                     src_sw = connected_sw
 570                     src_sw_inport_nr = link_dict[link]['dst_port_nr']
 571                     src_sw_inport_name = link_dict[link]['dst_port_name']
 572                     break
 573
 574         if vnf_dst_interface is None:
 575             # take first interface by default
 576             connected_sw = self.DCNetwork_graph.neighbors(vnf_dst_name)[0]
 577             link_dict = self.DCNetwork_graph[connected_sw][vnf_dst_name]
 578             vnf_dst_interface = link_dict[0]['dst_port_id']
 579
 580         vnf_dst_name = vnf_dst_name.split(':')[0]
 581         for connected_sw in self.DCNetwork_graph.neighbors(vnf_dst_name):
 582             link_dict = self.DCNetwork_graph[connected_sw][vnf_dst_name]
 583             for link in link_dict:
 584                 if link_dict[link]['dst_port_id'] == vnf_dst_interface or \
 585                         link_dict[link]['dst_port_name'] == vnf_dst_interface:  # Fix: we might also get interface names, e.g, from a son-emu-cli call
 586                     # found the right link and connected switch
 587                     dst_sw = connected_sw
 588                     dst_sw_outport_nr = link_dict[link]['src_port_nr']
 589                     dst_sw_outport_name = link_dict[link]['src_port_name']
 590                     break
 591
 592
 593         # get shortest path
 594         try:
 595             # returns the first found shortest path
 596             # if all shortest paths are wanted, use: all_shortest_paths
 597             path = nx.shortest_path(self.DCNetwork_graph, src_sw, dst_sw, weight=kwargs.get('weight'))
 598         except:
 599             LOG.exception("No path could be found between {0} and {1} using src_sw={2} and dst_sw={3}".format(
 600                 vnf_src_name, vnf_dst_name, src_sw, dst_sw))
 601             LOG.debug("Graph nodes: %r" % self.DCNetwork_graph.nodes())
 602             LOG.debug("Graph edges: %r" % self.DCNetwork_graph.edges())
 603             for e, v in self.DCNetwork_graph.edges():
 604                 LOG.debug("%r" % self.DCNetwork_graph[e][v])
 605             return "No path could be found between {0} and {1}".format(vnf_src_name, vnf_dst_name)
 606
 607         LOG.info("Path between {0} and {1}: {2}".format(vnf_src_name, vnf_dst_name, path))
 608
 609         current_hop = src_sw
 610         switch_inport_nr = src_sw_inport_nr
 611
 612         # choose free vlan
 613         ## if path contains more than 1 switch
 614         cmd = kwargs.get('cmd')
 615         vlan = None
 616         if cmd == 'add-flow':
 617             if kwargs.get('tag'):
 618                 # use pre-defined tag
 619                 vlan = kwargs.get('tag')
 620             else:
 621                 vlan = self.vlans.pop()
 622
 623         # store the used vlan tag to identify this chain
 624         if not kwargs.get('monitor'):
 625             chain_dict = {}
 626             chain_dict['vnf_src_name'] = vnf_src_name
 627             chain_dict['vnf_dst_name'] = vnf_dst_name
 628             chain_dict['vnf_src_interface'] = vnf_src_interface
 629             chain_dict['vnf_dst_interface'] = vnf_dst_interface
 630             chain_dict['tag'] = vlan
 631             self.installed_chains.append(chain_dict)
 632
 633         #iterate through the path to install the flow-entries
 634         for i in range(0,len(path)):
 635             current_node = self.getNodeByName(current_hop)
 636
 637             if path.index(current_hop) < len(path)-1:
 638                 next_hop = path[path.index(current_hop)+1]
 639             else:
 640                 #last switch reached
 641                 next_hop = vnf_dst_name
 642
 643             next_node = self.getNodeByName(next_hop)
 644
 645             if next_hop == vnf_dst_name:
 646                 switch_outport_nr = dst_sw_outport_nr
 647                 LOG.info("end node reached: {0}".format(vnf_dst_name))
 648             elif not isinstance( next_node, OVSSwitch ):
 649                 LOG.info("Next node: {0} is not a switch".format(next_hop))
 650                 return "Next node: {0} is not a switch".format(next_hop)
 651             else:
 652                 # take first link between switches by default
 653                 index_edge_out = 0
 654                 switch_outport_nr = self.DCNetwork_graph[current_hop][next_hop][index_edge_out]['src_port_nr']
 655
 656
 657            # set of entry via ovs-ofctl
 658             if isinstance( current_node, OVSSwitch ):
 659                 kwargs['vlan'] = vlan
 660                 kwargs['path'] = path
 661                 kwargs['current_hop'] = current_hop
 662                 kwargs['switch_inport_name'] = src_sw_inport_name
 663                 kwargs['switch_outport_name'] = dst_sw_outport_name
 664
 665                 if self.controller == RemoteController:
 666                     ## set flow entry via ryu rest api
 667                     self._set_flow_entry_ryu_rest(current_node, switch_inport_nr, switch_outport_nr, **kwargs)
 668                 else:
 669                     ## set flow entry via ovs-ofctl
 670                     self._set_flow_entry_dpctl(current_node, switch_inport_nr, switch_outport_nr, **kwargs)
 671
 672             # take first link between switches by default
 673             if isinstance( next_node, OVSSwitch ):
 674                 switch_inport_nr = self.DCNetwork_graph[current_hop][next_hop][0]['dst_port_nr']
 675                 current_hop = next_hop
 676
 677         return "path {2} between {0} and {1}".format(vnf_src_name, vnf_dst_name, cmd)
 678
 679     def _set_flow_entry_ryu_rest(self, node, switch_inport_nr, switch_outport_nr, **kwargs):
 680         match = 'in_port=%s' % switch_inport_nr
 681
 682         cookie = kwargs.get('cookie')
 683         match_input = kwargs.get('match')
 684         cmd = kwargs.get('cmd')
 685         path = kwargs.get('path')
 686         current_hop = kwargs.get('current_hop')
 687         vlan = kwargs.get('vlan')
 688         priority = kwargs.get('priority')
 689         # flag to not set the ovs port vlan tag
 690         skip_vlan_tag = kwargs.get('skip_vlan_tag')
 691         # table id to put this flowentry
 692         table_id = kwargs.get('table_id')
 693         if not table_id:
 694             table_id = 0
 695
 696         s = ','
 697         if match_input:
 698             match = s.join([match, match_input])
 699
 700         flow = {}
 701         flow['dpid'] = int(node.dpid, 16)
 702
 703         if cookie:
 704             flow['cookie'] = int(cookie)
 705         if priority:
 706             flow['priority'] = int(priority)
 707
 708         flow['table_id'] = table_id
 709
 710         flow['actions'] = []
 711
 712         # possible Ryu actions, match fields:
 713         # http://ryu.readthedocs.io/en/latest/app/ofctl_rest.html#add-a-flow-entry
 714         if cmd == 'add-flow':
 715             prefix = 'stats/flowentry/add'
 716             if vlan != None:
 717                 if path.index(current_hop) == 0:  # first node
 718                     # set vlan tag in ovs instance (to isolate E-LANs)
 719                     if not skip_vlan_tag:
 720                         in_port_name = kwargs.get('switch_inport_name')
 721                         self._set_vlan_tag(node, in_port_name, vlan)
 722                     # set vlan push action if more than 1 switch in the path
 723                     if len(path) > 1:
 724                         action = {}
 725                         action['type'] = 'PUSH_VLAN'  # Push a new VLAN tag if a input frame is non-VLAN-tagged
 726                         action['ethertype'] = 33024   # Ethertype 0x8100(=33024): IEEE 802.1Q VLAN-tagged frame
 727                         flow['actions'].append(action)
 728                         action = {}
 729                         action['type'] = 'SET_FIELD'
 730                         action['field'] = 'vlan_vid'
 731                         action['value'] = vlan
 732                         flow['actions'].append(action)
 733
 734                 if path.index(current_hop) == len(path) - 1:  # last node
 735                     # set vlan tag in ovs instance (to isolate E-LANs)
 736                     if not skip_vlan_tag:
 737                         out_port_name = kwargs.get('switch_outport_name')
 738                         self._set_vlan_tag(node, out_port_name, vlan)
 739                     # set vlan pop action if more than 1 switch in the path
 740                     if len(path) > 1:
 741                         match += ',dl_vlan=%s' % vlan
 742                         action = {}
 743                         action['type'] = 'POP_VLAN'
 744                         flow['actions'].append(action)
 745
 746                 if 0 < path.index(current_hop) < (len(path) - 1):  # middle nodes
 747                     match += ',dl_vlan=%s' % vlan
 748
 749             # output action must come last
 750             action = {}
 751             action['type'] = 'OUTPUT'
 752             action['port'] = switch_outport_nr
 753             flow['actions'].append(action)
 754
 755         elif cmd == 'del-flows':
 756             prefix = 'stats/flowentry/delete'
 757
 758             if cookie:
 759                 # TODO: add cookie_mask as argument
 760                 flow['cookie_mask'] = int('0xffffffffffffffff', 16)  # need full mask to match complete cookie
 761
 762             action = {}
 763             action['type'] = 'OUTPUT'
 764             action['port'] = switch_outport_nr
 765             flow['actions'].append(action)
 766
 767         flow['match'] = self._parse_match(match)
 768         self.ryu_REST(prefix, data=flow)
 769
 770     def _set_vlan_tag(self, node, switch_port, tag):
 771         node.vsctl('set', 'port {0} tag={1}'.format(switch_port,tag))
 772         LOG.debug("set vlan in switch: {0} in_port: {1} vlan tag: {2}".format(node.name, switch_port, tag))
 773
 774     def _set_flow_entry_dpctl(self, node, switch_inport_nr, switch_outport_nr, **kwargs):
 775
 776         match = 'in_port=%s' % switch_inport_nr
 777
 778         cookie = kwargs.get('cookie')
 779         match_input = kwargs.get('match')
 780         cmd = kwargs.get('cmd')
 781         path = kwargs.get('path')
 782         current_hop = kwargs.get('current_hop')
 783         vlan = kwargs.get('vlan')
 784
 785         s = ','
 786         if cookie:
 787             cookie = 'cookie=%s' % cookie
 788             match = s.join([cookie, match])
 789         if match_input:
 790             match = s.join([match, match_input])
 791         if cmd == 'add-flow':
 792             action = 'action=%s' % switch_outport_nr
 793             if vlan != None:
 794                 if path.index(current_hop) == 0:  # first node
 795                     action = ('action=mod_vlan_vid:%s' % vlan) + (',output=%s' % switch_outport_nr)
 796                     match = '-O OpenFlow13 ' + match
 797                 elif path.index(current_hop) == len(path) - 1:  # last node
 798                     match += ',dl_vlan=%s' % vlan
 799                     action = 'action=strip_vlan,output=%s' % switch_outport_nr
 800                 else:  # middle nodes
 801                     match += ',dl_vlan=%s' % vlan
 802             ofcmd = s.join([match, action])
 803         elif cmd == 'del-flows':
 804             ofcmd = match
 805         else:
 806             ofcmd = ''
 807
 808         node.dpctl(cmd, ofcmd)
 809         LOG.info("{3} in switch: {0} in_port: {1} out_port: {2}".format(node.name, switch_inport_nr,
 810                                                                                  switch_outport_nr, cmd))
 811
 812     # start Ryu Openflow controller as Remote Controller for the DCNetwork
 813     def startRyu(self, learning_switch=True):
 814         # start Ryu controller with rest-API
 815         python_install_path = site.getsitepackages()[0]
 816         # ryu default learning switch
 817         #ryu_path = python_install_path + '/ryu/app/simple_switch_13.py'
 818         #custom learning switch that installs a default NORMAL action in the ovs switches
 819         dir_path = os.path.dirname(os.path.realpath(__file__))
 820         ryu_path = dir_path + '/son_emu_simple_switch_13.py'
 821         ryu_path2 = python_install_path + '/ryu/app/ofctl_rest.py'
 822         # change the default Openflow controller port to 6653 (official IANA-assigned port number), as used by Mininet
 823         # Ryu still uses 6633 as default
 824         ryu_option = '--ofp-tcp-listen-port'
 825         ryu_of_port = '6653'
 826         ryu_cmd = 'ryu-manager'
 827         FNULL = open("/tmp/ryu.log", 'w')
 828         if learning_switch:
 829             self.ryu_process = Popen([ryu_cmd, ryu_path, ryu_path2, ryu_option, ryu_of_port], stdout=FNULL, stderr=FNULL)
 830             LOG.debug('starting ryu-controller with {0}'.format(ryu_path))
 831             LOG.debug('starting ryu-controller with {0}'.format(ryu_path2))
 832         else:
 833             # no learning switch, but with rest api
 834             self.ryu_process = Popen([ryu_cmd, ryu_path2, ryu_option, ryu_of_port], stdout=FNULL, stderr=FNULL)
 835             LOG.debug('starting ryu-controller with {0}'.format(ryu_path2))
 836         time.sleep(1)
 837
 838     def killRyu(self):
 839         """
 840         Stop the Ryu controller that might be started by son-emu.
 841         :return:
 842         """
 843         # try it nicely
 844         if self.ryu_process is not None:
 845             self.ryu_process.terminate()
 846             self.ryu_process.kill()
 847         # ensure its death ;-)
 848         Popen(['pkill', '-f', 'ryu-manager'])
 849
 850     def ryu_REST(self, prefix, dpid=None, data=None):
 851
 852         if dpid:
 853             url = self.ryu_REST_api + '/' + str(prefix) + '/' + str(dpid)
 854         else:
 855             url = self.ryu_REST_api + '/' + str(prefix)
 856         if data:
 857             req = self.RyuSession.post(url, json=data)
 858         else:
 859             req = self.RyuSession.get(url)
 860
 861
 862         # do extra logging if status code is not 200 (OK)
 863         if req.status_code is not requests.codes.ok:
 864             logging.info(
 865                 'type {0}  encoding: {1} text: {2} headers: {3} history: {4}'.format(req.headers['content-type'],
 866                                                                                      req.encoding, req.text,
 867                                                                                      req.headers, req.history))
 868             LOG.info('url: {0}'.format(str(url)))
 869             if data: LOG.info('POST: {0}'.format(str(data)))
 870             LOG.info('status: {0} reason: {1}'.format(req.status_code, req.reason))
 871
 872
 873         if 'json' in req.headers['content-type']:
 874             ret = req.json()
 875             return ret
 876
 877         ret = req.text.rstrip()
 878         return ret
 879
 880
 881     # need to respect that some match fields must be integers
 882     # http://ryu.readthedocs.io/en/latest/app/ofctl_rest.html#description-of-match-and-actions
 883     def _parse_match(self, match):
 884         matches = match.split(',')
 885         dict = {}
 886         for m in matches:
 887             match = m.split('=')
 888             if len(match) == 2:
 889                 try:
 890                     m2 = int(match[1], 0)
 891                 except:
 892                     m2 = match[1]
 893
 894                 dict.update({match[0]:m2})
 895         return dict
 896
 897     def find_connected_dc_interface(self, vnf_src_name, vnf_src_interface):
 898         for connected_sw in self.DCNetwork_graph.neighbors(vnf_src_name):
 899             link_dict = self.DCNetwork_graph[vnf_src_name][connected_sw]
 900             for link in link_dict:
 901                 if (link_dict[link]['src_port_id'] == vnf_src_interface or
 902                         link_dict[link]['src_port_name'] == vnf_src_interface):  # Fix: we might also get interface names, e.g, from a son-emu-cli call
 903                     # found the right link and connected switch
 904                     src_sw = connected_sw
 905                     src_sw_inport_nr = link_dict[link]['dst_port_nr']
 906                     src_sw_inport_name = link_dict[link]['dst_port_name']
 907                     return src_sw_inport_name