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
38 from urllib
.parse
import quote
40 '''contain the openvim virtual machine status to openmano status'''
41 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
43 'SUSPENDED': 'SUSPENDED',
44 'INACTIVE':'INACTIVE',
46 'ERROR':'ERROR','DELETED':'DELETED'
48 netStatus2manoFormat
={'ACTIVE':'ACTIVE','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED', 'DOWN':'DOWN'
66 "required": ["id","name"]
74 "required": ["id","name"]
76 new_host_response_schema
= {
77 "title":"host response information schema",
78 "$schema": "http://json-schema.org/draft-04/schema#",
84 "additionalProperties": False
87 get_images_response_schema
= {
88 "title":"openvim images response information schema",
89 "$schema": "http://json-schema.org/draft-04/schema#",
94 "items": image_schema
,
97 "required": ["images"],
98 "additionalProperties": False
101 get_hosts_response_schema
= {
102 "title":"openvim hosts response information schema",
103 "$schema": "http://json-schema.org/draft-04/schema#",
108 "items": host_schema
,
111 "required": ["hosts"],
112 "additionalProperties": False
115 get_host_detail_response_schema
= new_host_response_schema
# TODO: Content is not parsed yet
117 get_server_response_schema
= {
118 "title":"openvim server response information schema",
119 "$schema": "http://json-schema.org/draft-04/schema#",
124 "items": server_schema
,
127 "required": ["servers"],
128 "additionalProperties": False
131 new_tenant_response_schema
= {
132 "title":"tenant response information schema",
133 "$schema": "http://json-schema.org/draft-04/schema#",
140 "name": nameshort_schema
,
141 "description":description_schema
,
142 "enabled":{"type" : "boolean"}
147 "required": ["tenant"],
148 "additionalProperties": False
151 new_network_response_schema
= {
152 "title":"network response information schema",
153 "$schema": "http://json-schema.org/draft-04/schema#",
161 "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
162 "shared":{"type":"boolean"},
163 "tenant_id":id_schema
,
164 "admin_state_up":{"type":"boolean"},
165 "vlan":vlan1000_schema
170 "required": ["network"],
171 "additionalProperties": False
175 # get_network_response_schema = {
176 # "title":"get network response information schema",
177 # "$schema": "http://json-schema.org/draft-04/schema#",
184 # "name":name_schema,
185 # "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
186 # "shared":{"type":"boolean"},
187 # "tenant_id":id_schema,
188 # "admin_state_up":{"type":"boolean"},
189 # "vlan":vlan1000_schema
194 # "required": ["network"],
195 # "additionalProperties": False
199 new_port_response_schema
= {
200 "title":"port response information schema",
201 "$schema": "http://json-schema.org/draft-04/schema#",
212 "required": ["port"],
213 "additionalProperties": False
216 get_flavor_response_schema
= {
217 "title":"openvim flavors response information schema",
218 "$schema": "http://json-schema.org/draft-04/schema#",
226 "extended": {"type":"object"},
228 "required": ["id", "name"],
231 "required": ["flavor"],
232 "additionalProperties": False
235 new_flavor_response_schema
= {
236 "title":"flavor response information schema",
237 "$schema": "http://json-schema.org/draft-04/schema#",
248 "required": ["flavor"],
249 "additionalProperties": False
252 get_image_response_schema
= {
253 "title":"openvim images response information schema",
254 "$schema": "http://json-schema.org/draft-04/schema#",
263 "required": ["id", "name"],
266 "required": ["flavor"],
267 "additionalProperties": False
269 new_image_response_schema
= {
270 "title":"image response information schema",
271 "$schema": "http://json-schema.org/draft-04/schema#",
282 "required": ["image"],
283 "additionalProperties": False
286 new_vminstance_response_schema
= {
287 "title":"server response information schema",
288 "$schema": "http://json-schema.org/draft-04/schema#",
299 "required": ["server"],
300 "additionalProperties": False
303 get_processor_rankings_response_schema
= {
304 "title":"processor rankings information schema",
305 "$schema": "http://json-schema.org/draft-04/schema#",
313 "model": description_schema
,
314 "value": integer0_schema
316 "additionalProperties": False,
317 "required": ["model","value"]
320 "additionalProperties": False,
321 "required": ["rankings"]
325 class vimconnector(vimconn
.vimconnector
):
326 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,
327 log_level
="DEBUG", config
={}, persistent_info
={}):
328 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
330 self
.headers_req
= {'content-type': 'application/json'}
331 self
.logger
= logging
.getLogger('openmano.vim.openvim')
332 self
.persistent_info
= persistent_info
334 self
.tenant
= tenant_id
336 def __setitem__(self
,index
, value
):
337 '''Set individuals parameters
338 Throw TypeError, KeyError
340 if index
=='tenant_id':
342 elif index
=='tenant_name':
344 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
346 def _get_my_tenant(self
):
347 '''Obtain uuid of my tenant from name
352 url
= self
.url
+'/tenants?name='+ quote(self
.tenant_name
)
353 self
.logger
.info("Getting VIM tenant_id GET %s", url
)
354 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
355 self
._check
_http
_request
_response
(vim_response
)
357 tenant_list
= vim_response
.json()["tenants"]
358 if len(tenant_list
) == 0:
359 raise vimconn
.vimconnNotFoundException("No tenant found for name '%s'" % str(self
.tenant_name
))
360 elif len(tenant_list
) > 1:
361 raise vimconn
.vimconnConflictException ("More that one tenant found for name '%s'" % str(self
.tenant_name
))
362 self
.tenant
= tenant_list
[0]["id"]
364 except Exception as e
:
365 raise vimconn
.vimconnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e
).__name
__, str(e
)))
367 def _format_jsonerror(self
,http_response
):
368 #DEPRECATED, to delete in the future
370 data
= http_response
.json()
371 return data
["error"]["description"]
373 return http_response
.text
375 def _format_in(self
, http_response
, schema
):
376 #DEPRECATED, to delete in the future
378 client_data
= http_response
.json()
379 js_v(client_data
, schema
)
380 #print "Input data: ", str(client_data)
381 return True, client_data
382 except js_e
.ValidationError
as exc
:
383 print("validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
)
384 return False, ("validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
)
386 def _remove_extra_items(self
, data
, schema
):
388 if type(data
) is tuple or type(data
) is list:
390 a
= self
._remove
_extra
_items
(d
, schema
['items'])
391 if a
is not None: deleted
.append(a
)
392 elif type(data
) is dict:
393 for k
in list(data
.keys()):
394 if 'properties' not in schema
or k
not in list(schema
['properties'].keys()):
398 a
= self
._remove
_extra
_items
(data
[k
], schema
['properties'][k
])
399 if a
is not None: deleted
.append({k
:a
})
400 if len(deleted
) == 0: return None
401 elif len(deleted
) == 1: return deleted
[0]
404 def _format_request_exception(self
, request_exception
):
405 '''Transform a request exception into a vimconn exception'''
406 if isinstance(request_exception
, js_e
.ValidationError
):
407 raise vimconn
.vimconnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception
.message
, request_exception
.path
))
408 elif isinstance(request_exception
, requests
.exceptions
.HTTPError
):
409 raise vimconn
.vimconnUnexpectedResponse(type(request_exception
).__name
__ + ": " + str(request_exception
))
411 raise vimconn
.vimconnConnectionException(type(request_exception
).__name
__ + ": " + str(request_exception
))
413 def _check_http_request_response(self
, request_response
):
414 '''Raise a vimconn exception if the response is not Ok'''
415 if request_response
.status_code
>= 200 and request_response
.status_code
< 300:
417 if request_response
.status_code
== vimconn
.HTTP_Unauthorized
:
418 raise vimconn
.vimconnAuthException(request_response
.text
)
419 elif request_response
.status_code
== vimconn
.HTTP_Not_Found
:
420 raise vimconn
.vimconnNotFoundException(request_response
.text
)
421 elif request_response
.status_code
== vimconn
.HTTP_Conflict
:
422 raise vimconn
.vimconnConflictException(request_response
.text
)
424 raise vimconn
.vimconnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response
.status_code
, str(request_response
.text
)))
426 def new_tenant(self
,tenant_name
,tenant_description
):
427 '''Adds a new tenant to VIM with this name and description, returns the tenant identifier'''
428 #print "VIMConnector: Adding a new tenant to VIM"
429 payload_dict
= {"tenant": {"name":tenant_name
,"description": tenant_description
, "enabled": True}}
430 payload_req
= json
.dumps(payload_dict
)
432 url
= self
.url_admin
+'/tenants'
433 self
.logger
.info("Adding a new tenant %s", url
)
434 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
435 self
._check
_http
_request
_response
(vim_response
)
436 self
.logger
.debug(vim_response
.text
)
437 #print json.dumps(vim_response.json(), indent=4)
438 response
= vim_response
.json()
439 js_v(response
, new_tenant_response_schema
)
440 #r = self._remove_extra_items(response, new_tenant_response_schema)
442 # self.logger.warn("Warning: remove extra items %s", str(r))
443 tenant_id
= response
['tenant']['id']
445 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
446 self
._format
_request
_exception
(e
)
448 def delete_tenant(self
,tenant_id
):
449 '''Delete a tenant from VIM. Returns the old tenant identifier'''
451 url
= self
.url_admin
+'/tenants/'+tenant_id
452 self
.logger
.info("Delete a tenant DELETE %s", url
)
453 vim_response
= requests
.delete(url
, headers
= self
.headers_req
)
454 self
._check
_http
_request
_response
(vim_response
)
455 self
.logger
.debug(vim_response
.text
)
456 #print json.dumps(vim_response.json(), indent=4)
458 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
459 self
._format
_request
_exception
(e
)
461 def get_tenant_list(self
, filter_dict
={}):
462 '''Obtain tenants of VIM
463 filter_dict can contain the following keys:
464 name: filter by tenant name
465 id: filter by tenant uuid/id
467 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
471 for k
,v
in filter_dict
.items():
472 filterquery
.append(str(k
)+'='+str(v
))
473 if len(filterquery
)>0:
474 filterquery_text
='?'+ '&'.join(filterquery
)
476 url
= self
.url
+'/tenants'+filterquery_text
477 self
.logger
.info("get_tenant_list GET %s", url
)
478 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
479 self
._check
_http
_request
_response
(vim_response
)
480 self
.logger
.debug(vim_response
.text
)
481 #print json.dumps(vim_response.json(), indent=4)
482 return vim_response
.json()["tenants"]
483 except requests
.exceptions
.RequestException
as e
:
484 self
._format
_request
_exception
(e
)
486 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None): #, **vim_specific):
487 '''Adds a tenant network to VIM'''
488 '''Returns the network identifier'''
490 self
._get
_my
_tenant
()
491 if net_type
=="bridge":
492 net_type
="bridge_data"
493 payload_req
= {"name": net_name
, "type": net_type
, "tenant_id": self
.tenant
, "shared": shared
}
495 payload_req
["provider:vlan"] = vlan
496 # payload_req.update(vim_specific)
497 url
= self
.url
+'/networks'
498 self
.logger
.info("Adding a new network POST: %s DATA: %s", url
, str(payload_req
))
499 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps({"network": payload_req
}) )
500 self
._check
_http
_request
_response
(vim_response
)
501 self
.logger
.debug(vim_response
.text
)
502 #print json.dumps(vim_response.json(), indent=4)
503 response
= vim_response
.json()
504 js_v(response
, new_network_response_schema
)
505 #r = self._remove_extra_items(response, new_network_response_schema)
507 # self.logger.warn("Warning: remove extra items %s", str(r))
508 network_id
= response
['network']['id']
510 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
511 self
._format
_request
_exception
(e
)
513 def get_network_list(self
, filter_dict
={}):
514 '''Obtain tenant networks of VIM
520 admin_state_up: boolean
522 Returns the network list of dictionaries
525 if 'tenant_id' not in filter_dict
:
526 filter_dict
["tenant_id"] = self
._get
_my
_tenant
()
527 elif not filter_dict
["tenant_id"]:
528 del filter_dict
["tenant_id"]
531 for k
,v
in filter_dict
.items():
532 filterquery
.append(str(k
)+'='+str(v
))
533 if len(filterquery
)>0:
534 filterquery_text
='?'+ '&'.join(filterquery
)
535 url
= self
.url
+'/networks'+filterquery_text
536 self
.logger
.info("Getting network list GET %s", url
)
537 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
538 self
._check
_http
_request
_response
(vim_response
)
539 self
.logger
.debug(vim_response
.text
)
540 #print json.dumps(vim_response.json(), indent=4)
541 response
= vim_response
.json()
542 return response
['networks']
543 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
544 self
._format
_request
_exception
(e
)
546 def get_network(self
, net_id
):
547 '''Obtain network details of network id'''
549 url
= self
.url
+'/networks/'+net_id
550 self
.logger
.info("Getting network GET %s", url
)
551 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
552 self
._check
_http
_request
_response
(vim_response
)
553 self
.logger
.debug(vim_response
.text
)
554 #print json.dumps(vim_response.json(), indent=4)
555 response
= vim_response
.json()
556 return response
['network']
557 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
558 self
._format
_request
_exception
(e
)
560 def delete_network(self
, net_id
):
561 '''Deletes a tenant network from VIM'''
562 '''Returns the network identifier'''
564 self
._get
_my
_tenant
()
565 url
= self
.url
+'/networks/'+net_id
566 self
.logger
.info("Deleting VIM network DELETE %s", url
)
567 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
568 self
._check
_http
_request
_response
(vim_response
)
569 #self.logger.debug(vim_response.text)
570 #print json.dumps(vim_response.json(), indent=4)
572 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
573 self
._format
_request
_exception
(e
)
575 def get_flavor(self
, flavor_id
):
576 '''Obtain flavor details from the VIM'''
578 self
._get
_my
_tenant
()
579 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
580 self
.logger
.info("Getting flavor GET %s", url
)
581 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
582 self
._check
_http
_request
_response
(vim_response
)
583 self
.logger
.debug(vim_response
.text
)
584 #print json.dumps(vim_response.json(), indent=4)
585 response
= vim_response
.json()
586 js_v(response
, get_flavor_response_schema
)
587 r
= self
._remove
_extra
_items
(response
, get_flavor_response_schema
)
589 self
.logger
.warn("Warning: remove extra items %s", str(r
))
590 return response
['flavor']
591 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
592 self
._format
_request
_exception
(e
)
594 def new_flavor(self
, flavor_data
):
595 '''Adds a tenant flavor to VIM'''
596 '''Returns the flavor identifier'''
598 new_flavor_dict
= flavor_data
.copy()
599 for device
in new_flavor_dict
.get('extended', {}).get('devices', ()):
600 if 'image name' in device
:
601 del device
['image name']
602 new_flavor_dict
["name"] = flavor_data
["name"][:64]
603 self
._get
_my
_tenant
()
604 payload_req
= json
.dumps({'flavor': new_flavor_dict
})
605 url
= self
.url
+'/'+self
.tenant
+'/flavors'
606 self
.logger
.info("Adding a new VIM flavor POST %s", url
)
607 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
608 self
._check
_http
_request
_response
(vim_response
)
609 self
.logger
.debug(vim_response
.text
)
610 #print json.dumps(vim_response.json(), indent=4)
611 response
= vim_response
.json()
612 js_v(response
, new_flavor_response_schema
)
613 r
= self
._remove
_extra
_items
(response
, new_flavor_response_schema
)
615 self
.logger
.warn("Warning: remove extra items %s", str(r
))
616 flavor_id
= response
['flavor']['id']
618 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
619 self
._format
_request
_exception
(e
)
621 def delete_flavor(self
,flavor_id
):
622 '''Deletes a tenant flavor from VIM'''
623 '''Returns the old flavor_id'''
625 self
._get
_my
_tenant
()
626 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
627 self
.logger
.info("Deleting VIM flavor DELETE %s", url
)
628 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
629 self
._check
_http
_request
_response
(vim_response
)
630 #self.logger.debug(vim_response.text)
631 #print json.dumps(vim_response.json(), indent=4)
633 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
634 self
._format
_request
_exception
(e
)
636 def get_image(self
, image_id
):
637 '''Obtain image details from the VIM'''
639 self
._get
_my
_tenant
()
640 url
= self
.url
+'/'+self
.tenant
+'/images/'+image_id
641 self
.logger
.info("Getting image GET %s", url
)
642 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
643 self
._check
_http
_request
_response
(vim_response
)
644 self
.logger
.debug(vim_response
.text
)
645 #print json.dumps(vim_response.json(), indent=4)
646 response
= vim_response
.json()
647 js_v(response
, get_image_response_schema
)
648 r
= self
._remove
_extra
_items
(response
, get_image_response_schema
)
650 self
.logger
.warn("Warning: remove extra items %s", str(r
))
651 return response
['image']
652 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
653 self
._format
_request
_exception
(e
)
655 def new_image(self
,image_dict
):
656 ''' Adds a tenant image to VIM, returns image_id'''
658 self
._get
_my
_tenant
()
659 new_image_dict
={'name': image_dict
['name'][:64]}
660 if image_dict
.get('description'):
661 new_image_dict
['description'] = image_dict
['description']
662 if image_dict
.get('metadata'):
663 new_image_dict
['metadata'] = yaml
.load(image_dict
['metadata'])
664 if image_dict
.get('location'):
665 new_image_dict
['path'] = image_dict
['location']
666 payload_req
= json
.dumps({"image":new_image_dict
})
667 url
=self
.url
+ '/' + self
.tenant
+ '/images'
668 self
.logger
.info("Adding a new VIM image POST %s", url
)
669 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
670 self
._check
_http
_request
_response
(vim_response
)
671 self
.logger
.debug(vim_response
.text
)
672 #print json.dumps(vim_response.json(), indent=4)
673 response
= vim_response
.json()
674 js_v(response
, new_image_response_schema
)
675 r
= self
._remove
_extra
_items
(response
, new_image_response_schema
)
677 self
.logger
.warn("Warning: remove extra items %s", str(r
))
678 image_id
= response
['image']['id']
680 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
681 self
._format
_request
_exception
(e
)
683 def delete_image(self
, image_id
):
684 '''Deletes a tenant image from VIM'''
685 '''Returns the deleted image_id'''
687 self
._get
_my
_tenant
()
688 url
= self
.url
+ '/'+ self
.tenant
+'/images/'+image_id
689 self
.logger
.info("Deleting VIM image DELETE %s", url
)
690 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
691 self
._check
_http
_request
_response
(vim_response
)
692 #self.logger.debug(vim_response.text)
693 #print json.dumps(vim_response.json(), indent=4)
695 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
696 self
._format
_request
_exception
(e
)
698 def get_image_id_from_path(self
, path
):
699 '''Get the image id from image path in the VIM database. Returns the image_id'''
701 self
._get
_my
_tenant
()
702 url
=self
.url
+ '/' + self
.tenant
+ '/images?path='+quote(path
)
703 self
.logger
.info("Getting images GET %s", url
)
704 vim_response
= requests
.get(url
)
705 self
._check
_http
_request
_response
(vim_response
)
706 self
.logger
.debug(vim_response
.text
)
707 #print json.dumps(vim_response.json(), indent=4)
708 response
= vim_response
.json()
709 js_v(response
, get_images_response_schema
)
710 #r = self._remove_extra_items(response, get_images_response_schema)
712 # self.logger.warn("Warning: remove extra items %s", str(r))
713 if len(response
['images'])==0:
714 raise vimconn
.vimconnNotFoundException("Image not found at VIM with path '%s'", path
)
715 elif len(response
['images'])>1:
716 raise vimconn
.vimconnConflictException("More than one image found at VIM with path '%s'", path
)
717 return response
['images'][0]['id']
718 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
719 self
._format
_request
_exception
(e
)
721 def get_image_list(self
, filter_dict
={}):
722 '''Obtain tenant images from VIM
726 checksum: image checksum
728 Returns the image list of dictionaries:
729 [{<the fields at Filter_dict plus some VIM specific>}, ...]
733 self
._get
_my
_tenant
()
736 for k
,v
in filter_dict
.items():
737 filterquery
.append(str(k
)+'='+str(v
))
738 if len(filterquery
)>0:
739 filterquery_text
='?'+ '&'.join(filterquery
)
740 url
= self
.url
+'/'+self
.tenant
+'/images'+filterquery_text
741 self
.logger
.info("Getting image list GET %s", url
)
742 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
743 self
._check
_http
_request
_response
(vim_response
)
744 self
.logger
.debug(vim_response
.text
)
745 #print json.dumps(vim_response.json(), indent=4)
746 response
= vim_response
.json()
747 return response
['images']
748 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
749 self
._format
_request
_exception
(e
)
751 def new_vminstancefromJSON(self
, vm_data
):
752 '''Adds a VM instance to VIM'''
753 '''Returns the instance identifier'''
755 self
._get
_my
_tenant
()
756 except Exception as e
:
757 return -vimconn
.HTTP_Not_Found
, str(e
)
758 print("VIMConnector: Adding a new VM instance from JSON to VIM")
759 payload_req
= vm_data
761 vim_response
= requests
.post(self
.url
+'/'+self
.tenant
+'/servers', headers
= self
.headers_req
, data
=payload_req
)
762 except requests
.exceptions
.RequestException
as e
:
763 print("new_vminstancefromJSON Exception: ", e
.args
)
764 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
766 #print vim_response.status_code
767 if vim_response
.status_code
== 200:
768 #print vim_response.json()
769 #print json.dumps(vim_response.json(), indent=4)
770 res
,http_content
= self
._format
_in
(vim_response
, new_image_response_schema
)
773 r
= self
._remove
_extra
_items
(http_content
, new_image_response_schema
)
774 if r
is not None: print("Warning: remove extra items ", r
)
776 vminstance_id
= http_content
['server']['id']
777 print("Tenant image id: ",vminstance_id
)
778 return vim_response
.status_code
,vminstance_id
779 else: return -vimconn
.HTTP_Bad_Request
,http_content
781 #print vim_response.text
782 jsonerror
= self
._format
_jsonerror
(vim_response
)
783 text
= 'Error in VIM "%s": not possible to add new vm instance. HTTP Response: %d. Error: %s' % (self
.url
, vim_response
.status_code
, jsonerror
)
785 return -vim_response
.status_code
,text
787 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
788 availability_zone_index
=None, availability_zone_list
=None):
789 '''Adds a VM instance to VIM
791 start: indicates if VM must start or boot in pause mode. Ignored
792 image_id,flavor_id: image and flavor uuid
793 net_list: list of interfaces, each one is a dictionary with:
795 net_id: network uuid to connect
796 vpci: virtual vcpi to assign
797 model: interface model, virtio, e2000, ...
799 use: 'data', 'bridge', 'mgmt'
800 type: 'virtual', 'PF', 'VF', 'VFnotShared'
801 vim_id: filled/added by this function
802 #TODO ip, security groups
803 Returns the instance identifier
805 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'", image_id
, flavor_id
, str(net_list
))
807 self
._get
_my
_tenant
()
809 # for k,v in net_dict.items():
811 # net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
812 # net_list_string = ', '.join(net_list)
815 if not net
.get("net_id"):
817 net_dict
={'uuid': net
["net_id"]}
818 if net
.get("type"): net_dict
["type"] = net
["type"]
819 if net
.get("name"): net_dict
["name"] = net
["name"]
820 if net
.get("vpci"): net_dict
["vpci"] = net
["vpci"]
821 if net
.get("model"): net_dict
["model"] = net
["model"]
822 if net
.get("mac_address"): net_dict
["mac_address"] = net
["mac_address"]
823 virtio_net_list
.append(net_dict
)
824 payload_dict
={ "name": name
[:64],
825 "description": description
,
826 "imageRef": image_id
,
827 "flavorRef": flavor_id
,
828 "networks": virtio_net_list
831 payload_dict
["start"] = start
832 payload_req
= json
.dumps({"server": payload_dict
})
833 url
= self
.url
+'/'+self
.tenant
+'/servers'
834 self
.logger
.info("Adding a new vm POST %s DATA %s", url
, payload_req
)
835 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
836 self
._check
_http
_request
_response
(vim_response
)
837 self
.logger
.debug(vim_response
.text
)
838 #print json.dumps(vim_response.json(), indent=4)
839 response
= vim_response
.json()
840 js_v(response
, new_vminstance_response_schema
)
841 #r = self._remove_extra_items(response, new_vminstance_response_schema)
843 # self.logger.warn("Warning: remove extra items %s", str(r))
844 vminstance_id
= response
['server']['id']
846 #connect data plane interfaces to network
848 if net
["type"]=="virtual":
849 if not net
.get("net_id"):
851 for iface
in response
['server']['networks']:
853 if net
["name"]==iface
["name"]:
854 net
["vim_id"] = iface
['iface_id']
856 elif "net_id" in net
:
857 if net
["net_id"]==iface
["net_id"]:
858 net
["vim_id"] = iface
['iface_id']
861 for numa
in response
['server'].get('extended',{}).get('numas',() ):
862 for iface
in numa
.get('interfaces',() ):
863 if net
['name'] == iface
['name']:
864 net
['vim_id'] = iface
['iface_id']
865 #Code bellow is not needed, current openvim connect dataplane interfaces
866 #if net.get("net_id"):
867 ##connect dataplane interface
868 # result, port_id = self.connect_port_network(iface['iface_id'], net["net_id"])
870 # error_text = "Error attaching port %s to network %s: %s." % (iface['iface_id'], net["net_id"], port_id)
871 # print "new_vminstance: " + error_text
872 # self.delete_vminstance(vminstance_id)
873 # return result, error_text
877 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
878 self
._format
_request
_exception
(e
)
880 def get_vminstance(self
, vm_id
):
881 '''Returns the VM instance information from VIM'''
883 self
._get
_my
_tenant
()
884 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
885 self
.logger
.info("Getting vm GET %s", url
)
886 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
887 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
888 self
._check
_http
_request
_response
(vim_response
)
889 self
.logger
.debug(vim_response
.text
)
890 #print json.dumps(vim_response.json(), indent=4)
891 response
= vim_response
.json()
892 js_v(response
, new_vminstance_response_schema
)
893 #r = self._remove_extra_items(response, new_vminstance_response_schema)
895 # self.logger.warn("Warning: remove extra items %s", str(r))
896 return response
['server']
897 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
898 self
._format
_request
_exception
(e
)
900 def delete_vminstance(self
, vm_id
):
901 '''Removes a VM instance from VIM, returns the deleted vm_id'''
903 self
._get
_my
_tenant
()
904 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
905 self
.logger
.info("Deleting VIM vm DELETE %s", url
)
906 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
907 self
._check
_http
_request
_response
(vim_response
)
908 #self.logger.debug(vim_response.text)
909 #print json.dumps(vim_response.json(), indent=4)
911 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
912 self
._format
_request
_exception
(e
)
914 def refresh_vms_status(self
, vm_list
):
915 '''Refreshes the status of the virtual machines'''
917 self
._get
_my
_tenant
()
918 except requests
.exceptions
.RequestException
as e
:
919 self
._format
_request
_exception
(e
)
921 for vm_id
in vm_list
:
923 #print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
925 url
= self
.url
+'/'+self
.tenant
+'/servers/'+ vm_id
926 self
.logger
.info("Getting vm GET %s", url
)
927 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
928 self
._check
_http
_request
_response
(vim_response
)
929 response
= vim_response
.json()
930 js_v(response
, new_vminstance_response_schema
)
931 if response
['server']['status'] in vmStatus2manoFormat
:
932 vm
['status'] = vmStatus2manoFormat
[ response
['server']['status'] ]
934 vm
['status'] = "OTHER"
935 vm
['error_msg'] = "VIM status reported " + response
['server']['status']
936 if response
['server'].get('last_error'):
937 vm
['error_msg'] = response
['server']['last_error']
938 vm
["vim_info"] = yaml
.safe_dump(response
['server'])
941 management_ip
= False
942 url2
= self
.url
+'/ports?device_id='+ quote(vm_id
)
943 self
.logger
.info("Getting PORTS GET %s", url2
)
944 vim_response2
= requests
.get(url2
, headers
= self
.headers_req
)
945 self
._check
_http
_request
_response
(vim_response2
)
946 client_data
= vim_response2
.json()
947 if isinstance(client_data
.get("ports"), list):
949 for port
in client_data
.get("ports"):
951 interface
['vim_info'] = yaml
.safe_dump(port
)
952 interface
["mac_address"] = port
.get("mac_address")
953 interface
["vim_net_id"] = port
.get("network_id")
954 interface
["vim_interface_id"] = port
["id"]
955 interface
["ip_address"] = port
.get("ip_address")
956 if interface
["ip_address"]:
958 if interface
["ip_address"] == "0.0.0.0":
959 interface
["ip_address"] = None
960 vm
["interfaces"].append(interface
)
962 except Exception as e
:
963 self
.logger
.error("refresh_vms_and_nets. Port get %s: %s", type(e
).__name
__, str(e
))
965 if vm
['status'] == "ACTIVE" and not management_ip
:
966 vm
['status'] = "ACTIVE:NoMgmtIP"
968 except vimconn
.vimconnNotFoundException
as e
:
969 self
.logger
.error("Exception getting vm status: %s", str(e
))
970 vm
['status'] = "DELETED"
971 vm
['error_msg'] = str(e
)
972 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.vimconnException
) as e
:
973 self
.logger
.error("Exception getting vm status: %s", str(e
))
974 vm
['status'] = "VIM_ERROR"
975 vm
['error_msg'] = str(e
)
979 def refresh_nets_status(self
, net_list
):
980 '''Get the status of the networks
981 Params: the list of network identifiers
982 Returns a dictionary with:
983 net_id: #VIM id of this network
984 status: #Mandatory. Text with one of:
985 # DELETED (not found at vim)
986 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
987 # OTHER (Vim reported other status not understood)
988 # ERROR (VIM indicates an ERROR status)
989 # ACTIVE, INACTIVE, DOWN (admin down),
990 # BUILD (on building process)
992 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
993 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
997 self
._get
_my
_tenant
()
998 except requests
.exceptions
.RequestException
as e
:
999 self
._format
_request
_exception
(e
)
1002 for net_id
in net_list
:
1004 #print "VIMConnector refresh_tenant_vms_and_nets: Getting tenant network from VIM (tenant: " + str(self.tenant) + "): "
1006 net_vim
= self
.get_network(net_id
)
1007 if net_vim
['status'] in netStatus2manoFormat
:
1008 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
1010 net
["status"] = "OTHER"
1011 net
["error_msg"] = "VIM status reported " + net_vim
['status']
1013 if net
["status"] == "ACTIVE" and not net_vim
['admin_state_up']:
1014 net
["status"] = "DOWN"
1015 if net_vim
.get('last_error'):
1016 net
['error_msg'] = net_vim
['last_error']
1017 net
["vim_info"] = yaml
.safe_dump(net_vim
)
1018 except vimconn
.vimconnNotFoundException
as e
:
1019 self
.logger
.error("Exception getting net status: %s", str(e
))
1020 net
['status'] = "DELETED"
1021 net
['error_msg'] = str(e
)
1022 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.vimconnException
) as e
:
1023 self
.logger
.error("Exception getting net status: %s", str(e
))
1024 net
['status'] = "VIM_ERROR"
1025 net
['error_msg'] = str(e
)
1026 net_dict
[net_id
] = net
1029 def action_vminstance(self
, vm_id
, action_dict
):
1030 '''Send and action over a VM instance from VIM'''
1031 '''Returns the status'''
1033 self
._get
_my
_tenant
()
1034 if "console" in action_dict
:
1035 raise vimconn
.vimconnException("getting console is not available at openvim", http_code
=vimconn
.HTTP_Service_Unavailable
)
1036 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
+"/action"
1037 self
.logger
.info("Action over VM instance POST %s", url
)
1038 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps(action_dict
) )
1039 self
._check
_http
_request
_response
(vim_response
)
1041 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1042 self
._format
_request
_exception
(e
)
1044 #NOT USED METHODS in current version
1046 def host_vim2gui(self
, host
, server_dict
):
1047 '''Transform host dictionary from VIM format to GUI format,
1048 and append to the server_dict
1050 if type(server_dict
) is not dict:
1051 print('vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary')
1055 for numa
in host
['host']['numas']:
1059 RAD_item
['memory']={'size': str(numa
['memory'])+'GB', 'eligible': str(numa
['hugepages'])+'GB'}
1060 occupation_item
['memory']= str(numa
['hugepages_consumed'])+'GB'
1063 RAD_item
['cpus']['cores'] = []
1064 RAD_item
['cpus']['eligible_cores'] = []
1065 occupation_item
['cores']=[]
1066 for _
in range(0, len(numa
['cores']) / 2):
1067 RAD_item
['cpus']['cores'].append( [] )
1068 for core
in numa
['cores']:
1069 RAD_item
['cpus']['cores'][core
['core_id']].append(core
['thread_id'])
1070 if not 'status' in core
: RAD_item
['cpus']['eligible_cores'].append(core
['thread_id'])
1071 if 'instance_id' in core
: occupation_item
['cores'].append(core
['thread_id'])
1073 RAD_item
['ports']={}
1074 occupation_item
['ports']={}
1075 for iface
in numa
['interfaces']:
1076 RAD_item
['ports'][ iface
['pci'] ] = 'speed:'+str(iface
['Mbps'])+'M'
1077 occupation_item
['ports'][ iface
['pci'] ] = { 'occupied': str(100*iface
['Mbps_consumed'] / iface
['Mbps']) + "%" }
1079 RAD
[ numa
['numa_socket'] ] = RAD_item
1080 occupation
[ numa
['numa_socket'] ] = occupation_item
1081 server_dict
[ host
['host']['name'] ] = {'RAD':RAD
, 'occupation':occupation
}
1083 def get_hosts_info(self
):
1084 '''Get the information of deployed hosts
1085 Returns the hosts content'''
1087 url
=self
.url
+'/hosts'
1089 vim_response
= requests
.get(url
)
1090 except requests
.exceptions
.RequestException
as e
:
1091 print("get_hosts_info Exception: ", e
.args
)
1092 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1093 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1094 #print vim_response.status_code
1095 #print json.dumps(vim_response.json(), indent=4)
1096 if vim_response
.status_code
!= 200:
1098 print('vimconnector.get_hosts_info error getting host list %d %s' %(vim_response
.status_code
, vim_response
.json()))
1099 return -vim_response
.status_code
, "Error getting host list"
1101 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1104 print("vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts
)
1105 return vimconn
.HTTP_Internal_Server_Error
, hosts
1106 #obtain hosts details
1108 for host
in hosts
['hosts']:
1109 url
=self
.url
+'/hosts/'+host
['id']
1111 vim_response
= requests
.get(url
)
1112 except requests
.exceptions
.RequestException
as e
:
1113 print("get_hosts_info Exception: ", e
.args
)
1114 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1115 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1116 if vim_response
.status_code
!= 200:
1117 print('vimconnector.get_hosts_info error getting detailed host %d %s' %(vim_response
.status_code
, vim_response
.json()))
1119 res
,host_detail
= self
._format
_in
(vim_response
, get_host_detail_response_schema
)
1121 print("vimconnector.get_hosts_info error parsing GET HOSTS/%s vim response" % host
['id'], host_detail
)
1123 #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1124 self
.host_vim2gui(host_detail
, hosts_dict
)
1125 return 200, hosts_dict
1127 def get_hosts(self
, vim_tenant
):
1128 '''Get the hosts and deployed instances
1129 Returns the hosts content'''
1131 url
=self
.url
+'/hosts'
1133 vim_response
= requests
.get(url
)
1134 except requests
.exceptions
.RequestException
as e
:
1135 print("get_hosts Exception: ", e
.args
)
1136 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1137 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1138 #print vim_response.status_code
1139 #print json.dumps(vim_response.json(), indent=4)
1140 if vim_response
.status_code
!= 200:
1142 print('vimconnector.get_hosts error getting host list %d %s' %(vim_response
.status_code
, vim_response
.json()))
1143 return -vim_response
.status_code
, "Error getting host list"
1145 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1148 print("vimconnector.get_host error parsing GET HOSTS vim response", hosts
)
1149 return vimconn
.HTTP_Internal_Server_Error
, hosts
1150 #obtain instances from hosts
1151 for host
in hosts
['hosts']:
1152 url
=self
.url
+'/' + vim_tenant
+ '/servers?hostId='+host
['id']
1154 vim_response
= requests
.get(url
)
1155 except requests
.exceptions
.RequestException
as e
:
1156 print("get_hosts Exception: ", e
.args
)
1157 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1158 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1159 if vim_response
.status_code
!= 200:
1160 print('vimconnector.get_hosts error getting instances at host %d %s' %(vim_response
.status_code
, vim_response
.json()))
1162 res
,servers
= self
._format
_in
(vim_response
, get_server_response_schema
)
1164 print("vimconnector.get_host error parsing GET SERVERS/%s vim response" % host
['id'], servers
)
1166 #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1167 host
['instances'] = servers
['servers']
1168 return 200, hosts
['hosts']
1170 def get_processor_rankings(self
):
1171 '''Get the processor rankings in the VIM database'''
1172 url
=self
.url
+'/processor_ranking'
1174 vim_response
= requests
.get(url
)
1175 except requests
.exceptions
.RequestException
as e
:
1176 print("get_processor_rankings Exception: ", e
.args
)
1177 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1178 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1179 #print vim_response.status_code
1180 #print json.dumps(vim_response.json(), indent=4)
1181 if vim_response
.status_code
!= 200:
1183 print('vimconnector.get_processor_rankings error getting processor rankings %d %s' %(vim_response
.status_code
, vim_response
.json()))
1184 return -vim_response
.status_code
, "Error getting processor rankings"
1186 res
,rankings
= self
._format
_in
(vim_response
, get_processor_rankings_response_schema
)
1187 return res
, rankings
['rankings']
1189 def new_host(self
, host_data
):
1190 '''Adds a new host to VIM'''
1191 '''Returns status code of the VIM response'''
1192 payload_req
= host_data
1194 url
= self
.url_admin
+'/hosts'
1195 self
.logger
.info("Adding a new host POST %s", url
)
1196 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
1197 self
._check
_http
_request
_response
(vim_response
)
1198 self
.logger
.debug(vim_response
.text
)
1199 #print json.dumps(vim_response.json(), indent=4)
1200 response
= vim_response
.json()
1201 js_v(response
, new_host_response_schema
)
1202 r
= self
._remove
_extra
_items
(response
, new_host_response_schema
)
1204 self
.logger
.warn("Warning: remove extra items %s", str(r
))
1205 host_id
= response
['host']['id']
1207 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1208 self
._format
_request
_exception
(e
)
1210 def new_external_port(self
, port_data
):
1211 '''Adds a external port to VIM'''
1212 '''Returns the port identifier'''
1213 #TODO change to logging exception code policies
1214 print("VIMConnector: Adding a new external port")
1215 payload_req
= port_data
1217 vim_response
= requests
.post(self
.url_admin
+'/ports', headers
= self
.headers_req
, data
=payload_req
)
1218 except requests
.exceptions
.RequestException
as e
:
1219 self
.logger
.error("new_external_port Exception: ", str(e
))
1220 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1222 #print vim_response.status_code
1223 if vim_response
.status_code
== 200:
1224 #print vim_response.json()
1225 #print json.dumps(vim_response.json(), indent=4)
1226 res
, http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1229 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1230 if r
is not None: print("Warning: remove extra items ", r
)
1232 port_id
= http_content
['port']['id']
1233 print("Port id: ",port_id
)
1234 return vim_response
.status_code
,port_id
1235 else: return -vimconn
.HTTP_Bad_Request
,http_content
1237 #print vim_response.text
1238 jsonerror
= self
._format
_jsonerror
(vim_response
)
1239 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
)
1241 return -vim_response
.status_code
,text
1243 def new_external_network(self
,net_name
,net_type
):
1244 '''Adds a external network to VIM (shared)'''
1245 '''Returns the network identifier'''
1246 #TODO change to logging exception code policies
1247 print("VIMConnector: Adding external shared network to VIM (type " + net_type
+ "): "+ net_name
)
1249 payload_req
= '{"network":{"name": "' + net_name
+ '","shared":true,"type": "' + net_type
+ '"}}'
1251 vim_response
= requests
.post(self
.url
+'/networks', headers
= self
.headers_req
, data
=payload_req
)
1252 except requests
.exceptions
.RequestException
as e
:
1253 self
.logger
.error( "new_external_network Exception: ", e
.args
)
1254 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1256 #print vim_response.status_code
1257 if vim_response
.status_code
== 200:
1258 #print vim_response.json()
1259 #print json.dumps(vim_response.json(), indent=4)
1260 res
,http_content
= self
._format
_in
(vim_response
, new_network_response_schema
)
1263 r
= self
._remove
_extra
_items
(http_content
, new_network_response_schema
)
1264 if r
is not None: print("Warning: remove extra items ", r
)
1266 network_id
= http_content
['network']['id']
1267 print("Network id: ",network_id
)
1268 return vim_response
.status_code
,network_id
1269 else: return -vimconn
.HTTP_Bad_Request
,http_content
1271 #print vim_response.text
1272 jsonerror
= self
._format
_jsonerror
(vim_response
)
1273 text
= 'Error in VIM "%s": not possible to add new external network. HTTP Response: %d. Error: %s' % (self
.url
, vim_response
.status_code
, jsonerror
)
1275 return -vim_response
.status_code
,text
1277 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1278 '''Connects a external port to a network'''
1279 '''Returns status code of the VIM response'''
1280 #TODO change to logging exception code policies
1281 print("VIMConnector: Connecting external port to network")
1283 payload_req
= '{"port":{"network_id":"' + network_id
+ '"}}'
1285 if self
.url_admin
==None:
1286 return -vimconn
.HTTP_Unauthorized
, "datacenter cannot contain admin URL"
1291 vim_response
= requests
.put(url
+'/ports/'+port_id
, headers
= self
.headers_req
, data
=payload_req
)
1292 except requests
.exceptions
.RequestException
as e
:
1293 print("connect_port_network Exception: ", e
.args
)
1294 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1296 #print vim_response.status_code
1297 if vim_response
.status_code
== 200:
1298 #print vim_response.json()
1299 #print json.dumps(vim_response.json(), indent=4)
1300 res
,http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1303 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1304 if r
is not None: print("Warning: remove extra items ", r
)
1306 port_id
= http_content
['port']['id']
1307 print("Port id: ",port_id
)
1308 return vim_response
.status_code
,port_id
1309 else: return -vimconn
.HTTP_Bad_Request
,http_content
1311 print(vim_response
.text
)
1312 jsonerror
= self
._format
_jsonerror
(vim_response
)
1313 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
)
1315 return -vim_response
.status_code
,text