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
  17 LOG = logging.getLogger(__name__)
  18 LOG.setLevel(logging.DEBUG)
  19
  20
  21 def get_core_api():     # pragma: no cover
  22     try:
  23         config.load_kube_config(config_file=consts.K8S_CONF_FILE)
  24     except IOError:
  25         LOG.exception('config file not found')
  26         raise
  27
  28     return client.CoreV1Api()
  29
  30
  31 def get_node_list(**kwargs):        # pragma: no cover
  32     core_v1_api = get_core_api()
  33     try:
  34         return core_v1_api.list_node(**kwargs)
  35     except ApiException:
  36         LOG.exception('Get node list failed')
  37         raise
  38
  39
  40 def create_service(template,
  41                    namespace='default',
  42                    wait=False,
  43                    **kwargs):       # pragma: no cover
  44     # pylint: disable=unused-argument
  45     core_v1_api = get_core_api()
  46     metadata = client.V1ObjectMeta(**template.get('metadata', {}))
  47
  48     ports = [client.V1ServicePort(**port) for port in
  49              template.get('spec', {}).get('ports', [])]
  50     template['spec']['ports'] = ports
  51     spec = client.V1ServiceSpec(**template.get('spec', {}))
  52
  53     service = client.V1Service(metadata=metadata, spec=spec)
  54
  55     try:
  56         core_v1_api.create_namespaced_service('default', service)
  57     except ApiException:
  58         LOG.exception('Create Service failed')
  59         raise
  60
  61
  62 def delete_service(name,
  63                    namespace='default',
  64                    **kwargs):       # pragma: no cover
  65     core_v1_api = get_core_api()
  66     try:
  67         body = client.V1DeleteOptions()
  68         core_v1_api.delete_namespaced_service(name, namespace, body, **kwargs)
  69     except ApiException:
  70         LOG.exception('Delete Service failed')
  71
  72
  73 def get_service_list(namespace='default', **kwargs):
  74     core_v1_api = get_core_api()
  75     try:
  76         return core_v1_api.list_namespaced_service(namespace, **kwargs)
  77     except ApiException:
  78         LOG.exception('Get Service list failed')
  79         raise
  80
  81
  82 def get_service_by_name(name):      # pragma: no cover
  83     service_list = get_service_list()
  84     return next((s.spec for s in service_list.items if s.metadata.name == name), None)
  85
  86
  87 def create_replication_controller(template,
  88                                   namespace='default',
  89                                   wait=False,
  90                                   **kwargs):    # pragma: no cover
  91     # pylint: disable=unused-argument
  92     core_v1_api = get_core_api()
  93     try:
  94         core_v1_api.create_namespaced_replication_controller(namespace,
  95                                                              template,
  96                                                              **kwargs)
  97     except ApiException:
  98         LOG.exception('Create replication controller failed')
  99         raise
 100
 101
 102 def delete_replication_controller(name,
 103                                   namespace='default',
 104                                   wait=False,
 105                                   **kwargs):    # pragma: no cover
 106     # pylint: disable=unused-argument
 107     core_v1_api = get_core_api()
 108     body = kwargs.get('body', client.V1DeleteOptions())
 109     kwargs.pop('body', None)
 110     try:
 111         core_v1_api.delete_namespaced_replication_controller(name,
 112                                                              namespace,
 113                                                              body,
 114                                                              **kwargs)
 115     except ApiException:
 116         LOG.exception('Delete replication controller failed')
 117         raise
 118
 119
 120 def delete_pod(name,
 121                namespace='default',
 122                wait=False,
 123                **kwargs):    # pragma: no cover
 124     # pylint: disable=unused-argument
 125     core_v1_api = get_core_api()
 126     body = kwargs.get('body', client.V1DeleteOptions())
 127     kwargs.pop('body', None)
 128     try:
 129         core_v1_api.delete_namespaced_pod(name,
 130                                           namespace,
 131                                           body,
 132                                           **kwargs)
 133     except ApiException:
 134         LOG.exception('Delete pod failed')
 135         raise
 136
 137
 138 def read_pod(name,
 139              namespace='default',
 140              **kwargs):  # pragma: no cover
 141     core_v1_api = get_core_api()
 142     try:
 143         resp = core_v1_api.read_namespaced_pod(name, namespace, **kwargs)
 144     except ApiException:
 145         LOG.exception('Read pod failed')
 146         raise
 147     else:
 148         return resp
 149
 150
 151 def read_pod_status(name, namespace='default', **kwargs):   # pragma: no cover
 152     # pylint: disable=unused-argument
 153     return read_pod(name).status.phase
 154
 155
 156 def create_config_map(name,
 157                       data,
 158                       namespace='default',
 159                       wait=False,
 160                       **kwargs):   # pragma: no cover
 161     # pylint: disable=unused-argument
 162     core_v1_api = get_core_api()
 163     metadata = client.V1ObjectMeta(name=name)
 164     body = client.V1ConfigMap(data=data, metadata=metadata)
 165     try:
 166         core_v1_api.create_namespaced_config_map(namespace, body, **kwargs)
 167     except ApiException:
 168         LOG.exception('Create config map failed')
 169         raise
 170
 171
 172 def delete_config_map(name,
 173                       namespace='default',
 174                       wait=False,
 175                       **kwargs):     # pragma: no cover
 176     # pylint: disable=unused-argument
 177     core_v1_api = get_core_api()
 178     body = kwargs.get('body', client.V1DeleteOptions())
 179     kwargs.pop('body', None)
 180     try:
 181         core_v1_api.delete_namespaced_config_map(name,
 182                                                  namespace,
 183                                                  body,
 184                                                  **kwargs)
 185     except ApiException:
 186         LOG.exception('Delete config map failed')
 187         raise
 188
 189
 190 def get_pod_list(namespace='default'):      # pragma: no cover
 191     core_v1_api = get_core_api()
 192     try:
 193         return core_v1_api.list_namespaced_pod(namespace=namespace)
 194     except ApiException:
 195         LOG.exception('Get pod list failed')
 196         raise
 197
 198
 199 def get_pod_by_name(name):  # pragma: no cover
 200     pod_list = get_pod_list()
 201     return next((n for n in pod_list.items if n.metadata.name.startswith(name)), None)
 202
 203
 204 def get_volume_types():
 205     """Return the "volume" types supported by the current API"""
 206     return [vtype for vtype in client.V1Volume.attribute_map.values()
 207             if vtype != 'name']