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         if self._shorten_server_name(name_or_id) in self.computeUnits:
 490             return self.computeUnits[name_or_id]
 491
 492         for server in self.computeUnits.values():
 493             if server.name == name_or_id or server.template_name == name_or_id or server.full_name == name_or_id:
 494                 return server
 495             if (server.name == self._shorten_server_name(name_or_id)
 496                 or server.template_name ==  self._shorten_server_name(name_or_id)
 497                 or server.full_name == self._shorten_server_name(name_or_id)):
 498                 return server
 499         return None
 500
 501     def create_server(self, name, stack_operation=False):
 502         """
 503         Creates a server with the specified name. Raises an exception when a server with the given name already
 504         exists!
 505
 506         :param name: Name of the new server.
 507         :type name: ``str``
 508         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 509         :type stack_operation: ``bool``
 510         :return: Returns the created server.
 511         :rtype: :class:`heat.resources.server`
 512         """
 513         if self.find_server_by_name_or_id(name) is not None and not stack_operation:
 514             raise Exception("Server with name %s already exists." % name)
 515         safe_name = self._shorten_server_name(name)
 516         server = Server(safe_name)
 517         server.id = str(uuid.uuid4())
 518         if not stack_operation:
 519             self.computeUnits[server.id] = server
 520         return server
 521
 522     def _shorten_server_name(self, name, char_limit=64):
 523         """
 524         Docker does not like too long instance names.
 525         This function provides a shorter name if needed
 526         """
 527         LOG.debug("Long server name: {}".format(name))
 528         if len(name) > char_limit:
 529             # construct a short name
 530             name = name[-char_limit:].strip("-_ .")
 531         LOG.debug("Short server name: {}".format(name))
 532         return name
 533
 534     def delete_server(self, server):
 535         """
 536         Deletes the given server from the stack dictionary and the computeUnits dictionary.
 537
 538         :param server: Reference of the server that should be deleted.
 539         :type server: :class:`heat.resources.server`
 540         :return: * *False*: If the server name is not in the correct format ('datacentername_stackname_servername') \
 541                 or when no stack with the correct stackname was found.
 542             * *True*: Else
 543         :rtype: ``bool``
 544         """
 545         if server is None:
 546             return False
 547         name_parts = server.name.split('_')
 548         if len(name_parts) < 3:
 549             return False
 550
 551         for stack in self.stacks.values():
 552             if stack.stack_name == name_parts[1]:
 553                 stack.servers.pop(server.id, None)
 554         if self.computeUnits.pop(server.id, None) is None:
 555             return False
 556         return True
 557
 558     def find_network_by_name_or_id(self, name_or_id):
 559         """
 560         Tries to find the network by ID and if this does not succeed then tries to find it via name.
 561
 562         :param name_or_id: UUID or name of the network.
 563         :type name_or_id: ``str``
 564         :return: Returns the network reference if it was found or None
 565         :rtype: :class:`heat.resources.net`
 566         """
 567         if name_or_id in self.nets:
 568             return self.nets[name_or_id]
 569         for net in self.nets.values():
 570             if net.name == name_or_id:
 571                 return net
 572
 573         return None
 574
 575     def create_network(self, name, stack_operation=False):
 576         """
 577         Creates a new network with the given name. Raises an exception when a network with the given name already
 578         exists!
 579
 580         :param name: Name of the new network.
 581         :type name: ``str``
 582         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 583         :type stack_operation: ``bool``
 584         :return: :class:`heat.resources.net`
 585         """
 586         LOG.debug("Creating network with name %s" % name)
 587         if self.find_network_by_name_or_id(name) is not None and not stack_operation:
 588             LOG.warning("Creating network with name %s failed, as it already exists" % name)
 589             raise Exception("Network with name %s already exists." % name)
 590         network = Net(name)
 591         network.id = str(uuid.uuid4())
 592         if not stack_operation:
 593             self.nets[network.id] = network
 594         return network
 595
 596     def delete_network(self, name_or_id):
 597         """
 598         Deletes the given network.
 599
 600         :param name_or_id: Name or UUID of the network.
 601         :type name_or_id: ``str``
 602         """
 603         net = self.find_network_by_name_or_id(name_or_id)
 604         if net is None:
 605             raise Exception("Network with name or id %s does not exists." % name_or_id)
 606
 607         for stack in self.stacks.values():
 608             stack.nets.pop(net.name, None)
 609
 610         self.nets.pop(net.id, None)
 611
 612     def create_port(self, name, stack_operation=False):
 613         """
 614         Creates a new port with the given name. Raises an exception when a port with the given name already
 615         exists!
 616
 617         :param name: Name of the new port.
 618         :type name: ``str``
 619         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 620         :type stack_operation: ``bool``
 621         :return: Returns the created port.
 622         :rtype: :class:`heat.resources.port`
 623         """
 624         port = self.find_port_by_name_or_id(name)
 625         if port is not None and not stack_operation:
 626             LOG.warning("Creating port with name %s failed, as it already exists" % name)
 627             raise Exception("Port with name %s already exists." % name)
 628         LOG.debug("Creating port with name %s" % name)
 629         port = Port(name)
 630         if not stack_operation:
 631             self.ports[port.id] = port
 632             port.create_intf_name()
 633         return port
 634
 635     def find_port_by_name_or_id(self, name_or_id):
 636         """
 637         Tries to find the port by ID and if this does not succeed then tries to find it via name.
 638
 639         :param name_or_id: UUID or name of the network.
 640         :type name_or_id: ``str``
 641         :return: Returns the port reference if it was found or None
 642         :rtype: :class:`heat.resources.port`
 643         """
 644         if name_or_id in self.ports:
 645             return self.ports[name_or_id]
 646         for port in self.ports.values():
 647             if port.name == name_or_id or port.template_name == name_or_id:
 648                 return port
 649
 650         return None
 651
 652     def delete_port(self, name_or_id):
 653         """
 654         Deletes the given port. Raises an exception when the port was not found!
 655
 656         :param name_or_id:  UUID or name of the port.
 657         :type name_or_id: ``str``
 658         """
 659         port = self.find_port_by_name_or_id(name_or_id)
 660         if port is None:
 661             raise Exception("Port with name or id %s does not exists." % name_or_id)
 662
 663         my_links = self.dc.net.links
 664         for link in my_links:
 665             if str(link.intf1) == port.intf_name and \
 666                             str(link.intf1.ip) == port.ip_address.split('/')[0]:
 667                 self._remove_link(link.intf1.node.name, link)
 668                 break
 669
 670         self.ports.pop(port.id, None)
 671         for stack in self.stacks.values():
 672             stack.ports.pop(port.name, None)
 673
 674     def create_port_pair(self, name, stack_operation=False):
 675         """
 676         Creates a new port pair with the given name. Raises an exception when a port pair with the given name already
 677         exists!
 678
 679         :param name: Name of the new port pair.
 680         :type name: ``str``
 681         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 682         :type stack_operation: ``bool``
 683         :return: Returns the created port pair.
 684         :rtype: :class:`openstack.resources.port_pair`
 685         """
 686         port_pair = self.find_port_pair_by_name_or_id(name)
 687         if port_pair is not None and not stack_operation:
 688             logging.warning("Creating port pair with name %s failed, as it already exists" % name)
 689             raise Exception("Port pair with name %s already exists." % name)
 690         logging.debug("Creating port pair with name %s" % name)
 691         port_pair = PortPair(name)
 692         if not stack_operation:
 693             self.port_pairs[port_pair.id] = port_pair
 694         return port_pair
 695
 696     def find_port_pair_by_name_or_id(self, name_or_id):
 697         """
 698         Tries to find the port pair by ID and if this does not succeed then tries to find it via name.
 699
 700         :param name_or_id: UUID or name of the port pair.
 701         :type name_or_id: ``str``
 702         :return: Returns the port pair reference if it was found or None
 703         :rtype: :class:`openstack.resources.port_pair`
 704         """
 705         if name_or_id in self.port_pairs:
 706             return self.port_pairs[name_or_id]
 707         for port_pair in self.port_pairs.values():
 708             if port_pair.name == name_or_id:
 709                 return port_pair
 710
 711         return None
 712
 713     def delete_port_pair(self, name_or_id):
 714         """
 715         Deletes the given port pair. Raises an exception when the port pair was not found!
 716
 717         :param name_or_id:  UUID or name of the port pair.
 718         :type name_or_id: ``str``
 719         """
 720         port_pair = self.find_port_pair_by_name_or_id(name_or_id)
 721         if port_pair is None:
 722             raise Exception("Port pair with name or id %s does not exists." % name_or_id)
 723
 724         self.port_pairs.pop(port_pair.id, None)
 725
 726     def create_port_pair_group(self, name, stack_operation=False):
 727         """
 728         Creates a new port pair group with the given name. Raises an exception when a port pair group
 729         with the given name already exists!
 730
 731         :param name: Name of the new port pair group.
 732         :type name: ``str``
 733         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 734         :type stack_operation: ``bool``
 735         :return: Returns the created port pair group .
 736         :rtype: :class:`openstack.resources.port_pair_group`
 737         """
 738         port_pair_group = self.find_port_pair_group_by_name_or_id(name)
 739         if port_pair_group is not None and not stack_operation:
 740             logging.warning("Creating port pair group with name %s failed, as it already exists" % name)
 741             raise Exception("Port pair group with name %s already exists." % name)
 742         logging.debug("Creating port pair group with name %s" % name)
 743         port_pair_group = PortPairGroup(name)
 744         if not stack_operation:
 745             self.port_pair_groups[port_pair_group.id] = port_pair_group
 746         return port_pair_group
 747
 748     def find_port_pair_group_by_name_or_id(self, name_or_id):
 749         """
 750         Tries to find the port pair group by ID and if this does not succeed then tries to find it via name.
 751
 752         :param name_or_id: UUID or name of the port pair group.
 753         :type name_or_id: ``str``
 754         :return: Returns the port pair group reference if it was found or None
 755         :rtype: :class:`openstack.resources.port_pair_group`
 756         """
 757         if name_or_id in self.port_pair_groups:
 758             return self.port_pair_groups[name_or_id]
 759         for port_pair_group in self.port_pair_groups.values():
 760             if port_pair_group.name == name_or_id:
 761                 return port_pair_group
 762
 763         return None
 764
 765     def delete_port_pair_group(self, name_or_id):
 766         """
 767         Deletes the given port pair group. Raises an exception when the port pair group was not found!
 768
 769         :param name_or_id:  UUID or name of the port pair group.
 770         :type name_or_id: ``str``
 771         """
 772         port_pair_group = self.find_port_pair_group_by_name_or_id(name_or_id)
 773         if port_pair_group is None:
 774             raise Exception("Port pair with name or id %s does not exists." % name_or_id)
 775
 776         self.port_pair_groups.pop(port_pair_group.id, None)
 777
 778     def create_port_chain(self, name, stack_operation=False):
 779         """
 780         Creates a new port chain with the given name. Raises an exception when a port chain with the given name already
 781         exists!
 782
 783         :param name: Name of the new port chain
 784         :type name: ``str``
 785         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 786         :type stack_operation: ``bool``
 787         :return: Returns the created port chain.
 788         :rtype: :class:`openstack.resources.port_chain.PortChain`
 789         """
 790         port_chain = self.find_port_chain_by_name_or_id(name)
 791         if port_chain is not None and not stack_operation:
 792             logging.warning("Creating port chain with name %s failed, as it already exists" % name)
 793             raise Exception("Port chain with name %s already exists." % name)
 794         logging.debug("Creating port chain with name %s" % name)
 795         port_chain = PortChain(name)
 796         if not stack_operation:
 797             self.port_chains[port_chain.id] = port_chain
 798         return port_chain
 799
 800     def find_port_chain_by_name_or_id(self, name_or_id):
 801         """
 802         Tries to find the port chain by ID and if this does not succeed then tries to find it via name.
 803
 804         :param name_or_id: UUID or name of the port chain.
 805         :type name_or_id: ``str``
 806         :return: Returns the port chain reference if it was found or None
 807         :rtype: :class:`openstack.resources.port_chain.PortChain`
 808         """
 809         if name_or_id in self.port_chains:
 810             return self.port_chains[name_or_id]
 811         for port_chain in self.port_chains.values():
 812             if port_chain.name == name_or_id:
 813                 return port_chain
 814         return None
 815
 816     def delete_port_chain(self, name_or_id):
 817         """
 818         Deletes the given port chain. Raises an exception when the port chain was not found!
 819
 820         :param name_or_id:  UUID or name of the port chain.
 821         :type name_or_id: ``str``
 822         """
 823         port_chain = self.find_port_chain_by_name_or_id(name_or_id)
 824         port_chain.uninstall(self)
 825         if port_chain is None:
 826             raise Exception("Port chain with name or id %s does not exists." % name_or_id)
 827
 828         self.port_chains.pop(port_chain.id, None)
 829
 830     def create_flow_classifier(self, name, stack_operation=False):
 831         """
 832         Creates a new flow classifier with the given name. Raises an exception when a flow classifier with the given name already
 833         exists!
 834
 835         :param name: Name of the new flow classifier.
 836         :type name: ``str``
 837         :param stack_operation: Allows the heat parser to create modules without adapting the current emulation.
 838         :type stack_operation: ``bool``
 839         :return: Returns the created flow classifier.
 840         :rtype: :class:`openstack.resources.flow_classifier`
 841         """
 842         flow_classifier = self.find_flow_classifier_by_name_or_id(name)
 843         if flow_classifier is not None and not stack_operation:
 844             logging.warning("Creating flow classifier with name %s failed, as it already exists" % name)
 845             raise Exception("Flow classifier with name %s already exists." % name)
 846         logging.debug("Creating flow classifier with name %s" % name)
 847         flow_classifier = FlowClassifier(name)
 848         if not stack_operation:
 849             self.flow_classifiers[flow_classifier.id] = flow_classifier
 850         return flow_classifier
 851
 852     def find_flow_classifier_by_name_or_id(self, name_or_id):
 853         """
 854         Tries to find the flow classifier by ID and if this does not succeed then tries to find it via name.
 855
 856         :param name_or_id: UUID or name of the flow classifier.
 857         :type name_or_id: ``str``
 858         :return: Returns the flow classifier reference if it was found or None
 859         :rtype: :class:`openstack.resources.flow_classifier`
 860         """
 861         if name_or_id in self.flow_classifiers:
 862             return self.flow_classifiers[name_or_id]
 863         for flow_classifier in self.flow_classifiers.values():
 864             if flow_classifier.name == name_or_id:
 865                 return flow_classifier
 866
 867         return None
 868
 869     def delete_flow_classifier(self, name_or_id):
 870         """
 871         Deletes the given flow classifier. Raises an exception when the flow classifier was not found!
 872
 873         :param name_or_id:  UUID or name of the flow classifier.
 874         :type name_or_id: ``str``
 875         """
 876         flow_classifier = self.find_flow_classifier_by_name_or_id(name_or_id)
 877         if flow_classifier is None:
 878             raise Exception("Flow classifier with name or id %s does not exists." % name_or_id)
 879
 880         self.flow_classifiers.pop(flow_classifier.id, None)
 881
 882     def _add_link(self, node_name, ip_address, link_name, net_name):
 883         """
 884         Adds a new link between datacenter switch and the node with the given name.
 885
 886         :param node_name: Name of the required node.
 887         :type node_name: ``str``
 888         :param ip_address: IP-Address of the node.
 889         :type ip_address: ``str``
 890         :param link_name: Link name.
 891         :type link_name: ``str``
 892         :param net_name: Network name.
 893         :type net_name: ``str``
 894         """
 895         node = self.dc.net.get(node_name)
 896         params = {'params1': {'ip': ip_address,
 897                               'id': link_name,
 898                               link_name: net_name},
 899                   'intfName1': link_name,
 900                   'cls': Link}
 901         link = self.dc.net.addLink(node, self.dc.switch, **params)
 902         OpenstackCompute.timeout_sleep(link.intf1.isUp, 1)
 903
 904     def _remove_link(self, server_name, link):
 905         """
 906         Removes a link between server and datacenter switch.
 907
 908         :param server_name: Specifies the server where the link starts.
 909         :type server_name: ``str``
 910         :param link: A reference of the link which should be removed.
 911         :type link: :class:`mininet.link`
 912         """
 913         self.dc.switch.detach(link.intf2)
 914         del self.dc.switch.intfs[self.dc.switch.ports[link.intf2]]
 915         del self.dc.switch.ports[link.intf2]
 916         del self.dc.switch.nameToIntf[link.intf2.name]
 917         self.dc.net.removeLink(link=link)
 918         for intf_key in self.dc.net[server_name].intfs.keys():
 919             if self.dc.net[server_name].intfs[intf_key].link == link:
 920                 self.dc.net[server_name].intfs[intf_key].delete()
 921                 del self.dc.net[server_name].intfs[intf_key]
 922
 923     @staticmethod
 924     def timeout_sleep(function, max_sleep):
 925         """
 926         This function will execute a function all 0.1 seconds until it successfully returns.
 927         Will return after `max_sleep` seconds if not successful.
 928
 929         :param function: The function to execute. Should return true if done.
 930         :type function: ``function``
 931         :param max_sleep: Max seconds to sleep. 1 equals 1 second.
 932         :type max_sleep: ``float``
 933         """
 934         current_time = time.time()
 935         stop_time = current_time + max_sleep
 936         while not function() and current_time < stop_time:
 937             current_time = time.time()
 938             time.sleep(0.1)