1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
5 # This file is part of openmano
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
12 # http://www.apache.org/licenses/LICENSE-2.0
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact with: nfvlabs@tid.es
25 HTTP server implementing the openmano API. It will answer to POST, PUT, GET methods in the appropriate URLs
26 and will use the nfvo.py module to run the appropriate method.
27 Every YAML/JSON file is checked against a schema in openmano_schemas.py module.
29 __author__
="Alfonso Tierno, Gerardo Garcia"
30 __date__
="$17-sep-2014 09:07:15$"
39 from jsonschema
import validate
as js_v
, exceptions
as js_e
40 from openmano_schemas
import vnfd_schema_v01
, vnfd_schema_v02
, \
41 nsd_schema_v01
, nsd_schema_v02
, nsd_schema_v03
, scenario_edit_schema
, \
42 scenario_action_schema
, instance_scenario_action_schema
, instance_scenario_create_schema_v01
, \
43 tenant_schema
, tenant_edit_schema
,\
44 datacenter_schema
, datacenter_edit_schema
, datacenter_action_schema
, datacenter_associate_schema
,\
45 object_schema
, netmap_new_schema
, netmap_edit_schema
48 from db_base
import db_base_Exception
49 from functools
import wraps
57 HTTP_Bad_Request
= 400
58 HTTP_Unauthorized
= 401
61 HTTP_Method_Not_Allowed
= 405
62 HTTP_Not_Acceptable
= 406
63 HTTP_Service_Unavailable
= 503
64 HTTP_Internal_Server_Error
= 500
66 def delete_nulls(var
):
69 if var
[k
] is None: del var
[k
]
70 elif type(var
[k
]) is dict or type(var
[k
]) is list or type(var
[k
]) is tuple:
71 if delete_nulls(var
[k
]): del var
[k
]
72 if len(var
) == 0: return True
73 elif type(var
) is list or type(var
) is tuple:
75 if type(k
) is dict: delete_nulls(k
)
76 if len(var
) == 0: return True
79 def convert_datetime2str(var
):
80 '''Converts a datetime variable to a string with the format '%Y-%m-%dT%H:%i:%s'
81 It enters recursively in the dict var finding this kind of variables
84 for k
,v
in var
.items():
85 if type(v
) is float and k
in ("created_at", "modified_at"):
86 var
[k
] = time
.strftime("%Y-%m-%dT%H:%M:%S", time
.localtime(v
) )
87 elif type(v
) is dict or type(v
) is list or type(v
) is tuple:
88 convert_datetime2str(v
)
89 if len(var
) == 0: return True
90 elif type(var
) is list or type(var
) is tuple:
92 convert_datetime2str(v
)
94 def log_to_logger(fn
):
96 Wrap a Bottle request so that a log line is emitted after it's handled.
97 (This decorator can be extended to take the desired logger as a param.)
100 def _log_to_logger(*args
, **kwargs
):
101 actual_response
= fn(*args
, **kwargs
)
102 # modify this to log exactly what you need:
103 logger
.info('FROM %s %s %s %s' % (bottle
.request
.remote_addr
,
104 bottle
.request
.method
,
106 bottle
.response
.status
))
107 return actual_response
108 return _log_to_logger
110 class httpserver(threading
.Thread
):
111 def __init__(self
, db
, admin
=False, host
='localhost', port
=9090):
117 logger
= logging
.getLogger('openmano.http')
118 threading
.Thread
.__init
__(self
)
120 self
.port
= port
#Port where the listen service must be started
122 self
.name
= "http_admin"
125 #self.url_preffix = 'http://' + host + ':' + str(port) + url_base
127 #self.first_usable_connection_index = 10
128 #self.next_connection_index = self.first_usable_connection_index #The next connection index to be used
129 #Ensure that when the main program exits the thread will also exit
134 bottle
.install(log_to_logger
)
135 bottle
.run(host
=self
.host
, port
=self
.port
, debug
=False, quiet
=True)
137 def run_bottle(db
, host_
='localhost', port_
=9090):
138 '''used for launching in main thread, so that it can be debugged'''
141 bottle
.run(host
=host_
, port
=port_
, debug
=True) #quiet=True
144 @bottle.route(url_base
+ '/', method
='GET')
147 return 'works' #TODO: to be completed
153 def change_keys_http2db(data
, http_db
, reverse
=False):
154 '''Change keys of dictionary data acording to the key_dict values
155 This allow change from http interface names to database names.
156 When reverse is True, the change is otherwise
158 data: can be a dictionary or a list
159 http_db: is a dictionary with hhtp names as keys and database names as value
160 reverse: by default change is done from http api to database. If True change is done otherwise
161 Return: None, but data is modified'''
162 if type(data
) is tuple or type(data
) is list:
164 change_keys_http2db(d
, http_db
, reverse
)
165 elif type(data
) is dict or type(data
) is bottle
.FormsDict
:
167 for k
,v
in http_db
.items():
168 if v
in data
: data
[k
]=data
.pop(v
)
170 for k
,v
in http_db
.items():
171 if k
in data
: data
[v
]=data
.pop(k
)
173 def format_out(data
):
174 '''return string of dictionary data according to requested json, yaml, xml. By default json'''
175 logger
.debug("OUT: " + yaml
.safe_dump(data
, explicit_start
=True, indent
=4, default_flow_style
=False, tags
=False, encoding
='utf-8', allow_unicode
=True) )
176 if 'application/yaml' in bottle
.request
.headers
.get('Accept'):
177 bottle
.response
.content_type
='application/yaml'
178 return yaml
.safe_dump(data
, explicit_start
=True, indent
=4, default_flow_style
=False, tags
=False, encoding
='utf-8', allow_unicode
=True) #, canonical=True, default_style='"'
179 else: #by default json
180 bottle
.response
.content_type
='application/json'
181 #return data #json no style
182 return json
.dumps(data
, indent
=4) + "\n"
184 def format_in(default_schema
, version_fields
=None, version_dict_schema
=None):
185 ''' Parse the content of HTTP request against a json_schema
187 default_schema: The schema to be parsed by default if no version field is found in the client data
188 version_fields: If provided it contains a tuple or list with the fields to iterate across the client data to obtain the version
189 version_dict_schema: It contains a dictionary with the version as key, and json schema to apply as value
190 It can contain a None as key, and this is apply if the client data version does not match any key
192 user_data, used_schema: if the data is successfully decoded and matches the schema
193 launch a bottle abort if fails
195 #print "HEADERS :" + str(bottle.request.headers.items())
197 error_text
= "Invalid header format "
198 format_type
= bottle
.request
.headers
.get('Content-Type', 'application/json')
199 if 'application/json' in format_type
:
200 error_text
= "Invalid json format "
201 #Use the json decoder instead of bottle decoder because it informs about the location of error formats with a ValueError exception
202 client_data
= json
.load(bottle
.request
.body
)
203 #client_data = bottle.request.json()
204 elif 'application/yaml' in format_type
:
205 error_text
= "Invalid yaml format "
206 client_data
= yaml
.load(bottle
.request
.body
)
207 elif 'application/xml' in format_type
:
208 bottle
.abort(501, "Content-Type: application/xml not supported yet.")
210 logger
.warning('Content-Type ' + str(format_type
) + ' not supported.')
211 bottle
.abort(HTTP_Not_Acceptable
, 'Content-Type ' + str(format_type
) + ' not supported.')
213 #if client_data == None:
214 # bottle.abort(HTTP_Bad_Request, "Content error, empty")
217 logger
.debug('IN: %s', yaml
.safe_dump(client_data
, explicit_start
=True, indent
=4, default_flow_style
=False, tags
=False, encoding
='utf-8', allow_unicode
=True) )
218 #look for the client provider version
219 error_text
= "Invalid content "
220 client_version
= None
222 if version_fields
!= None:
223 client_version
= client_data
224 for field
in version_fields
:
225 if field
in client_version
:
226 client_version
= client_version
[field
]
230 if client_version
==None:
231 used_schema
=default_schema
232 elif version_dict_schema
!=None:
233 if client_version
in version_dict_schema
:
234 used_schema
= version_dict_schema
[client_version
]
235 elif None in version_dict_schema
:
236 used_schema
= version_dict_schema
[None]
237 if used_schema
==None:
238 bottle
.abort(HTTP_Bad_Request
, "Invalid schema version or missing version field")
240 js_v(client_data
, used_schema
)
241 return client_data
, used_schema
242 except (ValueError, yaml
.YAMLError
) as exc
:
243 error_text
+= str(exc
)
244 logger
.error(error_text
)
245 bottle
.abort(HTTP_Bad_Request
, error_text
)
246 except js_e
.ValidationError
as exc
:
247 logger
.error("validate_in error, jsonschema exception at '%s' '%s' ", str(exc
.path
), str(exc
.message
))
249 if len(exc
.path
)>0: error_pos
=" at " + ":".join(map(json
.dumps
, exc
.path
))
250 bottle
.abort(HTTP_Bad_Request
, error_text
+ exc
.message
+ error_pos
)
252 # bottle.abort(HTTP_Bad_Request, "Content error: Failed to parse Content-Type", error_pos)
255 def filter_query_string(qs
, http2db
, allowed
):
256 '''Process query string (qs) checking that contains only valid tokens for avoiding SQL injection
258 'qs': bottle.FormsDict variable to be processed. None or empty is considered valid
259 'http2db': dictionary with change from http API naming (dictionary key) to database naming(dictionary value)
260 'allowed': list of allowed string tokens (API http naming). All the keys of 'qs' must be one of 'allowed'
261 Return: A tuple with the (select,where,limit) to be use in a database query. All of then transformed to the database naming
262 select: list of items to retrieve, filtered by query string 'field=token'. If no 'field' is present, allowed list is returned
263 where: dictionary with key, value, taken from the query string token=value. Empty if nothing is provided
264 limit: limit dictated by user with the query string 'limit'. 100 by default
265 abort if not permited, using bottel.abort
270 #if type(qs) is not bottle.FormsDict:
271 # bottle.abort(HTTP_Internal_Server_Error, '!!!!!!!!!!!!!!invalid query string not a dictionary')
272 # #bottle.abort(HTTP_Internal_Server_Error, "call programmer")
275 select
+= qs
.getall(k
)
278 bottle
.abort(HTTP_Bad_Request
, "Invalid query string at 'field="+v
+"'")
283 bottle
.abort(HTTP_Bad_Request
, "Invalid query string at 'limit="+qs
[k
]+"'")
286 bottle
.abort(HTTP_Bad_Request
, "Invalid query string at '"+k
+"="+qs
[k
]+"'")
287 if qs
[k
]!="null": where
[k
]=qs
[k
]
289 if len(select
)==0: select
+= allowed
290 #change from http api to database naming
291 for i
in range(0,len(select
)):
293 if http2db
and k
in http2db
:
294 select
[i
] = http2db
[k
]
296 change_keys_http2db(where
, http2db
)
297 #print "filter_query_string", select,where,limit
299 return select
,where
,limit
301 @bottle.hook('after_request')
303 '''Don't know yet if really needed. Keep it just in case'''
304 bottle
.response
.headers
['Access-Control-Allow-Origin'] = '*'
310 @bottle.route(url_base
+ '/tenants', method
='GET')
311 def http_get_tenants():
312 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
313 select_
,where_
,limit_
= filter_query_string(bottle
.request
.query
, None,
314 ('uuid','name','description','created_at') )
316 tenants
= mydb
.get_rows(FROM
='nfvo_tenants', SELECT
=select_
,WHERE
=where_
,LIMIT
=limit_
)
317 #change_keys_http2db(content, http2db_tenant, reverse=True)
318 convert_datetime2str(tenants
)
319 data
={'tenants' : tenants
}
320 return format_out(data
)
321 except db_base_Exception
as e
:
322 logger
.error("http_get_tenants error {}: {}".format(e
.http_code
, str(e
)))
323 bottle
.abort(e
.http_code
, str(e
))
325 @bottle.route(url_base
+ '/tenants/<tenant_id>', method
='GET')
326 def http_get_tenant_id(tenant_id
):
327 '''get tenant details, can use both uuid or name'''
329 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
331 tenant
= mydb
.get_table_by_uuid_name('nfvo_tenants', tenant_id
, "tenant")
332 #change_keys_http2db(content, http2db_tenant, reverse=True)
333 convert_datetime2str(tenant
)
334 data
={'tenant' : tenant
}
335 return format_out(data
)
336 except db_base_Exception
as e
:
337 logger
.error("http_get_tenant_id error {}: {}".format(e
.http_code
, str(e
)))
338 bottle
.abort(e
.http_code
, str(e
))
340 @bottle.route(url_base
+ '/tenants', method
='POST')
341 def http_post_tenants():
342 '''insert a tenant into the catalogue. '''
344 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
345 http_content
,_
= format_in( tenant_schema
)
346 r
= utils
.remove_extra_items(http_content
, tenant_schema
)
348 logger
.debug("Remove received extra items %s", str(r
))
350 data
= nfvo
.new_tenant(mydb
, http_content
['tenant'])
351 return http_get_tenant_id(data
)
352 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
353 logger
.error("http_post_tenants error {}: {}".format(e
.http_code
, str(e
)))
354 bottle
.abort(e
.http_code
, str(e
))
356 @bottle.route(url_base
+ '/tenants/<tenant_id>', method
='PUT')
357 def http_edit_tenant_id(tenant_id
):
358 '''edit tenant details, can use both uuid or name'''
360 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
361 http_content
,_
= format_in( tenant_edit_schema
)
362 r
= utils
.remove_extra_items(http_content
, tenant_edit_schema
)
364 logger
.debug("Remove received extra items %s", str(r
))
366 #obtain data, check that only one exist
368 tenant
= mydb
.get_table_by_uuid_name('nfvo_tenants', tenant_id
)
370 tenant_id
= tenant
['uuid']
371 where
={'uuid': tenant
['uuid']}
372 mydb
.update_rows('nfvo_tenants', http_content
['tenant'], where
)
373 return http_get_tenant_id(tenant_id
)
374 except db_base_Exception
as e
:
375 logger
.error("http_edit_tenant_id error {}: {}".format(e
.http_code
, str(e
)))
376 bottle
.abort(e
.http_code
, str(e
))
378 @bottle.route(url_base
+ '/tenants/<tenant_id>', method
='DELETE')
379 def http_delete_tenant_id(tenant_id
):
380 '''delete a tenant from database, can use both uuid or name'''
381 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
383 data
= nfvo
.delete_tenant(mydb
, tenant_id
)
384 return format_out({"result":"tenant " + data
+ " deleted"})
385 except db_base_Exception
as e
:
386 logger
.error("http_delete_tenant_id error {}: {}".format(e
.http_code
, str(e
)))
387 bottle
.abort(e
.http_code
, str(e
))
390 @bottle.route(url_base
+ '/<tenant_id>/datacenters', method
='GET')
391 def http_get_datacenters(tenant_id
):
392 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
394 if tenant_id
!= 'any':
395 #check valid tenant_id
396 nfvo
.check_tenant(mydb
, tenant_id
)
397 select_
,where_
,limit_
= filter_query_string(bottle
.request
.query
, None,
398 ('uuid','name','vim_url','type','created_at') )
399 if tenant_id
!= 'any':
400 where_
['nfvo_tenant_id'] = tenant_id
401 if 'created_at' in select_
:
402 select_
[ select_
.index('created_at') ] = 'd.created_at as created_at'
403 if 'created_at' in where_
:
404 where_
['d.created_at'] = where_
.pop('created_at')
405 datacenters
= mydb
.get_rows(FROM
='datacenters as d join tenants_datacenters as td on d.uuid=td.datacenter_id',
406 SELECT
=select_
,WHERE
=where_
,LIMIT
=limit_
)
408 datacenters
= mydb
.get_rows(FROM
='datacenters',
409 SELECT
=select_
,WHERE
=where_
,LIMIT
=limit_
)
410 #change_keys_http2db(content, http2db_tenant, reverse=True)
411 convert_datetime2str(datacenters
)
412 data
={'datacenters' : datacenters
}
413 return format_out(data
)
414 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
415 logger
.error("http_get_datacenters error {}: {}".format(e
.http_code
, str(e
)))
416 bottle
.abort(e
.http_code
, str(e
))
418 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>', method
='GET')
419 def http_get_datacenter_id(tenant_id
, datacenter_id
):
420 '''get datacenter details, can use both uuid or name'''
421 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
423 if tenant_id
!= 'any':
424 #check valid tenant_id
425 nfvo
.check_tenant(mydb
, tenant_id
)
427 what
= 'uuid' if utils
.check_valid_uuid(datacenter_id
) else 'name'
429 where_
[what
] = datacenter_id
430 select_
=['uuid', 'name','vim_url', 'vim_url_admin', 'type', 'config', 'description', 'd.created_at as created_at']
431 if tenant_id
!= 'any':
432 select_
.append("datacenter_tenant_id")
433 where_
['td.nfvo_tenant_id']= tenant_id
434 from_
='datacenters as d join tenants_datacenters as td on d.uuid=td.datacenter_id'
436 from_
='datacenters as d'
437 datacenters
= mydb
.get_rows(
442 if len(datacenters
)==0:
443 bottle
.abort( HTTP_Not_Found
, "No datacenter found for tenant with {} '{}'".format(what
, datacenter_id
) )
444 elif len(datacenters
)>1:
445 bottle
.abort( HTTP_Bad_Request
, "More than one datacenter found for tenant with {} '{}'".format(what
, datacenter_id
) )
446 datacenter
= datacenters
[0]
447 if tenant_id
!= 'any':
449 vim_tenants
= mydb
.get_rows(
450 SELECT
=("vim_tenant_name", "vim_tenant_id", "user"),
451 FROM
="datacenter_tenants",
452 WHERE
={"uuid": datacenters
[0]["datacenter_tenant_id"]},
453 ORDER_BY
=("created", ) )
454 del datacenter
["datacenter_tenant_id"]
455 datacenter
["vim_tenants"] = vim_tenants
457 if datacenter
['config'] != None:
459 config_dict
= yaml
.load(datacenter
['config'])
460 datacenter
['config'] = config_dict
462 logger
.error("Exception '%s' while trying to load config information", str(e
))
463 #change_keys_http2db(content, http2db_datacenter, reverse=True)
464 convert_datetime2str(datacenter
)
465 data
={'datacenter' : datacenter
}
466 return format_out(data
)
467 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
468 logger
.error("http_get_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
469 bottle
.abort(e
.http_code
, str(e
))
471 @bottle.route(url_base
+ '/datacenters', method
='POST')
472 def http_post_datacenters():
473 '''insert a tenant into the catalogue. '''
475 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
476 http_content
,_
= format_in( datacenter_schema
)
477 r
= utils
.remove_extra_items(http_content
, datacenter_schema
)
479 logger
.debug("Remove received extra items %s", str(r
))
481 data
= nfvo
.new_datacenter(mydb
, http_content
['datacenter'])
482 return http_get_datacenter_id('any', data
)
483 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
484 logger
.error("http_post_datacenters error {}: {}".format(e
.http_code
, str(e
)))
485 bottle
.abort(e
.http_code
, str(e
))
487 @bottle.route(url_base
+ '/datacenters/<datacenter_id_name>', method
='PUT')
488 def http_edit_datacenter_id(datacenter_id_name
):
489 '''edit datacenter details, can use both uuid or name'''
490 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
492 http_content
,_
= format_in( datacenter_edit_schema
)
493 r
= utils
.remove_extra_items(http_content
, datacenter_edit_schema
)
495 logger
.debug("Remove received extra items %s", str(r
))
498 datacenter_id
= nfvo
.edit_datacenter(mydb
, datacenter_id_name
, http_content
['datacenter'])
499 return http_get_datacenter_id('any', datacenter_id
)
500 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
501 logger
.error("http_edit_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
502 bottle
.abort(e
.http_code
, str(e
))
504 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/networks', method
='GET') #deprecated
505 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/netmaps', method
='GET')
506 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/netmaps/<netmap_id>', method
='GET')
507 def http_getnetmap_datacenter_id(tenant_id
, datacenter_id
, netmap_id
=None):
508 '''get datacenter networks, can use both uuid or name'''
509 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
512 datacenter_dict
= mydb
.get_table_by_uuid_name('datacenters', datacenter_id
, "datacenter")
513 where_
= {"datacenter_id":datacenter_dict
['uuid']}
515 if utils
.check_valid_uuid(netmap_id
):
516 where_
["uuid"] = netmap_id
518 where_
["name"] = netmap_id
519 netmaps
=mydb
.get_rows(FROM
='datacenter_nets',
520 SELECT
=('name','vim_net_id as vim_id', 'uuid', 'type','multipoint','shared','description', 'created_at'),
522 convert_datetime2str(netmaps
)
523 utils
.convert_str2boolean(netmaps
, ('shared', 'multipoint') )
524 if netmap_id
and len(netmaps
)==1:
525 data
={'netmap' : netmaps
[0]}
526 elif netmap_id
and len(netmaps
)==0:
527 bottle
.abort(HTTP_Not_Found
, "No netmap found with " + " and ".join(map(lambda x
: str(x
[0])+": "+str(x
[1]), where_
.iteritems())) )
530 data
={'netmaps' : netmaps
}
531 return format_out(data
)
532 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
533 logger
.error("http_getnetwork_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
534 bottle
.abort(e
.http_code
, str(e
))
536 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/netmaps', method
='DELETE')
537 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/netmaps/<netmap_id>', method
='DELETE')
538 def http_delnetmap_datacenter_id(tenant_id
, datacenter_id
, netmap_id
=None):
539 '''get datacenter networks, can use both uuid or name'''
540 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
543 datacenter_dict
= mydb
.get_table_by_uuid_name('datacenters', datacenter_id
, "datacenter")
544 where_
= {"datacenter_id":datacenter_dict
['uuid']}
546 if utils
.check_valid_uuid(netmap_id
):
547 where_
["uuid"] = netmap_id
549 where_
["name"] = netmap_id
550 #change_keys_http2db(content, http2db_tenant, reverse=True)
551 deleted
= mydb
.delete_row(FROM
='datacenter_nets', WHERE
= where_
)
552 if deleted
== 0 and netmap_id
:
553 bottle
.abort(HTTP_Not_Found
, "No netmap found with " + " and ".join(map(lambda x
: str(x
[0])+": "+str(x
[1]), where_
.iteritems())) )
555 return format_out({"result": "netmap %s deleted" % netmap_id
})
557 return format_out({"result": "%d netmap deleted" % deleted
})
558 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
559 logger
.error("http_delnetmap_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
560 bottle
.abort(e
.http_code
, str(e
))
563 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/netmaps/upload', method
='POST')
564 def http_uploadnetmap_datacenter_id(tenant_id
, datacenter_id
):
565 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
567 netmaps
= nfvo
.datacenter_new_netmap(mydb
, tenant_id
, datacenter_id
, None)
568 convert_datetime2str(netmaps
)
569 utils
.convert_str2boolean(netmaps
, ('shared', 'multipoint') )
570 data
={'netmaps' : netmaps
}
571 return format_out(data
)
572 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
573 logger
.error("http_uploadnetmap_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
574 bottle
.abort(e
.http_code
, str(e
))
576 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/netmaps', method
='POST')
577 def http_postnetmap_datacenter_id(tenant_id
, datacenter_id
):
578 '''creates a new netmap'''
579 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
581 http_content
,_
= format_in( netmap_new_schema
)
582 r
= utils
.remove_extra_items(http_content
, netmap_new_schema
)
584 logger
.debug("Remove received extra items %s", str(r
))
586 #obtain data, check that only one exist
587 netmaps
= nfvo
.datacenter_new_netmap(mydb
, tenant_id
, datacenter_id
, http_content
)
588 convert_datetime2str(netmaps
)
589 utils
.convert_str2boolean(netmaps
, ('shared', 'multipoint') )
590 data
={'netmaps' : netmaps
}
591 return format_out(data
)
592 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
593 logger
.error("http_postnetmap_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
594 bottle
.abort(e
.http_code
, str(e
))
596 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/netmaps/<netmap_id>', method
='PUT')
597 def http_putnettmap_datacenter_id(tenant_id
, datacenter_id
, netmap_id
):
599 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
601 http_content
,_
= format_in( netmap_edit_schema
)
602 r
= utils
.remove_extra_items(http_content
, netmap_edit_schema
)
604 logger
.debug("Remove received extra items %s", str(r
))
606 #obtain data, check that only one exist
608 nfvo
.datacenter_edit_netmap(mydb
, tenant_id
, datacenter_id
, netmap_id
, http_content
)
609 return http_getnetmap_datacenter_id(tenant_id
, datacenter_id
, netmap_id
)
610 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
611 logger
.error("http_putnettmap_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
612 bottle
.abort(e
.http_code
, str(e
))
615 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>/action', method
='POST')
616 def http_action_datacenter_id(tenant_id
, datacenter_id
):
617 '''perform an action over datacenter, can use both uuid or name'''
618 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
620 http_content
,_
= format_in( datacenter_action_schema
)
621 r
= utils
.remove_extra_items(http_content
, datacenter_action_schema
)
623 logger
.debug("Remove received extra items %s", str(r
))
625 #obtain data, check that only one exist
626 result
= nfvo
.datacenter_action(mydb
, tenant_id
, datacenter_id
, http_content
)
627 if 'net-update' in http_content
:
628 return http_getnetmap_datacenter_id(datacenter_id
)
630 return format_out(result
)
631 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
632 logger
.error("http_action_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
633 bottle
.abort(e
.http_code
, str(e
))
636 @bottle.route(url_base
+ '/datacenters/<datacenter_id>', method
='DELETE')
637 def http_delete_datacenter_id( datacenter_id
):
638 '''delete a tenant from database, can use both uuid or name'''
640 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
642 data
= nfvo
.delete_datacenter(mydb
, datacenter_id
)
643 return format_out({"result":"datacenter '" + data
+ "' deleted"})
644 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
645 logger
.error("http_delete_datacenter_id error {}: {}".format(e
.http_code
, str(e
)))
646 bottle
.abort(e
.http_code
, str(e
))
648 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>', method
='POST')
649 def http_associate_datacenters(tenant_id
, datacenter_id
):
650 '''associate an existing datacenter to a this tenant. '''
651 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
653 http_content
,_
= format_in( datacenter_associate_schema
)
654 r
= utils
.remove_extra_items(http_content
, datacenter_associate_schema
)
656 logger
.debug("Remove received extra items %s", str(r
))
658 id_
= nfvo
.associate_datacenter_to_tenant(mydb
, tenant_id
, datacenter_id
,
659 http_content
['datacenter'].get('vim_tenant'),
660 http_content
['datacenter'].get('vim_tenant_name'),
661 http_content
['datacenter'].get('vim_username'),
662 http_content
['datacenter'].get('vim_password')
664 return http_get_datacenter_id(tenant_id
, id_
)
665 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
666 logger
.error("http_associate_datacenters error {}: {}".format(e
.http_code
, str(e
)))
667 bottle
.abort(e
.http_code
, str(e
))
669 @bottle.route(url_base
+ '/<tenant_id>/datacenters/<datacenter_id>', method
='DELETE')
670 def http_deassociate_datacenters(tenant_id
, datacenter_id
):
671 '''deassociate an existing datacenter to a this tenant. '''
672 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
674 data
= nfvo
.deassociate_datacenter_to_tenant(mydb
, tenant_id
, datacenter_id
)
675 return format_out({"result": data
})
676 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
677 logger
.error("http_deassociate_datacenters error {}: {}".format(e
.http_code
, str(e
)))
678 bottle
.abort(e
.http_code
, str(e
))
680 @bottle.route(url_base
+ '/<tenant_id>/vim/<datacenter_id>/<item>', method
='GET')
681 @bottle.route(url_base
+ '/<tenant_id>/vim/<datacenter_id>/<item>/<name>', method
='GET')
682 def http_get_vim_items(tenant_id
, datacenter_id
, item
, name
=None):
683 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
685 data
= nfvo
.vim_action_get(mydb
, tenant_id
, datacenter_id
, item
, name
)
686 return format_out(data
)
687 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
688 logger
.error("http_get_vim_items error {}: {}".format(e
.http_code
, str(e
)))
689 bottle
.abort(e
.http_code
, str(e
))
691 @bottle.route(url_base
+ '/<tenant_id>/vim/<datacenter_id>/<item>/<name>', method
='DELETE')
692 def http_del_vim_items(tenant_id
, datacenter_id
, item
, name
):
693 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
695 data
= nfvo
.vim_action_delete(mydb
, tenant_id
, datacenter_id
, item
, name
)
696 return format_out({"result":data
})
697 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
698 logger
.error("http_del_vim_items error {}: {}".format(e
.http_code
, str(e
)))
699 bottle
.abort(e
.http_code
, str(e
))
700 @bottle.route(url_base
+ '/<tenant_id>/vim/<datacenter_id>/<item>', method
='POST')
701 def http_post_vim_items(tenant_id
, datacenter_id
, item
):
702 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
703 http_content
,_
= format_in( object_schema
)
705 data
= nfvo
.vim_action_create(mydb
, tenant_id
, datacenter_id
, item
, http_content
)
706 return format_out(data
)
707 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
708 logger
.error("http_post_vim_items error {}: {}".format(e
.http_code
, str(e
)))
709 bottle
.abort(e
.http_code
, str(e
))
711 @bottle.route(url_base
+ '/<tenant_id>/vnfs', method
='GET')
712 def http_get_vnfs(tenant_id
):
713 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
715 if tenant_id
!= 'any':
716 #check valid tenant_id
717 nfvo
.check_tenant(mydb
, tenant_id
)
718 select_
,where_
,limit_
= filter_query_string(bottle
.request
.query
, None,
719 ('uuid','name','description','public', "tenant_id", "created_at") )
721 if tenant_id
!= "any":
722 where_or
["tenant_id"] = tenant_id
723 where_or
["public"] = True
724 vnfs
= mydb
.get_rows(FROM
='vnfs', SELECT
=select_
,WHERE
=where_
,WHERE_OR
=where_or
, WHERE_AND_OR
="AND",LIMIT
=limit_
)
725 #change_keys_http2db(content, http2db_vnf, reverse=True)
726 utils
.convert_str2boolean(vnfs
, ('public',))
727 convert_datetime2str(vnfs
)
729 return format_out(data
)
730 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
731 logger
.error("http_get_vnfs error {}: {}".format(e
.http_code
, str(e
)))
732 bottle
.abort(e
.http_code
, str(e
))
734 @bottle.route(url_base
+ '/<tenant_id>/vnfs/<vnf_id>', method
='GET')
735 def http_get_vnf_id(tenant_id
,vnf_id
):
736 '''get vnf details, can use both uuid or name'''
737 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
739 vnf
= nfvo
.get_vnf_id(mydb
,tenant_id
,vnf_id
)
740 utils
.convert_str2boolean(vnf
, ('public',))
741 convert_datetime2str(vnf
)
742 return format_out(vnf
)
743 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
744 logger
.error("http_get_vnf_id error {}: {}".format(e
.http_code
, str(e
)))
745 bottle
.abort(e
.http_code
, str(e
))
747 @bottle.route(url_base
+ '/<tenant_id>/vnfs', method
='POST')
748 def http_post_vnfs(tenant_id
):
749 '''insert a vnf into the catalogue. Creates the flavor and images in the VIM, and creates the VNF and its internal structure in the OPENMANO DB'''
750 #print "Parsing the YAML file of the VNF"
752 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
753 http_content
, used_schema
= format_in( vnfd_schema_v01
, ("schema_version",), {"0.2": vnfd_schema_v02
})
754 r
= utils
.remove_extra_items(http_content
, used_schema
)
756 logger
.debug("Remove received extra items %s", str(r
))
758 if used_schema
== vnfd_schema_v01
:
759 vnf_id
= nfvo
.new_vnf(mydb
,tenant_id
,http_content
)
760 elif used_schema
== vnfd_schema_v02
:
761 vnf_id
= nfvo
.new_vnf_v02(mydb
,tenant_id
,http_content
)
763 logger
.warning('Unexpected schema_version: %s', http_content
.get("schema_version"))
764 bottle
.abort(HTTP_Bad_Request
, "Invalid schema version")
765 return http_get_vnf_id(tenant_id
, vnf_id
)
766 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
767 logger
.error("http_post_vnfs error {}: {}".format(e
.http_code
, str(e
)))
768 bottle
.abort(e
.http_code
, str(e
))
770 @bottle.route(url_base
+ '/<tenant_id>/vnfs/<vnf_id>', method
='DELETE')
771 def http_delete_vnf_id(tenant_id
,vnf_id
):
772 '''delete a vnf from database, and images and flavors in VIM when appropriate, can use both uuid or name'''
773 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
774 #check valid tenant_id and deletes the vnf, including images,
776 data
= nfvo
.delete_vnf(mydb
,tenant_id
,vnf_id
)
777 #print json.dumps(data, indent=4)
778 return format_out({"result":"VNF " + data
+ " deleted"})
779 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
780 logger
.error("http_delete_vnf_id error {}: {}".format(e
.http_code
, str(e
)))
781 bottle
.abort(e
.http_code
, str(e
))
783 #@bottle.route(url_base + '/<tenant_id>/hosts/topology', method='GET')
784 #@bottle.route(url_base + '/<tenant_id>/physicalview/Madrid-Alcantara', method='GET')
785 @bottle.route(url_base
+ '/<tenant_id>/physicalview/<datacenter>', method
='GET')
786 def http_get_hosts(tenant_id
, datacenter
):
787 '''get the tidvim host hopology from the vim.'''
788 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
789 #print "http_get_hosts received by tenant " + tenant_id + ' datacenter ' + datacenter
791 if datacenter
== 'treeview':
792 data
= nfvo
.get_hosts(mydb
, tenant_id
)
794 #openmano-gui is using a hardcoded value for the datacenter
795 result
, data
= nfvo
.get_hosts_info(mydb
, tenant_id
) #, datacenter)
798 #print "http_get_hosts error %d %s" % (-result, data)
799 bottle
.abort(-result
, data
)
801 convert_datetime2str(data
)
802 #print json.dumps(data, indent=4)
803 return format_out(data
)
804 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
805 logger
.error("http_get_hosts error {}: {}".format(e
.http_code
, str(e
)))
806 bottle
.abort(e
.http_code
, str(e
))
809 @bottle.route(url_base
+ '/<path:path>', method
='OPTIONS')
810 def http_options_deploy(path
):
811 '''For some reason GUI web ask for OPTIONS that must be responded'''
812 #TODO: check correct path, and correct headers request
813 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
814 bottle
.response
.set_header('Access-Control-Allow-Methods','POST, GET, PUT, DELETE, OPTIONS')
815 bottle
.response
.set_header('Accept','application/yaml,application/json')
816 bottle
.response
.set_header('Content-Type','application/yaml,application/json')
817 bottle
.response
.set_header('Access-Control-Allow-Headers','content-type')
818 bottle
.response
.set_header('Access-Control-Allow-Origin','*')
821 @bottle.route(url_base
+ '/<tenant_id>/topology/deploy', method
='POST')
822 def http_post_deploy(tenant_id
):
823 '''post topology deploy.'''
824 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
826 http_content
, used_schema
= format_in( nsd_schema_v01
, ("schema_version",), {2: nsd_schema_v02
})
827 #r = utils.remove_extra_items(http_content, used_schema)
828 #if r is not None: print "http_post_deploy: Warning: remove extra items ", r
829 #print "http_post_deploy input: ", http_content
832 scenario_id
= nfvo
.new_scenario(mydb
, tenant_id
, http_content
)
833 instance
= nfvo
.start_scenario(mydb
, tenant_id
, scenario_id
, http_content
['name'], http_content
['name'])
834 #print json.dumps(data, indent=4)
835 return format_out(instance
)
836 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
837 logger
.error("http_post_deploy error {}: {}".format(e
.http_code
, str(e
)))
838 bottle
.abort(e
.http_code
, str(e
))
840 @bottle.route(url_base
+ '/<tenant_id>/topology/verify', method
='POST')
841 def http_post_verify(tenant_id
):
843 # '''post topology verify'''
844 # print "http_post_verify by tenant " + tenant_id + ' datacenter ' + datacenter
845 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
852 @bottle.route(url_base
+ '/<tenant_id>/scenarios', method
='POST')
853 def http_post_scenarios(tenant_id
):
854 '''add a scenario into the catalogue. Creates the scenario and its internal structure in the OPENMANO DB'''
855 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
856 http_content
, used_schema
= format_in( nsd_schema_v01
, ("schema_version",), {2: nsd_schema_v02
, "0.3": nsd_schema_v03
})
857 #r = utils.remove_extra_items(http_content, used_schema)
858 #if r is not None: print "http_post_scenarios: Warning: remove extra items ", r
859 #print "http_post_scenarios input: ", http_content
861 if used_schema
== nsd_schema_v01
:
862 scenario_id
= nfvo
.new_scenario(mydb
, tenant_id
, http_content
)
863 elif used_schema
== nsd_schema_v02
:
864 scenario_id
= nfvo
.new_scenario_v02(mydb
, tenant_id
, http_content
)
865 elif used_schema
== nsd_schema_v03
:
866 scenario_id
= nfvo
.new_scenario_v03(mydb
, tenant_id
, http_content
)
868 logger
.warning('Unexpected schema_version: %s', http_content
.get("schema_version"))
869 bottle
.abort(HTTP_Bad_Request
, "Invalid schema version")
870 #print json.dumps(data, indent=4)
871 #return format_out(data)
872 return http_get_scenario_id(tenant_id
, scenario_id
)
873 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
874 logger
.error("http_post_scenarios error {}: {}".format(e
.http_code
, str(e
)))
875 bottle
.abort(e
.http_code
, str(e
))
877 @bottle.route(url_base
+ '/<tenant_id>/scenarios/<scenario_id>/action', method
='POST')
878 def http_post_scenario_action(tenant_id
, scenario_id
):
879 '''take an action over a scenario'''
880 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
881 #check valid tenant_id
883 nfvo
.check_tenant(mydb
, tenant_id
)
885 http_content
,_
= format_in( scenario_action_schema
)
886 r
= utils
.remove_extra_items(http_content
, scenario_action_schema
)
888 logger
.debug("Remove received extra items %s", str(r
))
889 if "start" in http_content
:
890 data
= nfvo
.start_scenario(mydb
, tenant_id
, scenario_id
, http_content
['start']['instance_name'], \
891 http_content
['start'].get('description',http_content
['start']['instance_name']),
892 http_content
['start'].get('datacenter') )
893 return format_out(data
)
894 elif "deploy" in http_content
: #Equivalent to start
895 data
= nfvo
.start_scenario(mydb
, tenant_id
, scenario_id
, http_content
['deploy']['instance_name'],
896 http_content
['deploy'].get('description',http_content
['deploy']['instance_name']),
897 http_content
['deploy'].get('datacenter') )
898 return format_out(data
)
899 elif "reserve" in http_content
: #Reserve resources
900 data
= nfvo
.start_scenario(mydb
, tenant_id
, scenario_id
, http_content
['reserve']['instance_name'],
901 http_content
['reserve'].get('description',http_content
['reserve']['instance_name']),
902 http_content
['reserve'].get('datacenter'), startvms
=False )
903 return format_out(data
)
904 elif "verify" in http_content
: #Equivalent to start and then delete
905 data
= nfvo
.start_scenario(mydb
, tenant_id
, scenario_id
, http_content
['verify']['instance_name'],
906 http_content
['verify'].get('description',http_content
['verify']['instance_name']),
907 http_content
['verify'].get('datacenter'), startvms
=False )
908 instance_id
= data
['uuid']
909 nfvo
.delete_instance(mydb
, tenant_id
,instance_id
)
910 return format_out({"result":"Verify OK"})
911 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
912 logger
.error("http_post_scenario_action error {}: {}".format(e
.http_code
, str(e
)))
913 bottle
.abort(e
.http_code
, str(e
))
915 @bottle.route(url_base
+ '/<tenant_id>/scenarios', method
='GET')
916 def http_get_scenarios(tenant_id
):
917 '''get scenarios list'''
918 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
920 #check valid tenant_id
921 if tenant_id
!= "any":
922 nfvo
.check_tenant(mydb
, tenant_id
)
924 s
,w
,l
=filter_query_string(bottle
.request
.query
, None, ('uuid', 'name', 'description', 'tenant_id', 'created_at', 'public'))
926 if tenant_id
!= "any":
927 where_or
["tenant_id"] = tenant_id
928 where_or
["public"] = True
929 scenarios
= mydb
.get_rows(SELECT
=s
, WHERE
=w
, WHERE_OR
=where_or
, WHERE_AND_OR
="AND", LIMIT
=l
, FROM
='scenarios')
930 convert_datetime2str(scenarios
)
931 utils
.convert_str2boolean(scenarios
, ('public',) )
932 data
={'scenarios':scenarios
}
933 #print json.dumps(scenarios, indent=4)
934 return format_out(data
)
935 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
936 logger
.error("http_get_scenarios error {}: {}".format(e
.http_code
, str(e
)))
937 bottle
.abort(e
.http_code
, str(e
))
939 @bottle.route(url_base
+ '/<tenant_id>/scenarios/<scenario_id>', method
='GET')
940 def http_get_scenario_id(tenant_id
, scenario_id
):
941 '''get scenario details, can use both uuid or name'''
942 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
944 #check valid tenant_id
945 if tenant_id
!= "any":
946 nfvo
.check_tenant(mydb
, tenant_id
)
948 scenario
= mydb
.get_scenario(scenario_id
, tenant_id
)
949 convert_datetime2str(scenario
)
950 data
={'scenario' : scenario
}
951 return format_out(data
)
952 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
953 logger
.error("http_get_scenarios error {}: {}".format(e
.http_code
, str(e
)))
954 bottle
.abort(e
.http_code
, str(e
))
956 @bottle.route(url_base
+ '/<tenant_id>/scenarios/<scenario_id>', method
='DELETE')
957 def http_delete_scenario_id(tenant_id
, scenario_id
):
958 '''delete a scenario from database, can use both uuid or name'''
960 #check valid tenant_id
961 if tenant_id
!= "any":
962 nfvo
.check_tenant(mydb
, tenant_id
)
964 data
= mydb
.delete_scenario(scenario_id
, tenant_id
)
965 #print json.dumps(data, indent=4)
966 return format_out({"result":"scenario " + data
+ " deleted"})
967 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
968 logger
.error("http_delete_scenario_id error {}: {}".format(e
.http_code
, str(e
)))
969 bottle
.abort(e
.http_code
, str(e
))
972 @bottle.route(url_base
+ '/<tenant_id>/scenarios/<scenario_id>', method
='PUT')
973 def http_put_scenario_id(tenant_id
, scenario_id
):
974 '''edit an existing scenario id'''
975 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
976 http_content
,_
= format_in( scenario_edit_schema
)
977 #r = utils.remove_extra_items(http_content, scenario_edit_schema)
978 #if r is not None: print "http_put_scenario_id: Warning: remove extra items ", r
979 #print "http_put_scenario_id input: ", http_content
981 nfvo
.edit_scenario(mydb
, tenant_id
, scenario_id
, http_content
)
982 #print json.dumps(data, indent=4)
983 #return format_out(data)
984 return http_get_scenario_id(tenant_id
, scenario_id
)
985 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
986 logger
.error("http_put_scenario_id error {}: {}".format(e
.http_code
, str(e
)))
987 bottle
.abort(e
.http_code
, str(e
))
989 @bottle.route(url_base
+ '/<tenant_id>/instances', method
='POST')
990 def http_post_instances(tenant_id
):
991 '''take an action over a scenario'''
992 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
994 #check valid tenant_id
995 if tenant_id
!= "any":
996 nfvo
.check_tenant(mydb
, tenant_id
)
998 http_content
,used_schema
= format_in( instance_scenario_create_schema_v01
)
999 r
= utils
.remove_extra_items(http_content
, used_schema
)
1001 logger
.warning("http_post_instances: Warning: remove extra items %s", str(r
))
1002 data
= nfvo
.create_instance(mydb
, tenant_id
, http_content
["instance"])
1003 return format_out(data
)
1004 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
1005 logger
.error("http_post_instances error {}: {}".format(e
.http_code
, str(e
)))
1006 bottle
.abort(e
.http_code
, str(e
))
1011 @bottle.route(url_base
+ '/<tenant_id>/instances', method
='GET')
1012 def http_get_instances(tenant_id
):
1013 '''get instance list'''
1015 #check valid tenant_id
1016 if tenant_id
!= "any":
1017 nfvo
.check_tenant(mydb
, tenant_id
)
1019 s
,w
,l
=filter_query_string(bottle
.request
.query
, None, ('uuid', 'name', 'scenario_id', 'tenant_id', 'description', 'created_at'))
1020 if tenant_id
!= "any":
1021 w
['tenant_id'] = tenant_id
1022 instances
= mydb
.get_rows(SELECT
=s
, WHERE
=w
, LIMIT
=l
, FROM
='instance_scenarios')
1023 convert_datetime2str(instances
)
1024 utils
.convert_str2boolean(instances
, ('public',) )
1025 data
={'instances':instances
}
1026 return format_out(data
)
1027 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
1028 logger
.error("http_get_instances error {}: {}".format(e
.http_code
, str(e
)))
1029 bottle
.abort(e
.http_code
, str(e
))
1031 @bottle.route(url_base
+ '/<tenant_id>/instances/<instance_id>', method
='GET')
1032 def http_get_instance_id(tenant_id
, instance_id
):
1033 '''get instances details, can use both uuid or name'''
1034 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
1036 #check valid tenant_id
1037 if tenant_id
!= "any":
1038 nfvo
.check_tenant(mydb
, tenant_id
)
1039 if tenant_id
== "any":
1041 #obtain data (first time is only to check that the instance exists)
1042 instance_dict
= mydb
.get_instance_scenario(instance_id
, tenant_id
, verbose
=True)
1044 nfvo
.refresh_instance(mydb
, tenant_id
, instance_dict
)
1045 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
1046 logger
.warn("nfvo.refresh_instance couldn't refresh the status of the instance: %s" % str(e
))
1047 #obtain data with results upated
1048 instance
= mydb
.get_instance_scenario(instance_id
, tenant_id
)
1049 convert_datetime2str(instance
)
1050 #print json.dumps(instance, indent=4)
1051 return format_out(instance
)
1052 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
1053 logger
.error("http_get_instance_id error {}: {}".format(e
.http_code
, str(e
)))
1054 bottle
.abort(e
.http_code
, str(e
))
1056 @bottle.route(url_base
+ '/<tenant_id>/instances/<instance_id>', method
='DELETE')
1057 def http_delete_instance_id(tenant_id
, instance_id
):
1058 '''delete instance from VIM and from database, can use both uuid or name'''
1059 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
1061 #check valid tenant_id
1062 if tenant_id
!= "any":
1063 nfvo
.check_tenant(mydb
, tenant_id
)
1064 if tenant_id
== "any":
1067 message
= nfvo
.delete_instance(mydb
, tenant_id
,instance_id
)
1068 return format_out({"result":message
})
1069 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
1070 logger
.error("http_delete_instance_id error {}: {}".format(e
.http_code
, str(e
)))
1071 bottle
.abort(e
.http_code
, str(e
))
1073 @bottle.route(url_base
+ '/<tenant_id>/instances/<instance_id>/action', method
='POST')
1074 def http_post_instance_scenario_action(tenant_id
, instance_id
):
1075 '''take an action over a scenario instance'''
1076 logger
.debug('FROM %s %s %s', bottle
.request
.remote_addr
, bottle
.request
.method
, bottle
.request
.url
)
1078 #check valid tenant_id
1079 if tenant_id
!= "any":
1080 nfvo
.check_tenant(mydb
, tenant_id
)
1083 http_content
,_
= format_in( instance_scenario_action_schema
)
1084 r
= utils
.remove_extra_items(http_content
, instance_scenario_action_schema
)
1086 logger
.debug("Remove received extra items %s", str(r
))
1087 #print "http_post_instance_scenario_action input: ", http_content
1089 instance
= mydb
.get_instance_scenario(instance_id
, tenant_id
)
1090 instance_id
= instance
["uuid"]
1092 data
= nfvo
.instance_action(mydb
, tenant_id
, instance_id
, http_content
)
1093 return format_out(data
)
1094 except (nfvo
.NfvoException
, db_base_Exception
) as e
:
1095 logger
.error("http_post_instance_scenario_action error {}: {}".format(e
.http_code
, str(e
)))
1096 bottle
.abort(e
.http_code
, str(e
))
1108 def error400(error
):
1109 e
={"error":{"code":error
.status_code
, "type":error
.status
, "description":error
.body
}}
1110 bottle
.response
.headers
['Access-Control-Allow-Origin'] = '*'
1111 return format_out(e
)