src/emuvim/api/openstack/compute.py

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