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 vimconnector implements all the methods to interact with openvim using the openvim API.
27 __author__
="Alfonso Tierno, Gerardo Garcia"
28 __date__
="$26-aug-2014 11:09:29$"
35 from openmano_schemas
import id_schema
, name_schema
, nameshort_schema
, description_schema
, \
36 vlan1000_schema
, integer0_schema
37 from jsonschema
import validate
as js_v
, exceptions
as js_e
39 from urllib
import quote
# Python 2.X
41 from urllib
.parse
import quote
# Python 3+
43 '''contain the openvim virtual machine status to openmano status'''
44 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
46 'SUSPENDED': 'SUSPENDED',
47 'INACTIVE':'INACTIVE',
49 'ERROR':'ERROR','DELETED':'DELETED'
51 netStatus2manoFormat
={'ACTIVE':'ACTIVE','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED', 'DOWN':'DOWN'
69 "required": ["id","name"]
77 "required": ["id","name"]
79 new_host_response_schema
= {
80 "title":"host response information schema",
81 "$schema": "http://json-schema.org/draft-04/schema#",
87 "additionalProperties": False
90 get_images_response_schema
= {
91 "title":"openvim images response information schema",
92 "$schema": "http://json-schema.org/draft-04/schema#",
97 "items": image_schema
,
100 "required": ["images"],
101 "additionalProperties": False
104 get_hosts_response_schema
= {
105 "title":"openvim hosts response information schema",
106 "$schema": "http://json-schema.org/draft-04/schema#",
111 "items": host_schema
,
114 "required": ["hosts"],
115 "additionalProperties": False
118 get_host_detail_response_schema
= new_host_response_schema
# TODO: Content is not parsed yet
120 get_server_response_schema
= {
121 "title":"openvim server response information schema",
122 "$schema": "http://json-schema.org/draft-04/schema#",
127 "items": server_schema
,
130 "required": ["servers"],
131 "additionalProperties": False
134 new_tenant_response_schema
= {
135 "title":"tenant response information schema",
136 "$schema": "http://json-schema.org/draft-04/schema#",
143 "name": nameshort_schema
,
144 "description":description_schema
,
145 "enabled":{"type" : "boolean"}
150 "required": ["tenant"],
151 "additionalProperties": False
154 new_network_response_schema
= {
155 "title":"network response information schema",
156 "$schema": "http://json-schema.org/draft-04/schema#",
164 "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
165 "shared":{"type":"boolean"},
166 "tenant_id":id_schema
,
167 "admin_state_up":{"type":"boolean"},
168 "vlan":vlan1000_schema
173 "required": ["network"],
174 "additionalProperties": False
178 # get_network_response_schema = {
179 # "title":"get network response information schema",
180 # "$schema": "http://json-schema.org/draft-04/schema#",
187 # "name":name_schema,
188 # "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
189 # "shared":{"type":"boolean"},
190 # "tenant_id":id_schema,
191 # "admin_state_up":{"type":"boolean"},
192 # "vlan":vlan1000_schema
197 # "required": ["network"],
198 # "additionalProperties": False
202 new_port_response_schema
= {
203 "title":"port response information schema",
204 "$schema": "http://json-schema.org/draft-04/schema#",
215 "required": ["port"],
216 "additionalProperties": False
219 get_flavor_response_schema
= {
220 "title":"openvim flavors response information schema",
221 "$schema": "http://json-schema.org/draft-04/schema#",
229 "extended": {"type":"object"},
231 "required": ["id", "name"],
234 "required": ["flavor"],
235 "additionalProperties": False
238 new_flavor_response_schema
= {
239 "title":"flavor response information schema",
240 "$schema": "http://json-schema.org/draft-04/schema#",
251 "required": ["flavor"],
252 "additionalProperties": False
255 get_image_response_schema
= {
256 "title":"openvim images response information schema",
257 "$schema": "http://json-schema.org/draft-04/schema#",
266 "required": ["id", "name"],
269 "required": ["flavor"],
270 "additionalProperties": False
272 new_image_response_schema
= {
273 "title":"image response information schema",
274 "$schema": "http://json-schema.org/draft-04/schema#",
285 "required": ["image"],
286 "additionalProperties": False
289 new_vminstance_response_schema
= {
290 "title":"server response information schema",
291 "$schema": "http://json-schema.org/draft-04/schema#",
302 "required": ["server"],
303 "additionalProperties": False
306 get_processor_rankings_response_schema
= {
307 "title":"processor rankings information schema",
308 "$schema": "http://json-schema.org/draft-04/schema#",
316 "model": description_schema
,
317 "value": integer0_schema
319 "additionalProperties": False,
320 "required": ["model","value"]
323 "additionalProperties": False,
324 "required": ["rankings"]
328 class vimconnector(vimconn
.vimconnector
):
329 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,
330 log_level
="DEBUG", config
={}, persistent_info
={}):
331 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
333 self
.headers_req
= {'content-type': 'application/json'}
334 self
.logger
= logging
.getLogger('openmano.vim.openvim')
335 self
.persistent_info
= persistent_info
337 self
.tenant
= tenant_id
339 def __setitem__(self
,index
, value
):
340 '''Set individuals parameters
341 Throw TypeError, KeyError
343 if index
=='tenant_id':
345 elif index
=='tenant_name':
347 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
349 def _get_my_tenant(self
):
350 '''Obtain uuid of my tenant from name
355 url
= self
.url
+'/tenants?name='+ quote(self
.tenant_name
)
356 self
.logger
.info("Getting VIM tenant_id GET %s", url
)
357 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
358 self
._check
_http
_request
_response
(vim_response
)
360 tenant_list
= vim_response
.json()["tenants"]
361 if len(tenant_list
) == 0:
362 raise vimconn
.vimconnNotFoundException("No tenant found for name '%s'" % str(self
.tenant_name
))
363 elif len(tenant_list
) > 1:
364 raise vimconn
.vimconnConflictException ("More that one tenant found for name '%s'" % str(self
.tenant_name
))
365 self
.tenant
= tenant_list
[0]["id"]
367 except Exception as e
:
368 raise vimconn
.vimconnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e
).__name
__, str(e
)))
370 def _format_jsonerror(self
,http_response
):
371 #DEPRECATED, to delete in the future
373 data
= http_response
.json()
374 return data
["error"]["description"]
376 return http_response
.text
378 def _format_in(self
, http_response
, schema
):
379 #DEPRECATED, to delete in the future
381 client_data
= http_response
.json()
382 js_v(client_data
, schema
)
383 #print("Input data: ", str(client_data))
384 return True, client_data
385 except js_e
.ValidationError
as exc
:
386 print("validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
)
387 return False, ("validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
)
389 def _remove_extra_items(self
, data
, schema
):
391 if type(data
) is tuple or type(data
) is list:
393 a
= self
._remove
_extra
_items
(d
, schema
['items'])
394 if a
is not None: deleted
.append(a
)
395 elif type(data
) is dict:
396 for k
in data
.keys():
397 if 'properties' not in schema
or k
not in schema
['properties'].keys():
401 a
= self
._remove
_extra
_items
(data
[k
], schema
['properties'][k
])
402 if a
is not None: deleted
.append({k
:a
})
403 if len(deleted
) == 0: return None
404 elif len(deleted
) == 1: return deleted
[0]
407 def _format_request_exception(self
, request_exception
):
408 '''Transform a request exception into a vimconn exception'''
409 if isinstance(request_exception
, js_e
.ValidationError
):
410 raise vimconn
.vimconnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception
.message
, request_exception
.path
))
411 elif isinstance(request_exception
, requests
.exceptions
.HTTPError
):
412 raise vimconn
.vimconnUnexpectedResponse(type(request_exception
).__name
__ + ": " + str(request_exception
))
414 raise vimconn
.vimconnConnectionException(type(request_exception
).__name
__ + ": " + str(request_exception
))
416 def _check_http_request_response(self
, request_response
):
417 '''Raise a vimconn exception if the response is not Ok'''
418 if request_response
.status_code
>= 200 and request_response
.status_code
< 300:
420 if request_response
.status_code
== vimconn
.HTTP_Unauthorized
:
421 raise vimconn
.vimconnAuthException(request_response
.text
)
422 elif request_response
.status_code
== vimconn
.HTTP_Not_Found
:
423 raise vimconn
.vimconnNotFoundException(request_response
.text
)
424 elif request_response
.status_code
== vimconn
.HTTP_Conflict
:
425 raise vimconn
.vimconnConflictException(request_response
.text
)
427 raise vimconn
.vimconnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response
.status_code
, str(request_response
.text
)))
429 def new_tenant(self
,tenant_name
,tenant_description
):
430 '''Adds a new tenant to VIM with this name and description, returns the tenant identifier'''
431 #print("VIMConnector: Adding a new tenant to VIM")
432 payload_dict
= {"tenant": {"name":tenant_name
,"description": tenant_description
, "enabled": True}}
433 payload_req
= json
.dumps(payload_dict
)
435 url
= self
.url_admin
+'/tenants'
436 self
.logger
.info("Adding a new tenant %s", url
)
437 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
438 self
._check
_http
_request
_response
(vim_response
)
439 self
.logger
.debug(vim_response
.text
)
440 #print(json.dumps(vim_response.json(), indent=4))
441 response
= vim_response
.json()
442 js_v(response
, new_tenant_response_schema
)
443 #r = self._remove_extra_items(response, new_tenant_response_schema)
445 # self.logger.warn("Warning: remove extra items %s", str(r))
446 tenant_id
= response
['tenant']['id']
448 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
449 self
._format
_request
_exception
(e
)
451 def delete_tenant(self
,tenant_id
):
452 '''Delete a tenant from VIM. Returns the old tenant identifier'''
454 url
= self
.url_admin
+'/tenants/'+tenant_id
455 self
.logger
.info("Delete a tenant DELETE %s", url
)
456 vim_response
= requests
.delete(url
, headers
= self
.headers_req
)
457 self
._check
_http
_request
_response
(vim_response
)
458 self
.logger
.debug(vim_response
.text
)
459 #print(json.dumps(vim_response.json(), indent=4))
461 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
462 self
._format
_request
_exception
(e
)
464 def get_tenant_list(self
, filter_dict
={}):
465 '''Obtain tenants of VIM
466 filter_dict can contain the following keys:
467 name: filter by tenant name
468 id: filter by tenant uuid/id
470 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
474 for k
,v
in filter_dict
.iteritems():
475 filterquery
.append(str(k
)+'='+str(v
))
476 if len(filterquery
)>0:
477 filterquery_text
='?'+ '&'.join(filterquery
)
479 url
= self
.url
+'/tenants'+filterquery_text
480 self
.logger
.info("get_tenant_list GET %s", url
)
481 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
482 self
._check
_http
_request
_response
(vim_response
)
483 self
.logger
.debug(vim_response
.text
)
484 #print(json.dumps(vim_response.json(), indent=4))
485 return vim_response
.json()["tenants"]
486 except requests
.exceptions
.RequestException
as e
:
487 self
._format
_request
_exception
(e
)
489 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None): #, **vim_specific):
490 '''Adds a tenant network to VIM'''
491 '''Returns the network identifier'''
493 self
._get
_my
_tenant
()
494 if net_type
=="bridge":
495 net_type
="bridge_data"
496 payload_req
= {"name": net_name
, "type": net_type
, "tenant_id": self
.tenant
, "shared": shared
}
498 payload_req
["provider:vlan"] = vlan
499 # payload_req.update(vim_specific)
500 url
= self
.url
+'/networks'
501 self
.logger
.info("Adding a new network POST: %s DATA: %s", url
, str(payload_req
))
502 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps({"network": payload_req
}) )
503 self
._check
_http
_request
_response
(vim_response
)
504 self
.logger
.debug(vim_response
.text
)
505 #print(json.dumps(vim_response.json(), indent=4))
506 response
= vim_response
.json()
507 js_v(response
, new_network_response_schema
)
508 #r = self._remove_extra_items(response, new_network_response_schema)
510 # self.logger.warn("Warning: remove extra items %s", str(r))
511 network_id
= response
['network']['id']
513 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
514 self
._format
_request
_exception
(e
)
516 def get_network_list(self
, filter_dict
={}):
517 '''Obtain tenant networks of VIM
523 admin_state_up: boolean
525 Returns the network list of dictionaries
528 if 'tenant_id' not in filter_dict
:
529 filter_dict
["tenant_id"] = self
._get
_my
_tenant
()
530 elif not filter_dict
["tenant_id"]:
531 del filter_dict
["tenant_id"]
534 for k
,v
in filter_dict
.iteritems():
535 filterquery
.append(str(k
)+'='+str(v
))
536 if len(filterquery
)>0:
537 filterquery_text
='?'+ '&'.join(filterquery
)
538 url
= self
.url
+'/networks'+filterquery_text
539 self
.logger
.info("Getting network list GET %s", url
)
540 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
541 self
._check
_http
_request
_response
(vim_response
)
542 self
.logger
.debug(vim_response
.text
)
543 #print(json.dumps(vim_response.json(), indent=4))
544 response
= vim_response
.json()
545 return response
['networks']
546 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
547 self
._format
_request
_exception
(e
)
549 def get_network(self
, net_id
):
550 '''Obtain network details of network id'''
552 url
= self
.url
+'/networks/'+net_id
553 self
.logger
.info("Getting network GET %s", url
)
554 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
555 self
._check
_http
_request
_response
(vim_response
)
556 self
.logger
.debug(vim_response
.text
)
557 #print(json.dumps(vim_response.json(), indent=4))
558 response
= vim_response
.json()
559 return response
['network']
560 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
561 self
._format
_request
_exception
(e
)
563 def delete_network(self
, net_id
):
564 '''Deletes a tenant network from VIM'''
565 '''Returns the network identifier'''
567 self
._get
_my
_tenant
()
568 url
= self
.url
+'/networks/'+net_id
569 self
.logger
.info("Deleting VIM network DELETE %s", url
)
570 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
571 self
._check
_http
_request
_response
(vim_response
)
572 #self.logger.debug(vim_response.text)
573 #print(json.dumps(vim_response.json(), indent=4))
575 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
576 self
._format
_request
_exception
(e
)
578 def get_flavor(self
, flavor_id
):
579 '''Obtain flavor details from the VIM'''
581 self
._get
_my
_tenant
()
582 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
583 self
.logger
.info("Getting flavor GET %s", url
)
584 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
585 self
._check
_http
_request
_response
(vim_response
)
586 self
.logger
.debug(vim_response
.text
)
587 #print(json.dumps(vim_response.json(), indent=4))
588 response
= vim_response
.json()
589 js_v(response
, get_flavor_response_schema
)
590 r
= self
._remove
_extra
_items
(response
, get_flavor_response_schema
)
592 self
.logger
.warn("Warning: remove extra items %s", str(r
))
593 return response
['flavor']
594 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
595 self
._format
_request
_exception
(e
)
597 def new_flavor(self
, flavor_data
):
598 '''Adds a tenant flavor to VIM'''
599 '''Returns the flavor identifier'''
601 new_flavor_dict
= flavor_data
.copy()
602 for device
in new_flavor_dict
.get('extended', {}).get('devices', ()):
603 if 'image name' in device
:
604 del device
['image name']
605 new_flavor_dict
["name"] = flavor_data
["name"][:64]
606 self
._get
_my
_tenant
()
607 payload_req
= json
.dumps({'flavor': new_flavor_dict
})
608 url
= self
.url
+'/'+self
.tenant
+'/flavors'
609 self
.logger
.info("Adding a new VIM flavor POST %s", url
)
610 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
611 self
._check
_http
_request
_response
(vim_response
)
612 self
.logger
.debug(vim_response
.text
)
613 #print(json.dumps(vim_response.json(), indent=4))
614 response
= vim_response
.json()
615 js_v(response
, new_flavor_response_schema
)
616 r
= self
._remove
_extra
_items
(response
, new_flavor_response_schema
)
618 self
.logger
.warn("Warning: remove extra items %s", str(r
))
619 flavor_id
= response
['flavor']['id']
621 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
622 self
._format
_request
_exception
(e
)
624 def delete_flavor(self
,flavor_id
):
625 '''Deletes a tenant flavor from VIM'''
626 '''Returns the old flavor_id'''
628 self
._get
_my
_tenant
()
629 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
630 self
.logger
.info("Deleting VIM flavor DELETE %s", url
)
631 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
632 self
._check
_http
_request
_response
(vim_response
)
633 #self.logger.debug(vim_response.text)
634 #print(json.dumps(vim_response.json(), indent=4))
636 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
637 self
._format
_request
_exception
(e
)
639 def get_image(self
, image_id
):
640 '''Obtain image details from the VIM'''
642 self
._get
_my
_tenant
()
643 url
= self
.url
+'/'+self
.tenant
+'/images/'+image_id
644 self
.logger
.info("Getting image GET %s", url
)
645 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
646 self
._check
_http
_request
_response
(vim_response
)
647 self
.logger
.debug(vim_response
.text
)
648 #print(json.dumps(vim_response.json(), indent=4))
649 response
= vim_response
.json()
650 js_v(response
, get_image_response_schema
)
651 r
= self
._remove
_extra
_items
(response
, get_image_response_schema
)
653 self
.logger
.warn("Warning: remove extra items %s", str(r
))
654 return response
['image']
655 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
656 self
._format
_request
_exception
(e
)
658 def new_image(self
,image_dict
):
659 ''' Adds a tenant image to VIM, returns image_id'''
661 self
._get
_my
_tenant
()
662 new_image_dict
={'name': image_dict
['name'][:64]}
663 if image_dict
.get('description'):
664 new_image_dict
['description'] = image_dict
['description']
665 if image_dict
.get('metadata'):
666 new_image_dict
['metadata'] = yaml
.load(image_dict
['metadata'])
667 if image_dict
.get('location'):
668 new_image_dict
['path'] = image_dict
['location']
669 payload_req
= json
.dumps({"image":new_image_dict
})
670 url
=self
.url
+ '/' + self
.tenant
+ '/images'
671 self
.logger
.info("Adding a new VIM image POST %s", url
)
672 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
673 self
._check
_http
_request
_response
(vim_response
)
674 self
.logger
.debug(vim_response
.text
)
675 #print(json.dumps(vim_response.json(), indent=4))
676 response
= vim_response
.json()
677 js_v(response
, new_image_response_schema
)
678 r
= self
._remove
_extra
_items
(response
, new_image_response_schema
)
680 self
.logger
.warn("Warning: remove extra items %s", str(r
))
681 image_id
= response
['image']['id']
683 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
684 self
._format
_request
_exception
(e
)
686 def delete_image(self
, image_id
):
687 '''Deletes a tenant image from VIM'''
688 '''Returns the deleted image_id'''
690 self
._get
_my
_tenant
()
691 url
= self
.url
+ '/'+ self
.tenant
+'/images/'+image_id
692 self
.logger
.info("Deleting VIM image DELETE %s", url
)
693 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
694 self
._check
_http
_request
_response
(vim_response
)
695 #self.logger.debug(vim_response.text)
696 #print(json.dumps(vim_response.json(), indent=4))
698 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
699 self
._format
_request
_exception
(e
)
701 def get_image_id_from_path(self
, path
):
702 '''Get the image id from image path in the VIM database. Returns the image_id'''
704 self
._get
_my
_tenant
()
705 url
=self
.url
+ '/' + self
.tenant
+ '/images?path='+quote(path
)
706 self
.logger
.info("Getting images GET %s", url
)
707 vim_response
= requests
.get(url
)
708 self
._check
_http
_request
_response
(vim_response
)
709 self
.logger
.debug(vim_response
.text
)
710 #print(json.dumps(vim_response.json(), indent=4))
711 response
= vim_response
.json()
712 js_v(response
, get_images_response_schema
)
713 #r = self._remove_extra_items(response, get_images_response_schema)
715 # self.logger.warn("Warning: remove extra items %s", str(r))
716 if len(response
['images'])==0:
717 raise vimconn
.vimconnNotFoundException("Image not found at VIM with path '%s'", path
)
718 elif len(response
['images'])>1:
719 raise vimconn
.vimconnConflictException("More than one image found at VIM with path '%s'", path
)
720 return response
['images'][0]['id']
721 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
722 self
._format
_request
_exception
(e
)
724 def get_image_list(self
, filter_dict
={}):
725 '''Obtain tenant images from VIM
729 checksum: image checksum
731 Returns the image list of dictionaries:
732 [{<the fields at Filter_dict plus some VIM specific>}, ...]
736 self
._get
_my
_tenant
()
739 for k
,v
in filter_dict
.iteritems():
740 filterquery
.append(str(k
)+'='+str(v
))
741 if len(filterquery
)>0:
742 filterquery_text
='?'+ '&'.join(filterquery
)
743 url
= self
.url
+'/'+self
.tenant
+'/images'+filterquery_text
744 self
.logger
.info("Getting image list GET %s", url
)
745 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
746 self
._check
_http
_request
_response
(vim_response
)
747 self
.logger
.debug(vim_response
.text
)
748 #print(json.dumps(vim_response.json(), indent=4))
749 response
= vim_response
.json()
750 return response
['images']
751 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
752 self
._format
_request
_exception
(e
)
754 def new_vminstancefromJSON(self
, vm_data
):
755 '''Adds a VM instance to VIM'''
756 '''Returns the instance identifier'''
758 self
._get
_my
_tenant
()
759 except Exception as e
:
760 return -vimconn
.HTTP_Not_Found
, str(e
)
761 print("VIMConnector: Adding a new VM instance from JSON to VIM")
762 payload_req
= vm_data
764 vim_response
= requests
.post(self
.url
+'/'+self
.tenant
+'/servers', headers
= self
.headers_req
, data
=payload_req
)
765 except requests
.exceptions
.RequestException
as e
:
766 print("new_vminstancefromJSON Exception: ", e
.args
)
767 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
769 #print(vim_response.status_code)
770 if vim_response
.status_code
== 200:
771 #print(vim_response.json())
772 #print(json.dumps(vim_response.json(), indent=4))
773 res
,http_content
= self
._format
_in
(vim_response
, new_image_response_schema
)
776 r
= self
._remove
_extra
_items
(http_content
, new_image_response_schema
)
777 if r
is not None: print("Warning: remove extra items ", r
)
779 vminstance_id
= http_content
['server']['id']
780 print("Tenant image id: ",vminstance_id
)
781 return vim_response
.status_code
,vminstance_id
782 else: return -vimconn
.HTTP_Bad_Request
,http_content
784 #print(vim_response.text)
785 jsonerror
= self
._format
_jsonerror
(vim_response
)
786 text
= 'Error in VIM "%s": not possible to add new vm instance. HTTP Response: %d. Error: %s' % (self
.url
, vim_response
.status_code
, jsonerror
)
788 return -vim_response
.status_code
,text
790 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
791 availability_zone_index
=None, availability_zone_list
=None):
792 '''Adds a VM instance to VIM
794 start: indicates if VM must start or boot in pause mode. Ignored
795 image_id,flavor_id: image and flavor uuid
796 net_list: list of interfaces, each one is a dictionary with:
798 net_id: network uuid to connect
799 vpci: virtual vcpi to assign
800 model: interface model, virtio, e2000, ...
802 use: 'data', 'bridge', 'mgmt'
803 type: 'virtual', 'PF', 'VF', 'VFnotShared'
804 vim_id: filled/added by this function
805 #TODO ip, security groups
806 Returns the instance identifier
808 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'", image_id
, flavor_id
, str(net_list
))
810 self
._get
_my
_tenant
()
812 # for k,v in net_dict.items():
814 # net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
815 # net_list_string = ', '.join(net_list)
818 if not net
.get("net_id"):
820 net_dict
={'uuid': net
["net_id"]}
821 if net
.get("type"): net_dict
["type"] = net
["type"]
822 if net
.get("name"): net_dict
["name"] = net
["name"]
823 if net
.get("vpci"): net_dict
["vpci"] = net
["vpci"]
824 if net
.get("model"): net_dict
["model"] = net
["model"]
825 if net
.get("mac_address"): net_dict
["mac_address"] = net
["mac_address"]
826 virtio_net_list
.append(net_dict
)
827 payload_dict
={ "name": name
[:64],
828 "description": description
,
829 "imageRef": image_id
,
830 "flavorRef": flavor_id
,
831 "networks": virtio_net_list
834 payload_dict
["start"] = start
835 payload_req
= json
.dumps({"server": payload_dict
})
836 url
= self
.url
+'/'+self
.tenant
+'/servers'
837 self
.logger
.info("Adding a new vm POST %s DATA %s", url
, payload_req
)
838 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
839 self
._check
_http
_request
_response
(vim_response
)
840 self
.logger
.debug(vim_response
.text
)
841 #print(json.dumps(vim_response.json(), indent=4))
842 response
= vim_response
.json()
843 js_v(response
, new_vminstance_response_schema
)
844 #r = self._remove_extra_items(response, new_vminstance_response_schema)
846 # self.logger.warn("Warning: remove extra items %s", str(r))
847 vminstance_id
= response
['server']['id']
849 #connect data plane interfaces to network
851 if net
["type"]=="virtual":
852 if not net
.get("net_id"):
854 for iface
in response
['server']['networks']:
856 if net
["name"]==iface
["name"]:
857 net
["vim_id"] = iface
['iface_id']
859 elif "net_id" in net
:
860 if net
["net_id"]==iface
["net_id"]:
861 net
["vim_id"] = iface
['iface_id']
864 for numa
in response
['server'].get('extended',{}).get('numas',() ):
865 for iface
in numa
.get('interfaces',() ):
866 if net
['name'] == iface
['name']:
867 net
['vim_id'] = iface
['iface_id']
868 #Code bellow is not needed, current openvim connect dataplane interfaces
869 #if net.get("net_id"):
870 ##connect dataplane interface
871 # result, port_id = self.connect_port_network(iface['iface_id'], net["net_id"])
873 # error_text = "Error attaching port %s to network %s: %s." % (iface['iface_id'], net["net_id"], port_id)
874 # print("new_vminstance: " + error_text)
875 # self.delete_vminstance(vminstance_id)
876 # return result, error_text
880 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
881 self
._format
_request
_exception
(e
)
883 def get_vminstance(self
, vm_id
):
884 '''Returns the VM instance information from VIM'''
886 self
._get
_my
_tenant
()
887 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
888 self
.logger
.info("Getting vm GET %s", url
)
889 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
890 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
891 self
._check
_http
_request
_response
(vim_response
)
892 self
.logger
.debug(vim_response
.text
)
893 #print(json.dumps(vim_response.json(), indent=4))
894 response
= vim_response
.json()
895 js_v(response
, new_vminstance_response_schema
)
896 #r = self._remove_extra_items(response, new_vminstance_response_schema)
898 # self.logger.warn("Warning: remove extra items %s", str(r))
899 return response
['server']
900 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
901 self
._format
_request
_exception
(e
)
903 def delete_vminstance(self
, vm_id
):
904 '''Removes a VM instance from VIM, returns the deleted vm_id'''
906 self
._get
_my
_tenant
()
907 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
908 self
.logger
.info("Deleting VIM vm DELETE %s", url
)
909 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
910 self
._check
_http
_request
_response
(vim_response
)
911 #self.logger.debug(vim_response.text)
912 #print(json.dumps(vim_response.json(), indent=4))
914 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
915 self
._format
_request
_exception
(e
)
917 def refresh_vms_status(self
, vm_list
):
918 '''Refreshes the status of the virtual machines'''
920 self
._get
_my
_tenant
()
921 except requests
.exceptions
.RequestException
as e
:
922 self
._format
_request
_exception
(e
)
924 for vm_id
in vm_list
:
926 #print("VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM")
928 url
= self
.url
+'/'+self
.tenant
+'/servers/'+ vm_id
929 self
.logger
.info("Getting vm GET %s", url
)
930 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
931 self
._check
_http
_request
_response
(vim_response
)
932 response
= vim_response
.json()
933 js_v(response
, new_vminstance_response_schema
)
934 if response
['server']['status'] in vmStatus2manoFormat
:
935 vm
['status'] = vmStatus2manoFormat
[ response
['server']['status'] ]
937 vm
['status'] = "OTHER"
938 vm
['error_msg'] = "VIM status reported " + response
['server']['status']
939 if response
['server'].get('last_error'):
940 vm
['error_msg'] = response
['server']['last_error']
941 vm
["vim_info"] = yaml
.safe_dump(response
['server'])
944 management_ip
= False
945 url2
= self
.url
+'/ports?device_id='+ quote(vm_id
)
946 self
.logger
.info("Getting PORTS GET %s", url2
)
947 vim_response2
= requests
.get(url2
, headers
= self
.headers_req
)
948 self
._check
_http
_request
_response
(vim_response2
)
949 client_data
= vim_response2
.json()
950 if isinstance(client_data
.get("ports"), list):
952 for port
in client_data
.get("ports"):
954 interface
['vim_info'] = yaml
.safe_dump(port
)
955 interface
["mac_address"] = port
.get("mac_address")
956 interface
["vim_net_id"] = port
.get("network_id")
957 interface
["vim_interface_id"] = port
["id"]
958 interface
["ip_address"] = port
.get("ip_address")
959 if interface
["ip_address"]:
961 if interface
["ip_address"] == "0.0.0.0":
962 interface
["ip_address"] = None
963 vm
["interfaces"].append(interface
)
965 except Exception as e
:
966 self
.logger
.error("refresh_vms_and_nets. Port get %s: %s", type(e
).__name
__, str(e
))
968 if vm
['status'] == "ACTIVE" and not management_ip
:
969 vm
['status'] = "ACTIVE:NoMgmtIP"
971 except vimconn
.vimconnNotFoundException
as e
:
972 self
.logger
.error("Exception getting vm status: %s", str(e
))
973 vm
['status'] = "DELETED"
974 vm
['error_msg'] = str(e
)
975 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.vimconnException
) as e
:
976 self
.logger
.error("Exception getting vm status: %s", str(e
))
977 vm
['status'] = "VIM_ERROR"
978 vm
['error_msg'] = str(e
)
982 def refresh_nets_status(self
, net_list
):
983 '''Get the status of the networks
984 Params: the list of network identifiers
985 Returns a dictionary with:
986 net_id: #VIM id of this network
987 status: #Mandatory. Text with one of:
988 # DELETED (not found at vim)
989 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
990 # OTHER (Vim reported other status not understood)
991 # ERROR (VIM indicates an ERROR status)
992 # ACTIVE, INACTIVE, DOWN (admin down),
993 # BUILD (on building process)
995 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
996 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1000 self
._get
_my
_tenant
()
1001 except requests
.exceptions
.RequestException
as e
:
1002 self
._format
_request
_exception
(e
)
1005 for net_id
in net_list
:
1007 #print("VIMConnector refresh_tenant_vms_and_nets: Getting tenant network from VIM (tenant: " + str(self.tenant) + "): ")
1009 net_vim
= self
.get_network(net_id
)
1010 if net_vim
['status'] in netStatus2manoFormat
:
1011 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
1013 net
["status"] = "OTHER"
1014 net
["error_msg"] = "VIM status reported " + net_vim
['status']
1016 if net
["status"] == "ACTIVE" and not net_vim
['admin_state_up']:
1017 net
["status"] = "DOWN"
1018 if net_vim
.get('last_error'):
1019 net
['error_msg'] = net_vim
['last_error']
1020 net
["vim_info"] = yaml
.safe_dump(net_vim
)
1021 except vimconn
.vimconnNotFoundException
as e
:
1022 self
.logger
.error("Exception getting net status: %s", str(e
))
1023 net
['status'] = "DELETED"
1024 net
['error_msg'] = str(e
)
1025 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.vimconnException
) as e
:
1026 self
.logger
.error("Exception getting net status: %s", str(e
))
1027 net
['status'] = "VIM_ERROR"
1028 net
['error_msg'] = str(e
)
1029 net_dict
[net_id
] = net
1032 def action_vminstance(self
, vm_id
, action_dict
):
1033 '''Send and action over a VM instance from VIM'''
1034 '''Returns the status'''
1036 self
._get
_my
_tenant
()
1037 if "console" in action_dict
:
1038 raise vimconn
.vimconnException("getting console is not available at openvim", http_code
=vimconn
.HTTP_Service_Unavailable
)
1039 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
+"/action"
1040 self
.logger
.info("Action over VM instance POST %s", url
)
1041 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps(action_dict
) )
1042 self
._check
_http
_request
_response
(vim_response
)
1044 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1045 self
._format
_request
_exception
(e
)
1047 #NOT USED METHODS in current version
1049 def host_vim2gui(self
, host
, server_dict
):
1050 '''Transform host dictionary from VIM format to GUI format,
1051 and append to the server_dict
1053 if type(server_dict
) is not dict:
1054 print('vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary')
1058 for numa
in host
['host']['numas']:
1062 RAD_item
['memory']={'size': str(numa
['memory'])+'GB', 'eligible': str(numa
['hugepages'])+'GB'}
1063 occupation_item
['memory']= str(numa
['hugepages_consumed'])+'GB'
1066 RAD_item
['cpus']['cores'] = []
1067 RAD_item
['cpus']['eligible_cores'] = []
1068 occupation_item
['cores']=[]
1069 for _
in range(0, len(numa
['cores']) / 2):
1070 RAD_item
['cpus']['cores'].append( [] )
1071 for core
in numa
['cores']:
1072 RAD_item
['cpus']['cores'][core
['core_id']].append(core
['thread_id'])
1073 if not 'status' in core
: RAD_item
['cpus']['eligible_cores'].append(core
['thread_id'])
1074 if 'instance_id' in core
: occupation_item
['cores'].append(core
['thread_id'])
1076 RAD_item
['ports']={}
1077 occupation_item
['ports']={}
1078 for iface
in numa
['interfaces']:
1079 RAD_item
['ports'][ iface
['pci'] ] = 'speed:'+str(iface
['Mbps'])+'M'
1080 occupation_item
['ports'][ iface
['pci'] ] = { 'occupied': str(100*iface
['Mbps_consumed'] / iface
['Mbps']) + "%" }
1082 RAD
[ numa
['numa_socket'] ] = RAD_item
1083 occupation
[ numa
['numa_socket'] ] = occupation_item
1084 server_dict
[ host
['host']['name'] ] = {'RAD':RAD
, 'occupation':occupation
}
1086 def get_hosts_info(self
):
1087 '''Get the information of deployed hosts
1088 Returns the hosts content'''
1090 url
=self
.url
+'/hosts'
1092 vim_response
= requests
.get(url
)
1093 except requests
.exceptions
.RequestException
as e
:
1094 print("get_hosts_info Exception: ", e
.args
)
1095 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1096 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1097 #print(vim_response.status_code)
1098 #print(json.dumps(vim_response.json(), indent=4))
1099 if vim_response
.status_code
!= 200:
1101 print('vimconnector.get_hosts_info error getting host list %d %s' %(vim_response
.status_code
, vim_response
.json()))
1102 return -vim_response
.status_code
, "Error getting host list"
1104 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1107 print("vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts
)
1108 return vimconn
.HTTP_Internal_Server_Error
, hosts
1109 #obtain hosts details
1111 for host
in hosts
['hosts']:
1112 url
=self
.url
+'/hosts/'+host
['id']
1114 vim_response
= requests
.get(url
)
1115 except requests
.exceptions
.RequestException
as e
:
1116 print("get_hosts_info Exception: ", e
.args
)
1117 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1118 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1119 if vim_response
.status_code
!= 200:
1120 print('vimconnector.get_hosts_info error getting detailed host %d %s' %(vim_response
.status_code
, vim_response
.json()))
1122 res
,host_detail
= self
._format
_in
(vim_response
, get_host_detail_response_schema
)
1124 print("vimconnector.get_hosts_info error parsing GET HOSTS/%s vim response" % host
['id'], host_detail
)
1126 #print('host id '+host['id'], json.dumps(host_detail, indent=4))
1127 self
.host_vim2gui(host_detail
, hosts_dict
)
1128 return 200, hosts_dict
1130 def get_hosts(self
, vim_tenant
):
1131 '''Get the hosts and deployed instances
1132 Returns the hosts content'''
1134 url
=self
.url
+'/hosts'
1136 vim_response
= requests
.get(url
)
1137 except requests
.exceptions
.RequestException
as e
:
1138 print("get_hosts Exception: ", e
.args
)
1139 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1140 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1141 #print(vim_response.status_code)
1142 #print(json.dumps(vim_response.json(), indent=4))
1143 if vim_response
.status_code
!= 200:
1145 print('vimconnector.get_hosts error getting host list %d %s' %(vim_response
.status_code
, vim_response
.json()))
1146 return -vim_response
.status_code
, "Error getting host list"
1148 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1151 print("vimconnector.get_host error parsing GET HOSTS vim response", hosts
)
1152 return vimconn
.HTTP_Internal_Server_Error
, hosts
1153 #obtain instances from hosts
1154 for host
in hosts
['hosts']:
1155 url
=self
.url
+'/' + vim_tenant
+ '/servers?hostId='+host
['id']
1157 vim_response
= requests
.get(url
)
1158 except requests
.exceptions
.RequestException
as e
:
1159 print("get_hosts Exception: ", e
.args
)
1160 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1161 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1162 if vim_response
.status_code
!= 200:
1163 print('vimconnector.get_hosts error getting instances at host %d %s' %(vim_response
.status_code
, vim_response
.json()))
1165 res
,servers
= self
._format
_in
(vim_response
, get_server_response_schema
)
1167 print("vimconnector.get_host error parsing GET SERVERS/%s vim response" % host
['id'], servers
)
1169 #print('host id '+host['id'], json.dumps(host_detail, indent=4))
1170 host
['instances'] = servers
['servers']
1171 return 200, hosts
['hosts']
1173 def get_processor_rankings(self
):
1174 '''Get the processor rankings in the VIM database'''
1175 url
=self
.url
+'/processor_ranking'
1177 vim_response
= requests
.get(url
)
1178 except requests
.exceptions
.RequestException
as e
:
1179 print("get_processor_rankings Exception: ", e
.args
)
1180 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1181 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1182 #print(vim_response.status_code)
1183 #print(json.dumps(vim_response.json(), indent=4))
1184 if vim_response
.status_code
!= 200:
1186 print('vimconnector.get_processor_rankings error getting processor rankings %d %s' %(vim_response
.status_code
, vim_response
.json()))
1187 return -vim_response
.status_code
, "Error getting processor rankings"
1189 res
,rankings
= self
._format
_in
(vim_response
, get_processor_rankings_response_schema
)
1190 return res
, rankings
['rankings']
1192 def new_host(self
, host_data
):
1193 '''Adds a new host to VIM'''
1194 '''Returns status code of the VIM response'''
1195 payload_req
= host_data
1197 url
= self
.url_admin
+'/hosts'
1198 self
.logger
.info("Adding a new host POST %s", url
)
1199 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
1200 self
._check
_http
_request
_response
(vim_response
)
1201 self
.logger
.debug(vim_response
.text
)
1202 #print(json.dumps(vim_response.json(), indent=4))
1203 response
= vim_response
.json()
1204 js_v(response
, new_host_response_schema
)
1205 r
= self
._remove
_extra
_items
(response
, new_host_response_schema
)
1207 self
.logger
.warn("Warning: remove extra items %s", str(r
))
1208 host_id
= response
['host']['id']
1210 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1211 self
._format
_request
_exception
(e
)
1213 def new_external_port(self
, port_data
):
1214 '''Adds a external port to VIM'''
1215 '''Returns the port identifier'''
1216 #TODO change to logging exception code policies
1217 print("VIMConnector: Adding a new external port")
1218 payload_req
= port_data
1220 vim_response
= requests
.post(self
.url_admin
+'/ports', headers
= self
.headers_req
, data
=payload_req
)
1221 except requests
.exceptions
.RequestException
as e
:
1222 self
.logger
.error("new_external_port Exception: ", str(e
))
1223 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1225 #print(vim_response.status_code)
1226 if vim_response
.status_code
== 200:
1227 #print(vim_response.json())
1228 #print(json.dumps(vim_response.json(), indent=4))
1229 res
, http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1230 #print(http_content)
1232 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1233 if r
is not None: print("Warning: remove extra items ", r
)
1234 #print(http_content)
1235 port_id
= http_content
['port']['id']
1236 print("Port id: ",port_id
)
1237 return vim_response
.status_code
,port_id
1238 else: return -vimconn
.HTTP_Bad_Request
,http_content
1240 #print(vim_response.text)
1241 jsonerror
= self
._format
_jsonerror
(vim_response
)
1242 text
= 'Error in VIM "%s": not possible to add new external port. HTTP Response: %d. Error: %s' % (self
.url_admin
, vim_response
.status_code
, jsonerror
)
1244 return -vim_response
.status_code
,text
1246 def new_external_network(self
,net_name
,net_type
):
1247 '''Adds a external network to VIM (shared)'''
1248 '''Returns the network identifier'''
1249 #TODO change to logging exception code policies
1250 print("VIMConnector: Adding external shared network to VIM (type " + net_type
+ "): "+ net_name
)
1252 payload_req
= '{"network":{"name": "' + net_name
+ '","shared":true,"type": "' + net_type
+ '"}}'
1254 vim_response
= requests
.post(self
.url
+'/networks', headers
= self
.headers_req
, data
=payload_req
)
1255 except requests
.exceptions
.RequestException
as e
:
1256 self
.logger
.error( "new_external_network Exception: ", e
.args
)
1257 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1259 #print(vim_response.status_code)
1260 if vim_response
.status_code
== 200:
1261 #print(vim_response.json())
1262 #print(json.dumps(vim_response.json(), indent=4))
1263 res
,http_content
= self
._format
_in
(vim_response
, new_network_response_schema
)
1264 #print(http_content)
1266 r
= self
._remove
_extra
_items
(http_content
, new_network_response_schema
)
1267 if r
is not None: print("Warning: remove extra items ", r
)
1268 #print(http_content)
1269 network_id
= http_content
['network']['id']
1270 print("Network id: ",network_id
)
1271 return vim_response
.status_code
,network_id
1272 else: return -vimconn
.HTTP_Bad_Request
,http_content
1274 #print(vim_response.text)
1275 jsonerror
= self
._format
_jsonerror
(vim_response
)
1276 text
= 'Error in VIM "%s": not possible to add new external network. HTTP Response: %d. Error: %s' % (self
.url
, vim_response
.status_code
, jsonerror
)
1278 return -vim_response
.status_code
,text
1280 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1281 '''Connects a external port to a network'''
1282 '''Returns status code of the VIM response'''
1283 #TODO change to logging exception code policies
1284 print("VIMConnector: Connecting external port to network")
1286 payload_req
= '{"port":{"network_id":"' + network_id
+ '"}}'
1288 if self
.url_admin
==None:
1289 return -vimconn
.HTTP_Unauthorized
, "datacenter cannot contain admin URL"
1294 vim_response
= requests
.put(url
+'/ports/'+port_id
, headers
= self
.headers_req
, data
=payload_req
)
1295 except requests
.exceptions
.RequestException
as e
:
1296 print("connect_port_network Exception: ", e
.args
)
1297 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1299 #print(vim_response.status_code)
1300 if vim_response
.status_code
== 200:
1301 #print(vim_response.json())
1302 #print(json.dumps(vim_response.json(), indent=4))
1303 res
,http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1304 #print(http_content)
1306 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1307 if r
is not None: print("Warning: remove extra items ", r
)
1308 #print(http_content)
1309 port_id
= http_content
['port']['id']
1310 print("Port id: ",port_id
)
1311 return vim_response
.status_code
,port_id
1312 else: return -vimconn
.HTTP_Bad_Request
,http_content
1314 print(vim_response
.text
)
1315 jsonerror
= self
._format
_jsonerror
(vim_response
)
1316 text
= 'Error in VIM "%s": not possible to connect external port to network. HTTP Response: %d. Error: %s' % (self
.url_admin
, vim_response
.status_code
, jsonerror
)
1318 return -vim_response
.status_code
,text