yardstick/common/kubernetes_utils.py

   1 ##############################################################################
   2 # Copyright (c) 2017 Huawei Technologies Co.,Ltd.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9 import logging
  10
  11 from kubernetes import client
  12 from kubernetes import config
  13 from kubernetes.client.rest import ApiException
  14
  15 from yardstick.common import constants as consts
  16 from yardstick.common import exceptions
  17
  18
  19 LOG = logging.getLogger(__name__)
  20 LOG.setLevel(logging.DEBUG)
  21
  22
  23 def get_core_api():     # pragma: no cover
  24     try:
  25         config.load_kube_config(config_file=consts.K8S_CONF_FILE)
  26     except IOError:
  27         raise exceptions.KubernetesConfigFileNotFound()
  28     return client.CoreV1Api()
  29
  30
  31 def get_extensions_v1beta_api():
  32     try:
  33         config.load_kube_config(config_file=consts.K8S_CONF_FILE)
  34     except IOError:
  35         raise exceptions.KubernetesConfigFileNotFound()
  36     return client.ApiextensionsV1beta1Api()
  37
  38
  39 def get_custom_objects_api():
  40     try:
  41         config.load_kube_config(config_file=consts.K8S_CONF_FILE)
  42     except IOError:
  43         raise exceptions.KubernetesConfigFileNotFound()
  44     return client.CustomObjectsApi()
  45
  46
  47 def get_node_list(**kwargs):        # pragma: no cover
  48     core_v1_api = get_core_api()
  49     try:
  50         return core_v1_api.list_node(**kwargs)
  51     except ApiException:
  52         LOG.exception('Get node list failed')
  53         raise
  54
  55
  56 def create_service(template,
  57                    namespace='default',
  58                    wait=False,
  59                    **kwargs):       # pragma: no cover
  60     # pylint: disable=unused-argument
  61     core_v1_api = get_core_api()
  62     metadata = client.V1ObjectMeta(**template.get('metadata', {}))
  63
  64     ports = [client.V1ServicePort(**port) for port in
  65              template.get('spec', {}).get('ports', [])]
  66     template['spec']['ports'] = ports
  67     spec = client.V1ServiceSpec(**template.get('spec', {}))
  68
  69     service = client.V1Service(metadata=metadata, spec=spec)
  70
  71     try:
  72         core_v1_api.create_namespaced_service('default', service)
  73     except ApiException:
  74         LOG.exception('Create Service failed')
  75         raise
  76
  77
  78 def delete_service(name,
  79                    namespace='default',
  80                    **kwargs):       # pragma: no cover
  81     core_v1_api = get_core_api()
  82     try:
  83         body = client.V1DeleteOptions()
  84         core_v1_api.delete_namespaced_service(name, namespace, body, **kwargs)
  85     except ApiException:
  86         LOG.exception('Delete Service failed')
  87
  88
  89 def get_service_list(namespace='default', **kwargs):
  90     core_v1_api = get_core_api()
  91     try:
  92         return core_v1_api.list_namespaced_service(namespace, **kwargs)
  93     except ApiException:
  94         LOG.exception('Get Service list failed')
  95         raise
  96
  97
  98 def get_service_by_name(name):      # pragma: no cover
  99     service_list = get_service_list()
 100     return next((s.spec for s in service_list.items if s.metadata.name == name), None)
 101
 102
 103 def create_replication_controller(template,
 104                                   namespace='default',
 105                                   wait=False,
 106                                   **kwargs):    # pragma: no cover
 107     # pylint: disable=unused-argument
 108     core_v1_api = get_core_api()
 109     try:
 110         core_v1_api.create_namespaced_replication_controller(namespace,
 111                                                              template,
 112                                                              **kwargs)
 113     except ApiException:
 114         LOG.exception('Create replication controller failed')
 115         raise
 116
 117
 118 def delete_replication_controller(name,
 119                                   namespace='default',
 120                                   wait=False,
 121                                   **kwargs):    # pragma: no cover
 122     # pylint: disable=unused-argument
 123     core_v1_api = get_core_api()
 124     body = kwargs.get('body', client.V1DeleteOptions())
 125     kwargs.pop('body', None)
 126     try:
 127         core_v1_api.delete_namespaced_replication_controller(name,
 128                                                              namespace,
 129                                                              body,
 130                                                              **kwargs)
 131     except ApiException:
 132         LOG.exception('Delete replication controller failed')
 133         raise
 134
 135
 136 def delete_pod(name,
 137                namespace='default',
 138                wait=False,
 139                **kwargs):    # pragma: no cover
 140     # pylint: disable=unused-argument
 141     core_v1_api = get_core_api()
 142     body = kwargs.get('body', client.V1DeleteOptions())
 143     kwargs.pop('body', None)
 144     try:
 145         core_v1_api.delete_namespaced_pod(name,
 146                                           namespace,
 147                                           body,
 148                                           **kwargs)
 149     except ApiException:
 150         LOG.exception('Delete pod failed')
 151         raise
 152
 153
 154 def read_pod(name,
 155              namespace='default',
 156              **kwargs):  # pragma: no cover
 157     core_v1_api = get_core_api()
 158     try:
 159         resp = core_v1_api.read_namespaced_pod(name, namespace, **kwargs)
 160     except ApiException:
 161         LOG.exception('Read pod failed')
 162         raise
 163     else:
 164         return resp
 165
 166
 167 def read_pod_status(name, namespace='default', **kwargs):   # pragma: no cover
 168     # pylint: disable=unused-argument
 169     return read_pod(name).status.phase
 170
 171
 172 def create_config_map(name,
 173                       data,
 174                       namespace='default',
 175                       wait=False,
 176                       **kwargs):   # pragma: no cover
 177     # pylint: disable=unused-argument
 178     core_v1_api = get_core_api()
 179     metadata = client.V1ObjectMeta(name=name)
 180     body = client.V1ConfigMap(data=data, metadata=metadata)
 181     try:
 182         core_v1_api.create_namespaced_config_map(namespace, body, **kwargs)
 183     except ApiException:
 184         LOG.exception('Create config map failed')
 185         raise
 186
 187
 188 def delete_config_map(name,
 189                       namespace='default',
 190                       wait=False,
 191                       **kwargs):     # pragma: no cover
 192     # pylint: disable=unused-argument
 193     core_v1_api = get_core_api()
 194     body = kwargs.get('body', client.V1DeleteOptions())
 195     kwargs.pop('body', None)
 196     try:
 197         core_v1_api.delete_namespaced_config_map(name,
 198                                                  namespace,
 199                                                  body,
 200                                                  **kwargs)
 201     except ApiException:
 202         LOG.exception('Delete config map failed')
 203         raise
 204
 205
 206 def create_custom_resource_definition(body):
 207     api = get_extensions_v1beta_api()
 208     body_obj = client.V1beta1CustomResourceDefinition(
 209         spec=body['spec'], metadata=body['metadata'])
 210     try:
 211         api.create_custom_resource_definition(body_obj)
 212     except ValueError:
 213         # NOTE(ralonsoh): bug in kubernetes-client/python 6.0.0
 214         # https://github.com/kubernetes-client/python/issues/491
 215         pass
 216     except ApiException:
 217         raise exceptions.KubernetesApiException(
 218             action='create', resource='CustomResourceDefinition')
 219
 220
 221 def delete_custom_resource_definition(name):
 222     api = get_extensions_v1beta_api()
 223     body_obj = client.V1DeleteOptions()
 224     try:
 225         api.delete_custom_resource_definition(name, body_obj)
 226     except ApiException:
 227         raise exceptions.KubernetesApiException(
 228             action='delete', resource='CustomResourceDefinition')
 229
 230
 231 def get_custom_resource_definition(kind):
 232     api = get_extensions_v1beta_api()
 233     try:
 234         crd_list = api.list_custom_resource_definition()
 235         for crd_obj in (crd_obj for crd_obj in crd_list.items
 236                         if crd_obj.spec.names.kind == kind):
 237             return crd_obj
 238         return None
 239     except ApiException:
 240         raise exceptions.KubernetesApiException(
 241             action='delete', resource='CustomResourceDefinition')
 242
 243
 244 def create_network(scope, group, version, plural, body, namespace='default'):
 245     api = get_custom_objects_api()
 246     try:
 247         if scope == consts.SCOPE_CLUSTER:
 248             api.create_cluster_custom_object(group, version, plural, body)
 249         else:
 250             api.create_namespaced_custom_object(
 251                 group, version, namespace, plural, body)
 252     except ApiException:
 253         raise exceptions.KubernetesApiException(
 254             action='create', resource='Custom Object: Network')
 255
 256
 257 def delete_network(scope, group, version, plural, name, namespace='default'):
 258     api = get_custom_objects_api()
 259     try:
 260         if scope == consts.SCOPE_CLUSTER:
 261             api.delete_cluster_custom_object(group, version, plural, name, {})
 262         else:
 263             api.delete_namespaced_custom_object(
 264                 group, version, namespace, plural, name, {})
 265     except ApiException:
 266         raise exceptions.KubernetesApiException(
 267             action='delete', resource='Custom Object: Network')
 268
 269
 270 def get_pod_list(namespace='default'):      # pragma: no cover
 271     core_v1_api = get_core_api()
 272     try:
 273         return core_v1_api.list_namespaced_pod(namespace=namespace)
 274     except ApiException:
 275         LOG.exception('Get pod list failed')
 276         raise
 277
 278
 279 def get_pod_by_name(name):  # pragma: no cover
 280     pod_list = get_pod_list()
 281     return next((n for n in pod_list.items if n.metadata.name.startswith(name)), None)
 282
 283
 284 def get_volume_types():
 285     """Return the "volume" types supported by the current API"""
 286     return [vtype for vtype in client.V1Volume.attribute_map.values()
 287             if vtype != 'name']