planetstack/openstack_observer/steps/sync_network_slivers.py

   1 import os
   2 import base64
   3 from django.db.models import F, Q
   4 from planetstack.config import Config
   5 from observer.openstacksyncstep import OpenStackSyncStep
   6 from core.models import Controller
   7 from core.models.network import *
   8 from util.logger import Logger, logging
   9
  10 logger = Logger(level=logging.INFO)
  11
  12 class SyncNetworkSlivers(OpenStackSyncStep):
  13     requested_interval = 0 # 3600
  14     provides=[NetworkSliver]
  15
  16     #     The way it works is to enumerate the all of the ports that quantum
  17     #     has, and then work backward from each port's network-id to determine
  18     #     which Network is associated from the port.
  19
  20     def call(self, **args):
  21         logger.info("sync'ing network slivers")
  22
  23         networkSlivers = NetworkSliver.objects.all()
  24         networkSlivers_by_id = {}
  25         networkSlivers_by_port = {}
  26         for networkSliver in networkSlivers:
  27             networkSlivers_by_id[networkSliver.id] = networkSliver
  28             networkSlivers_by_port[networkSliver.port_id] = networkSliver
  29
  30         networks = Network.objects.all()
  31         networks_by_id = {}
  32         for network in networks:
  33             for nd in network.controllernetworks.all():
  34                 networks_by_id[nd.net_id] = network
  35
  36         #logger.info("networks_by_id = ")
  37         #for (network_id, network) in networks_by_id.items():
  38         #    logger.info("   %s: %s" % (network_id, network.name))
  39
  40         slivers = Sliver.objects.all()
  41         slivers_by_instance_id = {}
  42         for sliver in slivers:
  43             slivers_by_instance_id[sliver.instance_id] = sliver
  44
  45         # Get all ports in all controllers
  46
  47         ports_by_id = {}
  48         for controller in Controller.objects.all():
  49             if not controller.admin_tenant:
  50                 logger.info("controller %s has no admin_tenant" % controller)
  51                 continue
  52             try:
  53                 driver = self.driver.admin_driver(controller = controller,tenant='admin')
  54                 ports = driver.shell.quantum.list_ports()["ports"]
  55             except:
  56                 logger.log_exc("failed to get ports from controller %s" % controller)
  57                 continue
  58
  59             for port in ports:
  60                 ports_by_id[port["id"]] = port
  61
  62         for port in ports_by_id.values():
  63             #logger.info("port %s" % str(port))
  64             if port["id"] in networkSlivers_by_port:
  65                 # we already have it
  66                 #logger.info("already accounted for port %s" % port["id"])
  67                 continue
  68
  69             if port["device_owner"] != "compute:nova":
  70                 # we only want the ports that connect to instances
  71                 #logger.info("port %s is not a compute port, it is a %s" % (port["id"], port["device_owner"]))
  72                 continue
  73
  74             sliver = slivers_by_instance_id.get(port['device_id'], None)
  75             if not sliver:
  76                 logger.info("no sliver for port %s device_id %s" % (port["id"], port['device_id']))
  77                 continue
  78
  79             network = networks_by_id.get(port['network_id'], None)
  80             if not network:
  81                 logger.info("no network for port %s network %s" % (port["id"], port["network_id"]))
  82
  83                 # we know it's associated with a sliver, but we don't know
  84                 # which network it is part of.
  85
  86                 continue
  87
  88             if network.template.shared_network_name:
  89                 # If it's a shared network template, then more than one network
  90                 # object maps to the quantum network. We have to do a whole bunch
  91                 # of extra work to find the right one.
  92                 networks = network.template.network_set.all()
  93                 network = None
  94                 for candidate_network in networks:
  95                     if (candidate_network.owner == sliver.slice):
  96                         print "found network", candidate_network
  97                         network = candidate_network
  98
  99                 if not network:
 100                     logger.info("failed to find the correct network for a shared template for port %s network %s" % (port["id"], port["network_id"]))
 101                     continue
 102
 103             if not port["fixed_ips"]:
 104                 logger.info("port %s has no fixed_ips" % port["id"])
 105                 continue
 106
 107             ip=port["fixed_ips"][0]["ip_address"]
 108             logger.info("creating NetworkSliver (%s, %s, %s, %s)" % (str(network), str(sliver), ip, str(port["id"])))
 109
 110             ns = NetworkSliver(network=network,
 111                                sliver=sliver,
 112                                ip=ip,
 113                                port_id=port["id"])
 114             ns.save()
 115
 116         # Now, handle port forwarding
 117         # We get the list of NetworkSlivers again, since we might have just
 118         # added a few. Then, for each one of them we find it's quantum port and
 119         # make sure quantum's nat:forward_ports argument is the same.
 120
 121         for networkSliver in NetworkSliver.objects.all():
 122             try:
 123                 nat_list = networkSliver.network.nat_list
 124             except (TypeError, ValueError), e:
 125                 logger.info("Failed to decode nat_list: %s" % str(e))
 126                 continue
 127
 128             if not networkSliver.port_id:
 129                 continue
 130
 131             neutron_port = ports_by_id.get(networkSliver.port_id, None)
 132             if not neutron_port:
 133                 continue
 134
 135             neutron_nat_list = neutron_port.get("nat:forward_ports", None)
 136             if not neutron_nat_list:
 137                 # make sure that None and the empty set are treated identically
 138                 neutron_nat_list = []
 139
 140             if (neutron_nat_list != nat_list):
 141                 logger.info("Setting nat:forward_ports for port %s network %s sliver %s to %s" % (str(networkSliver.port_id), str(networkSliver.network.id), str(networkSliver.sliver), str(nat_list)))
 142                 try:
 143                     driver = self.driver.admin_driver(controller=networkSliver.sliver.node.site_deployment.controller,tenant='admin')
 144                     driver.shell.quantum.update_port(networkSliver.port_id, {"port": {"nat:forward_ports": nat_list}})
 145                 except:
 146                     logger.log_exc("failed to update port with nat_list %s" % str(nat_list))
 147                     continue
 148             else:
 149                 #logger.info("port %s network %s sliver %s nat %s is already set" % (str(networkSliver.port_id), str(networkSliver.network.id), str(networkSliver.sliver), str(nat_list)))
 150                 pass
 151
 152     def delete_record(self, network_sliver):
 153         # Nothing to do, this is an OpenCloud object
 154         pass
 155