1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefonica Investigacion 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$"
30 from osm_ro_plugin
import vimconn
36 from osm_ro
.openmano_schemas
import id_schema
, name_schema
, nameshort_schema
, description_schema
, \
37 vlan1000_schema
, integer0_schema
38 from jsonschema
import validate
as js_v
, exceptions
as js_e
39 from urllib
.parse
import quote
41 '''contain the openvim virtual machine status to openmano status'''
42 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
44 'SUSPENDED': 'SUSPENDED',
45 'INACTIVE':'INACTIVE',
47 'ERROR':'ERROR','DELETED':'DELETED'
49 netStatus2manoFormat
={'ACTIVE':'ACTIVE','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED', 'DOWN':'DOWN'
67 "required": ["id","name"]
75 "required": ["id","name"]
77 new_host_response_schema
= {
78 "title":"host response information schema",
79 "$schema": "http://json-schema.org/draft-04/schema#",
85 "additionalProperties": False
88 get_images_response_schema
= {
89 "title":"openvim images response information schema",
90 "$schema": "http://json-schema.org/draft-04/schema#",
95 "items": image_schema
,
98 "required": ["images"],
99 "additionalProperties": False
102 get_hosts_response_schema
= {
103 "title":"openvim hosts response information schema",
104 "$schema": "http://json-schema.org/draft-04/schema#",
109 "items": host_schema
,
112 "required": ["hosts"],
113 "additionalProperties": False
116 get_host_detail_response_schema
= new_host_response_schema
# TODO: Content is not parsed yet
118 get_server_response_schema
= {
119 "title":"openvim server response information schema",
120 "$schema": "http://json-schema.org/draft-04/schema#",
125 "items": server_schema
,
128 "required": ["servers"],
129 "additionalProperties": False
132 new_tenant_response_schema
= {
133 "title":"tenant response information schema",
134 "$schema": "http://json-schema.org/draft-04/schema#",
141 "name": nameshort_schema
,
142 "description":description_schema
,
143 "enabled":{"type" : "boolean"}
148 "required": ["tenant"],
149 "additionalProperties": False
152 new_network_response_schema
= {
153 "title":"network response information schema",
154 "$schema": "http://json-schema.org/draft-04/schema#",
162 "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
163 "shared":{"type":"boolean"},
164 "tenant_id":id_schema
,
165 "admin_state_up":{"type":"boolean"},
166 "vlan":vlan1000_schema
171 "required": ["network"],
172 "additionalProperties": False
176 # get_network_response_schema = {
177 # "title":"get network response information schema",
178 # "$schema": "http://json-schema.org/draft-04/schema#",
185 # "name":name_schema,
186 # "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
187 # "shared":{"type":"boolean"},
188 # "tenant_id":id_schema,
189 # "admin_state_up":{"type":"boolean"},
190 # "vlan":vlan1000_schema
195 # "required": ["network"],
196 # "additionalProperties": False
200 new_port_response_schema
= {
201 "title":"port response information schema",
202 "$schema": "http://json-schema.org/draft-04/schema#",
213 "required": ["port"],
214 "additionalProperties": False
217 get_flavor_response_schema
= {
218 "title":"openvim flavors response information schema",
219 "$schema": "http://json-schema.org/draft-04/schema#",
227 "extended": {"type":"object"},
229 "required": ["id", "name"],
232 "required": ["flavor"],
233 "additionalProperties": False
236 new_flavor_response_schema
= {
237 "title":"flavor response information schema",
238 "$schema": "http://json-schema.org/draft-04/schema#",
249 "required": ["flavor"],
250 "additionalProperties": False
253 get_image_response_schema
= {
254 "title":"openvim images response information schema",
255 "$schema": "http://json-schema.org/draft-04/schema#",
264 "required": ["id", "name"],
267 "required": ["flavor"],
268 "additionalProperties": False
270 new_image_response_schema
= {
271 "title":"image response information schema",
272 "$schema": "http://json-schema.org/draft-04/schema#",
283 "required": ["image"],
284 "additionalProperties": False
287 new_vminstance_response_schema
= {
288 "title":"server response information schema",
289 "$schema": "http://json-schema.org/draft-04/schema#",
300 "required": ["server"],
301 "additionalProperties": False
304 get_processor_rankings_response_schema
= {
305 "title":"processor rankings information schema",
306 "$schema": "http://json-schema.org/draft-04/schema#",
314 "model": description_schema
,
315 "value": integer0_schema
317 "additionalProperties": False,
318 "required": ["model","value"]
321 "additionalProperties": False,
322 "required": ["rankings"]
327 class vimconnector(vimconn
.VimConnector
):
328 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,
329 log_level
="DEBUG", config
={}, persistent_info
={}):
330 vimconn
.VimConnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
332 self
.headers_req
= {'content-type': 'application/json'}
333 self
.logger
= logging
.getLogger('openmano.vim.openvim')
334 self
.persistent_info
= persistent_info
336 self
.tenant
= tenant_id
338 def __setitem__(self
,index
, value
):
339 '''Set individuals parameters
340 Throw TypeError, KeyError
342 if index
=='tenant_id':
344 elif index
=='tenant_name':
346 vimconn
.VimConnector
.__setitem
__(self
,index
, value
)
348 def _get_my_tenant(self
):
349 '''Obtain uuid of my tenant from name
354 url
= self
.url
+'/tenants?name='+ quote(self
.tenant_name
)
355 self
.logger
.info("Getting VIM tenant_id GET %s", url
)
356 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
357 self
._check
_http
_request
_response
(vim_response
)
359 tenant_list
= vim_response
.json()["tenants"]
360 if len(tenant_list
) == 0:
361 raise vimconn
.VimConnNotFoundException("No tenant found for name '{}'".format(self
.tenant_name
))
362 elif len(tenant_list
) > 1:
363 raise vimconn
.VimConnConflictException ("More that one tenant found for name '{}'".format(self
.tenant_name
))
364 self
.tenant
= tenant_list
[0]["id"]
366 except Exception as e
:
367 raise vimconn
.VimConnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e
).__name
__, str(e
)))
369 def _format_jsonerror(self
,http_response
):
370 #DEPRECATED, to delete in the future
372 data
= http_response
.json()
373 return data
["error"]["description"]
375 return http_response
.text
377 def _format_in(self
, http_response
, schema
):
378 #DEPRECATED, to delete in the future
380 client_data
= http_response
.json()
381 js_v(client_data
, schema
)
382 #print "Input data: ", str(client_data)
383 return True, client_data
384 except js_e
.ValidationError
as exc
:
385 print("validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
)
386 return False, ("validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
)
388 def _remove_extra_items(self
, data
, schema
):
390 if type(data
) is tuple or type(data
) is list:
392 a
= self
._remove
_extra
_items
(d
, schema
['items'])
393 if a
is not None: deleted
.append(a
)
394 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
})
405 if len(deleted
) == 0: return None
406 elif len(deleted
) == 1: return deleted
[0]
409 def _format_request_exception(self
, request_exception
):
410 '''Transform a request exception into a vimconn exception'''
411 if isinstance(request_exception
, js_e
.ValidationError
):
412 raise vimconn
.VimConnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception
.message
, request_exception
.path
))
413 elif isinstance(request_exception
, requests
.exceptions
.HTTPError
):
414 raise vimconn
.VimConnUnexpectedResponse(type(request_exception
).__name
__ + ": " + str(request_exception
))
416 raise vimconn
.VimConnConnectionException(type(request_exception
).__name
__ + ": " + str(request_exception
))
418 def _check_http_request_response(self
, request_response
):
419 '''Raise a vimconn exception if the response is not Ok'''
420 if request_response
.status_code
>= 200 and request_response
.status_code
< 300:
422 if request_response
.status_code
== vimconn
.HTTP_Unauthorized
:
423 raise vimconn
.VimConnAuthException(request_response
.text
)
424 elif request_response
.status_code
== vimconn
.HTTP_Not_Found
:
425 raise vimconn
.VimConnNotFoundException(request_response
.text
)
426 elif request_response
.status_code
== vimconn
.HTTP_Conflict
:
427 raise vimconn
.VimConnConflictException(request_response
.text
)
429 raise vimconn
.VimConnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response
.status_code
, str(request_response
.text
)))
431 def new_tenant(self
,tenant_name
,tenant_description
):
432 '''Adds a new tenant to VIM with this name and description, returns the tenant identifier'''
433 #print "VIMConnector: Adding a new tenant to VIM"
434 payload_dict
= {"tenant": {"name":tenant_name
,"description": tenant_description
, "enabled": True}}
435 payload_req
= json
.dumps(payload_dict
)
437 url
= self
.url_admin
+'/tenants'
438 self
.logger
.info("Adding a new tenant %s", url
)
439 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
440 self
._check
_http
_request
_response
(vim_response
)
441 self
.logger
.debug(vim_response
.text
)
442 #print json.dumps(vim_response.json(), indent=4)
443 response
= vim_response
.json()
444 js_v(response
, new_tenant_response_schema
)
445 #r = self._remove_extra_items(response, new_tenant_response_schema)
447 # self.logger.warn("Warning: remove extra items %s", str(r))
448 tenant_id
= response
['tenant']['id']
450 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
451 self
._format
_request
_exception
(e
)
453 def delete_tenant(self
,tenant_id
):
454 '''Delete a tenant from VIM. Returns the old tenant identifier'''
456 url
= self
.url_admin
+'/tenants/'+tenant_id
457 self
.logger
.info("Delete a tenant DELETE %s", url
)
458 vim_response
= requests
.delete(url
, headers
= self
.headers_req
)
459 self
._check
_http
_request
_response
(vim_response
)
460 self
.logger
.debug(vim_response
.text
)
461 #print json.dumps(vim_response.json(), indent=4)
463 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
464 self
._format
_request
_exception
(e
)
466 def get_tenant_list(self
, filter_dict
={}):
467 '''Obtain tenants of VIM
468 filter_dict can contain the following keys:
469 name: filter by tenant name
470 id: filter by tenant uuid/id
472 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
476 for k
,v
in filter_dict
.items():
477 filterquery
.append(str(k
)+'='+str(v
))
478 if len(filterquery
)>0:
479 filterquery_text
='?'+ '&'.join(filterquery
)
481 url
= self
.url
+'/tenants'+filterquery_text
482 self
.logger
.info("get_tenant_list GET %s", url
)
483 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
484 self
._check
_http
_request
_response
(vim_response
)
485 self
.logger
.debug(vim_response
.text
)
486 #print json.dumps(vim_response.json(), indent=4)
487 return vim_response
.json()["tenants"]
488 except requests
.exceptions
.RequestException
as e
:
489 self
._format
_request
_exception
(e
)
491 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, provider_network_profile
=None): #, **vim_specific):
492 """Adds a tenant network to VIM
494 'net_name': name of the network
496 'bridge': overlay isolated network
497 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
498 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
499 'ip_profile': is a dict containing the IP parameters of the network
500 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
501 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
502 'gateway_address': (Optional) ip_schema, that is X.X.X.X
503 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
504 'dhcp_enabled': True or False
505 'dhcp_start_address': ip_schema, first IP to grant
506 'dhcp_count': number of IPs to grant.
507 'shared': if this network can be seen/use by other tenants/organization
508 'provider_network_profile': (optional) contains {segmentation-id: vlan, provider-network: vim_netowrk}
509 Returns a tuple with the network identifier and created_items, or raises an exception on error
510 created_items can be None or a dictionary where this method can include key-values that will be passed to
511 the method delete_network. Can be used to store created segments, created l2gw connections, etc.
512 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
517 if provider_network_profile
:
518 vlan
= provider_network_profile
.get("segmentation-id")
520 self
._get
_my
_tenant
()
521 if net_type
=="bridge":
522 net_type
="bridge_data"
523 payload_req
= {"name": net_name
, "type": net_type
, "tenant_id": self
.tenant
, "shared": shared
}
525 payload_req
["provider:vlan"] = vlan
526 # payload_req.update(vim_specific)
527 url
= self
.url
+'/networks'
528 self
.logger
.info("Adding a new network POST: %s DATA: %s", url
, str(payload_req
))
529 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps({"network": payload_req
}) )
530 self
._check
_http
_request
_response
(vim_response
)
531 self
.logger
.debug(vim_response
.text
)
532 #print json.dumps(vim_response.json(), indent=4)
533 response
= vim_response
.json()
534 js_v(response
, new_network_response_schema
)
535 #r = self._remove_extra_items(response, new_network_response_schema)
537 # self.logger.warn("Warning: remove extra items %s", str(r))
538 network_id
= response
['network']['id']
539 return network_id
, created_items
540 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
541 self
._format
_request
_exception
(e
)
543 def get_network_list(self
, filter_dict
={}):
544 '''Obtain tenant networks of VIM
550 admin_state_up: boolean
552 Returns the network list of dictionaries
555 if 'tenant_id' not in filter_dict
:
556 filter_dict
["tenant_id"] = self
._get
_my
_tenant
()
557 elif not filter_dict
["tenant_id"]:
558 del filter_dict
["tenant_id"]
561 for k
,v
in filter_dict
.items():
562 filterquery
.append(str(k
)+'='+str(v
))
563 if len(filterquery
)>0:
564 filterquery_text
='?'+ '&'.join(filterquery
)
565 url
= self
.url
+'/networks'+filterquery_text
566 self
.logger
.info("Getting network list GET %s", url
)
567 vim_response
= requests
.get(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)
571 response
= vim_response
.json()
572 return response
['networks']
573 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
574 self
._format
_request
_exception
(e
)
576 def get_network(self
, net_id
):
577 '''Obtain network details of network id'''
579 url
= self
.url
+'/networks/'+net_id
580 self
.logger
.info("Getting network 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 return response
['network']
587 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
588 self
._format
_request
_exception
(e
)
590 def delete_network(self
, net_id
, created_items
=None):
592 Removes a tenant network from VIM and its associated elements
593 :param net_id: VIM identifier of the network, provided by method new_network
594 :param created_items: dictionary with extra items to be deleted. provided by method new_network
595 Returns the network identifier or raises an exception upon error or when network is not found
598 self
._get
_my
_tenant
()
599 url
= self
.url
+'/networks/'+net_id
600 self
.logger
.info("Deleting VIM network DELETE %s", url
)
601 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
602 self
._check
_http
_request
_response
(vim_response
)
603 #self.logger.debug(vim_response.text)
604 #print json.dumps(vim_response.json(), indent=4)
606 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
607 self
._format
_request
_exception
(e
)
609 def get_flavor(self
, flavor_id
):
610 '''Obtain flavor details from the VIM'''
612 self
._get
_my
_tenant
()
613 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
614 self
.logger
.info("Getting flavor GET %s", url
)
615 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
616 self
._check
_http
_request
_response
(vim_response
)
617 self
.logger
.debug(vim_response
.text
)
618 #print json.dumps(vim_response.json(), indent=4)
619 response
= vim_response
.json()
620 js_v(response
, get_flavor_response_schema
)
621 r
= self
._remove
_extra
_items
(response
, get_flavor_response_schema
)
623 self
.logger
.warn("Warning: remove extra items %s", str(r
))
624 return response
['flavor']
625 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
626 self
._format
_request
_exception
(e
)
628 def new_flavor(self
, flavor_data
):
629 '''Adds a tenant flavor to VIM'''
630 '''Returns the flavor identifier'''
632 new_flavor_dict
= flavor_data
.copy()
633 for device
in new_flavor_dict
.get('extended', {}).get('devices', ()):
634 if 'image name' in device
:
635 del device
['image name']
638 numas
= new_flavor_dict
.get('extended', {}).get('numas')
641 # translate memory, cpus to EPA
642 if "cores" not in numa
and "threads" not in numa
and "paired-threads" not in numa
:
643 numa
["paired-threads"] = new_flavor_dict
["vcpus"]
644 if "memory" not in numa
:
645 numa
["memory"] = int(math
.ceil(new_flavor_dict
["ram"] / 1024.0))
646 for iface
in numa
.get("interfaces", ()):
647 if not iface
.get("bandwidth"):
648 iface
["bandwidth"] = "1 Mbps"
650 new_flavor_dict
["name"] = flavor_data
["name"][:64]
651 self
._get
_my
_tenant
()
652 payload_req
= json
.dumps({'flavor': new_flavor_dict
})
653 url
= self
.url
+'/'+self
.tenant
+'/flavors'
654 self
.logger
.info("Adding a new VIM flavor POST %s", url
)
655 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
656 self
._check
_http
_request
_response
(vim_response
)
657 self
.logger
.debug(vim_response
.text
)
658 #print json.dumps(vim_response.json(), indent=4)
659 response
= vim_response
.json()
660 js_v(response
, new_flavor_response_schema
)
661 r
= self
._remove
_extra
_items
(response
, new_flavor_response_schema
)
663 self
.logger
.warn("Warning: remove extra items %s", str(r
))
664 flavor_id
= response
['flavor']['id']
666 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
667 self
._format
_request
_exception
(e
)
669 def delete_flavor(self
,flavor_id
):
670 '''Deletes a tenant flavor from VIM'''
671 '''Returns the old flavor_id'''
673 self
._get
_my
_tenant
()
674 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
675 self
.logger
.info("Deleting VIM flavor DELETE %s", url
)
676 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
677 self
._check
_http
_request
_response
(vim_response
)
678 #self.logger.debug(vim_response.text)
679 #print json.dumps(vim_response.json(), indent=4)
681 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
682 self
._format
_request
_exception
(e
)
684 def get_image(self
, image_id
):
685 '''Obtain image details from the VIM'''
687 self
._get
_my
_tenant
()
688 url
= self
.url
+'/'+self
.tenant
+'/images/'+image_id
689 self
.logger
.info("Getting image GET %s", url
)
690 vim_response
= requests
.get(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)
694 response
= vim_response
.json()
695 js_v(response
, get_image_response_schema
)
696 r
= self
._remove
_extra
_items
(response
, get_image_response_schema
)
698 self
.logger
.warn("Warning: remove extra items %s", str(r
))
699 return response
['image']
700 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
701 self
._format
_request
_exception
(e
)
703 def new_image(self
,image_dict
):
704 ''' Adds a tenant image to VIM, returns image_id'''
706 self
._get
_my
_tenant
()
707 new_image_dict
={'name': image_dict
['name'][:64]}
708 if image_dict
.get('description'):
709 new_image_dict
['description'] = image_dict
['description']
710 if image_dict
.get('metadata'):
711 new_image_dict
['metadata'] = yaml
.load(image_dict
['metadata'], Loader
=yaml
.SafeLoader
)
712 if image_dict
.get('location'):
713 new_image_dict
['path'] = image_dict
['location']
714 payload_req
= json
.dumps({"image":new_image_dict
})
715 url
=self
.url
+ '/' + self
.tenant
+ '/images'
716 self
.logger
.info("Adding a new VIM image POST %s", url
)
717 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
718 self
._check
_http
_request
_response
(vim_response
)
719 self
.logger
.debug(vim_response
.text
)
720 #print json.dumps(vim_response.json(), indent=4)
721 response
= vim_response
.json()
722 js_v(response
, new_image_response_schema
)
723 r
= self
._remove
_extra
_items
(response
, new_image_response_schema
)
725 self
.logger
.warn("Warning: remove extra items %s", str(r
))
726 image_id
= response
['image']['id']
728 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
729 self
._format
_request
_exception
(e
)
731 def delete_image(self
, image_id
):
732 '''Deletes a tenant image from VIM'''
733 '''Returns the deleted image_id'''
735 self
._get
_my
_tenant
()
736 url
= self
.url
+ '/'+ self
.tenant
+'/images/'+image_id
737 self
.logger
.info("Deleting VIM image DELETE %s", url
)
738 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
739 self
._check
_http
_request
_response
(vim_response
)
740 #self.logger.debug(vim_response.text)
741 #print json.dumps(vim_response.json(), indent=4)
743 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
744 self
._format
_request
_exception
(e
)
746 def get_image_id_from_path(self
, path
):
747 '''Get the image id from image path in the VIM database. Returns the image_id'''
749 self
._get
_my
_tenant
()
750 url
=self
.url
+ '/' + self
.tenant
+ '/images?path='+quote(path
)
751 self
.logger
.info("Getting images GET %s", url
)
752 vim_response
= requests
.get(url
)
753 self
._check
_http
_request
_response
(vim_response
)
754 self
.logger
.debug(vim_response
.text
)
755 #print json.dumps(vim_response.json(), indent=4)
756 response
= vim_response
.json()
757 js_v(response
, get_images_response_schema
)
758 #r = self._remove_extra_items(response, get_images_response_schema)
760 # self.logger.warn("Warning: remove extra items %s", str(r))
761 if len(response
['images'])==0:
762 raise vimconn
.VimConnNotFoundException("Image not found at VIM with path '{}'".format(path
))
763 elif len(response
['images'])>1:
764 raise vimconn
.VimConnConflictException("More than one image found at VIM with path '{}'".format(path
))
765 return response
['images'][0]['id']
766 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
767 self
._format
_request
_exception
(e
)
769 def get_image_list(self
, filter_dict
={}):
770 '''Obtain tenant images from VIM
774 checksum: image checksum
776 Returns the image list of dictionaries:
777 [{<the fields at Filter_dict plus some VIM specific>}, ...]
781 self
._get
_my
_tenant
()
784 for k
,v
in filter_dict
.items():
785 filterquery
.append(str(k
)+'='+str(v
))
786 if len(filterquery
)>0:
787 filterquery_text
='?'+ '&'.join(filterquery
)
788 url
= self
.url
+'/'+self
.tenant
+'/images'+filterquery_text
789 self
.logger
.info("Getting image list GET %s", url
)
790 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
791 self
._check
_http
_request
_response
(vim_response
)
792 self
.logger
.debug(vim_response
.text
)
793 #print json.dumps(vim_response.json(), indent=4)
794 response
= vim_response
.json()
795 return response
['images']
796 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
797 self
._format
_request
_exception
(e
)
799 def new_vminstancefromJSON(self
, vm_data
):
800 '''Adds a VM instance to VIM'''
801 '''Returns the instance identifier'''
803 self
._get
_my
_tenant
()
804 except Exception as e
:
805 return -vimconn
.HTTP_Not_Found
, str(e
)
806 print("VIMConnector: Adding a new VM instance from JSON to VIM")
807 payload_req
= vm_data
809 vim_response
= requests
.post(self
.url
+'/'+self
.tenant
+'/servers', headers
= self
.headers_req
, data
=payload_req
)
810 except requests
.exceptions
.RequestException
as e
:
811 print( "new_vminstancefromJSON Exception: ", e
.args
)
812 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
814 #print vim_response.status_code
815 if vim_response
.status_code
== 200:
816 #print vim_response.json()
817 #print json.dumps(vim_response.json(), indent=4)
818 res
,http_content
= self
._format
_in
(vim_response
, new_image_response_schema
)
821 r
= self
._remove
_extra
_items
(http_content
, new_image_response_schema
)
822 if r
is not None: print("Warning: remove extra items ", r
)
824 vminstance_id
= http_content
['server']['id']
825 print( "Tenant image id: ",vminstance_id
)
826 return vim_response
.status_code
,vminstance_id
827 else: return -vimconn
.HTTP_Bad_Request
,http_content
829 #print vim_response.text
830 jsonerror
= self
._format
_jsonerror
(vim_response
)
831 text
= 'Error in VIM "{}": not possible to add new vm instance. HTTP Response: {}. Error: {}'.format(
832 self
.url
, vim_response
.status_code
, jsonerror
)
834 return -vim_response
.status_code
,text
836 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
837 availability_zone_index
=None, availability_zone_list
=None):
838 """Adds a VM instance to VIM
840 start: indicates if VM must start or boot in pause mode. Ignored
841 image_id,flavor_id: image and flavor uuid
842 net_list: list of interfaces, each one is a dictionary with:
844 net_id: network uuid to connect
845 vpci: virtual vcpi to assign
846 model: interface model, virtio, e1000, ...
848 use: 'data', 'bridge', 'mgmt'
849 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
850 vim_id: filled/added by this function
851 #TODO ip, security groups
852 Returns a tuple with the instance identifier and created_items or raises an exception on error
853 created_items can be None or a dictionary where this method can include key-values that will be passed to
854 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
855 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
858 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'", image_id
, flavor_id
, str(net_list
))
860 self
._get
_my
_tenant
()
862 # for k,v in net_dict.items():
864 # net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
865 # net_list_string = ', '.join(net_list)
868 if not net
.get("net_id"):
870 net_dict
= {'uuid': net
["net_id"]}
872 if net
["type"] == "SR-IOV":
873 net_dict
["type"] = "VF"
874 elif net
["type"] == "PCI-PASSTHROUGH":
875 net_dict
["type"] = "PF"
877 net_dict
["type"] = net
["type"]
879 net_dict
["name"] = net
["name"]
881 net_dict
["vpci"] = net
["vpci"]
883 if net
["model"] == "VIRTIO" or net
["model"] == "paravirt":
884 net_dict
["model"] = "virtio"
886 net_dict
["model"] = net
["model"]
887 if net
.get("mac_address"):
888 net_dict
["mac_address"] = net
["mac_address"]
889 if net
.get("ip_address"):
890 net_dict
["ip_address"] = net
["ip_address"]
891 virtio_net_list
.append(net_dict
)
892 payload_dict
={ "name": name
[:64],
893 "description": description
,
894 "imageRef": image_id
,
895 "flavorRef": flavor_id
,
896 "networks": virtio_net_list
899 payload_dict
["start"] = start
900 payload_req
= json
.dumps({"server": payload_dict
})
901 url
= self
.url
+'/'+self
.tenant
+'/servers'
902 self
.logger
.info("Adding a new vm POST %s DATA %s", url
, payload_req
)
903 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
904 self
._check
_http
_request
_response
(vim_response
)
905 self
.logger
.debug(vim_response
.text
)
906 #print json.dumps(vim_response.json(), indent=4)
907 response
= vim_response
.json()
908 js_v(response
, new_vminstance_response_schema
)
909 #r = self._remove_extra_items(response, new_vminstance_response_schema)
911 # self.logger.warn("Warning: remove extra items %s", str(r))
912 vminstance_id
= response
['server']['id']
914 #connect data plane interfaces to network
916 if net
["type"]=="virtual":
917 if not net
.get("net_id"):
919 for iface
in response
['server']['networks']:
921 if net
["name"]==iface
["name"]:
922 net
["vim_id"] = iface
['iface_id']
924 elif "net_id" in net
:
925 if net
["net_id"]==iface
["net_id"]:
926 net
["vim_id"] = iface
['iface_id']
929 for numa
in response
['server'].get('extended',{}).get('numas',() ):
930 for iface
in numa
.get('interfaces',() ):
931 if net
['name'] == iface
['name']:
932 net
['vim_id'] = iface
['iface_id']
933 #Code bellow is not needed, current openvim connect dataplane interfaces
934 #if net.get("net_id"):
935 ##connect dataplane interface
936 # result, port_id = self.connect_port_network(iface['iface_id'], net["net_id"])
938 # error_text = "Error attaching port %s to network %s: %s." % (iface['iface_id'], net["net_id"], port_id)
939 # print "new_vminstance: " + error_text
940 # self.delete_vminstance(vminstance_id)
941 # return result, error_text
944 return vminstance_id
, None
945 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
946 self
._format
_request
_exception
(e
)
948 def get_vminstance(self
, vm_id
):
949 '''Returns the VM instance information from VIM'''
951 self
._get
_my
_tenant
()
952 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
953 self
.logger
.info("Getting vm GET %s", url
)
954 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
955 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
956 self
._check
_http
_request
_response
(vim_response
)
957 self
.logger
.debug(vim_response
.text
)
958 #print json.dumps(vim_response.json(), indent=4)
959 response
= vim_response
.json()
960 js_v(response
, new_vminstance_response_schema
)
961 #r = self._remove_extra_items(response, new_vminstance_response_schema)
963 # self.logger.warn("Warning: remove extra items %s", str(r))
964 return response
['server']
965 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
966 self
._format
_request
_exception
(e
)
968 def delete_vminstance(self
, vm_id
, created_items
=None):
969 '''Removes a VM instance from VIM, returns the deleted vm_id'''
971 self
._get
_my
_tenant
()
972 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
973 self
.logger
.info("Deleting VIM vm DELETE %s", url
)
974 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
975 self
._check
_http
_request
_response
(vim_response
)
976 #self.logger.debug(vim_response.text)
977 #print json.dumps(vim_response.json(), indent=4)
979 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
980 self
._format
_request
_exception
(e
)
982 def refresh_vms_status(self
, vm_list
):
983 '''Refreshes the status of the virtual machines'''
985 self
._get
_my
_tenant
()
986 except requests
.exceptions
.RequestException
as e
:
987 self
._format
_request
_exception
(e
)
989 for vm_id
in vm_list
:
991 #print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
993 url
= self
.url
+ '/' + self
.tenant
+ '/servers/' + vm_id
994 self
.logger
.info("Getting vm GET %s", url
)
995 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
996 self
._check
_http
_request
_response
(vim_response
)
997 response
= vim_response
.json()
998 js_v(response
, new_vminstance_response_schema
)
999 if response
['server']['status'] in vmStatus2manoFormat
:
1000 vm
['status'] = vmStatus2manoFormat
[ response
['server']['status'] ]
1002 vm
['status'] = "OTHER"
1003 vm
['error_msg'] = "VIM status reported " + response
['server']['status']
1004 if response
['server'].get('last_error'):
1005 vm
['error_msg'] = response
['server']['last_error']
1006 vm
["vim_info"] = yaml
.safe_dump(response
['server'])
1007 #get interfaces info
1009 management_ip
= False
1010 url2
= self
.url
+ '/ports?device_id=' + quote(vm_id
)
1011 self
.logger
.info("Getting PORTS GET %s", url2
)
1012 vim_response2
= requests
.get(url2
, headers
= self
.headers_req
)
1013 self
._check
_http
_request
_response
(vim_response2
)
1014 client_data
= vim_response2
.json()
1015 if isinstance(client_data
.get("ports"), list):
1017 for port
in client_data
.get("ports"):
1019 interface
['vim_info'] = yaml
.safe_dump(port
)
1020 interface
["mac_address"] = port
.get("mac_address")
1021 interface
["vim_net_id"] = port
.get("network_id")
1022 interface
["vim_interface_id"] = port
["id"]
1023 interface
["ip_address"] = port
.get("ip_address")
1024 if interface
["ip_address"]:
1025 management_ip
= True
1026 if interface
["ip_address"] == "0.0.0.0":
1027 interface
["ip_address"] = None
1028 vm
["interfaces"].append(interface
)
1030 except Exception as e
:
1031 self
.logger
.error("refresh_vms_and_nets. Port get %s: %s", type(e
).__name
__, str(e
))
1033 if vm
['status'] == "ACTIVE" and not management_ip
:
1034 vm
['status'] = "ACTIVE:NoMgmtIP"
1036 except vimconn
.VimConnNotFoundException
as e
:
1037 self
.logger
.error("Exception getting vm status: %s", str(e
))
1038 vm
['status'] = "DELETED"
1039 vm
['error_msg'] = str(e
)
1040 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.VimConnException
) as e
:
1041 self
.logger
.error("Exception getting vm status: %s", str(e
))
1042 vm
['status'] = "VIM_ERROR"
1043 vm
['error_msg'] = str(e
)
1047 def refresh_nets_status(self
, net_list
):
1048 '''Get the status of the networks
1049 Params: the list of network identifiers
1050 Returns a dictionary with:
1051 net_id: #VIM id of this network
1052 status: #Mandatory. Text with one of:
1053 # DELETED (not found at vim)
1054 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1055 # OTHER (Vim reported other status not understood)
1056 # ERROR (VIM indicates an ERROR status)
1057 # ACTIVE, INACTIVE, DOWN (admin down),
1058 # BUILD (on building process)
1060 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1061 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1065 self
._get
_my
_tenant
()
1066 except requests
.exceptions
.RequestException
as e
:
1067 self
._format
_request
_exception
(e
)
1070 for net_id
in net_list
:
1072 #print "VIMConnector refresh_tenant_vms_and_nets: Getting tenant network from VIM (tenant: " + str(self.tenant) + "): "
1074 net_vim
= self
.get_network(net_id
)
1075 if net_vim
['status'] in netStatus2manoFormat
:
1076 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
1078 net
["status"] = "OTHER"
1079 net
["error_msg"] = "VIM status reported " + net_vim
['status']
1081 if net
["status"] == "ACTIVE" and not net_vim
['admin_state_up']:
1082 net
["status"] = "DOWN"
1083 if net_vim
.get('last_error'):
1084 net
['error_msg'] = net_vim
['last_error']
1085 net
["vim_info"] = yaml
.safe_dump(net_vim
)
1086 except vimconn
.VimConnNotFoundException
as e
:
1087 self
.logger
.error("Exception getting net status: %s", str(e
))
1088 net
['status'] = "DELETED"
1089 net
['error_msg'] = str(e
)
1090 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.VimConnException
) as e
:
1091 self
.logger
.error("Exception getting net status: %s", str(e
))
1092 net
['status'] = "VIM_ERROR"
1093 net
['error_msg'] = str(e
)
1094 net_dict
[net_id
] = net
1097 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
1098 '''Send and action over a VM instance from VIM'''
1099 '''Returns the status'''
1101 self
._get
_my
_tenant
()
1102 if "console" in action_dict
:
1103 raise vimconn
.VimConnException("getting console is not available at openvim", http_code
=vimconn
.HTTP_Service_Unavailable
)
1104 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
+"/action"
1105 self
.logger
.info("Action over VM instance POST %s", url
)
1106 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps(action_dict
) )
1107 self
._check
_http
_request
_response
(vim_response
)
1109 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1110 self
._format
_request
_exception
(e
)
1112 #NOT USED METHODS in current version
1114 def host_vim2gui(self
, host
, server_dict
):
1115 '''Transform host dictionary from VIM format to GUI format,
1116 and append to the server_dict
1118 if type(server_dict
) is not dict:
1119 print( 'vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary')
1123 for numa
in host
['host']['numas']:
1127 RAD_item
['memory']={'size': str(numa
['memory'])+'GB', 'eligible': str(numa
['hugepages'])+'GB'}
1128 occupation_item
['memory']= str(numa
['hugepages_consumed'])+'GB'
1131 RAD_item
['cpus']['cores'] = []
1132 RAD_item
['cpus']['eligible_cores'] = []
1133 occupation_item
['cores']=[]
1134 for _
in range(0, len(numa
['cores']) // 2):
1135 RAD_item
['cpus']['cores'].append( [] )
1136 for core
in numa
['cores']:
1137 RAD_item
['cpus']['cores'][core
['core_id']].append(core
['thread_id'])
1138 if not 'status' in core
: RAD_item
['cpus']['eligible_cores'].append(core
['thread_id'])
1139 if 'instance_id' in core
: occupation_item
['cores'].append(core
['thread_id'])
1141 RAD_item
['ports']={}
1142 occupation_item
['ports']={}
1143 for iface
in numa
['interfaces']:
1144 RAD_item
['ports'][ iface
['pci'] ] = 'speed:'+str(iface
['Mbps'])+'M'
1145 occupation_item
['ports'][ iface
['pci'] ] = { 'occupied': str(100*iface
['Mbps_consumed'] // iface
['Mbps']) + "%" }
1147 RAD
[ numa
['numa_socket'] ] = RAD_item
1148 occupation
[ numa
['numa_socket'] ] = occupation_item
1149 server_dict
[ host
['host']['name'] ] = {'RAD':RAD
, 'occupation':occupation
}
1151 def get_hosts_info(self
):
1152 '''Get the information of deployed hosts
1153 Returns the hosts content'''
1155 url
=self
.url
+'/hosts'
1157 vim_response
= requests
.get(url
)
1158 except requests
.exceptions
.RequestException
as e
:
1159 print( "get_hosts_info 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 #print vim_response.status_code
1163 #print json.dumps(vim_response.json(), indent=4)
1164 if vim_response
.status_code
!= 200:
1166 print('vimconnector.get_hosts_info error getting host list {} {}'.format(vim_response
.status_code
, vim_response
.json()))
1167 return -vim_response
.status_code
, "Error getting host list"
1169 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1172 print("vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts
)
1173 return vimconn
.HTTP_Internal_Server_Error
, hosts
1174 #obtain hosts details
1176 for host
in hosts
['hosts']:
1177 url
=self
.url
+'/hosts/'+host
['id']
1179 vim_response
= requests
.get(url
)
1180 except requests
.exceptions
.RequestException
as e
:
1181 print( "get_hosts_info Exception: ", e
.args
)
1182 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1183 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1184 if vim_response
.status_code
!= 200:
1185 print('vimconnector.get_hosts_info error getting detailed host {} {}'.format(vim_response
.status_code
, vim_response
.json()))
1187 res
,host_detail
= self
._format
_in
(vim_response
, get_host_detail_response_schema
)
1189 print ("vimconnector.get_hosts_info error parsing GET HOSTS/{} vim response {}".format(host
['id']), host_detail
)
1191 #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1192 self
.host_vim2gui(host_detail
, hosts_dict
)
1193 return 200, hosts_dict
1195 def get_hosts(self
, vim_tenant
):
1196 '''Get the hosts and deployed instances
1197 Returns the hosts content'''
1199 url
=self
.url
+'/hosts'
1201 vim_response
= requests
.get(url
)
1202 except requests
.exceptions
.RequestException
as e
:
1203 print("get_hosts Exception: ", e
.args
)
1204 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1205 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1206 #print vim_response.status_code
1207 #print json.dumps(vim_response.json(), indent=4)
1208 if vim_response
.status_code
!= 200:
1210 print('vimconnector.get_hosts error getting host list {} {}'.format(vim_response
.status_code
, vim_response
.json()))
1211 return -vim_response
.status_code
, "Error getting host list"
1213 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1216 print("vimconnector.get_host error parsing GET HOSTS vim response", hosts
)
1217 return vimconn
.HTTP_Internal_Server_Error
, hosts
1218 #obtain instances from hosts
1219 for host
in hosts
['hosts']:
1220 url
=self
.url
+'/' + vim_tenant
+ '/servers?hostId='+host
['id']
1222 vim_response
= requests
.get(url
)
1223 except requests
.exceptions
.RequestException
as e
:
1224 print("get_hosts Exception: ", e
.args
)
1225 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1226 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1227 if vim_response
.status_code
!= 200:
1228 print('vimconnector.get_hosts error getting instances at host {} {}'.format(vim_response
.status_code
, vim_response
.json()))
1230 res
,servers
= self
._format
_in
(vim_response
, get_server_response_schema
)
1232 print("vimconnector.get_host error parsing GET SERVERS/{} vim response {}".format(host
['id']), servers
)
1234 #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1235 host
['instances'] = servers
['servers']
1236 return 200, hosts
['hosts']
1238 def get_processor_rankings(self
):
1239 '''Get the processor rankings in the VIM database'''
1240 url
=self
.url
+'/processor_ranking'
1242 vim_response
= requests
.get(url
)
1243 except requests
.exceptions
.RequestException
as e
:
1244 print("get_processor_rankings Exception: ", e
.args
)
1245 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1246 print("vim get", url
, "response:", vim_response
.status_code
, vim_response
.json())
1247 #print vim_response.status_code
1248 #print json.dumps(vim_response.json(), indent=4)
1249 if vim_response
.status_code
!= 200:
1251 print('vimconnector.get_processor_rankings error getting processor rankings {} {}'.format(vim_response
.status_code
, vim_response
.json()))
1252 return -vim_response
.status_code
, "Error getting processor rankings"
1254 res
,rankings
= self
._format
_in
(vim_response
, get_processor_rankings_response_schema
)
1255 return res
, rankings
['rankings']
1257 def new_host(self
, host_data
):
1258 '''Adds a new host to VIM'''
1259 '''Returns status code of the VIM response'''
1260 payload_req
= host_data
1262 url
= self
.url_admin
+'/hosts'
1263 self
.logger
.info("Adding a new host POST %s", url
)
1264 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
1265 self
._check
_http
_request
_response
(vim_response
)
1266 self
.logger
.debug(vim_response
.text
)
1267 #print json.dumps(vim_response.json(), indent=4)
1268 response
= vim_response
.json()
1269 js_v(response
, new_host_response_schema
)
1270 r
= self
._remove
_extra
_items
(response
, new_host_response_schema
)
1272 self
.logger
.warn("Warning: remove extra items %s", str(r
))
1273 host_id
= response
['host']['id']
1275 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1276 self
._format
_request
_exception
(e
)
1278 def new_external_port(self
, port_data
):
1279 '''Adds a external port to VIM'''
1280 '''Returns the port identifier'''
1281 #TODO change to logging exception code policies
1282 print( "VIMConnector: Adding a new external port")
1283 payload_req
= port_data
1285 vim_response
= requests
.post(self
.url_admin
+'/ports', headers
= self
.headers_req
, data
=payload_req
)
1286 except requests
.exceptions
.RequestException
as e
:
1287 self
.logger
.error("new_external_port Exception: ", str(e
))
1288 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1289 print( vim_response
)
1290 #print vim_response.status_code
1291 if vim_response
.status_code
== 200:
1292 #print vim_response.json()
1293 #print json.dumps(vim_response.json(), indent=4)
1294 res
, http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1297 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1298 if r
is not None: print("Warning: remove extra items ", r
)
1300 port_id
= http_content
['port']['id']
1301 print("Port id: ",port_id
)
1302 return vim_response
.status_code
,port_id
1303 else: return -vimconn
.HTTP_Bad_Request
,http_content
1305 #print vim_response.text
1306 jsonerror
= self
._format
_jsonerror
(vim_response
)
1307 text
= 'Error in VIM "{}": not possible to add new external port. HTTP Response: {}. Error: {}'.format(
1308 self
.url_admin
, vim_response
.status_code
, jsonerror
)
1310 return -vim_response
.status_code
,text
1312 def new_external_network(self
,net_name
,net_type
):
1313 '''Adds a external network to VIM (shared)'''
1314 '''Returns the network identifier'''
1315 #TODO change to logging exception code policies
1316 print("VIMConnector: Adding external shared network to VIM (type " + net_type
+ "): "+ net_name
)
1318 payload_req
= '{"network":{"name": "' + net_name
+ '","shared":true,"type": "' + net_type
+ '"}}'
1320 vim_response
= requests
.post(self
.url
+'/networks', headers
= self
.headers_req
, data
=payload_req
)
1321 except requests
.exceptions
.RequestException
as e
:
1322 self
.logger
.error( "new_external_network Exception: ", e
.args
)
1323 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1325 #print vim_response.status_code
1326 if vim_response
.status_code
== 200:
1327 #print vim_response.json()
1328 #print json.dumps(vim_response.json(), indent=4)
1329 res
,http_content
= self
._format
_in
(vim_response
, new_network_response_schema
)
1332 r
= self
._remove
_extra
_items
(http_content
, new_network_response_schema
)
1333 if r
is not None: print("Warning: remove extra items ", r
)
1335 network_id
= http_content
['network']['id']
1336 print( "Network id: ",network_id
)
1337 return vim_response
.status_code
,network_id
1338 else: return -vimconn
.HTTP_Bad_Request
,http_content
1340 #print vim_response.text
1341 jsonerror
= self
._format
_jsonerror
(vim_response
)
1342 text
= 'Error in VIM "{}": not possible to add new external network. HTTP Response: {}. Error: {}'.format(
1343 self
.url
, vim_response
.status_code
, jsonerror
)
1345 return -vim_response
.status_code
,text
1347 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1348 '''Connects a external port to a network'''
1349 '''Returns status code of the VIM response'''
1350 #TODO change to logging exception code policies
1351 print("VIMConnector: Connecting external port to network")
1353 payload_req
= '{"port":{"network_id":"' + network_id
+ '"}}'
1355 if self
.url_admin
==None:
1356 return -vimconn
.HTTP_Unauthorized
, "datacenter cannot contain admin URL"
1361 vim_response
= requests
.put(url
+'/ports/'+port_id
, headers
= self
.headers_req
, data
=payload_req
)
1362 except requests
.exceptions
.RequestException
as e
:
1363 print("connect_port_network Exception: ", e
.args
)
1364 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1366 #print vim_response.status_code
1367 if vim_response
.status_code
== 200:
1368 #print vim_response.json()
1369 #print json.dumps(vim_response.json(), indent=4)
1370 res
,http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1373 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1374 if r
is not None: print("Warning: remove extra items ", r
)
1376 port_id
= http_content
['port']['id']
1377 print("Port id: ",port_id
)
1378 return vim_response
.status_code
,port_id
1379 else: return -vimconn
.HTTP_Bad_Request
,http_content
1381 print(vim_response
.text
)
1382 jsonerror
= self
._format
_jsonerror
(vim_response
)
1383 text
= 'Error in VIM "{}": not possible to connect external port to network. HTTP Response: {}.' \
1384 ' Error: {}'.format(self
.url_admin
, vim_response
.status_code
, jsonerror
)
1386 return -vim_response
.status_code
,text