def add_vif(self, network_identifier=None, **kwargs):
"""Add a virtual network interface to local VM.
If mac_address is specified, it will be assigned to the interface.
network_identifier must be specified.
"""
#NOTE: User need to specify network name in UI form of publish services
#TODO: Ensure the new VIF becomes eth2 inside VM otherwise need to
# find a way to discover device number
mac_address = None
for key in kwargs:
if key == 'mac_address':
mac_address = kwargs[key]
if not network_identifier:
exc_msg = exception.exc_strs.NETWORK_MISSING_PARAMETER % \
'network_identifier'
raise exception.HAPIFailure(
exception.exc_codes.NETWORK_MISSING_PARAMETER, exc_msg)
client_factory = self.session._get_vim().client.factory
nic_spec = util.create_vif_spec(client_factory, network_identifier,
mac_address)
device_config_spec = [nic_spec]
vm_config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')
vm_config_spec.deviceChange = device_config_spec
reconfig_task = self.session._call_method(self.session._get_vim(),
"ReconfigVM_Task",
self.vm,
spec=vm_config_spec)
util.wait_for_task(self.session, reconfig_task)
def add_vif(self, network_identifier=None, **kwargs):
"""Add a virtual network interface to local VM.
device must be specified
mac_address can be omitted"""
bridge = network_identifier
network_by_bridge = self.get_network_by_component(bridge)
mac_address = device = ''
for key in kwargs:
if key == 'mac_address':
mac_address = kwargs[key]
elif key == 'device':
device = kwargs[key]
if device == '':
exc_msg = exception.exc_strs.NETWORK_MISSING_PARAMETER % 'device'
raise \
exception.HAPIFailure(exception.exc_codes.NETWORK_MISSING_PARAMETER,
exc_msg)
vif_ref = self.session.xenapi.VIF.create({
'VM': self.vm,
'device': device,
'network': network_by_bridge,
'MAC': mac_address,
'MTU': "1500",
'other_config': {},
'qos_algorithm_type': "",
'qos_algorithm_params': {}
})
self.session.xenapi.VIF.plug(vif_ref)
return self.session.xenapi.VIF.get_uuid(vif_ref)
def create_virtualdisk(self,
size=1024,
name_label='OS_VPX_virtualdisk',
key=None):
try:
# add a default key to other-config
other_config = {'os-vpx-extra': 'true'}
if key:
other_config[key] = 'true'
vdi_ref = self.session.xenapi.VDI.create({
'name_label': name_label,
'name_description': '',
'SR': self.container,
'virtual_size': str(size),
'type': 'User',
'sharable': False,
'read_only': False,
'xenstore_data': {},
'other_config': other_config,
'sm_config': {},
'tags': []
})
return self.session.xenapi.VDI.get_uuid(vdi_ref)
except XenAPI.Failure, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKCREATE_ERROR,
exception.exc_strs.STORAGE_DISKCREATE_ERROR, inner_exception)
def createSession(cls, session_type=None):
cls.hv_session = config_util.load_session(session_type)
if cls.hv_session is None:
raise exception.HAPIFailure(exception.exc_codes.\
UNCLASSIFIED_SESSION_FAILURE,
exception.exc_strs.\
UNCLASSIFIED_SESSION_FAILURE)
return cls.hv_session
def create_virtualdisk(self,
size=1024,
name_label='OS_VPX_virtualdisk',
key=None):
"""Create virtual disk of specified size with name as
'[datastore1] name_label.__key__.vmdk'.
TODO: We might want to create sub folders with name 'key' to
maintain name_label and key separate as entities."""
if not key:
key = "geppetto-openstack"
#Retrieve all virtual disks matching the specified key
vmdk_list = self.find_virtualdisk(key)
new_seqnumber = util.get_max_seqnumber(vmdk_list, name_label, key)
new_diskname = name_label + '__' + str(new_seqnumber + 1) \
+ '__' + key + '__.vmdk'
size_kb = int(size) / 1024
vmdk_create_spec = util.get_vmdk_create_spec(
self.session._get_vim().client.factory, size_kb, self.adapter_type)
datastore_name = self.container.name
datacenter_obj = util.get_datacenter(self.session)
virtual_disk_path = util.format_virtual_disk_path(
datastore_name, new_diskname)
try:
create_task = self.session._call_method(
self.session._get_vim(),
"CreateVirtualDisk_Task",
self.session.service_content.virtualDiskManager,
name=virtual_disk_path,
datacenter=datacenter_obj.mor,
spec=vmdk_create_spec)
#Wait for the asynchronous task to complete
is_created = util.wait_for_task(self.session, create_task)
if is_created:
return virtual_disk_path
else:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKCREATE_ERROR,
exception.exc_strs.STORAGE_DISKCREATE_ERROR, None)
#TODO: Add VSphereAPI.Failure instead of Exception
except Exception, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKCREATE_ERROR,
exception.exc_strs.STORAGE_DISKCREATE_ERROR, inner_exception)
def delete_vif(self, vif):
try:
vif_ref = self.session.xenapi.VIF.get_by_uuid(vif['uuid'])
self.session.xenapi.VIF.unplug(vif_ref)
self.session.xenapi.VIF.destroy(vif_ref)
except XenAPI.Failure, inner_exception:
raise exception.HAPIFailure(exception.exc_codes.NETWORK_VIF_ERROR,
exception.exc_strs.NETWORK_VIF_ERROR,
inner_exception)
def _login(self, host, username, password, wsdl_file, version):
"""Creates a session with the ESX host."""
try:
self._vsphereapi = VSphereAPISession(host, username, password,
wsdl_file)
except Exception, inner_exc:
raise exception.HAPIFailure(
exception.exc_codes.UNCLASSIFIED_AUTHENTICATION_FAILURE,
exception.exc_strs.UNCLASSIFIED_AUTHENTICATION_FAILURE,
inner_exc)
class VSphereAPISession(object):
"""Manages a session with the ESX host and handles
vSphere API calls made to the host.
"""
def __init__(self,
host=None,
user="******",
password=None,
wsdl_file=None,
api_retry_count=10,
scheme="https"):
self.api_retry_count = api_retry_count
self.host = host
self.user = user
self.password = password
self.scheme = scheme
self.wsdl_file = wsdl_file
self._session_id = None
self.vim = None
self._create_session()
self.service_content = self.vim.get_service_content()
self.client_factory = self.vim.client.factory
def _create_session(self):
"""Creates a session with the ESX host."""
while True:
try:
# Login and setup the session with the ESX host for making
# API calls
self.vim = self._get_vim_object()
session = self.vim.Login(
self.vim.get_service_content().sessionManager,
userName=self.user,
password=self.password)
# Terminate the earlier session, since there is a limit
# to the number of sessions a client can own
if self._session_id:
try:
self.vim.TerminateSession(
self.vim.get_service_content().sessionManager,
sessionId=[self._session_id])
except Exception, excep:
print(excep)
self._session_id = session.key
return
except Exception, excep:
excep.message = "In vsphereapi _create_session, " \
"exception while creating session. " + excep
raise excep
except Exception, inner_exc:
raise exception.HAPIFailure(
exception.exc_codes.UNCLASSIFIED_AUTHENTICATION_FAILURE,
exception.exc_strs.UNCLASSIFIED_AUTHENTICATION_FAILURE,
inner_exc)
def find_virtualdisk(self, search_key=None, **kwargs):
try:
return [
vdi['uuid'] for vdi in
self.session.xenapi.VDI.get_all_records().itervalues()
if vdi['other_config'].get(search_key) == 'true'
]
except XenAPI.Failure, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKFIND_ERROR,
exception.exc_strs.STORAGE_DISKFIND_ERROR, inner_exception)
def login(self, username='******', password=None):
host = _get_connection_url()
config = config_util.parse_config('/etc/openstack/hapi')
username = config_util.config_get(config, 'HAPI_USER', 'root')
pwd = password != None and password or \
config_util.config_get(config, 'HAPI_PASS')
if not pwd:
raise exception.HAPIFailure(
exception.exc_codes.UNCLASSIFIED_PASSWORD_UNCONFIGURED,
exception.exc_strs.UNCLASSIFIED_PASSWORD_UNCONFIGURED)
wsdl_directory = config_util.config_get(config, 'WSDL_LOC',
'/etc/openstack/visdk')
if not wsdl_directory:
raise exception.HAPIFailure(
exception.exc_codes.UNCLASSIFIED_MISSING_VMWAREWSDL_FILES,
exception.exc_strs.UNCLASSIFIED_MISSING_VMWAREWSDL_FILES)
wsdl_file = "file://" + wsdl_directory + "/vimService.wsdl"
self._login(host, username, pwd, wsdl_file,
config_util.get_vpx_version())
def login(self, username='******', password=None):
url = _get_connection_url()
config = config_util.parse_config('/etc/openstack/hapi')
username = config_util.config_get(config, 'HAPI_USER', 'root')
pwd = password != None and password or \
config_util.config_get(config, 'HAPI_PASS')
if not pwd:
raise exception.HAPIFailure(
exception.exc_codes.UNCLASSIFIED_PASSWORD_UNCONFIGURED,
exception.exc_strs.UNCLASSIFIED_PASSWORD_UNCONFIGURED)
self._login(url, username, pwd, config_util.get_vpx_version())
def get_properties(self, property_list):
vm_prop_dict = {}
vm_rec = self.session.xenapi.VM.get_record(self.vm)
for vm_property in property_list:
try:
vm_prop_dict[vm_property] = vm_rec[self._mapping[vm_property]]
except:
raise exception.HAPIFailure(
exception.exc_codes.VM_PROPERTY_ERROR,
exception.exc_strs.VM_PROPERTY_ERROR)
return vm_prop_dict
def _login(self, url, username, password, version):
try:
self._xapi = XenAPI.Session(url)
self._xapi._ServerProxy__transport.user_agent = \
'os-vpx/%s' % version
self._xapi.xenapi.login_with_password(username, password)
except XenAPI.Failure, inner_exc:
raise exception.HAPIFailure(
exception.exc_codes.UNCLASSIFIED_AUTHENTICATION_FAILURE,
exception.exc_strs.UNCLASSIFIED_AUTHENTICATION_FAILURE,
inner_exc)
def find_vif(self, **kwargs):
device = None
for key in kwargs:
if key == 'device':
device = kwargs[key]
if device == None:
exc_msg = exception.exc_strs.NETWORK_MISSING_PARAMETER % 'device'
raise exception.HAPIFailure(
exception.exc_codes.NETWORK_MISSING_PARAMETER, exc_msg)
#Search specified device by looking for deviceInfo.label
#If found return key (VirtualDevice property) - class VirtualPCNet32
return util.find_device_by_label(self.session, self.vm, device)
def is_virtualdisk_in_use(self, vdisk_id):
try:
vdisk = self.session.xenapi.VDI.get_by_uuid(vdisk_id)
allowed = self.session.xenapi.VDI.get_allowed_operations(vdisk)
if 'destroy' in allowed:
return False
else:
return True
except XenAPI.Failure, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKFIND_ERROR,
exception.exc_strs.STORAGE_DISKFIND_ERROR, inner_exception)
def set_properties(self, **kwargs):
for key in kwargs:
if key == interface.VM.NAME:
self.session.xenapi.VM.set_name_label(self.vm, kwargs[key])
elif key == interface.VM.NAME_DESCRIPTION:
self.session.xenapi.VM.set_name_description(
self.vm, kwargs[key])
elif key == interface.VM.TAGS:
self.session.xenapi.VM.set_tags(self.vm, kwargs[key])
else:
raise exception.HAPIFailure(
exception.exc_codes.VM_PROPERTY_ERROR,
exception.exc_strs.VM_PROPERTY_ERROR)
def set_properties(self, **kwargs):
"""Set properties of local VM as per specified key value pair args."""
args = {}
for key in kwargs:
if key == interface.VM.NAME_DESCRIPTION:
args[key] = kwargs[key]
elif key == interface.VM.NAME:
args[key] = kwargs[key]
else:
pass
try:
util.set_config_params(self.session, self.vm, args)
except:
raise exception.HAPIFailure(exception.exc_codes.VM_PROPERTY_ERROR,
exception.exc_strs.VM_PROPERTY_ERROR)
def get_properties(self, property_list):
vm_prop_dict = {}
for vm_property in property_list:
#if self._mapping.has_key(vm_property) == False:
# raise NotImplementedError()
try:
if vm_property != self._mapping[vm_property]:
vm_prop_dict[vm_property] = self.session._call_method(\
vsphereapi.vim_util, "get_dynamic_property",
self.vm, "VirtualMachine",
self._mapping[vm_property])
except:
raise exception.HAPIFailure(
exception.exc_codes.VM_PROPERTY_ERROR,
exception.exc_strs.VM_PROPERTY_ERROR)
return vm_prop_dict
def is_virtualdisk_in_use(self, vdisk_id):
"""Checks if the specified virtual disk is attached
to local VM or not. Returns True if the virtual disk is attached."""
vmdk_name = util.format_virtual_disk_path(self.container.name,
vdisk_id)
try:
disks = util.get_disks_of_vm(self.session, self.vm)
for disk in disks:
if disk == vmdk_name:
return True
return False
except Exception, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKFIND_ERROR,
exception.exc_strs.STORAGE_DISKFIND_ERROR, inner_exception)
def delete_vif(self, vif):
try:
key = vif
client_factory = self.session._get_vim().client.factory
delete_spec = util.delete_vif_spec(client_factory, key)
reconfig_task = self.session._call_method(self.session._get_vim(),
"ReconfigVM_Task",
self.vm,
spec=vm_config_spec)
util.wait_for_task(self.session, reconfig_task)
#TODO: Add vSphere API Exception
except Exception, inner_exception:
raise exception.HAPIFailure(exception.exc_codes.NETWORK_VIF_ERROR,
exception.exc_strs.NETWORK_VIF_ERROR,
inner_exception)
def find_vif(self, **kwargs):
device = None
for key in kwargs:
if key == 'device':
device = kwargs[key]
if device == None:
exc_msg = exception.exc_strs.NETWORK_MISSING_PARAMETER % 'device'
raise \
exception.HAPIFailure(exception.exc_codes.NETWORK_MISSING_PARAMETER,
exc_msg)
vif = [
vif
for vif in self.session.xenapi.VIF.get_all_records().itervalues()
if ((vif['VM'] == self.vm) and (str(vif['device']) == device))
]
if len(vif) == 1:
return vif[0]
else:
return None
def find_virtualdisk(self, search_key=None, **kwargs):
"""Finds virtual disk in the host that matches the specified key.
Returns virtual disk name."""
disk_list = []
try:
vmdk_list = util.get_disks_in_datastore(self.session,
self.container)
for full_name in vmdk_list:
split_full_name = full_name.rsplit('__' + search_key + '__.',
1)
if len(split_full_name) > 1:
name_with_seqnumber = split_full_name[0]
split_name = name_with_seqnumber.rsplit('__', 1)
if len(split_name) > 1:
disk_list.append(full_name)
return disk_list
except Exception, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKFIND_ERROR,
exception.exc_strs.STORAGE_DISKFIND_ERROR, inner_exception)
def attach_virtualdisk(self, vdisk, **kwargs):
"""Attach specified virtual disk to local VM."""
size_kb = 1024
for key in kwargs:
if key == 'size':
size_kb = kwargs[key] * 1024 * 1024 # size will be in GB
if vdisk[0] == '[':
vdisk_path = vdisk
else:
vdisk_path = util.format_virtual_disk_path(self.container.name,
vdisk)
disks = util.get_disks_of_vm(self.session, self.vm)
unit_number = len(disks)
#Avoid clash with SCSI Controller that sits on it's own bus.
if unit_number >= 7:
unit_number = unit_number + 1
try:
attach_config_spec = util.get_vmdk_attach_spec(
self.session._get_vim().client.factory, size_kb, vdisk_path,
self.adapter_type, unit_number)
#("Reconfiguring VM instance %s to attach the disk %s")
# % (self.vm, vdisk_path)
reconfig_task = self.session._call_method(self.session._get_vim(),
"ReconfigVM_Task",
self.vm,
spec=attach_config_spec)
util.wait_for_task(self.session, reconfig_task)
#NOTE:Forced scsi_host bus scan to hook up to the hot added disk
util.scan_scsi_bus()
time.sleep(2)
#TODO: Add VSphereAPI.Failure type instead of Exception
except Exception, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKATTACH_ERROR,
exception.exc_strs.STORAGE_DISKATTACH_ERROR, inner_exception)
def attach_virtualdisk(self, vdisk, **kwargs):
for key in kwargs:
if key == 'user_device':
device = kwargs[key]
vdi_ref = self.session.xenapi.VDI.get_by_uuid(vdisk)
vdi_rec = self.session.xenapi.VDI.get_record(vdi_ref)
vbd_ref = None
try:
vbd_ref = self.session.xenapi.VBD.create({
'VM':
self.vm,
'VDI':
vdi_ref,
'userdevice':
str(device),
'bootable':
False,
'mode':
'RW',
'type':
'disk',
'unpluggable':
True,
'empty':
False,
'other_config':
vdi_rec['other_config'],
'qos_algorithm_type':
'',
'qos_algorithm_params': {},
'qos_supported_algorithms': [],
})
self.session.xenapi.VBD.plug(vbd_ref)
except XenAPI.Failure, inner_exception:
raise exception.HAPIFailure(
exception.exc_codes.STORAGE_DISKATTACH_ERROR,
exception.exc_strs.STORAGE_DISKATTACH_ERROR, inner_exception)
