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}