def delete_deployment(username, machine_name, logger):
"""Unregister and destroy a user's Deployment
:Returns: None
:param username: The user who wants to delete their jumpbox
:type username: String
:param machine_name: The name of the VM to delete
:type machine_name: String
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \
password=const.INF_VCENTER_PASSWORD) as vcenter:
folder = vcenter.get_by_name(name=username, vimtype=vim.Folder)
tasks = []
for entity in folder.childEntity:
info = virtual_machine.get_info(vcenter, entity, username)
if info['meta'].get('deployment', False) == True:
logger.debug('powering off VM %s', entity.name)
virtual_machine.power(entity, state='off')
delete_task = entity.Destroy_Task()
tasks.append(delete_task)
if tasks:
logger.debug('blocking while VMs are being destroyed')
for task in tasks:
consume_task(task)
else:
raise ValueError('No {} named {} found'.format('deployment', machine_name))
def delete_windows(username, machine_name, logger):
"""Unregister and destroy a user's Windows
:Returns: None
:param username: The user who wants to delete their jumpbox
:type username: String
:param machine_name: The name of the VM to delete
:type machine_name: String
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \
password=const.INF_VCENTER_PASSWORD) as vcenter:
folder = vcenter.get_by_name(name=username, vimtype=vim.Folder)
for entity in folder.childEntity:
if entity.name == machine_name:
info = virtual_machine.get_info(vcenter, entity, username)
if info['meta']['component'] == 'Windows':
logger.debug('powering off VM')
virtual_machine.power(entity, state='off')
delete_task = entity.Destroy_Task()
logger.debug('blocking while VM is being destroyed')
consume_task(delete_task)
break
else:
raise ValueError('No {} named {} found'.format(
'windows', machine_name))
def create_esxi(username, machine_name, image, network, logger):
"""Deploy a new instance of ESXi
:Returns: Dictionary
:param username: The name of the user who wants to create a new ESXi
:type username: String
:param machine_name: The name of the new instance of ESXi
:type machine_name: String
:param image: The image/version of ESXi to create
:type image: String
:param network: The name of the network to connect the new ESXi instance up to
:type network: String
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER,
password=const.INF_VCENTER_PASSWORD) as vcenter:
image_name = convert_name(image)
logger.info(image_name)
ova = Ova(os.path.join(const.VLAB_ESXI_IMAGES_DIR, image_name))
try:
network_map = vim.OvfManager.NetworkMapping()
network_map.name = ova.networks[0]
try:
network_map.network = vcenter.networks[network]
except KeyError:
raise ValueError('No such network named {}'.format(network))
the_vm = virtual_machine.deploy_from_ova(vcenter=vcenter,
ova=ova,
network_map=[network_map],
username=username,
machine_name=machine_name,
logger=logger,
power_on=False)
finally:
ova.close()
config_vm(the_vm)
virtual_machine.power(the_vm, state='on')
meta_data = {'component' : "ESXi",
'created': time.time(),
'version': image,
'configured': False,
'generation': 1,
}
virtual_machine.set_meta(the_vm, meta_data)
info = virtual_machine.get_info(vcenter, the_vm, username, ensure_ip=True)
return {the_vm.name: info}
def test_power_on_already(self):
"""``virtual_machine`` - power returns True if the VM is already in the requested power state"""
vm = MagicMock()
vm.runtime.powerState = 'poweredOn'
result = virtual_machine.power(vm, state='on')
expected = True
self.assertEqual(result, expected)
def delete_jumpbox(username):
"""Unregister and destroy the user's jumpbox
:Returns: None
:param username: The user who wants to delete their jumpbox
:type username: String
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \
password=const.INF_VCENTER_PASSWORD) as vcenter:
folder = vcenter.get_by_name(name=username, vimtype=vim.Folder)
for entity in folder.childEntity:
if entity.name == COMPONENT_NAME:
logger.debug('powering off VM')
virtual_machine.power(entity, state='off')
delete_task = entity.Destroy_Task()
logger.debug('blocking while VM is being destroyed')
consume_task(delete_task)
def test_power_timeout(self, fake_sleep):
"""``virtual_machine`` - power returns false if the task timesout"""
vm = MagicMock()
vm.runtime.powerState = 'poweredOn'
vm.ResetVM_Task.return_value.info.completeTime = None
result = virtual_machine.power(vm, state='restart')
expected = False
self.assertEqual(result, expected)
self.assertTrue(fake_sleep.called)
def test_power_reset_while_off(self):
"""``virtual_machine`` - power can restart a powered off VM"""
vm = MagicMock()
vm.runtime.powerState = 'poweredOff'
vm.PowerOn.return_value.info.completeTime = 1234
vm.PowerOn.return_value.info.error = None
result = virtual_machine.power(vm, state='restart')
expected = True
self.assertEqual(result, expected)
def test_power_reset(self):
"""``virtual_machine`` - power can reboot a VM"""
vm = MagicMock()
vm.runtime.powerState = 'poweredOn'
vm.ResetVM_Task.return_value.info.completeTime = 1234
vm.ResetVM_Task.return_value.info.error = None
result = virtual_machine.power(vm, state='restart')
expected = True
self.assertEqual(result, expected)
def test_power_off(self):
"""``virtual_machine`` - power can turn a VM off"""
vm = MagicMock()
vm.runtime.powerState = 'poweredOn'
vm.PowerOff.return_value.info.completeTime = 1234
vm.PowerOff.return_value.info.error = None
result = virtual_machine.power(vm, state='off')
expected = True
self.assertEqual(result, expected)
def delete_gateway(username, logger):
"""Unregister and destroy the defaultGateway virtual machine
:Returns: None
:param username: The user who wants to delete their defaultGateway
:type username: String
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \
password=const.INF_VCENTER_PASSWORD) as vcenter:
folder = vcenter.get_by_name(name=username, vimtype=vim.Folder)
for entity in folder.childEntity:
if entity.name == COMPONENT_NAME:
logger.debug('powering off VM')
virtual_machine.power(entity, state='off')
delete_task = entity.Destroy_Task()
logger.debug('blocking while VM is being destroyed')
consume_task(delete_task)
def modify_power(username, power_state, machine, logger):
"""Keeps business logic out of Celery task
:Returns: None
:Raises: ValueError, RuntimeError
:param username: The name of the user who owns the supplied VM(s)
:type username: String
:param power_state: The desired power state for the supplied VM(s)
:type power_state: String
:param machine: The name of the VM(s) to power on/off/restart
:type machine: String
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \
password=const.INF_VCENTER_PASSWORD) as vcenter:
folder = vcenter.get_by_name(name=username, vimtype=vim.Folder)
vms = [x for x in folder.childEntity]
logger.debug('All user VMS: {}'.format(','.join([x.name
for x in vms])))
if machine.lower() != 'all':
vms = [x for x in vms if x.name == machine]
if not vms:
error = 'No machine named {} found'.format(machine)
raise ValueError(error)
errors = []
debug_msg = 'VM(s) getting power state adjusted to {}: {}'.format(
','.join([x.name for x in vms]), power_state)
logger.debug(debug_msg)
for vm in vms:
ok = virtual_machine.power(vm, power_state)
if not ok:
msg = 'Unable to power {} {}'.format(power_state, vm.name)
errors.append(msg)
if errors:
msg = ', '.join(errors)
raise RuntimeError(msg)
def create_centos(username, machine_name, image, network, desktop, ram, cpu_count, logger):
"""Deploy a new instance of CentOS
:Returns: Dictionary
:param username: The name of the user who wants to create a new CentOS
:type username: String
:param machine_name: The name of the new instance of CentOS
:type machine_name: String
:param image: The image/version of CentOS to create
:type image: String
:param network: The name of the network to connect the new CentOS instance up to
:type network: String
:param network: The name of the network to connect the new CentOS instance up to
:type network: String
:param desktop: Deploy the VM with a GUI
:type desktop: Boolean
:param ram: The number of GB of RAM to allocate for the VM
:type ram: Integer
:param cpu_count: The number of CPU cores to allocate for the VM
:type cpu_count: Integer
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER,
password=const.INF_VCENTER_PASSWORD) as vcenter:
image_name = convert_name(image, desktop=desktop)
logger.info(image_name)
try:
ova = Ova(os.path.join(const.VLAB_CENTOS_IMAGES_DIR, image_name))
except FileNotFoundError:
error = "Invalid version of CentOS supplied: {}".format(image)
raise ValueError(error)
try:
network_map = vim.OvfManager.NetworkMapping()
network_map.name = ova.networks[0]
try:
network_map.network = vcenter.networks[network]
except KeyError:
raise ValueError('No such network named {}'.format(network))
the_vm = virtual_machine.deploy_from_ova(vcenter, ova, [network_map],
username, machine_name, logger,
power_on=False)
finally:
ova.close()
mb_of_ram = ram * 1024
virtual_machine.adjust_ram(the_vm, mb_of_ram)
virtual_machine.adjust_cpu(the_vm, cpu_count)
virtual_machine.power(the_vm, state='on')
meta_data = {'component' : "CentOS",
'created': time.time(),
'version': image,
'configured': False,
'generation': 1,
}
virtual_machine.set_meta(the_vm, meta_data)
info = virtual_machine.get_info(vcenter, the_vm, username, ensure_ip=True)
return {the_vm.name: info}
def test_power_value_error(self):
"""``virtual_machine`` - power raises ValueError when supplied with invalid power state value"""
vm = MagicMock()
with self.assertRaises(ValueError):
virtual_machine.power(vm, state='foo')
def create_onefs(username, machine_name, image, front_end, back_end, ram,
cpu_count, logger):
"""Deploy a OneFS node
:Returns: Dictionary
:param username: The user who wants to delete a OneFS node
:type username: String
:param machine_name: The name of the OneFS node
:type machine_name: String
:param image: The version/image of the OneFS node to create
:type image: String
:param front_end: The network to hook up the external network to
:type front_end: String
:param back_end: The network to hook the internal network to
:type back_end: String
:param ram: The number of GB of memory to provision the node with
:type ram: Integer
:param cpu_count: The number of CPU cores to allocate to the vOneFS node
:type cpu_count: Integer
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \
password=const.INF_VCENTER_PASSWORD) as vcenter:
ova_name = convert_name(image)
try:
ova = Ova(os.path.join(const.VLAB_ONEFS_IMAGES_DIR, ova_name))
except FileNotFoundError:
error = 'Invalid version of OneFS: {}'.format(image)
raise ValueError(error)
try:
network_map = make_network_map(vcenter.networks, front_end,
back_end)
the_vm = virtual_machine.deploy_from_ova(vcenter=vcenter,
ova=ova,
network_map=network_map,
username=username,
machine_name=machine_name,
logger=logger,
power_on=False)
finally:
ova.close()
# ram is supplied in GB
mb_of_ram = ram * 1024
virtual_machine.adjust_ram(the_vm, mb_of_ram=mb_of_ram)
virtual_machine.adjust_cpu(the_vm, cpu_count)
virtual_machine.power(the_vm, state='on')
meta_data = {
'component': 'OneFS',
'created': time.time(),
'version': image,
'configured': False,
'generation': 1
} # Versioning of the VM itself
virtual_machine.set_meta(the_vm, meta_data)
info = virtual_machine.get_info(vcenter, the_vm, username)
return {the_vm.name: info}
def create_dataiq(username, machine_name, image, network, static_ip,
default_gateway, netmask, dns, disk_size, cpu_count, ram, logger):
"""Deploy a new instance of DataIQ
:Returns: Dictionary
:param username: The name of the user who wants to create a new DataIQ
:type username: String
:param machine_name: The name of the new instance of DataIQ
:type machine_name: String
:param image: The image/version of DataIQ to create
:type image: String
:param network: The name of the network to connect the new DataIQ instance up to
:type network: String
:param static_ip: The IPv4 address to assign to the VM
:type static_ip: String
:param default_gateway: The IPv4 address of the network gateway
:type default_gateway: String
:param netmask: The subnet mask of the network, i.e. 255.255.255.0
:type netmask: String
:param dns: A list of DNS servers to use.
:type dns: List
:param disk_size: The number of GB to allocate for the DataIQ database
:type disk_size: Integer
:param cpu_count: Thenumber of CPU cores to allocate to the DataIQ machine
:type cpu_count: Integer
:param ram: The number of GB of RAM to allocate to the VM
:type ram: Integer
:param logger: An object for logging messages
:type logger: logging.LoggerAdapter
"""
with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER,
password=const.INF_VCENTER_PASSWORD) as vcenter:
image_name = convert_name(image)
logger.info(image)
ova = Ova(os.path.join(const.VLAB_DATAIQ_IMAGES_DIR, image_name))
try:
network_map = vim.OvfManager.NetworkMapping()
network_map.name = ova.networks[0]
try:
network_map.network = vcenter.networks[network]
except KeyError:
raise ValueError('No such network named {}'.format(network))
the_vm = virtual_machine.deploy_from_ova(vcenter=vcenter,
ova=ova,
network_map=[network_map],
username=username,
machine_name=machine_name,
logger=logger,
power_on=False)
finally:
ova.close()
mb_of_ram = ram * 1024
virtual_machine.adjust_ram(the_vm, mb_of_ram)
virtual_machine.adjust_cpu(the_vm, cpu_count)
virtual_machine.power(the_vm, state='on')
meta_data = {'component' : "DataIQ",
'created' : time.time(),
'version' : image,
'configured' : False,
'generation' : 1}
virtual_machine.set_meta(the_vm, meta_data)
logger.info("Adding DB VMDK")
_add_database_disk(the_vm, disk_size)
logger.info("Configuring network")
_config_network(vcenter, the_vm, static_ip, default_gateway, netmask, dns, logger)
logger.info("Adding GUI")
_add_gui(vcenter, the_vm, logger)
logger.info("Acquiring machine info")
info = virtual_machine.get_info(vcenter, the_vm, username, ensure_ip=True)
return {the_vm.name: info}
