src/emuvim/api/openstack/compute.py

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