X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=yardstick%2Fbenchmark%2Fcontexts%2Fkubernetes.py;h=e1553c72b50125598df28afafa319b593474919d;hb=d8cfab0d902b2d3d1a4234551807df68ac0b6b66;hp=a6b3ebad889b7983ba20e724adae85b681c24b88;hpb=6c0dccb32f6b22cd295d0a5e5cb296c6defcfed1;p=yardstick.git

diff --git a/yardstick/benchmark/contexts/kubernetes.py b/yardstick/benchmark/contexts/kubernetes.py
index a6b3ebad8..e1553c72b 100644
--- a/yardstick/benchmark/contexts/kubernetes.py
+++ b/yardstick/benchmark/contexts/kubernetes.py
@@ -7,25 +7,28 @@
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
 
+import collections
 import logging
-import time
 import pkg_resources
+import time
 
 import paramiko
 
 from yardstick.benchmark import contexts
-from yardstick.benchmark.contexts.base import Context
-from yardstick.orchestrator import kubernetes
+from yardstick.benchmark.contexts import base as ctx_base
+from yardstick.benchmark.contexts import model
 from yardstick.common import constants
 from yardstick.common import exceptions
 from yardstick.common import kubernetes_utils as k8s_utils
 from yardstick.common import utils
+from yardstick.orchestrator import kubernetes
+
 
 LOG = logging.getLogger(__name__)
 BITS_LENGTH = 2048
 
 
-class KubernetesContext(Context):
+class KubernetesContext(ctx_base.Context):
     """Class that handle nodes info"""
 
     __context_type__ = contexts.CONTEXT_KUBERNETES
@@ -40,10 +43,14 @@ class KubernetesContext(Context):
     def init(self, attrs):
         super(KubernetesContext, self).init(attrs)
 
+        networks = attrs.get('networks', {})
         self.template = kubernetes.KubernetesTemplate(self.name, attrs)
         self.ssh_key = '{}-key'.format(self.name)
         self.key_path = self._get_key_path()
         self.public_key_path = '{}.pub'.format(self.key_path)
+        self._networks = collections.OrderedDict(
+            (net_name, model.Network(net_name, self, network))
+            for net_name, network in networks.items())
 
     def deploy(self):
         LOG.info('Creating ssh key')
@@ -92,7 +99,7 @@ class KubernetesContext(Context):
             obj.delete()
 
     def _create_rcs(self):
-        for obj in self.template.k8s_objs:
+        for obj in self.template.rc_objs:
             self._create_rc(obj.get_template())
 
     def _create_rc(self, template):
@@ -103,14 +110,14 @@ class KubernetesContext(Context):
             self._delete_rc(rc)
 
     def _delete_rc(self, rc):
-        k8s_utils.delete_replication_controller(rc)
+        k8s_utils.delete_replication_controller(rc, skip_codes=[404])
 
     def _delete_pods(self):
         for pod in self.template.pods:
             self._delete_pod(pod)
 
     def _delete_pod(self, pod):
-        k8s_utils.delete_pod(pod)
+        k8s_utils.delete_pod(pod, skip_codes=[404])
 
     def _create_crd(self):
         LOG.info('Create Custom Resource Definition elements')
@@ -152,19 +159,15 @@ class KubernetesContext(Context):
         k8s_utils.create_config_map(self.ssh_key, {'authorized_keys': key})
 
     def _delete_ssh_key(self):
-        k8s_utils.delete_config_map(self.ssh_key)
+        k8s_utils.delete_config_map(self.ssh_key, skip_codes=[404])
         utils.remove_file(self.key_path)
         utils.remove_file(self.public_key_path)
 
     def _get_server(self, name):
-        service_name = '{}-service'.format(name)
-        service = k8s_utils.get_service_by_name(service_name)
-        if not service:
-            raise exceptions.KubernetesServiceObjectNotDefined()
-
-        for sn_port in (sn_port for sn_port in service.ports
-                        if sn_port.port == constants.SSH_PORT):
-            node_port = sn_port.node_port
+        node_ports = self._get_service_ports(name)
+        for sn_port in (sn_port for sn_port in node_ports
+                        if sn_port['port'] == constants.SSH_PORT):
+            node_port = sn_port['node_port']
             break
         else:
             raise exceptions.KubernetesSSHPortNotDefined()
@@ -175,17 +178,57 @@ class KubernetesContext(Context):
             'private_ip': k8s_utils.get_pod_by_name(name).status.pod_ip,
             'ssh_port': node_port,
             'user': 'root',
-            'key_filename': self.key_path
+            'key_filename': self.key_path,
+            'interfaces': self._get_interfaces(name),
+            'service_ports': node_ports
         }
 
+    def _get_network(self, net_name):
+        """Retrieves the network object, searching by name
+
+        :param net_name: (str) replication controller name
+        :return: (dict) network information (name)
+        """
+        network = self._networks.get(net_name)
+        if not network:
+            return
+        return {'name': net_name}
+
+    def _get_interfaces(self, rc_name):
+        """Retrieves the network list of a replication controller
+
+        :param rc_name: (str) replication controller name
+        :return: (dict) names and information of the networks used in this
+                 replication controller; those networks must be defined in the
+                 Kubernetes cluster
+        """
+        rc = self.template.get_rc_by_name(rc_name)
+        if not rc:
+            return {}
+        return {name: {'network_name': name,
+                       'local_mac': None,
+                       'local_ip': None}
+                for name in rc.networks}
+
     def _get_node_ip(self):
         return k8s_utils.get_node_list().items[0].status.addresses[0].address
 
-    def _get_network(self, attr_name):
-        return None
-
     def _get_physical_nodes(self):
         return None
 
     def _get_physical_node_for_server(self, server_name):
         return None
+
+    def _get_service_ports(self, name):
+        service_name = '{}-service'.format(name)
+        service = k8s_utils.get_service_by_name(service_name)
+        if not service:
+            raise exceptions.KubernetesServiceObjectNotDefined()
+        ports = []
+        for port in service.ports:
+            ports.append({'name': port.name,
+                          'node_port': port.node_port,
+                          'port': port.port,
+                          'protocol': port.protocol,
+                          'target_port': port.target_port})
+        return ports