osmclient/sol005/k8scluster.py

   1 #
   2 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   3 #    not use this file except in compliance with the License. You may obtain
   4 #    a copy of the License at
   5 #
   6 #         http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 #    Unless required by applicable law or agreed to in writing, software
   9 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  10 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  11 #    License for the specific language governing permissions and limitations
  12 #    under the License.
  13 #
  14
  15 """
  16 OSM K8s cluster API handling
  17 """
  18
  19 from osmclient.common import utils
  20 from osmclient.common.exceptions import NotFound
  21 from osmclient.common.exceptions import ClientException
  22 import json
  23
  24 class K8scluster(object):
  25     def __init__(self, http=None, client=None):
  26         self._http = http
  27         self._client = client
  28         self._apiName = '/admin'
  29         self._apiVersion = '/v1'
  30         self._apiResource = '/k8sclusters'
  31         self._apiBase = '{}{}{}'.format(self._apiName,
  32                                         self._apiVersion, self._apiResource)
  33
  34     def create(self, name, k8s_cluster):
  35
  36         def get_vim_account_id(vim_account):
  37             vim = self._client.vim.get(vim_account)
  38             if vim is None:
  39                 raise NotFound("cannot find vim account '{}'".format(vim_account))
  40             return vim['_id']
  41
  42         self._client.get_token()
  43         k8s_cluster['vim_account'] = get_vim_account_id(k8s_cluster['vim_account'])
  44         http_code, resp = self._http.post_cmd(endpoint=self._apiBase,
  45                                        postfields_dict=k8s_cluster)
  46         #print 'HTTP CODE: {}'.format(http_code)
  47         #print 'RESP: {}'.format(resp)
  48         #if http_code in (200, 201, 202, 204):
  49         if resp:
  50             resp = json.loads(resp)
  51         if not resp or 'id' not in resp:
  52             raise ClientException('unexpected response from server - {}'.format(resp))
  53         print(resp['id'])
  54         #else:
  55         #    msg = ""
  56         #    if resp:
  57         #        try:
  58         #            msg = json.loads(resp)
  59         #        except ValueError:
  60         #            msg = resp
  61         #    raise ClientException("failed to add K8s cluster {} - {}".format(name, msg))
  62
  63     def update(self, name, k8s_cluster):
  64         self._client.get_token()
  65         cluster = self.get(name)
  66         http_code, resp = self._http.put_cmd(endpoint='{}/{}'.format(self._apiBase,cluster['_id']),
  67                                        postfields_dict=k8s_cluster)
  68         # print 'HTTP CODE: {}'.format(http_code)
  69         # print 'RESP: {}'.format(resp)
  70         #if http_code in (200, 201, 202, 204):
  71         #    pass
  72         #else:
  73         #    msg = ""
  74         #    if resp:
  75         #        try:
  76         #            msg = json.loads(resp)
  77         #        except ValueError:
  78         #            msg = resp
  79         #    raise ClientException("failed to update K8s cluster {} - {}".format(name, msg))
  80
  81     def get_id(self, name):
  82         """Returns a K8s cluster id from a K8s cluster name
  83         """
  84         for cluster in self.list():
  85             if name == cluster['name']:
  86                 return cluster['_id']
  87         raise NotFound("K8s cluster {} not found".format(name))
  88
  89     def delete(self, name, force=False):
  90         self._client.get_token()
  91         cluster_id = name
  92         if not utils.validate_uuid4(name):
  93             cluster_id = self.get_id(name)
  94         querystring = ''
  95         if force:
  96             querystring = '?FORCE=True'
  97         http_code, resp = self._http.delete_cmd('{}/{}{}'.format(self._apiBase,
  98                                          cluster_id, querystring))
  99         #print 'HTTP CODE: {}'.format(http_code)
 100         #print 'RESP: {}'.format(resp)
 101         if http_code == 202:
 102             print('Deletion in progress')
 103         elif http_code == 204:
 104             print('Deleted')
 105         else:
 106             msg = resp or ""
 107         #     if resp:
 108         #         try:
 109         #             msg = json.loads(resp)
 110         #         except ValueError:
 111         #             msg = resp
 112             raise ClientException("failed to delete K8s cluster {} - {}".format(name, msg))
 113
 114     def list(self, filter=None):
 115         """Returns a list of K8s clusters
 116         """
 117         self._client.get_token()
 118         filter_string = ''
 119         if filter:
 120             filter_string = '?{}'.format(filter)
 121         _, resp = self._http.get2_cmd('{}{}'.format(self._apiBase,filter_string))
 122         if resp:
 123             return json.loads(resp)
 124         return list()
 125
 126     def get(self, name):
 127         """Returns a K8s cluster based on name or id
 128         """
 129         self._client.get_token()
 130         cluster_id = name
 131         if not utils.validate_uuid4(name):
 132             cluster_id = self.get_id(name)
 133         try:
 134             _, resp = self._http.get2_cmd('{}/{}'.format(self._apiBase,cluster_id))
 135             if resp:
 136                 resp = json.loads(resp)
 137             if not resp or '_id' not in resp:
 138                 raise ClientException('failed to get K8s cluster info: {}'.format(resp))
 139             return resp
 140         except NotFound:
 141             raise NotFound("K8s cluster {} not found".format(name))
 142