src/emuvim/api/openstack/compute.py

   1 from mininet.link import Link
   2
   3 from resources import *
   4 from docker import DockerClient
   5 import logging
   6 import threading
   7 import uuid
   8 import time
   9 import ip_handler as IP
  10
  11
  12 LOG = logging.getLogger("api.openstack.compute")
  13
  14
  15 class HeatApiStackInvalidException(Exception):
  16     """
  17     Exception thrown when a submitted stack is invalid.
  18     """
  19
  20     def __init__(self, value):
  21         self.value = value
  22
  23     def __str__(self):
  24         return repr(self.value)
  25
  26
  27 class OpenstackCompute(object):
  28     """
  29     This class is a datacenter specific compute object that tracks all containers that are running in a datacenter,
  30     as well as networks and configured ports.
  31     It has some stack dependet logic and can check if a received stack is valid.
  32
  33     It also handles start and stop of containers.
  34     """
  35
  36     def __init__(self):
  37         self.dc = None
  38         self.stacks = dict()
  39         self.computeUnits = dict()
  40         self.routers = dict()
  41         self.flavors = dict()
  42         self._images = dict()
  43         self.nets = dict()
  44         self.ports = dict()
  45         self.port_pairs = dict()
  46         self.port_pair_groups = dict()
  47         self.flow_classifiers = dict()
  48         self.port_chains = dict()
  49         self.compute_nets = dict()
  50         self.dcli = DockerClient(base_url='unix://var/run/docker.sock')
  51
  52     @property
  53     def images(self):
  54         """
  55         Updates the known images. Asks the docker daemon for a list of all known images and returns
  56         the new dictionary.
  57
  58         :return: Returns the new image dictionary.
  59         :rtype: ``dict``
  60         """
  61         for image in self.dcli.images.list():
  62             if len(image.tags) > 0:
  63                 for t in image.tags:
  64                     t = t.replace(":latest", "")  # only use short tag names for OSM compatibility
  65                     if t not in self._images:
  66                         self._images[t] = Image(t)
  67         return self._images
  68
  69     def add_stack(self, stack):
  70         """
  71         Adds a new stack to the compute node.
  72
  73         :param stack: Stack dictionary.
  74         :type stack: :class:`heat.resources.stack`
  75         """
  76         if not self.check_stack(stack):
  77             self.clean_broken_stack(stack)
  78             raise HeatApiStackInvalidException("Stack did not pass validity checks")
  79         self.stacks[stack.id] = stack
  80
  81     def clean_broken_stack(self, stack):
  82         for port in stack.ports.values():
  83             if port.id in self.ports:
  84                 del self.ports[port.id]
  85         for server in stack.servers.values():
  86             if server.id in self.computeUnits:
  87                 del self.computeUnits[server.id]
  88         for net in stack.nets.values():
  89             if net.id in self.nets:
  90                 del self.nets[net.id]
  91
  92     def check_stack(self, stack):
  93         """
  94         Checks all dependencies of all servers, ports and routers and their most important parameters.
  95
  96         :param stack: A reference of the stack that should be checked.
  97         :type stack: :class:`heat.resources.stack`
  98         :return: * *True*: If the stack is completely fine.
  99          * *False*: Else
 100         :rtype: ``bool``
 101         """
 102         everything_ok = True
 103         for server in stack.servers.values():
 104             for port_name in server.port_names:
 105                 if port_name not in stack.ports:
 106                     LOG.warning("Server %s of stack %s has a port named %s that is not known." %
 107                                     (server.name, stack.stack_name, port_name))
 108                     everything_ok = False
 109             if server.image is None:
 110                 LOG.warning("Server %s holds no image." % (server.name))
 111                 everything_ok = False
 112             if server.command is None:
 113                 LOG.warning("Server %s holds no command." % (server.name))
 114                 everything_ok = False
 115         for port in stack.ports.values():
 116             if port.net_name not in stack.nets:
 117                 LOG.warning("Port %s of stack %s has a network named %s that is not known." %
 118                                 (port.name, stack.stack_name, port.net_name))
 119                 everything_ok = False
 120             if port.intf_name is None:
 121                 LOG.warning("Port %s has no interface name." % (port.name))
 122                 everything_ok = False
 123             if port.ip_address is None:
 124                 LOG.warning("Port %s has no IP address." % (port.name))
 125                 everything_ok = False
 126         for router in stack.routers.values():
 127             for subnet_name in router.subnet_names:
 128                 found = False
 129                 for net in stack.nets.values():
 130                     if net.subnet_name == subnet_name:
 131                         found = True
 132                         break
 133                 if not found:
 134                     LOG.warning("Router %s of stack %s has a network named %s that is not known." %
 135                                     (router.name, stack.stack_name, subnet_name))
 136                     everything_ok = False
 137         return everything_ok
 138
 139     def add_flavor(self, name, cpu, memory, memory_unit, storage, storage_unit):
 140         """
 141         Adds a flavor to the stack.
 142
 143         :param name: Specifies the name of the flavor.
 144         :type name: ``str``
 145         :param cpu:
 146         :type cpu: ``str``
 147         :param memory:
 148         :type memory: ``str``
 149         :param memory_unit:
 150         :type memory_unit: ``str``
 151         :param storage:
 152         :type storage: ``str``
 153         :param storage_unit:
 154         :type storage_unit: ``str``
 155         """
 156         flavor = InstanceFlavor(name, cpu, memory, memory_unit, storage, storage_unit)
 157         self.flavors[flavor.name] = flavor
 158         return flavor
 159
 160     def deploy_stack(self, stackid):
 161         """
 162         Deploys the stack and starts the emulation.
 163
 164         :param stackid: An UUID str of the stack
 165         :type stackid: ``str``
 166         :return: * *False*: If the Datacenter is None
 167             * *True*: Else
 168         :rtype: ``bool``
 169         """
 170         if self.dc is None:
 171             return False
 172
 173         stack = self.stacks[stackid]
 174         self.update_compute_dicts(stack)
 175
 176         # Create the networks first
 177         for server in stack.servers.values():
 178             self._start_compute(server)
 179         return True
 180
 181     def delete_stack(self, stack_id):
 182         """
 183         Delete a stack and all its components.
 184
 185         :param stack_id: An UUID str of the stack
 186         :type stack_id: ``str``
 187         :return: * *False*: If the Datacenter is None
 188             * *True*: Else
 189         :rtype: ``bool``
 190         """
 191         if self.dc is None:
 192             return False
 193
 194         # Stop all servers and their links of this stack
 195         for server in self.stacks[stack_id].servers.values():
 196             self.stop_compute(server)
 197             self.delete_server(server)
 198         for net in self.stacks[stack_id].nets.values():
 199             self.delete_network(net.id)
 200         for port in self.stacks[stack_id].ports.values():
 201             self.delete_port(port.id)
 202
 203         del self.stacks[stack_id]
 204         return True
 205
 206     def update_stack(self, old_stack_id, new_stack):
 207         """
 208         Determines differences within the old and the new stack and deletes, create or changes only parts that
 209         differ between the two stacks.
 210
 211         :param old_stack_id: The ID of the old stack.
 212         :type old_stack_id: ``str``
 213         :param new_stack: A reference of the new stack.
 214         :type new_stack: :class:`heat.resources.stack`
 215         :return: * *True*: if the old stack could be updated to the new stack without any error.
 216             * *False*: else
 217         :rtype: ``bool``
 218         """
 219         LOG.debug("updating stack {} with new_stack {}".format(old_stack_id, new_stack))
 220         if old_stack_id not in self.stacks:
 221             return False
 222         old_stack = self.stacks[old_stack_id]
 223
 224         # Update Stack IDs
 225         for server in old_stack.servers.values():
 226             if server.name in new_stack.servers:
 227                 new_stack.servers[server.name].id = server.id
 228         for net in old_stack.nets.values():
 229             if net.name in new_stack.nets:
 230                 new_stack.nets[net.name].id = net.id
 231                 for subnet in new_stack.nets.values():
 232                     if subnet.subnet_name == net.subnet_name:
 233                         subnet.subnet_id = net.subnet_id
 234                         break
 235         for port in old_stack.ports.values():
 236             if port.name in new_stack.ports:
 237                 new_stack.ports[port.name].id = port.id
 238         for router in old_stack.routers.values():
 239             if router.name in new_stack.routers:
 240                 new_stack.routers[router.name].id = router.id
 241
 242         # Update the compute dicts to now contain the new_stack components
 243         self.update_compute_dicts(new_stack)
 244
 245         self.update_ip_addresses(old_stack, new_stack)
 246
 247         # Update all interface names - after each port has the correct UUID!!
 248         for port in new_stack.ports.values():
 249             port.create_intf_name()
 250
 251         if not self.check_stack(new_stack):
 252             return False
 253
 254         # Remove unnecessary networks
 255         for net in old_stack.nets.values():
 256             if not net.name in new_stack.nets:
 257                 self.delete_network(net.id)
 258
 259         # Remove all unnecessary servers
 260         for server in old_stack.servers.values():
 261             if server.name in new_stack.servers:
 262                 if not server.compare_attributes(new_stack.servers[server.name]):
 263                     self.stop_compute(server)
 264                 else:
 265                     # Delete unused and changed links
 266                     for port_name in server.port_names:
 267                         if port_name in old_stack.ports and port_name in new_stack.ports:
 268                             if not old_stack.ports.get(port_name) == new_stack.ports.get(port_name):
 269                                 my_links = self.dc.net.links
 270                                 for link in my_links:
 271                                     if str(link.intf1) == old_stack.ports[port_name].intf_name and \
 272                                                     str(link.intf1.ip) == \
 273                                                     old_stack.ports[port_name].ip_address.split('/')[0]:
 274                                         self._remove_link(server.name, link)
 275
 276                                         # Add changed link
 277                                         self._add_link(server.name,
 278                                                        new_stack.ports[port_name].ip_address,
 279                                                        new_stack.ports[port_name].intf_name,
 280                                                        new_stack.ports[port_name].net_name)
 281                                         break
 282                         else:
 283                             my_links = self.dc.net.links
 284                             for link in my_links:
 285                                 if str(link.intf1) == old_stack.ports[port_name].intf_name and \
 286                                    str(link.intf1.ip) == old_stack.ports[port_name].ip_address.split('/')[0]:
 287                                     self._remove_link(server.name, link)
 288                                     break
 289
 290                     # Create new links
 291                     for port_name in new_stack.servers[server.name].port_names:
 292                         if port_name not in server.port_names:
 293                             self._add_link(server.name,
 294                                            new_stack.ports[port_name].ip_address,
 295                                            new_stack.ports[port_name].intf_name,
 296                                            new_stack.ports[port_name].net_name)
 297             else:
 298                 self.stop_compute(server)
 299
 300         # Start all new servers
 301         for server in new_stack.servers.values():
 302             if server.name not in self.dc.containers:
 303                 self._start_compute(server)
 304             else:
 305                 server.emulator_compute = self.dc.containers.get(server.name)
 306
 307         del self.stacks[old_stack_id]
 308         self.stacks[new_stack.id] = new_stack
 309         return True
 310
 311     def update_ip_addresses(self, old_stack, new_stack):
 312         """
 313         Updates the subnet and the port IP addresses - which should always be in this order!
 314
 315         :param old_stack: The currently running stack
 316         :type old_stack: :class:`heat.resources.stack`
 317         :param new_stack: The new created stack
 318         :type new_stack: :class:`heat.resources.stack`
 319         """
 320         self.update_subnet_cidr(old_stack, new_stack)
 321         self.update_port_addresses(old_stack, new_stack)
 322
 323     def update_port_addresses(self, old_stack, new_stack):
 324         """
 325         Updates the port IP addresses. First resets all issued addresses. Then get all IP addresses from the old
 326         stack and sets them to the same ports in the new stack. Finally all new or changed instances will get new
 327         IP addresses.
 328
 329         :param old_stack: The currently running stack
 330         :type old_stack: :class:`heat.resources.stack`
 331         :param new_stack: The new created stack
 332         :type new_stack: :class:`heat.resources.stack`
 333         """
 334         for net in new_stack.nets.values():
 335             net.reset_issued_ip_addresses()
 336
 337         for old_port in old_stack.ports.values():
 338             for port in new_stack.ports.values():
 339                 if port.compare_attributes(old_port):
 340                     for net in new_stack.nets.values():
 341                         if net.name == port.net_name:
 342                             if net.assign_ip_address(old_port.ip_address, port.name):
 343                                 port.ip_address = old_port.ip_address
 344                                 port.mac_address = old_port.mac_address
 345                             else:
 346                                 port.ip_address = net.get_new_ip_address(port.name)
 347
 348         for port in new_stack.ports.values():
 349             for net in new_stack.nets.values():
 350                 if port.net_name == net.name and not net.is_my_ip(port.ip_address, port.name):
 351                     port.ip_address = net.get_new_ip_address(port.name)
 352
 353     def update_subnet_cidr(self, old_stack, new_stack):
 354         """
 355         Updates the subnet IP addresses. If the new stack contains subnets from the old stack it will take those
 356         IP addresses. Otherwise it will create new IP addresses for the subnet.
 357
 358         :param old_stack: The currently running stack
 359         :type old_stack: :class:`heat.resources.stack`
 360         :param new_stack: The new created stack
 361         :type new_stack: :class:`heat.resources.stack`
 362         """
 363         for old_subnet in old_stack.nets.values():
 364             IP.free_cidr(old_subnet.get_cidr(), old_subnet.subnet_id)
 365
 366         for subnet in new_stack.nets.values():
 367             subnet.clear_cidr()
 368             for old_subnet in old_stack.nets.values():
 369                 if subnet.subnet_name == old_subnet.subnet_name:
 370                     if IP.assign_cidr(old_subnet.get_cidr(), subnet.subnet_id):
 371                         subnet.set_cidr(old_subnet.get_cidr())
 372
 373         for subnet in new_stack.nets.values():
 374             if IP.is_cidr_issued(subnet.get_cidr()):
 375                 continue
 376
 377             cird = IP.get_new_cidr(subnet.subnet_id)
 378             subnet.set_cidr(cird)
 379         return
 380
 381     def update_compute_dicts(self, stack):
 382         """
 383         Update and add all stack components tho the compute dictionaries.
 384
 385         :param stack: A stack reference, to get all required components.
 386         :type stack: :class:`heat.resources.stack`
 387         """
 388         for server in stack.servers.values():
 389             self.computeUnits[server.id] = server
 390             if isinstance(server.flavor, dict):
 391                 self.add_flavor(server.flavor['flavorName'],
 392                                 server.flavor['vcpu'],
 393                                 server.flavor['ram'], 'MB',
 394                                 server.flavor['storage'], 'GB')
 395                 server.flavor = server.flavor['flavorName']
 396         for router in stack.routers.values():
 397             self.routers[router.id] = router
 398         for net in stack.nets.values():
 399             self.nets[net.id] = net
 400         for port in stack.ports.values():
 401             self.ports[port.id] = port
 402
 403     def _start_compute(self, server):
 404         """
 405         Starts a new compute object (docker container) inside the emulator.
 406         Should only be called by stack modifications and not directly.
 407
 408         :param server: Specifies the compute resource.
 409         :type server: :class:`heat.resources.server`
 410         """
 411         LOG.debug("Starting new compute resources %s" % server.name)
 412         network = list()
 413
 414         for port_name in server.port_names:
 415             network_dict = dict()
 416             port = self.find_port_by_name_or_id(port_name)
 417             if port is not None:
 418                 network_dict['id'] = port.intf_name
 419                 network_dict['ip'] = port.ip_address
 420                 network_dict[network_dict['id']] = self.find_network_by_name_or_id(port.net_name).name
 421                 network.append(network_dict)
 422         self.compute_nets[server.name] = network
 423         c = self.dc.startCompute(server.name, image=server.image, command=server.command,
 424                                  network=network, flavor_name=server.flavor,
 425                                  properties=server.properties)
 426         server.emulator_compute = c
 427
 428         for intf in c.intfs.values():
 429             for port_name in server.port_names:
 430                 port = self.find_port_by_name_or_id(port_name)
 431                 if port is not None:
 432                     if intf.name == port.intf_name:
 433                         # wait up to one second for the intf to come up
 434                         self.timeout_sleep(intf.isUp, 1)
 435                         if port.mac_address is not None:
 436                             intf.setMAC(port.mac_address)
 437                         else:
 438                             port.mac_address = intf.MAC()
 439
 440         # Start the real emulator command now as specified in the dockerfile
 441         # ENV SON_EMU_CMD
 442         config = c.dcinfo.get("Config", dict())
 443         env = config.get("Env", list())
 444         for env_var in env:
 445             if "SON_EMU_CMD=" in env_var:
 446                 cmd = str(env_var.split("=")[1])
 447                 server.son_emu_command = cmd
 448                 # execute command in new thread to ensure that GK is not blocked by VNF
 449                 t = threading.Thread(target=c.cmdPrint, args=(cmd,))
 450                 t.daemon = True
 451                 t.start()
 452
 453     def stop_compute(self, server):
 454         """
 455         Determines which links should be removed before removing the server itself.
 456
 457         :param server: The server that should be removed
 458         :type server: ``heat.resources.server``
 459         """
 460         LOG.debug("Stopping container %s with full name %s" % (server.name, server.full_name))
 461         link_names = list()
 462         for port_name in server.port_names:
 463             link_names.append(self.find_port_by_name_or_id(port_name).intf_name)
 464         my_links = self.dc.net.links
 465         for link in my_links:
 466             if str(link.intf1) in link_names:
 467                 # Remove all self created links that connect the server to the main switch
 468                 self._remove_link(server.name, link)
 469
 470         # Stop the server and the remaining connection to the datacenter switch
 471         self.dc.stopCompute(server.name)
 472         # Only now delete all its ports and the server itself
 473         for port_name in server.port_names:
 474             self.delete_port(port_name)
 475         self.delete_server(server)
 476
 477     def find_server_by_name_or_id(self, name_or_id):
 478         """
 479         Tries to find the server by ID and if this does not succeed then tries to find it via name.
 480
 481         :param name_or_id: UUID or name of the server.
 482         :type name_or_id: ``str``
 483         :return: Returns the server reference if it was found or None
 484         :rtype: :class:`heat.resources.server`
 485         """
 486         if name_or_id in self.computeUnits:
 487             return self.computeUnits[name_or_id]
 488
 489         for server in self.computeUnits.values():
 490             if server.name == name_or_id or server.template_name == name_or_id or server.full_name == name_or_id:
 491                 return server
 492         return None
 493
 494     def create_server(self, name, stack_operation=False):
 495         """
 496         Creates a server with the specified name. Raises an exception when a server with the given name already
 497         exists!
 498
 499         :param name: Name of the new server.
 500         :type name: ``str``
 501         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 502         :type stack_operation: ``bool``
 503         :return: Returns the created server.
 504         :rtype: :class:`heat.resources.server`
 505         """
 506         if self.find_server_by_name_or_id(name) is not None and not stack_operation:
 507             raise Exception("Server with name %s already exists." % name)
 508         server = Server(name)
 509         server.id = str(uuid.uuid4())
 510         if not stack_operation:
 511             self.computeUnits[server.id] = server
 512         return server
 513
 514     def delete_server(self, server):
 515         """
 516         Deletes the given server from the stack dictionary and the computeUnits dictionary.
 517
 518         :param server: Reference of the server that should be deleted.
 519         :type server: :class:`heat.resources.server`
 520         :return: * *False*: If the server name is not in the correct format ('datacentername_stackname_servername') \
 521                 or when no stack with the correct stackname was found.
 522             * *True*: Else
 523         :rtype: ``bool``
 524         """
 525         if server is None:
 526             return False
 527         name_parts = server.name.split('_')
 528         if len(name_parts) < 3:
 529             return False
 530
 531         for stack in self.stacks.values():
 532             if stack.stack_name == name_parts[1]:
 533                 stack.servers.pop(server.id, None)
 534         if self.computeUnits.pop(server.id, None) is None:
 535             return False
 536         return True
 537
 538     def find_network_by_name_or_id(self, name_or_id):
 539         """
 540         Tries to find the network by ID and if this does not succeed then tries to find it via name.
 541
 542         :param name_or_id: UUID or name of the network.
 543         :type name_or_id: ``str``
 544         :return: Returns the network reference if it was found or None
 545         :rtype: :class:`heat.resources.net`
 546         """
 547         if name_or_id in self.nets:
 548             return self.nets[name_or_id]
 549         for net in self.nets.values():
 550             if net.name == name_or_id:
 551                 return net
 552
 553         return None
 554
 555     def create_network(self, name, stack_operation=False):
 556         """
 557         Creates a new network with the given name. Raises an exception when a network with the given name already
 558         exists!
 559
 560         :param name: Name of the new network.
 561         :type name: ``str``
 562         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 563         :type stack_operation: ``bool``
 564         :return: :class:`heat.resources.net`
 565         """
 566         LOG.debug("Creating network with name %s" % name)
 567         if self.find_network_by_name_or_id(name) is not None and not stack_operation:
 568             LOG.warning("Creating network with name %s failed, as it already exists" % name)
 569             raise Exception("Network with name %s already exists." % name)
 570         network = Net(name)
 571         network.id = str(uuid.uuid4())
 572         if not stack_operation:
 573             self.nets[network.id] = network
 574         return network
 575
 576     def delete_network(self, name_or_id):
 577         """
 578         Deletes the given network.
 579
 580         :param name_or_id: Name or UUID of the network.
 581         :type name_or_id: ``str``
 582         """
 583         net = self.find_network_by_name_or_id(name_or_id)
 584         if net is None:
 585             raise Exception("Network with name or id %s does not exists." % name_or_id)
 586
 587         for stack in self.stacks.values():
 588             stack.nets.pop(net.name, None)
 589
 590         self.nets.pop(net.id, None)
 591
 592     def create_port(self, name, stack_operation=False):
 593         """
 594         Creates a new port with the given name. Raises an exception when a port with the given name already
 595         exists!
 596
 597         :param name: Name of the new port.
 598         :type name: ``str``
 599         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 600         :type stack_operation: ``bool``
 601         :return: Returns the created port.
 602         :rtype: :class:`heat.resources.port`
 603         """
 604         port = self.find_port_by_name_or_id(name)
 605         if port is not None and not stack_operation:
 606             LOG.warning("Creating port with name %s failed, as it already exists" % name)
 607             raise Exception("Port with name %s already exists." % name)
 608         LOG.debug("Creating port with name %s" % name)
 609         port = Port(name)
 610         if not stack_operation:
 611             self.ports[port.id] = port
 612             port.create_intf_name()
 613         return port
 614
 615     def find_port_by_name_or_id(self, name_or_id):
 616         """
 617         Tries to find the port by ID and if this does not succeed then tries to find it via name.
 618
 619         :param name_or_id: UUID or name of the network.
 620         :type name_or_id: ``str``
 621         :return: Returns the port reference if it was found or None
 622         :rtype: :class:`heat.resources.port`
 623         """
 624         if name_or_id in self.ports:
 625             return self.ports[name_or_id]
 626         for port in self.ports.values():
 627             if port.name == name_or_id or port.template_name == name_or_id:
 628                 return port
 629
 630         return None
 631
 632     def delete_port(self, name_or_id):
 633         """
 634         Deletes the given port. Raises an exception when the port was not found!
 635
 636         :param name_or_id:  UUID or name of the port.
 637         :type name_or_id: ``str``
 638         """
 639         port = self.find_port_by_name_or_id(name_or_id)
 640         if port is None:
 641             raise Exception("Port with name or id %s does not exists." % name_or_id)
 642
 643         my_links = self.dc.net.links
 644         for link in my_links:
 645             if str(link.intf1) == port.intf_name and \
 646                             str(link.intf1.ip) == port.ip_address.split('/')[0]:
 647                 self._remove_link(link.intf1.node.name, link)
 648                 break
 649
 650         self.ports.pop(port.id, None)
 651         for stack in self.stacks.values():
 652             stack.ports.pop(port.name, None)
 653
 654     def create_port_pair(self, name, stack_operation=False):
 655         """
 656         Creates a new port pair with the given name. Raises an exception when a port pair with the given name already
 657         exists!
 658
 659         :param name: Name of the new port pair.
 660         :type name: ``str``
 661         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 662         :type stack_operation: ``bool``
 663         :return: Returns the created port pair.
 664         :rtype: :class:`openstack.resources.port_pair`
 665         """
 666         port_pair = self.find_port_pair_by_name_or_id(name)
 667         if port_pair is not None and not stack_operation:
 668             logging.warning("Creating port pair with name %s failed, as it already exists" % name)
 669             raise Exception("Port pair with name %s already exists." % name)
 670         logging.debug("Creating port pair with name %s" % name)
 671         port_pair = PortPair(name)
 672         if not stack_operation:
 673             self.port_pairs[port_pair.id] = port_pair
 674         return port_pair
 675
 676     def find_port_pair_by_name_or_id(self, name_or_id):
 677         """
 678         Tries to find the port pair by ID and if this does not succeed then tries to find it via name.
 679
 680         :param name_or_id: UUID or name of the port pair.
 681         :type name_or_id: ``str``
 682         :return: Returns the port pair reference if it was found or None
 683         :rtype: :class:`openstack.resources.port_pair`
 684         """
 685         if name_or_id in self.port_pairs:
 686             return self.port_pairs[name_or_id]
 687         for port_pair in self.port_pairs.values():
 688             if port_pair.name == name_or_id:
 689                 return port_pair
 690
 691         return None
 692
 693     def delete_port_pair(self, name_or_id):
 694         """
 695         Deletes the given port pair. Raises an exception when the port pair was not found!
 696
 697         :param name_or_id:  UUID or name of the port pair.
 698         :type name_or_id: ``str``
 699         """
 700         port_pair = self.find_port_pair_by_name_or_id(name_or_id)
 701         if port_pair is None:
 702             raise Exception("Port pair with name or id %s does not exists." % name_or_id)
 703
 704         self.port_pairs.pop(port_pair.id, None)
 705
 706     def create_port_pair_group(self, name, stack_operation=False):
 707         """
 708         Creates a new port pair group with the given name. Raises an exception when a port pair group
 709         with the given name already exists!
 710
 711         :param name: Name of the new port pair group.
 712         :type name: ``str``
 713         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 714         :type stack_operation: ``bool``
 715         :return: Returns the created port pair group .
 716         :rtype: :class:`openstack.resources.port_pair_group`
 717         """
 718         port_pair_group = self.find_port_pair_group_by_name_or_id(name)
 719         if port_pair_group is not None and not stack_operation:
 720             logging.warning("Creating port pair group with name %s failed, as it already exists" % name)
 721             raise Exception("Port pair group with name %s already exists." % name)
 722         logging.debug("Creating port pair group with name %s" % name)
 723         port_pair_group = PortPairGroup(name)
 724         if not stack_operation:
 725             self.port_pair_groups[port_pair_group.id] = port_pair_group
 726         return port_pair_group
 727
 728     def find_port_pair_group_by_name_or_id(self, name_or_id):
 729         """
 730         Tries to find the port pair group by ID and if this does not succeed then tries to find it via name.
 731
 732         :param name_or_id: UUID or name of the port pair group.
 733         :type name_or_id: ``str``
 734         :return: Returns the port pair group reference if it was found or None
 735         :rtype: :class:`openstack.resources.port_pair_group`
 736         """
 737         if name_or_id in self.port_pair_groups:
 738             return self.port_pair_groups[name_or_id]
 739         for port_pair_group in self.port_pair_groups.values():
 740             if port_pair_group.name == name_or_id:
 741                 return port_pair_group
 742
 743         return None
 744
 745     def delete_port_pair_group(self, name_or_id):
 746         """
 747         Deletes the given port pair group. Raises an exception when the port pair group was not found!
 748
 749         :param name_or_id:  UUID or name of the port pair group.
 750         :type name_or_id: ``str``
 751         """
 752         port_pair_group = self.find_port_pair_group_by_name_or_id(name_or_id)
 753         if port_pair_group is None:
 754             raise Exception("Port pair with name or id %s does not exists." % name_or_id)
 755
 756         self.port_pair_groups.pop(port_pair_group.id, None)
 757
 758     def create_port_chain(self, name, stack_operation=False):
 759         """
 760         Creates a new port chain with the given name. Raises an exception when a port chain with the given name already
 761         exists!
 762
 763         :param name: Name of the new port chain
 764         :type name: ``str``
 765         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 766         :type stack_operation: ``bool``
 767         :return: Returns the created port chain.
 768         :rtype: :class:`openstack.resources.port_chain.PortChain`
 769         """
 770         port_chain = self.find_port_chain_by_name_or_id(name)
 771         if port_chain is not None and not stack_operation:
 772             logging.warning("Creating port chain with name %s failed, as it already exists" % name)
 773             raise Exception("Port chain with name %s already exists." % name)
 774         logging.debug("Creating port chain with name %s" % name)
 775         port_chain = PortChain(name)
 776         if not stack_operation:
 777             self.port_chains[port_chain.id] = port_chain
 778         return port_chain
 779
 780     def find_port_chain_by_name_or_id(self, name_or_id):
 781         """
 782         Tries to find the port chain by ID and if this does not succeed then tries to find it via name.
 783
 784         :param name_or_id: UUID or name of the port chain.
 785         :type name_or_id: ``str``
 786         :return: Returns the port chain reference if it was found or None
 787         :rtype: :class:`openstack.resources.port_chain.PortChain`
 788         """
 789         if name_or_id in self.port_chains:
 790             return self.port_chains[name_or_id]
 791         for port_chain in self.port_chains.values():
 792             if port_chain.name == name_or_id:
 793                 return port_chain
 794         return None
 795
 796     def delete_port_chain(self, name_or_id):
 797         """
 798         Deletes the given port chain. Raises an exception when the port chain was not found!
 799
 800         :param name_or_id:  UUID or name of the port chain.
 801         :type name_or_id: ``str``
 802         """
 803         port_chain = self.find_port_chain_by_name_or_id(name_or_id)
 804         port_chain.uninstall(self)
 805         if port_chain is None:
 806             raise Exception("Port chain with name or id %s does not exists." % name_or_id)
 807
 808         self.port_chains.pop(port_chain.id, None)
 809
 810     def create_flow_classifier(self, name, stack_operation=False):
 811         """
 812         Creates a new flow classifier with the given name. Raises an exception when a flow classifier with the given name already
 813         exists!
 814
 815         :param name: Name of the new flow classifier.
 816         :type name: ``str``
 817         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 818         :type stack_operation: ``bool``
 819         :return: Returns the created flow classifier.
 820         :rtype: :class:`openstack.resources.flow_classifier`
 821         """
 822         flow_classifier = self.find_flow_classifier_by_name_or_id(name)
 823         if flow_classifier is not None and not stack_operation:
 824             logging.warning("Creating flow classifier with name %s failed, as it already exists" % name)
 825             raise Exception("Flow classifier with name %s already exists." % name)
 826         logging.debug("Creating flow classifier with name %s" % name)
 827         flow_classifier = FlowClassifier(name)
 828         if not stack_operation:
 829             self.flow_classifiers[flow_classifier.id] = flow_classifier
 830         return flow_classifier
 831
 832     def find_flow_classifier_by_name_or_id(self, name_or_id):
 833         """
 834         Tries to find the flow classifier by ID and if this does not succeed then tries to find it via name.
 835
 836         :param name_or_id: UUID or name of the flow classifier.
 837         :type name_or_id: ``str``
 838         :return: Returns the flow classifier reference if it was found or None
 839         :rtype: :class:`openstack.resources.flow_classifier`
 840         """
 841         if name_or_id in self.flow_classifiers:
 842             return self.flow_classifiers[name_or_id]
 843         for flow_classifier in self.flow_classifiers.values():
 844             if flow_classifier.name == name_or_id:
 845                 return flow_classifier
 846
 847         return None
 848
 849     def delete_flow_classifier(self, name_or_id):
 850         """
 851         Deletes the given flow classifier. Raises an exception when the flow classifier was not found!
 852
 853         :param name_or_id:  UUID or name of the flow classifier.
 854         :type name_or_id: ``str``
 855         """
 856         flow_classifier = self.find_flow_classifier_by_name_or_id(name_or_id)
 857         if flow_classifier is None:
 858             raise Exception("Flow classifier with name or id %s does not exists." % name_or_id)
 859
 860         self.flow_classifiers.pop(flow_classifier.id, None)
 861
 862     def _add_link(self, node_name, ip_address, link_name, net_name):
 863         """
 864         Adds a new link between datacenter switch and the node with the given name.
 865
 866         :param node_name: Name of the required node.
 867         :type node_name: ``str``
 868         :param ip_address: IP-Address of the node.
 869         :type ip_address: ``str``
 870         :param link_name: Link name.
 871         :type link_name: ``str``
 872         :param net_name: Network name.
 873         :type net_name: ``str``
 874         """
 875         node = self.dc.net.get(node_name)
 876         params = {'params1': {'ip': ip_address,
 877                               'id': link_name,
 878                               link_name: net_name},
 879                   'intfName1': link_name,
 880                   'cls': Link}
 881         link = self.dc.net.addLink(node, self.dc.switch, **params)
 882         OpenstackCompute.timeout_sleep(link.intf1.isUp, 1)
 883
 884     def _remove_link(self, server_name, link):
 885         """
 886         Removes a link between server and datacenter switch.
 887
 888         :param server_name: Specifies the server where the link starts.
 889         :type server_name: ``str``
 890         :param link: A reference of the link which should be removed.
 891         :type link: :class:`mininet.link`
 892         """
 893         self.dc.switch.detach(link.intf2)
 894         del self.dc.switch.intfs[self.dc.switch.ports[link.intf2]]
 895         del self.dc.switch.ports[link.intf2]
 896         del self.dc.switch.nameToIntf[link.intf2.name]
 897         self.dc.net.removeLink(link=link)
 898         for intf_key in self.dc.net[server_name].intfs.keys():
 899             if self.dc.net[server_name].intfs[intf_key].link == link:
 900                 self.dc.net[server_name].intfs[intf_key].delete()
 901                 del self.dc.net[server_name].intfs[intf_key]
 902
 903     @staticmethod
 904     def timeout_sleep(function, max_sleep):
 905         """
 906         This function will execute a function all 0.1 seconds until it successfully returns.
 907         Will return after `max_sleep` seconds if not successful.
 908
 909         :param function: The function to execute. Should return true if done.
 910         :type function: ``function``
 911         :param max_sleep: Max seconds to sleep. 1 equals 1 second.
 912         :type max_sleep: ``float``
 913         """
 914         current_time = time.time()
 915         stop_time = current_time + max_sleep
 916         while not function() and current_time < stop_time:
 917             current_time = time.time()
 918             time.sleep(0.1)