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
.exceptions
import ClientException
23 from osmclient
.common
.exceptions
import NotFound
30 def __init__(self
, http
=None, client
=None):
33 self
._apiName
= '/nslcm'
34 self
._apiVersion
= '/v1'
35 self
._apiResource
= '/ns_instances_content'
36 self
._apiBase
= '{}{}{}'.format(self
._apiName
,
37 self
._apiVersion
, self
._apiResource
)
39 def list(self
, filter=None):
40 """Returns a list of NS
44 filter_string
= '?{}'.format(filter)
45 resp
= self
._http
.get_cmd('{}{}'.format(self
._apiBase
,filter_string
))
51 """Returns an NS based on name or id
53 if utils
.validate_uuid4(name
):
54 for ns
in self
.list():
58 for ns
in self
.list():
59 if name
== ns
['name']:
61 raise NotFound("ns {} not found".format(name
))
63 def get_individual(self
, name
):
65 if not utils
.validate_uuid4(name
):
66 for ns
in self
.list():
67 if name
== ns
['name']:
70 resp
= self
._http
.get_cmd('{}/{}'.format(self
._apiBase
, ns_id
))
71 #resp = self._http.get_cmd('{}/{}/nsd_content'.format(self._apiBase, ns_id))
72 #print yaml.safe_dump(resp)
75 raise NotFound("ns {} not found".format(name
))
77 def delete(self
, name
, force
=False):
81 querystring
= '?FORCE=True'
82 http_code
, resp
= self
._http
.delete_cmd('{}/{}{}'.format(self
._apiBase
,
83 ns
['_id'], querystring
))
84 #print 'HTTP CODE: {}'.format(http_code)
85 #print 'RESP: {}'.format(resp)
87 print('Deletion in progress')
88 elif http_code
== 204:
94 msg
= json
.loads(resp
)
97 raise ClientException("failed to delete ns {} - {}".format(name
, msg
))
99 def create(self
, nsd_name
, nsr_name
, account
, config
=None,
100 ssh_keys
=None, description
='default description',
101 admin_status
='ENABLED'):
103 nsd
= self
._client
.nsd
.get(nsd_name
)
107 def get_vim_account_id(vim_account
):
108 if vim_account_id
.get(vim_account
):
109 return vim_account_id
[vim_account
]
111 vim
= self
._client
.vim
.get(vim_account
)
113 raise NotFound("cannot find vim account '{}'".format(vim_account
))
114 vim_account_id
[vim_account
] = vim
['_id']
118 ns
['nsdId'] = nsd
['_id']
119 ns
['nsName'] = nsr_name
120 ns
['nsDescription'] = description
121 ns
['vimAccountId'] = get_vim_account_id(account
)
123 #ns['userdata']['key1']='value1'
124 #ns['userdata']['key2']='value2'
126 if ssh_keys
is not None:
127 # ssh_keys is comma separate list
128 # ssh_keys_format = []
129 # for key in ssh_keys.split(','):
130 # ssh_keys_format.append({'key-pair-ref': key})
132 # ns['ssh-authorized-key'] = ssh_keys_format
133 ns
['ssh-authorized-key'] = []
134 for pubkeyfile
in ssh_keys
.split(','):
135 with
open(pubkeyfile
, 'r') as f
:
136 ns
['ssh-authorized-key'].append(f
.read())
138 ns_config
= yaml
.load(config
)
139 if "vim-network-name" in ns_config
:
140 ns_config
["vld"] = ns_config
.pop("vim-network-name")
141 if "vld" in ns_config
:
142 for vld
in ns_config
["vld"]:
143 if vld
.get("vim-network-name"):
144 if isinstance(vld
["vim-network-name"], dict):
145 vim_network_name_dict
= {}
146 for vim_account
, vim_net
in list(vld
["vim-network-name"].items()):
147 vim_network_name_dict
[get_vim_account_id(vim_account
)] = vim_net
148 vld
["vim-network-name"] = vim_network_name_dict
149 ns
["vld"] = ns_config
["vld"]
150 if "vnf" in ns_config
:
151 for vnf
in ns_config
["vnf"]:
152 if vnf
.get("vim_account"):
153 vnf
["vimAccountId"] = get_vim_account_id(vnf
.pop("vim_account"))
155 ns
["vnf"] = ns_config
["vnf"]
157 #print yaml.safe_dump(ns)
159 self
._apiResource
= '/ns_instances_content'
160 self
._apiBase
= '{}{}{}'.format(self
._apiName
,
161 self
._apiVersion
, self
._apiResource
)
162 http_code
, resp
= self
._http
.post_cmd(endpoint
=self
._apiBase
,
164 #print 'HTTP CODE: {}'.format(http_code)
165 #print 'RESP: {}'.format(resp)
166 if http_code
in (200, 201, 202, 204):
168 resp
= json
.loads(resp
)
169 if not resp
or 'id' not in resp
:
170 raise ClientException('unexpected response from server - {} '.format(
177 msg
= json
.loads(resp
)
180 raise ClientException(msg
)
181 except ClientException
as exc
:
182 message
="failed to create ns: {} nsd: {}\nerror:\n{}".format(
186 raise ClientException(message
)
188 def list_op(self
, name
, filter=None):
189 """Returns the list of operations of a NS
193 self
._apiResource
= '/ns_lcm_op_occs'
194 self
._apiBase
= '{}{}{}'.format(self
._apiName
,
195 self
._apiVersion
, self
._apiResource
)
198 filter_string
= '&{}'.format(filter)
199 http_code
, resp
= self
._http
.get2_cmd('{}?nsInstanceId={}'.format(
200 self
._apiBase
, ns
['_id'],
202 #print 'HTTP CODE: {}'.format(http_code)
203 #print 'RESP: {}'.format(resp)
206 resp
= json
.loads(resp
)
209 raise ClientException('unexpected response from server')
214 resp
= json
.loads(resp
)
218 raise ClientException(msg
)
219 except ClientException
as exc
:
220 message
="failed to get operation list of NS {}:\nerror:\n{}".format(
223 raise ClientException(message
)
225 def get_op(self
, operationId
):
226 """Returns the status of an operation
229 self
._apiResource
= '/ns_lcm_op_occs'
230 self
._apiBase
= '{}{}{}'.format(self
._apiName
,
231 self
._apiVersion
, self
._apiResource
)
232 http_code
, resp
= self
._http
.get2_cmd('{}/{}'.format(self
._apiBase
, operationId
))
233 #print 'HTTP CODE: {}'.format(http_code)
234 #print 'RESP: {}'.format(resp)
237 resp
= json
.loads(resp
)
240 raise ClientException('unexpected response from server')
245 resp
= json
.loads(resp
)
249 raise ClientException(msg
)
250 except ClientException
as exc
:
251 message
="failed to get status of operation {}:\nerror:\n{}".format(
254 raise ClientException(message
)
256 def exec_op(self
, name
, op_name
, op_data
=None):
257 """Executes an operation on a NS
261 self
._apiResource
= '/ns_instances'
262 self
._apiBase
= '{}{}{}'.format(self
._apiName
,
263 self
._apiVersion
, self
._apiResource
)
264 endpoint
= '{}/{}/{}'.format(self
._apiBase
, ns
['_id'], op_name
)
265 #print 'OP_NAME: {}'.format(op_name)
266 #print 'OP_DATA: {}'.format(json.dumps(op_data))
267 http_code
, resp
= self
._http
.post_cmd(endpoint
=endpoint
, postfields_dict
=op_data
)
268 #print 'HTTP CODE: {}'.format(http_code)
269 #print 'RESP: {}'.format(resp)
270 if http_code
in (200, 201, 202, 204):
272 resp
= json
.loads(resp
)
273 if not resp
or 'id' not in resp
:
274 raise ClientException('unexpected response from server - {}'.format(
281 msg
= json
.loads(resp
)
284 raise ClientException(msg
)
285 except ClientException
as exc
:
286 message
="failed to exec operation {}:\nerror:\n{}".format(
289 raise ClientException(message
)
291 def create_alarm(self
, alarm
):
293 data
["create_alarm_request"] = {}
294 data
["create_alarm_request"]["alarm_create_request"] = alarm
296 http_code
, resp
= self
._http
.post_cmd(endpoint
='/test/message/alarm_request',
297 postfields_dict
=data
)
298 #print 'HTTP CODE: {}'.format(http_code)
299 #print 'RESP: {}'.format(resp)
300 if http_code
in (200, 201, 202, 204):
301 #resp = json.loads(resp)
302 print('Alarm created')
307 msg
= json
.loads(resp
)
310 raise ClientException('error: code: {}, resp: {}'.format(
312 except ClientException
as exc
:
313 message
="failed to create alarm: alarm {}\n{}".format(
316 raise ClientException(message
)
318 def delete_alarm(self
, name
):
320 data
["delete_alarm_request"] = {}
321 data
["delete_alarm_request"]["alarm_delete_request"] = {}
322 data
["delete_alarm_request"]["alarm_delete_request"]["alarm_uuid"] = name
324 http_code
, resp
= self
._http
.post_cmd(endpoint
='/test/message/alarm_request',
325 postfields_dict
=data
)
326 #print 'HTTP CODE: {}'.format(http_code)
327 #print 'RESP: {}'.format(resp)
328 if http_code
in (200, 201, 202, 204):
329 #resp = json.loads(resp)
330 print('Alarm deleted')
335 msg
= json
.loads(resp
)
338 raise ClientException('error: code: {}, resp: {}'.format(
340 except ClientException
as exc
:
341 message
="failed to delete alarm: alarm {}\n{}".format(
344 raise ClientException(message
)
346 def export_metric(self
, metric
):
348 data
["read_metric_data_request"] = metric
350 http_code
, resp
= self
._http
.post_cmd(endpoint
='/test/message/metric_request',
351 postfields_dict
=data
)
352 #print 'HTTP CODE: {}'.format(http_code)
353 #print 'RESP: {}'.format(resp)
354 if http_code
in (200, 201, 202, 204):
355 #resp = json.loads(resp)
356 return 'Metric exported'
361 msg
= json
.loads(resp
)
364 raise ClientException('error: code: {}, resp: {}'.format(
366 except ClientException
as exc
:
367 message
="failed to export metric: metric {}\n{}".format(
370 raise ClientException(message
)