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     core_v1_api = get_core_api()
  45     metadata = client.V1ObjectMeta(**template.get('metadata', {}))
  46
  47     ports = [client.V1ServicePort(**port) for port in
  48              template.get('spec', {}).get('ports', [])]
  49     template['spec']['ports'] = ports
  50     spec = client.V1ServiceSpec(**template.get('spec', {}))
  51
  52     service = client.V1Service(metadata=metadata, spec=spec)
  53
  54     try:
  55         core_v1_api.create_namespaced_service('default', service)
  56     except ApiException:
  57         LOG.exception('Create Service failed')
  58         raise
  59
  60
  61 def delete_service(name,
  62                    namespace='default',
  63                    **kwargs):       # pragma: no cover
  64     core_v1_api = get_core_api()
  65     try:
  66         core_v1_api.delete_namespaced_service(name, namespace, **kwargs)
  67     except ApiException:
  68         LOG.exception('Delete Service failed')
  69
  70
  71 def get_service_list(namespace='default', **kwargs):
  72     core_v1_api = get_core_api()
  73     try:
  74         return core_v1_api.list_namespaced_service(namespace, **kwargs)
  75     except ApiException:
  76         LOG.exception('Get Service list failed')
  77         raise
  78
  79
  80 def get_service_by_name(name):      # pragma: no cover
  81     service_list = get_service_list()
  82     return next((s.spec for s in service_list.items if s.metadata.name == name), None)
  83
  84
  85 def create_replication_controller(template,
  86                                   namespace='default',
  87                                   wait=False,
  88                                   **kwargs):    # pragma: no cover
  89
  90     core_v1_api = get_core_api()
  91     try:
  92         core_v1_api.create_namespaced_replication_controller(namespace,
  93                                                              template,
  94                                                              **kwargs)
  95     except ApiException:
  96         LOG.exception('Create replication controller failed')
  97         raise
  98
  99
 100 def delete_replication_controller(name,
 101                                   namespace='default',
 102                                   wait=False,
 103                                   **kwargs):    # pragma: no cover
 104
 105     core_v1_api = get_core_api()
 106     body = kwargs.get('body', client.V1DeleteOptions())
 107     kwargs.pop('body', None)
 108     try:
 109         core_v1_api.delete_namespaced_replication_controller(name,
 110                                                              namespace,
 111                                                              body,
 112                                                              **kwargs)
 113     except ApiException:
 114         LOG.exception('Delete replication controller failed')
 115         raise
 116
 117
 118 def delete_pod(name,
 119                namespace='default',
 120                wait=False,
 121                **kwargs):    # pragma: no cover
 122
 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_pod(name,
 128                                           namespace,
 129                                           body,
 130                                           **kwargs)
 131     except ApiException:
 132         LOG.exception('Delete pod failed')
 133         raise
 134
 135
 136 def read_pod(name,
 137              namespace='default',
 138              **kwargs):  # pragma: no cover
 139     core_v1_api = get_core_api()
 140     try:
 141         resp = core_v1_api.read_namespaced_pod(name, namespace, **kwargs)
 142     except ApiException:
 143         LOG.exception('Read pod failed')
 144         raise
 145     else:
 146         return resp
 147
 148
 149 def read_pod_status(name, namespace='default', **kwargs):   # pragma: no cover
 150     return read_pod(name).status.phase
 151
 152
 153 def create_config_map(name,
 154                       data,
 155                       namespace='default',
 156                       wait=False,
 157                       **kwargs):   # pragma: no cover
 158     core_v1_api = get_core_api()
 159     metadata = client.V1ObjectMeta(name=name)
 160     body = client.V1ConfigMap(data=data, metadata=metadata)
 161     try:
 162         core_v1_api.create_namespaced_config_map(namespace, body, **kwargs)
 163     except ApiException:
 164         LOG.exception('Create config map failed')
 165         raise
 166
 167
 168 def delete_config_map(name,
 169                       namespace='default',
 170                       wait=False,
 171                       **kwargs):     # pragma: no cover
 172     core_v1_api = get_core_api()
 173     body = kwargs.get('body', client.V1DeleteOptions())
 174     kwargs.pop('body', None)
 175     try:
 176         core_v1_api.delete_namespaced_config_map(name,
 177                                                  namespace,
 178                                                  body,
 179                                                  **kwargs)
 180     except ApiException:
 181         LOG.exception('Delete config map failed')
 182         raise
 183
 184
 185 def get_pod_list(namespace='default'):      # pragma: no cover
 186     core_v1_api = get_core_api()
 187     try:
 188         return core_v1_api.list_namespaced_pod(namespace=namespace)
 189     except ApiException:
 190         LOG.exception('Get pod list failed')
 191         raise
 192
 193
 194 def get_pod_by_name(name):  # pragma: no cover
 195     pod_list = get_pod_list()
 196     return next((n for n in pod_list.items if n.metadata.name.startswith(name)), None)