# 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
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')
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):
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')
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()
'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