fa401405651c054af33729eb15d63661a50c88eb
1 # Copyright 2018 Telefonica
5 # Licensed under the Apache License, Version 2.0 (the "License"); you may
6 # not use this file except in compliance with the License. You may obtain
7 # a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
13 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
14 # License for the specific language governing permissions and limitations
21 from osmclient
.common
import utils
22 from osmclient
.common
import wait
as WaitForStatus
23 from osmclient
.common
.exceptions
import ClientException
24 from osmclient
.common
.exceptions
import NotFound
31 def __init__(self
, http
=None, client
=None):
34 self
._logger
= logging
.getLogger("osmclient")
35 self
._apiName
= "/admin"
36 self
._apiVersion
= "/v1"
37 self
._apiResource
= "/vim_accounts"
38 self
._apiBase
= "{}{}{}".format(
39 self
._apiName
, self
._apiVersion
, self
._apiResource
43 def _wait(self
, id, wait_time
, deleteFlag
=False):
44 self
._logger
.debug("")
45 self
._client
.get_token()
46 # Endpoint to get operation status
47 apiUrlStatus
= "{}{}{}".format(self
._apiName
, self
._apiVersion
, "/vim_accounts")
48 # Wait for status for VIM instance creation/deletion
49 if isinstance(wait_time
, bool):
50 wait_time
= WaitForStatus
.TIMEOUT_VIM_OPERATION
51 WaitForStatus
.wait_for_status(
57 deleteFlag
=deleteFlag
,
60 def _get_id_for_wait(self
, name
):
61 """Returns id of name, or the id itself if given as argument"""
62 self
._logger
.debug("")
63 self
._client
.get_token()
64 for vim
in self
.list():
65 if name
== vim
["uuid"]:
67 for vim
in self
.list():
68 if name
== vim
["name"]:
78 sdn_port_mapping
=None,
84 vca
= self
._client
.vca
.get(vca
)
86 raise NotFound("cannot find vca '{}'".format(vca
))
89 self
._logger
.debug("")
90 self
._client
.get_token()
91 if "vca" in vim_access
:
92 vca_id
= get_vca_id(vim_access
["vca"])
93 if "vim-type" not in vim_access
:
94 # 'openstack' not in vim_access['vim-type']):
95 raise Exception("vim type not provided")
97 vim_account
["name"] = name
98 vim_account
= self
.update_vim_account_dict(vim_account
, vim_access
)
100 vim_account
["vca"] = vca_id
103 sdnc
= self
._client
.sdnc
.get(sdn_controller
)
104 vim_config
["sdn-controller"] = sdnc
["_id"]
106 with
open(sdn_port_mapping
, "r") as f
:
107 vim_config
["sdn-port-mapping"] = yaml
.safe_load(f
.read())
109 vim_account
["config"] = vim_config
110 # vim_account['config'] = json.dumps(vim_config)
111 http_code
, resp
= self
._http
.post_cmd(
112 endpoint
=self
._apiBase
, postfields_dict
=vim_account
114 # print('HTTP CODE: {}'.format(http_code))
115 # print('RESP: {}'.format(resp))
116 # if http_code in (200, 201, 202, 204):
118 resp
= json
.loads(resp
)
119 if not resp
or "id" not in resp
:
120 raise ClientException("unexpected response from server - {}".format(resp
))
122 # Wait for status for VIM instance creation
123 self
._wait
(resp
.get("id"), wait
)
129 # msg = json.loads(resp)
132 # raise ClientException("failed to create vim {} - {}".format(name, msg))
143 self
._logger
.debug("")
144 self
._client
.get_token()
145 vim
= self
.get(vim_name
)
146 vim_id_for_wait
= self
._get
_id
_for
_wait
(vim_name
)
148 if config
is not None:
149 if not config
and (sdn_controller
or sdn_port_mapping
):
150 # If config is empty (clearing config)
151 raise ClientException(
152 "clearing config is incompatible with updating SDN info"
155 if sdn_controller
== "":
156 vim_config
["sdn-controller"] = None
157 vim_config
["sdn-port-mapping"] = None
160 sdnc
= self
._client
.sdnc
.get(sdn_controller
)
161 vim_config
["sdn-controller"] = sdnc
["_id"]
163 with
open(sdn_port_mapping
, "r") as f
:
164 vim_config
["sdn-port-mapping"] = yaml
.safe_load(f
.read())
165 vim_account
["config"] = vim_config
166 # vim_account['config'] = json.dumps(vim_config)
167 http_code
, resp
= self
._http
.patch_cmd(
168 endpoint
="{}/{}".format(self
._apiBase
, vim
["_id"]),
169 postfields_dict
=vim_account
,
171 # print('HTTP CODE: {}'.format(http_code))
172 # print('RESP: {}'.format(resp))
173 # if http_code in (200, 201, 202, 204):
175 # In this case, 'resp' always returns None, so 'resp['id']' cannot be used.
176 # Use the previously obtained id instead.
177 wait_id
= vim_id_for_wait
178 # Wait for status for VI instance update
179 self
._wait
(wait_id
, wait
)
186 # msg = json.loads(resp)
189 # raise ClientException("failed to update vim {} - {}".format(vim_name, msg))
191 def update_vim_account_dict(self
, vim_account
, vim_access
):
192 self
._logger
.debug("")
193 vim_account
["vim_type"] = vim_access
["vim-type"]
194 vim_account
["description"] = vim_access
["description"]
195 vim_account
["vim_url"] = vim_access
["vim-url"] or "null"
196 vim_account
["vim_user"] = vim_access
["vim-username"] or "null"
197 vim_account
["vim_password"] = vim_access
["vim-password"] or "null"
198 vim_account
["vim_tenant_name"] = vim_access
["vim-tenant-name"] or "null"
199 if "prometheus-config" in vim_access
:
200 vim_account
["prometheus_config"] = vim_access
["prometheus-config"]
203 def get_id(self
, name
):
204 """Returns a VIM id from a VIM name"""
205 self
._logger
.debug("")
206 for vim
in self
.list():
207 if name
== vim
["name"]:
209 raise NotFound("vim {} not found".format(name
))
211 def delete(self
, vim_name
, force
=False, wait
=False):
212 self
._logger
.debug("")
213 self
._client
.get_token()
215 if not utils
.validate_uuid4(vim_name
):
216 vim_id
= self
.get_id(vim_name
)
219 querystring
= "?FORCE=True"
220 http_code
, resp
= self
._http
.delete_cmd(
221 "{}/{}{}".format(self
._apiBase
, vim_id
, querystring
)
223 # print('HTTP CODE: {}'.format(http_code))
224 # print('RESP: {}'.format(resp))
227 # When deleting an account, 'resp' may be None.
228 # In such a case, the 'id' from 'resp' cannot be used, so use 'vim_id' instead
231 resp
= json
.loads(resp
)
232 wait_id
= resp
.get("id")
233 # Wait for status for VIM account deletion
234 self
._wait
(wait_id
, wait
, deleteFlag
=True)
236 print("Deletion in progress")
237 elif http_code
== 204:
243 # msg = json.loads(resp)
246 raise ClientException("failed to delete vim {} - {}".format(vim_name
, msg
))
248 def list(self
, filter=None):
249 """Returns a list of VIM accounts"""
250 self
._logger
.debug("")
251 self
._client
.get_token()
254 filter_string
= "?{}".format(filter)
255 _
, resp
= self
._http
.get2_cmd("{}{}".format(self
._apiBase
, filter_string
))
258 vim_accounts
= json
.loads(resp
)
259 for datacenter
in vim_accounts
:
260 datacenter
["uuid"] = datacenter
.get("_id") # backward compatibility?
264 """Returns a VIM account based on name or id"""
265 self
._logger
.debug("")
266 self
._client
.get_token()
268 if not utils
.validate_uuid4(name
):
269 vim_id
= self
.get_id(name
)
271 _
, resp
= self
._http
.get2_cmd("{}/{}".format(self
._apiBase
, vim_id
))
273 resp
= json
.loads(resp
)
274 if not resp
or "_id" not in resp
:
275 raise ClientException("failed to get vim info: {}".format(resp
))
278 raise NotFound("vim '{}' not found".format(name
))