1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
5 # This file is part of openmano
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
12 # http://www.apache.org/licenses/LICENSE-2.0
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact with: nfvlabs@tid.es
25 vimconnector implements all the methods to interact with openvim using the openvim API.
27 __author__
="Alfonso Tierno, Gerardo Garcia"
28 __date__
="$26-aug-2014 11:09:29$"
35 from openmano_schemas
import id_schema
, name_schema
, nameshort_schema
, description_schema
, \
36 vlan1000_schema
, integer0_schema
37 from jsonschema
import validate
as js_v
, exceptions
as js_e
39 '''contain the openvim virtual machine status to openmano status'''
40 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
42 'SUSPENDED': 'SUSPENDED',
43 'INACTIVE':'INACTIVE',
45 'ERROR':'ERROR','DELETED':'DELETED'
47 netStatus2manoFormat
={'ACTIVE':'ACTIVE','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED', 'DOWN':'DOWN'
65 "required": ["id","name"]
73 "required": ["id","name"]
75 new_host_response_schema
= {
76 "title":"host response information schema",
77 "$schema": "http://json-schema.org/draft-04/schema#",
83 "additionalProperties": False
86 get_images_response_schema
= {
87 "title":"openvim images response information schema",
88 "$schema": "http://json-schema.org/draft-04/schema#",
93 "items": image_schema
,
96 "required": ["images"],
97 "additionalProperties": False
100 get_hosts_response_schema
= {
101 "title":"openvim hosts response information schema",
102 "$schema": "http://json-schema.org/draft-04/schema#",
107 "items": host_schema
,
110 "required": ["hosts"],
111 "additionalProperties": False
114 get_host_detail_response_schema
= new_host_response_schema
# TODO: Content is not parsed yet
116 get_server_response_schema
= {
117 "title":"openvim server response information schema",
118 "$schema": "http://json-schema.org/draft-04/schema#",
123 "items": server_schema
,
126 "required": ["servers"],
127 "additionalProperties": False
130 new_tenant_response_schema
= {
131 "title":"tenant response information schema",
132 "$schema": "http://json-schema.org/draft-04/schema#",
139 "name": nameshort_schema
,
140 "description":description_schema
,
141 "enabled":{"type" : "boolean"}
146 "required": ["tenant"],
147 "additionalProperties": False
150 new_network_response_schema
= {
151 "title":"network response information schema",
152 "$schema": "http://json-schema.org/draft-04/schema#",
160 "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
161 "shared":{"type":"boolean"},
162 "tenant_id":id_schema
,
163 "admin_state_up":{"type":"boolean"},
164 "vlan":vlan1000_schema
169 "required": ["network"],
170 "additionalProperties": False
174 # get_network_response_schema = {
175 # "title":"get network response information schema",
176 # "$schema": "http://json-schema.org/draft-04/schema#",
183 # "name":name_schema,
184 # "type":{"type":"string", "enum":["bridge_man","bridge_data","data", "ptp"]},
185 # "shared":{"type":"boolean"},
186 # "tenant_id":id_schema,
187 # "admin_state_up":{"type":"boolean"},
188 # "vlan":vlan1000_schema
193 # "required": ["network"],
194 # "additionalProperties": False
198 new_port_response_schema
= {
199 "title":"port response information schema",
200 "$schema": "http://json-schema.org/draft-04/schema#",
211 "required": ["port"],
212 "additionalProperties": False
215 get_flavor_response_schema
= {
216 "title":"openvim flavors response information schema",
217 "$schema": "http://json-schema.org/draft-04/schema#",
225 "extended": {"type":"object"},
227 "required": ["id", "name"],
230 "required": ["flavor"],
231 "additionalProperties": False
234 new_flavor_response_schema
= {
235 "title":"flavor response information schema",
236 "$schema": "http://json-schema.org/draft-04/schema#",
247 "required": ["flavor"],
248 "additionalProperties": False
251 get_image_response_schema
= {
252 "title":"openvim images response information schema",
253 "$schema": "http://json-schema.org/draft-04/schema#",
262 "required": ["id", "name"],
265 "required": ["flavor"],
266 "additionalProperties": False
268 new_image_response_schema
= {
269 "title":"image response information schema",
270 "$schema": "http://json-schema.org/draft-04/schema#",
281 "required": ["image"],
282 "additionalProperties": False
285 new_vminstance_response_schema
= {
286 "title":"server response information schema",
287 "$schema": "http://json-schema.org/draft-04/schema#",
298 "required": ["server"],
299 "additionalProperties": False
302 get_processor_rankings_response_schema
= {
303 "title":"processor rankings information schema",
304 "$schema": "http://json-schema.org/draft-04/schema#",
312 "model": description_schema
,
313 "value": integer0_schema
315 "additionalProperties": False,
316 "required": ["model","value"]
319 "additionalProperties": False,
320 "required": ["rankings"]
324 class vimconnector(vimconn
.vimconnector
):
325 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,log_level
="DEBUG",config
={}):
326 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
328 self
.headers_req
= {'content-type': 'application/json'}
329 self
.logger
= logging
.getLogger('mano.vim.openvim')
331 self
.tenant
= tenant_id
333 def __setitem__(self
,index
, value
):
334 '''Set individuals parameters
335 Throw TypeError, KeyError
337 if index
=='tenant_id':
339 elif index
=='tenant_name':
341 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
343 def _get_my_tenant(self
):
344 '''Obtain uuid of my tenant from name
349 url
= self
.url
+'/tenants?name='+ self
.tenant_name
350 self
.logger
.info("Getting VIM tenant_id GET %s", url
)
351 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
352 self
._check
_http
_request
_response
(vim_response
)
354 tenant_list
= vim_response
.json()["tenants"]
355 if len(tenant_list
) == 0:
356 raise vimconn
.vimconnNotFoundException("No tenant found for name '%s'" % str(self
.tenant_name
))
357 elif len(tenant_list
) > 1:
358 raise vimconn
.vimconnConflictException ("More that one tenant found for name '%s'" % str(self
.tenant_name
))
359 self
.tenant
= tenant_list
[0]["id"]
361 except Exception as e
:
362 raise vimconn
.vimconnUnexpectedResponse("Get VIM tenant {} '{}'".format(type(e
).__name
__, str(e
)))
364 def _format_jsonerror(self
,http_response
):
365 #DEPRECATED, to delete in the future
367 data
= http_response
.json()
368 return data
["error"]["description"]
370 return http_response
.text
372 def _format_in(self
, http_response
, schema
):
373 #DEPRECATED, to delete in the future
375 client_data
= http_response
.json()
376 js_v(client_data
, schema
)
377 #print "Input data: ", str(client_data)
378 return True, client_data
379 except js_e
.ValidationError
, exc
:
380 print "validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
381 return False, ("validate_in error, jsonschema exception ", exc
.message
, "at", exc
.path
)
383 def _remove_extra_items(self
, data
, schema
):
385 if type(data
) is tuple or type(data
) is list:
387 a
= self
._remove
_extra
_items
(d
, schema
['items'])
388 if a
is not None: deleted
.append(a
)
389 elif type(data
) is dict:
390 for k
in data
.keys():
391 if 'properties' not in schema
or k
not in schema
['properties'].keys():
395 a
= self
._remove
_extra
_items
(data
[k
], schema
['properties'][k
])
396 if a
is not None: deleted
.append({k
:a
})
397 if len(deleted
) == 0: return None
398 elif len(deleted
) == 1: return deleted
[0]
401 def _format_request_exception(self
, request_exception
):
402 '''Transform a request exception into a vimconn exception'''
403 if isinstance(request_exception
, js_e
.ValidationError
):
404 raise vimconn
.vimconnUnexpectedResponse("jsonschema exception '{}' at '{}'".format(request_exception
.message
, request_exception
.path
))
405 elif isinstance(request_exception
, requests
.exceptions
.HTTPError
):
406 raise vimconn
.vimconnUnexpectedResponse(type(request_exception
).__name
__ + ": " + str(request_exception
))
408 raise vimconn
.vimconnConnectionException(type(request_exception
).__name
__ + ": " + str(request_exception
))
410 def _check_http_request_response(self
, request_response
):
411 '''Raise a vimconn exception if the response is not Ok'''
412 if request_response
.status_code
>= 200 and request_response
.status_code
< 300:
414 if request_response
.status_code
== vimconn
.HTTP_Unauthorized
:
415 raise vimconn
.vimconnAuthException(request_response
.text
)
416 elif request_response
.status_code
== vimconn
.HTTP_Not_Found
:
417 raise vimconn
.vimconnNotFoundException(request_response
.text
)
418 elif request_response
.status_code
== vimconn
.HTTP_Conflict
:
419 raise vimconn
.vimconnConflictException(request_response
.text
)
421 raise vimconn
.vimconnUnexpectedResponse("VIM HTTP_response {}, {}".format(request_response
.status_code
, str(request_response
.text
)))
423 def new_tenant(self
,tenant_name
,tenant_description
):
424 '''Adds a new tenant to VIM with this name and description, returns the tenant identifier'''
425 #print "VIMConnector: Adding a new tenant to VIM"
426 payload_dict
= {"tenant": {"name":tenant_name
,"description": tenant_description
, "enabled": True}}
427 payload_req
= json
.dumps(payload_dict
)
429 url
= self
.url_admin
+'/tenants'
430 self
.logger
.info("Adding a new tenant %s", url
)
431 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
432 self
._check
_http
_request
_response
(vim_response
)
433 self
.logger
.debug(vim_response
.text
)
434 #print json.dumps(vim_response.json(), indent=4)
435 response
= vim_response
.json()
436 js_v(response
, new_tenant_response_schema
)
437 #r = self._remove_extra_items(response, new_tenant_response_schema)
439 # self.logger.warn("Warning: remove extra items %s", str(r))
440 tenant_id
= response
['tenant']['id']
442 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
443 self
._format
_request
_exception
(e
)
445 def delete_tenant(self
,tenant_id
):
446 '''Delete a tenant from VIM. Returns the old tenant identifier'''
448 url
= self
.url_admin
+'/tenants/'+tenant_id
449 self
.logger
.info("Delete a tenant DELETE %s", url
)
450 vim_response
= requests
.delete(url
, headers
= self
.headers_req
)
451 self
._check
_http
_request
_response
(vim_response
)
452 self
.logger
.debug(vim_response
.text
)
453 #print json.dumps(vim_response.json(), indent=4)
455 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
456 self
._format
_request
_exception
(e
)
458 def get_tenant_list(self
, filter_dict
={}):
459 '''Obtain tenants of VIM
460 filter_dict can contain the following keys:
461 name: filter by tenant name
462 id: filter by tenant uuid/id
464 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
468 for k
,v
in filter_dict
.iteritems():
469 filterquery
.append(str(k
)+'='+str(v
))
470 if len(filterquery
)>0:
471 filterquery_text
='?'+ '&'.join(filterquery
)
473 url
= self
.url
+'/tenants'+filterquery_text
474 self
.logger
.info("get_tenant_list GET %s", url
)
475 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
476 self
._check
_http
_request
_response
(vim_response
)
477 self
.logger
.debug(vim_response
.text
)
478 #print json.dumps(vim_response.json(), indent=4)
479 return vim_response
.json()["tenants"]
480 except requests
.exceptions
.RequestException
as e
:
481 self
._format
_request
_exception
(e
)
483 def new_network(self
,net_name
,net_type
, shared
=False, **vim_specific
):
484 '''Adds a tenant network to VIM'''
485 '''Returns the network identifier'''
487 self
._get
_my
_tenant
()
488 if net_type
=="bridge":
489 net_type
="bridge_data"
490 payload_req
= {"name": net_name
, "type": net_type
, "tenant_id": self
.tenant
, "shared": shared
}
491 payload_req
.update(vim_specific
)
492 url
= self
.url
+'/networks'
493 self
.logger
.info("Adding a new network POST: %s DATA: %s", url
, str(payload_req
))
494 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps({"network": payload_req
}) )
495 self
._check
_http
_request
_response
(vim_response
)
496 self
.logger
.debug(vim_response
.text
)
497 #print json.dumps(vim_response.json(), indent=4)
498 response
= vim_response
.json()
499 js_v(response
, new_network_response_schema
)
500 #r = self._remove_extra_items(response, new_network_response_schema)
502 # self.logger.warn("Warning: remove extra items %s", str(r))
503 network_id
= response
['network']['id']
505 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
506 self
._format
_request
_exception
(e
)
508 def get_network_list(self
, filter_dict
={}):
509 '''Obtain tenant networks of VIM
515 admin_state_up: boolean
517 Returns the network list of dictionaries
520 if 'tenant_id' not in filter_dict
:
521 filter_dict
["tenant_id"] = self
._get
_my
_tenant
()
522 elif not filter_dict
["tenant_id"]:
523 del filter_dict
["tenant_id"]
526 for k
,v
in filter_dict
.iteritems():
527 filterquery
.append(str(k
)+'='+str(v
))
528 if len(filterquery
)>0:
529 filterquery_text
='?'+ '&'.join(filterquery
)
530 url
= self
.url
+'/networks'+filterquery_text
531 self
.logger
.info("Getting network list GET %s", url
)
532 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
533 self
._check
_http
_request
_response
(vim_response
)
534 self
.logger
.debug(vim_response
.text
)
535 #print json.dumps(vim_response.json(), indent=4)
536 response
= vim_response
.json()
537 return response
['networks']
538 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
539 self
._format
_request
_exception
(e
)
541 def get_network(self
, net_id
):
542 '''Obtain network details of network id'''
544 url
= self
.url
+'/networks/'+net_id
545 self
.logger
.info("Getting network GET %s", url
)
546 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
547 self
._check
_http
_request
_response
(vim_response
)
548 self
.logger
.debug(vim_response
.text
)
549 #print json.dumps(vim_response.json(), indent=4)
550 response
= vim_response
.json()
551 return response
['network']
552 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
553 self
._format
_request
_exception
(e
)
555 def delete_network(self
, net_id
):
556 '''Deletes a tenant network from VIM'''
557 '''Returns the network identifier'''
559 self
._get
_my
_tenant
()
560 url
= self
.url
+'/networks/'+net_id
561 self
.logger
.info("Deleting VIM network DELETE %s", url
)
562 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
563 self
._check
_http
_request
_response
(vim_response
)
564 #self.logger.debug(vim_response.text)
565 #print json.dumps(vim_response.json(), indent=4)
567 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
568 self
._format
_request
_exception
(e
)
570 def get_flavor(self
, flavor_id
):
571 '''Obtain flavor details from the VIM'''
573 self
._get
_my
_tenant
()
574 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
575 self
.logger
.info("Getting flavor GET %s", url
)
576 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
577 self
._check
_http
_request
_response
(vim_response
)
578 self
.logger
.debug(vim_response
.text
)
579 #print json.dumps(vim_response.json(), indent=4)
580 response
= vim_response
.json()
581 js_v(response
, get_flavor_response_schema
)
582 r
= self
._remove
_extra
_items
(response
, get_flavor_response_schema
)
584 self
.logger
.warn("Warning: remove extra items %s", str(r
))
585 return response
['flavor']
586 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
587 self
._format
_request
_exception
(e
)
589 def new_flavor(self
, flavor_data
):
590 '''Adds a tenant flavor to VIM'''
591 '''Returns the flavor identifier'''
593 self
._get
_my
_tenant
()
594 payload_req
= json
.dumps({'flavor': flavor_data
})
595 url
= self
.url
+'/'+self
.tenant
+'/flavors'
596 self
.logger
.info("Adding a new VIM flavor POST %s", url
)
597 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
598 self
._check
_http
_request
_response
(vim_response
)
599 self
.logger
.debug(vim_response
.text
)
600 #print json.dumps(vim_response.json(), indent=4)
601 response
= vim_response
.json()
602 js_v(response
, new_flavor_response_schema
)
603 r
= self
._remove
_extra
_items
(response
, new_flavor_response_schema
)
605 self
.logger
.warn("Warning: remove extra items %s", str(r
))
606 flavor_id
= response
['flavor']['id']
608 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
609 self
._format
_request
_exception
(e
)
611 def delete_flavor(self
,flavor_id
):
612 '''Deletes a tenant flavor from VIM'''
613 '''Returns the old flavor_id'''
615 self
._get
_my
_tenant
()
616 url
= self
.url
+'/'+self
.tenant
+'/flavors/'+flavor_id
617 self
.logger
.info("Deleting VIM flavor DELETE %s", url
)
618 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
619 self
._check
_http
_request
_response
(vim_response
)
620 #self.logger.debug(vim_response.text)
621 #print json.dumps(vim_response.json(), indent=4)
623 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
624 self
._format
_request
_exception
(e
)
626 def get_image(self
, image_id
):
627 '''Obtain image details from the VIM'''
629 self
._get
_my
_tenant
()
630 url
= self
.url
+'/'+self
.tenant
+'/images/'+image_id
631 self
.logger
.info("Getting image GET %s", url
)
632 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
633 self
._check
_http
_request
_response
(vim_response
)
634 self
.logger
.debug(vim_response
.text
)
635 #print json.dumps(vim_response.json(), indent=4)
636 response
= vim_response
.json()
637 js_v(response
, get_image_response_schema
)
638 r
= self
._remove
_extra
_items
(response
, get_image_response_schema
)
640 self
.logger
.warn("Warning: remove extra items %s", str(r
))
641 return response
['image']
642 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
643 self
._format
_request
_exception
(e
)
645 def new_image(self
,image_dict
):
646 ''' Adds a tenant image to VIM, returns image_id'''
648 self
._get
_my
_tenant
()
649 new_image_dict
={'name': image_dict
['name']}
650 if image_dict
.get('description'):
651 new_image_dict
['description'] = image_dict
['description']
652 if image_dict
.get('metadata'):
653 new_image_dict
['metadata'] = yaml
.load(image_dict
['metadata'])
654 if image_dict
.get('location'):
655 new_image_dict
['path'] = image_dict
['location']
656 payload_req
= json
.dumps({"image":new_image_dict
})
657 url
=self
.url
+ '/' + self
.tenant
+ '/images'
658 self
.logger
.info("Adding a new VIM image POST %s", url
)
659 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
660 self
._check
_http
_request
_response
(vim_response
)
661 self
.logger
.debug(vim_response
.text
)
662 #print json.dumps(vim_response.json(), indent=4)
663 response
= vim_response
.json()
664 js_v(response
, new_image_response_schema
)
665 r
= self
._remove
_extra
_items
(response
, new_image_response_schema
)
667 self
.logger
.warn("Warning: remove extra items %s", str(r
))
668 image_id
= response
['image']['id']
670 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
671 self
._format
_request
_exception
(e
)
673 def delete_image(self
, image_id
):
674 '''Deletes a tenant image from VIM'''
675 '''Returns the deleted image_id'''
677 self
._get
_my
_tenant
()
678 url
= self
.url
+ '/'+ self
.tenant
+'/images/'+image_id
679 self
.logger
.info("Deleting VIM image DELETE %s", url
)
680 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
681 self
._check
_http
_request
_response
(vim_response
)
682 #self.logger.debug(vim_response.text)
683 #print json.dumps(vim_response.json(), indent=4)
685 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
686 self
._format
_request
_exception
(e
)
689 def get_image_id_from_path(self
, path
):
690 '''Get the image id from image path in the VIM database'''
692 self
._get
_my
_tenant
()
693 url
=self
.url
+ '/' + self
.tenant
+ '/images?path='+path
694 self
.logger
.info("Getting images GET %s", url
)
695 vim_response
= requests
.get(url
)
696 self
._check
_http
_request
_response
(vim_response
)
697 self
.logger
.debug(vim_response
.text
)
698 #print json.dumps(vim_response.json(), indent=4)
699 response
= vim_response
.json()
700 js_v(response
, get_images_response_schema
)
701 #r = self._remove_extra_items(response, get_images_response_schema)
703 # self.logger.warn("Warning: remove extra items %s", str(r))
704 if len(response
['images'])==0:
705 raise vimconn
.vimconnNotFoundException("Image not found at VIM with path '%s'", path
)
706 elif len(response
['images'])>1:
707 raise vimconn
.vimconnConflictException("More than one image found at VIM with path '%s'", path
)
708 return response
['images'][0]['id']
709 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
710 self
._format
_request
_exception
(e
)
712 def new_vminstancefromJSON(self
, vm_data
):
713 '''Adds a VM instance to VIM'''
714 '''Returns the instance identifier'''
716 self
._get
_my
_tenant
()
717 except Exception as e
:
718 return -vimconn
.HTTP_Not_Found
, str(e
)
719 print "VIMConnector: Adding a new VM instance from JSON to VIM"
720 payload_req
= vm_data
722 vim_response
= requests
.post(self
.url
+'/'+self
.tenant
+'/servers', headers
= self
.headers_req
, data
=payload_req
)
723 except requests
.exceptions
.RequestException
, e
:
724 print "new_vminstancefromJSON Exception: ", e
.args
725 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
727 #print vim_response.status_code
728 if vim_response
.status_code
== 200:
729 #print vim_response.json()
730 #print json.dumps(vim_response.json(), indent=4)
731 res
,http_content
= self
._format
_in
(vim_response
, new_image_response_schema
)
734 r
= self
._remove
_extra
_items
(http_content
, new_image_response_schema
)
735 if r
is not None: print "Warning: remove extra items ", r
737 vminstance_id
= http_content
['server']['id']
738 print "Tenant image id: ",vminstance_id
739 return vim_response
.status_code
,vminstance_id
740 else: return -vimconn
.HTTP_Bad_Request
,http_content
742 #print vim_response.text
743 jsonerror
= self
._format
_jsonerror
(vim_response
)
744 text
= 'Error in VIM "%s": not possible to add new vm instance. HTTP Response: %d. Error: %s' % (self
.url
, vim_response
.status_code
, jsonerror
)
746 return -vim_response
.status_code
,text
748 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
):
749 '''Adds a VM instance to VIM
751 start: indicates if VM must start or boot in pause mode. Ignored
752 image_id,flavor_id: image and flavor uuid
753 net_list: list of interfaces, each one is a dictionary with:
755 net_id: network uuid to connect
756 vpci: virtual vcpi to assign
757 model: interface model, virtio, e2000, ...
759 use: 'data', 'bridge', 'mgmt'
760 type: 'virtual', 'PF', 'VF', 'VFnotShared'
761 vim_id: filled/added by this function
762 #TODO ip, security groups
763 Returns the instance identifier
766 self
._get
_my
_tenant
()
768 # for k,v in net_dict.items():
770 # net_list.append('{"name":"' + k + '", "uuid":"' + v + '"}')
771 # net_list_string = ', '.join(net_list)
774 if not net
.get("net_id"):
776 net_dict
={'uuid': net
["net_id"]}
777 if net
.get("type"): net_dict
["type"] = net
["type"]
778 if net
.get("name"): net_dict
["name"] = net
["name"]
779 if net
.get("vpci"): net_dict
["vpci"] = net
["vpci"]
780 if net
.get("model"): net_dict
["model"] = net
["model"]
781 if net
.get("mac_address"): net_dict
["mac_address"] = net
["mac_address"]
782 virtio_net_list
.append(net_dict
)
783 payload_dict
={ "name": name
,
784 "description": description
,
785 "imageRef": image_id
,
786 "flavorRef": flavor_id
,
787 "networks": virtio_net_list
790 payload_dict
["start"] = start
791 payload_req
= json
.dumps({"server": payload_dict
})
792 url
= self
.url
+'/'+self
.tenant
+'/servers'
793 self
.logger
.info("Adding a new vm POST %s DATA %s", url
, payload_req
)
794 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
795 self
._check
_http
_request
_response
(vim_response
)
796 self
.logger
.debug(vim_response
.text
)
797 #print json.dumps(vim_response.json(), indent=4)
798 response
= vim_response
.json()
799 js_v(response
, new_vminstance_response_schema
)
800 #r = self._remove_extra_items(response, new_vminstance_response_schema)
802 # self.logger.warn("Warning: remove extra items %s", str(r))
803 vminstance_id
= response
['server']['id']
805 #connect data plane interfaces to network
807 if net
["type"]=="virtual":
808 if not net
.get("net_id"):
810 for iface
in response
['server']['networks']:
812 if net
["name"]==iface
["name"]:
813 net
["vim_id"] = iface
['iface_id']
815 elif "net_id" in net
:
816 if net
["net_id"]==iface
["net_id"]:
817 net
["vim_id"] = iface
['iface_id']
820 for numa
in response
['server'].get('extended',{}).get('numas',() ):
821 for iface
in numa
.get('interfaces',() ):
822 if net
['name'] == iface
['name']:
823 net
['vim_id'] = iface
['iface_id']
824 #Code bellow is not needed, current openvim connect dataplane interfaces
825 #if net.get("net_id"):
826 ##connect dataplane interface
827 # result, port_id = self.connect_port_network(iface['iface_id'], net["net_id"])
829 # error_text = "Error attaching port %s to network %s: %s." % (iface['iface_id'], net["net_id"], port_id)
830 # print "new_vminstance: " + error_text
831 # self.delete_vminstance(vminstance_id)
832 # return result, error_text
836 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
837 self
._format
_request
_exception
(e
)
839 def get_vminstance(self
, vm_id
):
840 '''Returns the VM instance information from VIM'''
842 self
._get
_my
_tenant
()
843 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
844 self
.logger
.info("Getting vm GET %s", url
)
845 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
846 vim_response
= requests
.get(url
, headers
= self
.headers_req
)
847 self
._check
_http
_request
_response
(vim_response
)
848 self
.logger
.debug(vim_response
.text
)
849 #print json.dumps(vim_response.json(), indent=4)
850 response
= vim_response
.json()
851 js_v(response
, new_vminstance_response_schema
)
852 #r = self._remove_extra_items(response, new_vminstance_response_schema)
854 # self.logger.warn("Warning: remove extra items %s", str(r))
855 return response
['server']
856 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
857 self
._format
_request
_exception
(e
)
859 def delete_vminstance(self
, vm_id
):
860 '''Removes a VM instance from VIM, returns the deleted vm_id'''
862 self
._get
_my
_tenant
()
863 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
864 self
.logger
.info("Deleting VIM vm DELETE %s", url
)
865 vim_response
= requests
.delete(url
, headers
=self
.headers_req
)
866 self
._check
_http
_request
_response
(vim_response
)
867 #self.logger.debug(vim_response.text)
868 #print json.dumps(vim_response.json(), indent=4)
870 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
871 self
._format
_request
_exception
(e
)
873 def refresh_vms_status(self
, vm_list
):
874 '''Refreshes the status of the virtual machines'''
876 self
._get
_my
_tenant
()
877 except requests
.exceptions
.RequestException
as e
:
878 self
._format
_request
_exception
(e
)
880 for vm_id
in vm_list
:
882 #print "VIMConnector refresh_tenant_vms and nets: Getting tenant VM instance information from VIM"
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 self
._check
_http
_request
_response
(vim_response
)
888 response
= vim_response
.json()
889 js_v(response
, new_vminstance_response_schema
)
890 if response
['server']['status'] in vmStatus2manoFormat
:
891 vm
['status'] = vmStatus2manoFormat
[ response
['server']['status'] ]
893 vm
['status'] = "OTHER"
894 vm
['error_msg'] = "VIM status reported " + response
['server']['status']
895 if response
['server'].get('last_error'):
896 vm
['error_msg'] = response
['server']['last_error']
897 vm
["vim_info"] = yaml
.safe_dump(response
['server'])
900 management_ip
= False
901 url2
= self
.url
+'/ports?device_id='+ vm_id
902 self
.logger
.info("Getting PORTS GET %s", url2
)
903 vim_response2
= requests
.get(url2
, headers
= self
.headers_req
)
904 self
._check
_http
_request
_response
(vim_response2
)
905 client_data
= vim_response2
.json()
906 if isinstance(client_data
.get("ports"), list):
908 for port
in client_data
.get("ports"):
910 interface
['vim_info'] = yaml
.safe_dump(port
)
911 interface
["mac_address"] = port
.get("mac_address")
912 interface
["vim_net_id"] = port
["network_id"]
913 interface
["vim_interface_id"] = port
["id"]
914 interface
["ip_address"] = port
.get("ip_address")
915 if interface
["ip_address"]:
917 if interface
["ip_address"] == "0.0.0.0":
918 interface
["ip_address"] = None
919 vm
["interfaces"].append(interface
)
921 except Exception as e
:
922 self
.logger
.error("refresh_vms_and_nets. Port get %s: %s", type(e
).__name
__, str(e
))
924 if vm
['status'] == "ACTIVE" and not management_ip
:
925 vm
['status'] = "ACTIVE:NoMgmtIP"
927 except vimconn
.vimconnNotFoundException
as e
:
928 self
.logger
.error("Exception getting vm status: %s", str(e
))
929 vm
['status'] = "DELETED"
930 vm
['error_msg'] = str(e
)
931 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.vimconnException
) as e
:
932 self
.logger
.error("Exception getting vm status: %s", str(e
))
933 vm
['status'] = "VIM_ERROR"
934 vm
['error_msg'] = str(e
)
938 def refresh_nets_status(self
, net_list
):
939 '''Get the status of the networks
940 Params: the list of network identifiers
941 Returns a dictionary with:
942 net_id: #VIM id of this network
943 status: #Mandatory. Text with one of:
944 # DELETED (not found at vim)
945 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
946 # OTHER (Vim reported other status not understood)
947 # ERROR (VIM indicates an ERROR status)
948 # ACTIVE, INACTIVE, DOWN (admin down),
949 # BUILD (on building process)
951 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
952 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
956 self
._get
_my
_tenant
()
957 except requests
.exceptions
.RequestException
as e
:
958 self
._format
_request
_exception
(e
)
961 for net_id
in net_list
:
963 #print "VIMConnector refresh_tenant_vms_and_nets: Getting tenant network from VIM (tenant: " + str(self.tenant) + "): "
965 net_vim
= self
.get_network(net_id
)
966 if net_vim
['status'] in netStatus2manoFormat
:
967 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
969 net
["status"] = "OTHER"
970 net
["error_msg"] = "VIM status reported " + net_vim
['status']
972 if net
["status"] == "ACTIVE" and not net_vim
['admin_state_up']:
973 net
["status"] = "DOWN"
974 if net_vim
.get('last_error'):
975 net
['error_msg'] = net_vim
['last_error']
976 net
["vim_info"] = yaml
.safe_dump(net_vim
)
977 except vimconn
.vimconnNotFoundException
as e
:
978 self
.logger
.error("Exception getting net status: %s", str(e
))
979 net
['status'] = "DELETED"
980 net
['error_msg'] = str(e
)
981 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
, vimconn
.vimconnException
) as e
:
982 self
.logger
.error("Exception getting net status: %s", str(e
))
983 net
['status'] = "VIM_ERROR"
984 net
['error_msg'] = str(e
)
985 net_dict
[net_id
] = net
988 def action_vminstance(self
, vm_id
, action_dict
):
989 '''Send and action over a VM instance from VIM'''
990 '''Returns the status'''
992 self
._get
_my
_tenant
()
993 if "console" in action_dict
:
994 raise vimconn
.vimconnException("getting console is not available at openvim", http_code
=vimconn
.HTTP_Service_Unavailable
)
995 url
= self
.url
+'/'+self
.tenant
+'/servers/'+vm_id
+"/action"
996 self
.logger
.info("Action over VM instance POST %s", url
)
997 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=json
.dumps(action_dict
) )
998 self
._check
_http
_request
_response
(vim_response
)
1000 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1001 self
._format
_request
_exception
(e
)
1003 #NOT USED METHODS in current version
1005 def host_vim2gui(self
, host
, server_dict
):
1006 '''Transform host dictionary from VIM format to GUI format,
1007 and append to the server_dict
1009 if type(server_dict
) is not dict:
1010 print 'vimconnector.host_vim2gui() ERROR, param server_dict must be a dictionary'
1014 for numa
in host
['host']['numas']:
1018 RAD_item
['memory']={'size': str(numa
['memory'])+'GB', 'eligible': str(numa
['hugepages'])+'GB'}
1019 occupation_item
['memory']= str(numa
['hugepages_consumed'])+'GB'
1022 RAD_item
['cpus']['cores'] = []
1023 RAD_item
['cpus']['eligible_cores'] = []
1024 occupation_item
['cores']=[]
1025 for _
in range(0, len(numa
['cores']) / 2):
1026 RAD_item
['cpus']['cores'].append( [] )
1027 for core
in numa
['cores']:
1028 RAD_item
['cpus']['cores'][core
['core_id']].append(core
['thread_id'])
1029 if not 'status' in core
: RAD_item
['cpus']['eligible_cores'].append(core
['thread_id'])
1030 if 'instance_id' in core
: occupation_item
['cores'].append(core
['thread_id'])
1032 RAD_item
['ports']={}
1033 occupation_item
['ports']={}
1034 for iface
in numa
['interfaces']:
1035 RAD_item
['ports'][ iface
['pci'] ] = 'speed:'+str(iface
['Mbps'])+'M'
1036 occupation_item
['ports'][ iface
['pci'] ] = { 'occupied': str(100*iface
['Mbps_consumed'] / iface
['Mbps']) + "%" }
1038 RAD
[ numa
['numa_socket'] ] = RAD_item
1039 occupation
[ numa
['numa_socket'] ] = occupation_item
1040 server_dict
[ host
['host']['name'] ] = {'RAD':RAD
, 'occupation':occupation
}
1042 def get_hosts_info(self
):
1043 '''Get the information of deployed hosts
1044 Returns the hosts content'''
1046 url
=self
.url
+'/hosts'
1048 vim_response
= requests
.get(url
)
1049 except requests
.exceptions
.RequestException
, e
:
1050 print "get_hosts_info Exception: ", e
.args
1051 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1052 print "vim get", url
, "response:", vim_response
.status_code
, vim_response
.json()
1053 #print vim_response.status_code
1054 #print json.dumps(vim_response.json(), indent=4)
1055 if vim_response
.status_code
!= 200:
1057 print 'vimconnector.get_hosts_info error getting host list %d %s' %(vim_response
.status_code
, vim_response
.json())
1058 return -vim_response
.status_code
, "Error getting host list"
1060 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1063 print "vimconnector.get_hosts_info error parsing GET HOSTS vim response", hosts
1064 return vimconn
.HTTP_Internal_Server_Error
, hosts
1065 #obtain hosts details
1067 for host
in hosts
['hosts']:
1068 url
=self
.url
+'/hosts/'+host
['id']
1070 vim_response
= requests
.get(url
)
1071 except requests
.exceptions
.RequestException
, e
:
1072 print "get_hosts_info Exception: ", e
.args
1073 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1074 print "vim get", url
, "response:", vim_response
.status_code
, vim_response
.json()
1075 if vim_response
.status_code
!= 200:
1076 print 'vimconnector.get_hosts_info error getting detailed host %d %s' %(vim_response
.status_code
, vim_response
.json())
1078 res
,host_detail
= self
._format
_in
(vim_response
, get_host_detail_response_schema
)
1080 print "vimconnector.get_hosts_info error parsing GET HOSTS/%s vim response" % host
['id'], host_detail
1082 #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1083 self
.host_vim2gui(host_detail
, hosts_dict
)
1084 return 200, hosts_dict
1086 def get_hosts(self
, vim_tenant
):
1087 '''Get the hosts and deployed instances
1088 Returns the hosts content'''
1090 url
=self
.url
+'/hosts'
1092 vim_response
= requests
.get(url
)
1093 except requests
.exceptions
.RequestException
, e
:
1094 print "get_hosts Exception: ", e
.args
1095 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1096 print "vim get", url
, "response:", vim_response
.status_code
, vim_response
.json()
1097 #print vim_response.status_code
1098 #print json.dumps(vim_response.json(), indent=4)
1099 if vim_response
.status_code
!= 200:
1101 print 'vimconnector.get_hosts error getting host list %d %s' %(vim_response
.status_code
, vim_response
.json())
1102 return -vim_response
.status_code
, "Error getting host list"
1104 res
,hosts
= self
._format
_in
(vim_response
, get_hosts_response_schema
)
1107 print "vimconnector.get_host error parsing GET HOSTS vim response", hosts
1108 return vimconn
.HTTP_Internal_Server_Error
, hosts
1109 #obtain instances from hosts
1110 for host
in hosts
['hosts']:
1111 url
=self
.url
+'/' + vim_tenant
+ '/servers?hostId='+host
['id']
1113 vim_response
= requests
.get(url
)
1114 except requests
.exceptions
.RequestException
, e
:
1115 print "get_hosts Exception: ", e
.args
1116 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1117 print "vim get", url
, "response:", vim_response
.status_code
, vim_response
.json()
1118 if vim_response
.status_code
!= 200:
1119 print 'vimconnector.get_hosts error getting instances at host %d %s' %(vim_response
.status_code
, vim_response
.json())
1121 res
,servers
= self
._format
_in
(vim_response
, get_server_response_schema
)
1123 print "vimconnector.get_host error parsing GET SERVERS/%s vim response" % host
['id'], servers
1125 #print 'host id '+host['id'], json.dumps(host_detail, indent=4)
1126 host
['instances'] = servers
['servers']
1127 return 200, hosts
['hosts']
1129 def get_processor_rankings(self
):
1130 '''Get the processor rankings in the VIM database'''
1131 url
=self
.url
+'/processor_ranking'
1133 vim_response
= requests
.get(url
)
1134 except requests
.exceptions
.RequestException
, e
:
1135 print "get_processor_rankings 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_processor_rankings error getting processor rankings %d %s' %(vim_response
.status_code
, vim_response
.json())
1143 return -vim_response
.status_code
, "Error getting processor rankings"
1145 res
,rankings
= self
._format
_in
(vim_response
, get_processor_rankings_response_schema
)
1146 return res
, rankings
['rankings']
1148 def new_host(self
, host_data
):
1149 '''Adds a new host to VIM'''
1150 '''Returns status code of the VIM response'''
1151 payload_req
= host_data
1153 url
= self
.url_admin
+'/hosts'
1154 self
.logger
.info("Adding a new host POST %s", url
)
1155 vim_response
= requests
.post(url
, headers
= self
.headers_req
, data
=payload_req
)
1156 self
._check
_http
_request
_response
(vim_response
)
1157 self
.logger
.debug(vim_response
.text
)
1158 #print json.dumps(vim_response.json(), indent=4)
1159 response
= vim_response
.json()
1160 js_v(response
, new_host_response_schema
)
1161 r
= self
._remove
_extra
_items
(response
, new_host_response_schema
)
1163 self
.logger
.warn("Warning: remove extra items %s", str(r
))
1164 host_id
= response
['host']['id']
1166 except (requests
.exceptions
.RequestException
, js_e
.ValidationError
) as e
:
1167 self
._format
_request
_exception
(e
)
1169 def new_external_port(self
, port_data
):
1170 '''Adds a external port to VIM'''
1171 '''Returns the port identifier'''
1172 #TODO change to logging exception code policies
1173 print "VIMConnector: Adding a new external port"
1174 payload_req
= port_data
1176 vim_response
= requests
.post(self
.url_admin
+'/ports', headers
= self
.headers_req
, data
=payload_req
)
1177 except requests
.exceptions
.RequestException
, e
:
1178 self
.logger
.error("new_external_port Exception: ", str(e
))
1179 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1181 #print vim_response.status_code
1182 if vim_response
.status_code
== 200:
1183 #print vim_response.json()
1184 #print json.dumps(vim_response.json(), indent=4)
1185 res
, http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1188 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1189 if r
is not None: print "Warning: remove extra items ", r
1191 port_id
= http_content
['port']['id']
1192 print "Port id: ",port_id
1193 return vim_response
.status_code
,port_id
1194 else: return -vimconn
.HTTP_Bad_Request
,http_content
1196 #print vim_response.text
1197 jsonerror
= self
._format
_jsonerror
(vim_response
)
1198 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
)
1200 return -vim_response
.status_code
,text
1202 def new_external_network(self
,net_name
,net_type
):
1203 '''Adds a external network to VIM (shared)'''
1204 '''Returns the network identifier'''
1205 #TODO change to logging exception code policies
1206 print "VIMConnector: Adding external shared network to VIM (type " + net_type
+ "): "+ net_name
1208 payload_req
= '{"network":{"name": "' + net_name
+ '","shared":true,"type": "' + net_type
+ '"}}'
1210 vim_response
= requests
.post(self
.url
+'/networks', headers
= self
.headers_req
, data
=payload_req
)
1211 except requests
.exceptions
.RequestException
, e
:
1212 self
.logger
.error( "new_external_network Exception: ", e
.args
)
1213 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1215 #print vim_response.status_code
1216 if vim_response
.status_code
== 200:
1217 #print vim_response.json()
1218 #print json.dumps(vim_response.json(), indent=4)
1219 res
,http_content
= self
._format
_in
(vim_response
, new_network_response_schema
)
1222 r
= self
._remove
_extra
_items
(http_content
, new_network_response_schema
)
1223 if r
is not None: print "Warning: remove extra items ", r
1225 network_id
= http_content
['network']['id']
1226 print "Network id: ",network_id
1227 return vim_response
.status_code
,network_id
1228 else: return -vimconn
.HTTP_Bad_Request
,http_content
1230 #print vim_response.text
1231 jsonerror
= self
._format
_jsonerror
(vim_response
)
1232 text
= 'Error in VIM "%s": not possible to add new external network. HTTP Response: %d. Error: %s' % (self
.url
, vim_response
.status_code
, jsonerror
)
1234 return -vim_response
.status_code
,text
1236 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1237 '''Connects a external port to a network'''
1238 '''Returns status code of the VIM response'''
1239 #TODO change to logging exception code policies
1240 print "VIMConnector: Connecting external port to network"
1242 payload_req
= '{"port":{"network_id":"' + network_id
+ '"}}'
1244 if self
.url_admin
==None:
1245 return -vimconn
.HTTP_Unauthorized
, "datacenter cannot contain admin URL"
1250 vim_response
= requests
.put(url
+'/ports/'+port_id
, headers
= self
.headers_req
, data
=payload_req
)
1251 except requests
.exceptions
.RequestException
, e
:
1252 print "connect_port_network Exception: ", e
.args
1253 return -vimconn
.HTTP_Not_Found
, str(e
.args
[0])
1255 #print vim_response.status_code
1256 if vim_response
.status_code
== 200:
1257 #print vim_response.json()
1258 #print json.dumps(vim_response.json(), indent=4)
1259 res
,http_content
= self
._format
_in
(vim_response
, new_port_response_schema
)
1262 r
= self
._remove
_extra
_items
(http_content
, new_port_response_schema
)
1263 if r
is not None: print "Warning: remove extra items ", r
1265 port_id
= http_content
['port']['id']
1266 print "Port id: ",port_id
1267 return vim_response
.status_code
,port_id
1268 else: return -vimconn
.HTTP_Bad_Request
,http_content
1270 print vim_response
.text
1271 jsonerror
= self
._format
_jsonerror
(vim_response
)
1272 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
)
1274 return -vim_response
.status_code
,text