| # -*- coding: utf-8 -*- |
| |
| ## |
| # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U. |
| # This file is part of openmano |
| # All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| # not use this file except in compliance with the License. You may obtain |
| # a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations |
| # under the License. |
| # |
| # For those usages not covered by the Apache License, Version 2.0 please |
| # contact with: nfvlabs@tid.es |
| ## |
| |
| ''' |
| vimconn_vmware implementation an Abstract class in order to interact with VMware vCloud Director. |
| mbayramov@vmware.com |
| ''' |
| import os |
| import requests |
| |
| |
| from xml.etree import ElementTree as ET |
| |
| from pyvcloud import Http |
| from pyvcloud.vcloudair import VCA |
| from pyvcloud.schema.vcd.v1_5.schemas.vcloud import sessionType, organizationType, \ |
| vAppType, organizationListType, vdcType, catalogType, queryRecordViewType, \ |
| networkType, vcloudType, taskType, diskType, vmsType, vdcTemplateListType, mediaType |
| from xml.sax.saxutils import escape |
| |
| import logging |
| import json |
| import vimconn |
| import time |
| import uuid |
| import httplib |
| |
| |
| __author__="Mustafa Bayramov" |
| __date__ ="$26-Aug-2016 11:09:29$" |
| |
| |
| #Error variables |
| HTTP_Bad_Request = 400 |
| HTTP_Unauthorized = 401 |
| HTTP_Not_Found = 404 |
| HTTP_Method_Not_Allowed = 405 |
| HTTP_Request_Timeout = 408 |
| HTTP_Conflict = 409 |
| HTTP_Not_Implemented = 501 |
| HTTP_Service_Unavailable = 503 |
| HTTP_Internal_Server_Error = 500 |
| |
| class vimconnException(Exception): |
| '''Common and base class Exception for all vimconnector exceptions''' |
| def __init__(self, message, http_code=HTTP_Bad_Request): |
| Exception.__init__(self, message) |
| self.http_code = http_code |
| |
| class vimconnConnectionException(vimconnException): |
| '''Connectivity error with the VIM''' |
| def __init__(self, message, http_code=HTTP_Service_Unavailable): |
| vimconnException.__init__(self, message, http_code) |
| |
| class vimconnUnexpectedResponse(vimconnException): |
| '''Get an wrong response from VIM''' |
| def __init__(self, message, http_code=HTTP_Service_Unavailable): |
| vimconnException.__init__(self, message, http_code) |
| |
| class vimconnAuthException(vimconnException): |
| '''Invalid credentials or authorization to perform this action over the VIM''' |
| def __init__(self, message, http_code=HTTP_Unauthorized): |
| vimconnException.__init__(self, message, http_code) |
| |
| class vimconnNotFoundException(vimconnException): |
| '''The item is not found at VIM''' |
| def __init__(self, message, http_code=HTTP_Not_Found): |
| vimconnException.__init__(self, message, http_code) |
| |
| class vimconnConflictException(vimconnException): |
| '''There is a conflict, e.g. more item found than one''' |
| def __init__(self, message, http_code=HTTP_Conflict): |
| vimconnException.__init__(self, message, http_code) |
| |
| class vimconnNotImplemented(vimconnException): |
| '''The method is not implemented by the connected''' |
| def __init__(self, message, http_code=HTTP_Not_Implemented): |
| vimconnException.__init__(self, message, http_code) |
| |
| |
| flavorlist = {} |
| |
| class vimconnector(): |
| '''Vmware VIM Connector base class |
| ''' |
| def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level="ERROR", config={}): |
| self.id = uuid |
| self.name = name |
| self.url = url |
| self.url_admin = url_admin |
| self.tenant_id = tenant_id |
| self.tenant_name = tenant_name |
| self.user = user |
| self.passwd = passwd |
| self.config = config |
| self.logger = logging.getLogger('mano.vim.vmware') |
| |
| formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') |
| ch = logging.StreamHandler() |
| ch.setLevel(log_level) |
| ch.setFormatter(formatter) |
| self.logger.addHandler(ch) |
| self.logger.setLevel( getattr(logging, log_level)) |
| |
| # self.logger = logging.getLogger('mano.vim.vmware') |
| |
| self.logger.debug("Vmware tenant from VIM filter: '%s'", user) |
| self.logger.debug("Vmware tenant from VIM filter: '%s'", passwd) |
| |
| if not url: |
| raise TypeError, 'url param can not be NoneType' |
| |
| if not self.url_admin: #try to use normal url |
| self.url_admin = self.url |
| |
| self.vcaversion = '5.6' |
| |
| print "Calling constructor with following paramters" |
| print " UUID: {} ".format(uuid) |
| print " name: {} ".format(name) |
| print " tenant_id: {} ".format(tenant_id) |
| print " tenant_name: {} ".format(tenant_name) |
| print " url: {} ".format(url) |
| print " url_admin: {} ".format(url_admin) |
| print " user: {} ".format(user) |
| print " passwd: {} ".format(passwd) |
| print " debug: {} ".format(log_level) |
| |
| def __getitem__(self,index): |
| if index=='tenant_id': |
| return self.tenant_id |
| if index=='tenant_name': |
| return self.tenant_name |
| elif index=='id': |
| return self.id |
| elif index=='name': |
| return self.name |
| elif index=='user': |
| return self.user |
| elif index=='passwd': |
| return self.passwd |
| elif index=='url': |
| return self.url |
| elif index=='url_admin': |
| return self.url_admin |
| elif index=="config": |
| return self.config |
| else: |
| raise KeyError("Invalid key '%s'" %str(index)) |
| |
| def __setitem__(self,index, value): |
| if index=='tenant_id': |
| self.tenant_id = value |
| if index=='tenant_name': |
| self.tenant_name = value |
| elif index=='id': |
| self.id = value |
| elif index=='name': |
| self.name = value |
| elif index=='user': |
| self.user = value |
| elif index=='passwd': |
| self.passwd = value |
| elif index=='url': |
| self.url = value |
| elif index=='url_admin': |
| self.url_admin = value |
| else: |
| raise KeyError("Invalid key '%s'" %str(index)) |
| |
| def connect(self): |
| |
| service_type = 'standalone' |
| version = '5.6' |
| |
| self.logger.debug("Logging in to a VCA '%s'", self.name) |
| |
| vca = VCA(host=self.url, username=self.user, service_type=service_type, version=version, verify=False, log=True) |
| result = vca.login(password=self.passwd, org=self.name) |
| if not result: |
| raise KeyError("Can't connect to a vCloud director.") |
| result = vca.login(token=vca.token, org=self.name, org_url=vca.vcloud_session.org_url) |
| if result is True: |
| self.logger.debug("Successfully logged to a VCA '%s'", self.name) |
| |
| # vca = VCA(host='172.16.254.206', username=self.user, service_type='standalone', version='5.6', verify=False, log=True) |
| # vca.login(password=self.passwd, org=self.name) |
| # vca.login(token=vca.token, org=self.name, org_url=vca.vcloud_session.org_url) |
| |
| # if not result: |
| # result = vca.login(token=vca.token, org=self.name, org_url=vca.vcloud_session.org_url) |
| # if not result: |
| # raise KeyError("Can't connect to a vcloud director") |
| # else: |
| # print "Logged to VCA via existing token" |
| # else: |
| # print "Logged to VCA" |
| |
| return vca |
| |
| |
| def new_tenant(self,tenant_name,tenant_description): |
| '''Adds a new tenant to VIM with this name and description, |
| returns the tenant identifier''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def delete_tenant(self,tenant_id,): |
| '''Delete a tenant from VIM''' |
| '''Returns the tenant identifier''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def get_tenant_list(self, filter_dict={}): |
| '''Obtain tenants of VIM |
| filter_dict can contain the following keys: |
| name: filter by tenant name |
| id: filter by tenant uuid/id |
| <other VIM specific> |
| Returns the tenant list of dictionaries: |
| [{'name':'<name>, 'id':'<id>, ...}, ...] |
| ''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def new_network(self,net_name, net_type, ip_profile=None, shared=False): |
| '''Adds a tenant network to VIM |
| net_name is the name |
| net_type can be 'bridge','data'.'ptp'. TODO: this need to be revised |
| ip_profile is a dict containing the IP parameters of the network |
| shared is a boolean |
| Returns the network identifier''' |
| |
| self.logger.debug("Vmware tenant from VIM filter: '%s'", net_name) |
| self.logger.debug("Vmware tenant from VIM filter: '%s'", net_type) |
| self.logger.debug("Vmware tenant from VIM filter: '%s'", ip_profile) |
| self.logger.debug("Vmware tenant from VIM filter: '%s'", shared) |
| |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def get_network_list(self, filter_dict={}): |
| '''Obtain tenant networks of VIM |
| Filter_dict can be: |
| name: network name |
| id: network uuid |
| shared: boolean |
| tenant_id: tenant |
| admin_state_up: boolean |
| status: 'ACTIVE' |
| Returns the network list of dictionaries: |
| [{<the fields at Filter_dict plus some VIM specific>}, ...] |
| List can be empty |
| ''' |
| |
| vca = self.connect() |
| if not vca: |
| raise vimconn.vimconnConnectionException("self.connect() is failed") |
| |
| vdc = vca.get_vdc(self.tenant_name) |
| vdcid = vdc.get_id().split(":") |
| |
| networks = vca.get_networks(vdc.get_name()) |
| network_list = [] |
| for network in networks: |
| filter_dict = {} |
| netid = network.get_id().split(":") |
| self.logger.debug ("Adding {} to a list".format(netid[3])) |
| self.logger.debug ("VDC ID {} to a list".format(vdcid[3])) |
| self.logger.debug ("Network {} to a list".format(network.get_name())) |
| |
| filter_dict["name"] = network.get_name() |
| filter_dict["id"] = netid[3] |
| filter_dict["shared"] = network.get_IsShared() |
| filter_dict["tenant_id"] = vdcid[3] |
| if network.get_status() == 1: |
| filter_dict["admin_state_up"] = True |
| else: |
| filter_dict["admin_state_up"] = False |
| filter_dict["status"] = "ACTIVE" |
| filter_dict["type"] = "bridge" |
| network_list.append(filter_dict) |
| |
| self.logger.debug("Returning {}".format(network_list)) |
| return network_list |
| |
| def get_network(self, net_id): |
| '''Obtain network details of net_id VIM network' |
| Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def delete_network(self, net_id): |
| '''Deletes a tenant network from VIM, provide the network id. |
| Returns the network identifier or raise an exception''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def refresh_nets_status(self, net_list): |
| '''Get the status of the networks |
| Params: the list of network identifiers |
| Returns a dictionary with: |
| net_id: #VIM id of this network |
| status: #Mandatory. Text with one of: |
| # DELETED (not found at vim) |
| # VIM_ERROR (Cannot connect to VIM, VIM response error, ...) |
| # OTHER (Vim reported other status not understood) |
| # ERROR (VIM indicates an ERROR status) |
| # ACTIVE, INACTIVE, DOWN (admin down), |
| # BUILD (on building process) |
| # |
| error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR |
| vim_info: #Text with plain information obtained from vim (yaml.safe_dump) |
| |
| ''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def get_flavor(self, flavor_id): |
| '''Obtain flavor details from the VIM |
| Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete |
| ''' |
| |
| print " get_flavor contains {}".format(flavor_id) |
| |
| vca = self.connect() |
| if not vca: |
| raise vimconn.vimconnConnectionException("self.connect() is failed.") |
| |
| def new_flavor(self, flavor_data): |
| '''Adds a tenant flavor to VIM |
| flavor_data contains a dictionary with information, keys: |
| name: flavor name |
| ram: memory (cloud type) in MBytes |
| vpcus: cpus (cloud type) |
| extended: EPA parameters |
| - numas: #items requested in same NUMA |
| memory: number of 1G huge pages memory |
| paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads |
| interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa |
| - name: interface name |
| dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC |
| bandwidth: X Gbps; requested guarantee bandwidth |
| vpci: requested virtual PCI address |
| disk: disk size |
| is_public: |
| |
| |
| |
| #TODO to concrete |
| Returns the flavor identifier''' |
| |
| flavor_uuid = uuid.uuid4() |
| flavorlist[flavor_uuid] = flavor_data |
| |
| print " new_flavor contains {}".format(flavor_data) |
| print " flavor list contains {}".format(flavorlist) |
| |
| return flavor_uuid |
| |
| def delete_flavor(self, flavor_id): |
| '''Deletes a tenant flavor from VIM identify by its id |
| Returns the used id or raise an exception''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def new_image(self,image_dict): |
| ''' |
| Adds a tenant image to VIM |
| Returns: |
| 200, image-id if the image is created |
| <0, message if there is an error |
| ''' |
| |
| print " ################################################################### " |
| print " new_image contains {}".format(image_dict) |
| print " ################################################################### " |
| |
| |
| def delete_image(self, image_id): |
| '''Deletes a tenant image from VIM''' |
| '''Returns the HTTP response code and a message indicating details of the success or fail''' |
| |
| print " ################################################################### " |
| print " delete_image contains {}".format(image_id) |
| print " ################################################################### " |
| |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def catalog_exists(self, catalog_name, catalogs): |
| for catalog in catalogs: |
| if catalog.name == catalog_name: |
| return True |
| return False |
| |
| def create_vimcatalog(self, vca, catalog_name): |
| """Create Catalog entry in VIM""" |
| task = vca.create_catalog(catalog_name, catalog_name) |
| result = vca.block_until_completed(task) |
| if not result: |
| return False |
| catalogs = vca.get_catalogs() |
| return self.catalog_exists(catalog_name, catalogs) |
| |
| |
| def upload_ovf(self, vca, catalog_name, item_name, media_file_name, description='', display_progress=False, |
| chunk_bytes=128 * 1024): |
| """ |
| Uploads a OVF file to a vCloud catalog |
| |
| :param catalog_name: (str): The name of the catalog to upload the media. |
| :param item_name: (str): The name of the media file in the catalog. |
| :param media_file_name: (str): The name of the local media file to upload. |
| :return: (bool) True if the media file was successfully uploaded, false otherwise. |
| """ |
| os.path.isfile(media_file_name) |
| statinfo = os.stat(media_file_name) |
| statinfo.st_size |
| |
| # find a catalog entry where we upload OVF. |
| # create vApp Template and check the status if vCD able to read OVF it will respond with appropirate |
| # status change. |
| # if VCD can parse OVF we upload VMDK file |
| for catalog in vca.get_catalogs(): |
| if catalog_name != catalog.name: |
| continue |
| link = filter(lambda link: link.get_type() == "application/vnd.vmware.vcloud.media+xml" and |
| link.get_rel() == 'add', catalog.get_Link()) |
| assert len(link) == 1 |
| data = """ |
| <UploadVAppTemplateParams name="%s Template" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>%s vApp Template</Description></UploadVAppTemplateParams> |
| """ % (escape(item_name), escape(description)) |
| headers = vca.vcloud_session.get_vcloud_headers() |
| headers['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml' |
| response = Http.post(link[0].get_href(), headers=headers, data=data, verify=vca.verify, logger=self.logger) |
| if response.status_code == requests.codes.created: |
| catalogItem = ET.fromstring(response.content) |
| entity = [child for child in catalogItem if |
| child.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0] |
| href = entity.get('href') |
| template = href |
| response = Http.get(href, headers=vca.vcloud_session.get_vcloud_headers(), |
| verify=vca.verify, logger=self.logger) |
| |
| if response.status_code == requests.codes.ok: |
| media = mediaType.parseString(response.content, True) |
| link = filter(lambda link: link.get_rel() == 'upload:default', media.get_Files().get_File()[0].get_Link())[0] |
| headers = vca.vcloud_session.get_vcloud_headers() |
| headers['Content-Type'] = 'Content-Type text/xml' |
| response = Http.put(link.get_href(), data=open(media_file_name, 'rb'), headers=headers, verify=vca.verify,logger=self.logger) |
| if response.status_code != requests.codes.ok: |
| self.logger.debug("Failed create vApp template for catalog name {} and image {}".format(catalog_name, media_file_name)) |
| return False |
| |
| time.sleep(5) |
| |
| self.logger.debug("Failed create vApp template for catalog name {} and image {}". |
| format(catalog_name, media_file_name)) |
| |
| # uploading VMDK file |
| # check status of OVF upload |
| response = Http.get(template, headers=vca.vcloud_session.get_vcloud_headers(), verify=vca.verify, logger=self.logger) |
| if response.status_code == requests.codes.ok: |
| media = mediaType.parseString(response.content, True) |
| link = filter(lambda link: link.get_rel() == 'upload:default', media.get_Files().get_File()[0].get_Link())[0] |
| |
| # The OVF file and VMDK must be in a same directory |
| head, tail = os.path.split(media_file_name) |
| filevmdk = head + '/' + os.path.basename(link.get_href()) |
| |
| os.path.isfile(filevmdk) |
| statinfo = os.stat(filevmdk) |
| |
| # TODO debug output remove it |
| #print media.get_Files().get_File()[0].get_Link()[0].get_href() |
| #print media.get_Files().get_File()[1].get_Link()[0].get_href() |
| #print link.get_href() |
| |
| # in case first element is pointer to OVF. |
| hrefvmdk = link.get_href().replace("descriptor.ovf","Cirros-disk1.vmdk") |
| |
| f = open(filevmdk, 'rb') |
| bytes_transferred = 0 |
| while bytes_transferred < statinfo.st_size: |
| my_bytes = f.read(chunk_bytes) |
| if len(my_bytes) <= chunk_bytes: |
| headers = vca.vcloud_session.get_vcloud_headers() |
| headers['Content-Range'] = 'bytes %s-%s/%s' % (bytes_transferred, len(my_bytes) - 1, statinfo.st_size) |
| headers['Content-Length'] = str(len(my_bytes)) |
| response = Http.put(hrefvmdk, headers=headers, data=my_bytes, verify=vca.verify,logger=None) |
| if response.status_code == requests.codes.ok: |
| bytes_transferred += len(my_bytes) |
| self.logger.debug('transferred %s of %s bytes' % (str(bytes_transferred), |
| str(statinfo.st_size))) |
| else: |
| self.logger.debug('file upload failed with error: [%s] %s' % (response.status_code, |
| response.content)) |
| return False |
| f.close() |
| return True |
| else: |
| self.logger.debug("Failed retrieve vApp template for catalog name {} for OVF {}". |
| format(catalog_name, media_file_name)) |
| return False |
| |
| self.logger.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name, media_file_name)) |
| return False |
| |
| def upload_vimimage(self,vca, catalog_name, media_name, medial_file_name): |
| """Upload media file""" |
| return self.upload_ovf(vca, catalog_name, media_name.split(".")[0], medial_file_name, medial_file_name, True) |
| |
| def get_catalogid(self, catalog_name, catalogs): |
| for catalog in catalogs: |
| if catalog.name == catalog_name: |
| print catalog.name |
| catalog_id = catalog.get_id().split(":") |
| return catalog_id[3] |
| return None |
| |
| def get_catalogbyid(self, catalog_id, catalogs): |
| for catalog in catalogs: |
| catalogid = catalog.get_id().split(":")[3] |
| if catalogid == catalog_id: |
| return catalog.name |
| return None |
| |
| def get_image_id_from_path(self, path): |
| '''Get the image id from image path in the VIM database''' |
| '''Returns: |
| 0,"Image not found" if there are no images with that path |
| 1,image-id if there is one image with that path |
| <0,message if there was an error (Image not found, error contacting VIM, more than 1 image with that path, etc.) |
| ''' |
| |
| vca = self.connect() |
| if not vca: |
| raise vimconn.vimconnConnectionException("self.connect() is failed") |
| |
| self.logger.debug("get_image_id_from_path path {}".format(path)) |
| |
| dirpath, filename = os.path.split(path) |
| flname, file_extension = os.path.splitext(path) |
| if file_extension != '.ovf': |
| self.logger.debug("Wrong file extension {}".format(file_extension)) |
| return -1, "Wrong container. vCloud director supports only OVF." |
| catalog_name = os.path.splitext(filename)[0] |
| |
| self.logger.debug("File name {} Catalog Name {} file path {}".format(filename, catalog_name, path)) |
| self.logger.debug("Catalog name {}".format(catalog_name)) |
| |
| catalogs = vca.get_catalogs() |
| if len(catalogs) == 0: |
| self.logger.info("Creating new catalog entry {} in vcloud director".format(catalog_name)) |
| result = self.create_vimcatalog(vca, catalog_name) |
| if not result: |
| return -1, "Failed create new catalog {} ".format(catalog_name) |
| result = self.upload_vimimage(vca, catalog_name, filename, path) |
| if not result: |
| return -1, "Failed create vApp template for catalog {} ".format(catalog_name) |
| return self.get_catalogid(catalog_name, vca.get_catalogs()) |
| else: |
| for catalog in catalogs: |
| # search for existing catalog if we find same name we return ID |
| # TODO optimize this |
| if catalog.name == catalog_name: |
| self.logger.debug("Found existing catalog entry for {} catalog id {}".format(catalog_name, self.get_catalogid(catalog_name, catalogs))) |
| return self.get_catalogid(catalog_name, vca.get_catalogs()) |
| |
| # if we didn't find existing catalog we create a new one. |
| self.logger.debug("Creating new catalog entry".format(catalog_name)) |
| result = self.create_vimcatalog(vca, catalog_name) |
| if not result: |
| return -1, "Failed create new catalog {} ".format(catalog_name) |
| result = self.upload_vimimage(vca, catalog_name, filename, path) |
| if not result: |
| return -1, "Failed create vApp template for catalog {} ".format(catalog_name) |
| |
| return self.get_catalogid(catalog_name, vca.get_catalogs()) |
| |
| def get_vappid(self, vdc, vapp_name): |
| """ Take vdc object and vApp name and returns vapp uuid or None |
| """ |
| #UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf |
| |
| try: |
| refs = filter(lambda ref: ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml', |
| vdc.ResourceEntities.ResourceEntity) |
| |
| if len(refs) == 1: |
| return refs[0].href.split("vapp")[1][1:] |
| except: |
| return None |
| return None |
| |
| def get_vappbyid(self, vdc, vapp_id): |
| refs = filter(lambda ref: ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml', |
| vdc.ResourceEntities.ResourceEntity) |
| for ref in refs: |
| print ref.href |
| |
| if len(refs) == 1: |
| return refs[0].href.split("vapp")[1][1:] |
| |
| def new_vminstance(self,name,description,start,image_id,flavor_id,net_list,cloud_config=None): |
| """Adds a VM instance to VIM |
| Params: |
| start: indicates if VM must start or boot in pause mode. Ignored |
| image_id,flavor_id: image and flavor uuid |
| net_list: list of interfaces, each one is a dictionary with: |
| name: |
| net_id: network uuid to connect |
| vpci: virtual vcpi to assign |
| model: interface model, virtio, e2000, ... |
| mac_address: |
| use: 'data', 'bridge', 'mgmt' |
| type: 'virtual', 'PF', 'VF', 'VFnotShared' |
| vim_id: filled/added by this function |
| cloud_config: can be a text script to be passed directly to cloud-init, |
| or an object to inject users and ssh keys with format: |
| key-pairs: [] list of keys to install to the default user |
| users: [{ name, key-pairs: []}] list of users to add with their key-pair |
| #TODO ip, security groups |
| Returns >=0, the instance identifier |
| <0, error_text |
| """ |
| |
| self.logger.info("Creating new instance for entry".format(name)) |
| self.logger.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {}". |
| format(description, start, image_id, flavor_id, net_list, cloud_config)) |
| vca = self.connect() |
| if not vca: |
| raise vimconn.vimconnConnectionException("self.connect() is failed.") |
| |
| # TODO following attribute need be featched from flavor / OVF file must contain same data. |
| # task = self.vca.create_vapp(vdc_name, vapp_name, template, catalog, |
| # vm_name=vm_name, |
| # vm_cpus=cpu, |
| # vm_memory=memory) |
| # |
| |
| catalogs = vca.get_catalogs() |
| #image upload creates template name as catalog name space Template. |
| templateName = self.get_catalogbyid(image_id, catalogs) + ' Template' |
| task = vca.create_vapp(self.tenant_name, name, templateName, self.get_catalogbyid(image_id,catalogs), vm_name=name) |
| if task is False: |
| return -1, " Failed deploy vApp {}".format(name) |
| |
| result = vca.block_until_completed(task) |
| if result: |
| vappID = self.get_vappid(vca.get_vdc(self.tenant_name), name) |
| if vappID is None: |
| return -1, " Failed featch UUID for vApp {}".format(name) |
| else: |
| return vappID |
| |
| return -1, " Failed create vApp {}".format(name) |
| |
| def get_vminstance(self,vm_id): |
| '''Returns the VM instance information from VIM''' |
| |
| vca = self.connect() |
| if not vca: |
| raise vimconn.vimconnConnectionException("self.connect() is failed.") |
| |
| |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def delete_vminstance(self, vm_id): |
| '''Removes a VM instance from VIM''' |
| '''Returns the instance identifier''' |
| |
| print " ###### {} ".format(vm_id) |
| |
| vca = self.connect() |
| if not vca: |
| raise vimconn.vimconnConnectionException("self.connect() is failed.") |
| |
| thevdc = vca.get_vdc(self.tenant_name) |
| self.get_vappid(vca.get_vdc(self.tenant_name), name) |
| |
| |
| |
| |
| def refresh_vms_status(self, vm_list): |
| '''Get the status of the virtual machines and their interfaces/ports |
| Params: the list of VM identifiers |
| Returns a dictionary with: |
| vm_id: #VIM id of this Virtual Machine |
| status: #Mandatory. Text with one of: |
| # DELETED (not found at vim) |
| # VIM_ERROR (Cannot connect to VIM, VIM response error, ...) |
| # OTHER (Vim reported other status not understood) |
| # ERROR (VIM indicates an ERROR status) |
| # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running), |
| # CREATING (on building process), ERROR |
| # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address |
| # |
| error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR |
| vim_info: #Text with plain information obtained from vim (yaml.safe_dump) |
| interfaces: |
| - vim_info: #Text with plain information obtained from vim (yaml.safe_dump) |
| mac_address: #Text format XX:XX:XX:XX:XX:XX |
| vim_net_id: #network id where this interface is connected |
| vim_interface_id: #interface/port VIM id |
| ip_address: #null, or text with IPv4, IPv6 address |
| ''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def action_vminstance(self, vm_id, action_dict): |
| '''Send and action over a VM instance from VIM |
| Returns the vm_id if the action was successfully sent to the VIM''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def get_vminstance_console(self,vm_id, console_type="vnc"): |
| ''' |
| Get a console for the virtual machine |
| Params: |
| vm_id: uuid of the VM |
| console_type, can be: |
| "novnc" (by default), "xvpvnc" for VNC types, |
| "rdp-html5" for RDP types, "spice-html5" for SPICE types |
| Returns dict with the console parameters: |
| protocol: ssh, ftp, http, https, ... |
| server: usually ip address |
| port: the http, ssh, ... port |
| suffix: extra text, e.g. the http path and query string |
| ''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| #NOT USED METHODS in current version |
| |
| def host_vim2gui(self, host, server_dict): |
| '''Transform host dictionary from VIM format to GUI format, |
| and append to the server_dict |
| ''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def get_hosts_info(self): |
| '''Get the information of deployed hosts |
| Returns the hosts content''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def get_hosts(self, vim_tenant): |
| '''Get the hosts and deployed instances |
| Returns the hosts content''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def get_processor_rankings(self): |
| '''Get the processor rankings in the VIM database''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def new_host(self, host_data): |
| '''Adds a new host to VIM''' |
| '''Returns status code of the VIM response''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def new_external_port(self, port_data): |
| '''Adds a external port to VIM''' |
| '''Returns the port identifier''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def new_external_network(self,net_name,net_type): |
| '''Adds a external network to VIM (shared)''' |
| '''Returns the network identifier''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def connect_port_network(self, port_id, network_id, admin=False): |
| '''Connects a external port to a network''' |
| '''Returns status code of the VIM response''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |
| def new_vminstancefromJSON(self, vm_data): |
| '''Adds a VM instance to VIM''' |
| '''Returns the instance identifier''' |
| raise vimconnNotImplemented( "Should have implemented this" ) |
| |