Generate pod.yaml from current context

[yardstick.git] / yardstick / benchmark / contexts / heat.py

diff --git a/yardstick/benchmark/contexts/heat.py b/yardstick/benchmark/contexts/heat.py
index deed4af..2f3cc5a 100644 (file)
--- a/yardstick/benchmark/contexts/heat.py
+++ b/yardstick/benchmark/contexts/heat.py
@@ -83,9 +83,14 @@ class HeatContext(Context):
         external_network = os.environ.get("EXTERNAL_NETWORK", "net04_ext")
 
         have_external_network = any(net.get("external_network") for net in networks.values())
-        if sorted_networks and not have_external_network:
-            # no external net defined, assign it to first network using os.environ
-            sorted_networks[0][1]["external_network"] = external_network
+        if not have_external_network:
+            # try looking for mgmt network first
+            try:
+                networks['mgmt']["external_network"] = external_network
+            except KeyError:
+                if sorted_networks:
+                    # otherwise assign it to first network using os.environ
+                    sorted_networks[0][1]["external_network"] = external_network
 
         return sorted_networks
 
@@ -295,7 +300,7 @@ class HeatContext(Context):
 
     def deploy(self):
         """deploys template into a stack using cloud"""
-        print("Deploying context '%s'" % self.name)
+        LOG.info("Deploying context '%s' START", self.name)
 
         heat_template = HeatTemplate(self.name, self.template_file,
                                      self.heat_parameters)
@@ -325,23 +330,33 @@ class HeatContext(Context):
                 server.public_ip = \
                     self.stack.outputs[server.floating_ip["stack_name"]]
 
-        print("Context '%s' deployed" % self.name)
+        LOG.info("Deploying context '%s' DONE", self.name)
 
     def add_server_port(self, server):
-        # TODO(hafe) can only handle one internal network for now
-        port = next(iter(server.ports.values()))
-        server.private_ip = self.stack.outputs[port["stack_name"]]
+        # use private ip from first port in first network
+        try:
+            private_port = next(iter(server.ports.values()))[0]
+        except IndexError:
+            LOG.exception("Unable to find first private port in %s", server.ports)
+            raise
+        server.private_ip = self.stack.outputs[private_port["stack_name"]]
         server.interfaces = {}
-        for network_name, port in server.ports.items():
-            server.interfaces[network_name] = self.make_interface_dict(
-                network_name, port['stack_name'], self.stack.outputs)
-
-    def make_interface_dict(self, network_name, stack_name, outputs):
+        for network_name, ports in server.ports.items():
+            for port in ports:
+                # port['port'] is either port name from mapping or default network_name
+                server.interfaces[port['port']] = self.make_interface_dict(network_name,
+                                                                           port['port'],
+                                                                           port['stack_name'],
+                                                                           self.stack.outputs)
+
+    def make_interface_dict(self, network_name, port, stack_name, outputs):
         private_ip = outputs[stack_name]
         mac_address = outputs[h_join(stack_name, "mac_address")]
+        # these are attributes of the network, not the port
         output_subnet_cidr = outputs[h_join(self.name, network_name,
                                             'subnet', 'cidr')]
 
+        # these are attributes of the network, not the port
         output_subnet_gateway = outputs[h_join(self.name, network_name,
                                                'subnet', 'gateway_ip')]
 
@@ -355,20 +370,20 @@ class HeatContext(Context):
             "mac_address": mac_address,
             "device_id": outputs[h_join(stack_name, "device_id")],
             "network_id": outputs[h_join(stack_name, "network_id")],
+            # this should be == vld_id for NSB tests
             "network_name": network_name,
             # to match vnf_generic
             "local_mac": mac_address,
             "local_ip": private_ip,
-            "vld_id": self.networks[network_name].vld_id,
         }
 
     def undeploy(self):
         """undeploys stack from cloud"""
         if self.stack:
-            print("Undeploying context '%s'" % self.name)
+            LOG.info("Undeploying context '%s' START", self.name)
             self.stack.delete()
             self.stack = None
-            print("Context '%s' undeployed" % self.name)
+            LOG.info("Undeploying context '%s' DONE", self.name)
 
         if os.path.exists(self.key_filename):
             try:
@@ -427,6 +442,8 @@ class HeatContext(Context):
             "routing_table": self.generate_routing_table(server),
             # empty IPv6 routing table
             "nd_route_tbl": [],
+            # we want to save the contex name so we can generate pod.yaml
+            "name": server.name,
         }
         # Target server may only have private_ip
         if server.public_ip:
@@ -439,9 +456,11 @@ class HeatContext(Context):
             network = self.networks.get(attr_name, None)
 
         else:
-            # Don't generalize too much  Just support vld_id
-            vld_id = attr_name.get('vld_id', {})
-            network_iter = (n for n in self.networks.values() if n.vld_id == vld_id)
+            # Only take the first key, value
+            key, value = next(iter(attr_name.items()), (None, None))
+            if key is None:
+                return None
+            network_iter = (n for n in self.networks.values() if getattr(n, key) == value)
             network = next(network_iter, None)
 
         if network is None:
@@ -449,7 +468,6 @@ class HeatContext(Context):
 
         result = {
             "name": network.name,
-            "vld_id": network.vld_id,
             "segmentation_id": network.segmentation_id,
             "network_type": network.network_type,
             "physical_network": network.physical_network,