def _create_vm(ova_file, machine_name, template, username, vm_kind, logger): with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, password=const.INF_VCENTER_PASSWORD) as vcenter: ova = Ova(ova_file) try: net_map = _get_network_mapping(vcenter, ova, vm_kind, username) the_vm = virtual_machine.deploy_from_ova(vcenter=vcenter, ova=ova, network_map=net_map, username=username, machine_name=machine_name, logger=logger) finally: ova.close() meta_data = {'component' : template, 'created' : time.time(), 'deployment': True, 'version' : 'n/a', 'configured' : True, 'generation' : 1} virtual_machine.set_meta(the_vm, meta_data) if vm_kind.lower() == 'onefs': info = virtual_machine.get_info(vcenter, the_vm, username, ensure_ip=False) else: info = virtual_machine.get_info(vcenter, the_vm, username, ensure_ip=True) return {the_vm.name: info}
def _make_ova(username, machine_name, template_dir, logger): """Export a VM to an OVA. :param username: The user creating a new deployment template. :type username: String :param machine_name: The name of the VM to include in the deployment template. :type machine_name: String :param template_dir: The folder to save the new VM OVA in. :type template_dir: String :param logger: An object for logging messages :type logger: logging.LoggerAdapter """ new_ova = '' kind = '' error = '' 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 vm in folder.childEntity: if vm.name == machine_name: # Avoids VM names getting crazy long as a result of users making # new templates from existing deployments. info = virtual_machine.get_info(vcenter, vm, username) kind = info['meta']['component'] ova_name = vm.name.replace(VM_NAME_APPEND, '') new_ova = virtual_machine.make_ova(vcenter, vm, template_dir, logger, ova_name=ova_name) break else: error = 'No VM named {} found.'.format(machine_name) return new_ova, kind, error
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 test_get_info_note_none(self, fake_get_vm_console_url, fake_get_vm_ips, fake_get_networks): """``virtual_machine`` - TODO""" fake_get_vm_ips.return_value = ['192.168.1.1'] fake_get_networks.return_value = ['network1', 'network2'] fake_get_vm_console_url.return_value = 'https://test-vm-url' vm = MagicMock() vm.runtime.powerState = 'poweredOn' vm.config.annotation = None vm._moId = 'vm-1234' vcenter = MagicMock() info = virtual_machine.get_info(vcenter, vm, 'alice') expected_info = { 'state': 'poweredOn', 'console': 'https://test-vm-url', 'ips': ['192.168.1.1'], 'networks': ['network1', 'network2'], 'moid': 'vm-1234', 'meta': { 'component': 'Unknown', 'created': 0, 'version': 'Unknown', 'generation': 0, 'configured': False } } self.assertEqual(info, expected_info)
def create_jumpbox(username, network, image_name='jumpBox-Ubuntu18.04.ova'): """Make a new jumpbox so a user can connect to their lab :Returns: Dictionary :param username: The user who wants to delete their jumpbox :type username: String :param network: The name of the network the jumpbox connects to :type network: string """ with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \ password=const.INF_VCENTER_PASSWORD) as vcenter: ova = Ova(os.path.join(const.VLAB_JUMPBOX_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, ova, [network_map], username, 'jumpBox', logger) finally: ova.close() _setup_jumpbox(vcenter, the_vm, username) # VMTools will be ready long before the full network stack is up. # Pause for a moment here so we can return an IP time.sleep(70) return virtual_machine.get_info(vcenter, the_vm)
def test_get_info(self, fake_get_vm_console_url, fake_get_vm_ips, fake_get_networks): """``virtual_machine`` - get_info returns the expected data""" fake_get_vm_ips.return_value = ['192.168.1.1'] fake_get_networks.return_value = ['network1', 'network2'] fake_get_vm_console_url.return_value = 'https://test-vm-url' vm = MagicMock() vm.runtime.powerState = 'poweredOn' vm.config.annotation = '{"json": true}' vm._moId = 'vm-1234' vcenter = MagicMock() info = virtual_machine.get_info(vcenter, vm, 'alice') expected_info = { 'state': 'poweredOn', 'console': 'https://test-vm-url', 'ips': ['192.168.1.1'], 'moid': 'vm-1234', 'networks': ['network1', 'network2'], 'meta': { 'json': True } } self.assertEqual(info, expected_info)
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 update_network(username, machine_name, new_network): """Implements the VM network update :param username: The name of the user who owns the virtual machine :type username: String :param machine_name: The name of the virtual machine :type machine_name: String :param new_network: The name of the new network to connect the VM to :type new_network: 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 == machine_name: info = virtual_machine.get_info(vcenter, entity, username) if info['meta']['component'] == 'Windows': the_vm = entity break else: error = 'No VM named {} found'.format(machine_name) raise ValueError(error) try: network = vcenter.networks[new_network] except KeyError: error = 'No VM named {} found'.format(machine_name) raise ValueError(error) else: virtual_machine.change_network(the_vm, network)
def create_windows(username, machine_name, image, network, logger): """Deploy a new instance of Windows :Returns: Dictionary :param username: The name of the user who wants to create a new Windows :type username: String :param machine_name: The name of the new instance of Windows :type machine_name: String :param image: The image/version of Windows to create :type image: String :param network: The name of the network to connect the new Windows 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) try: ova = Ova(os.path.join(const.VLAB_WINDOWS_IMAGES_DIR, image_name)) except FileNotFoundError: error = "Invalid verison of Windows 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) finally: ova.close() meta_data = { 'component': "Windows", '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 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 create_kemp(username, machine_name, image, network, logger): """Deploy a new instance of Kemp :Returns: Dictionary :param username: The name of the user who wants to create a new Kemp :type username: String :param machine_name: The name of the new instance of Kemp :type machine_name: String :param image: The image/version of Kemp to create :type image: String :param network: The name of the network to connect the new Kemp 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_KEMP_IMAGES_DIR, image_name)) network_map = _get_nic_network_map(network, vcenter.networks, ova.networks) try: the_vm = virtual_machine.deploy_from_ova(vcenter, ova, network_map, username, machine_name, logger) finally: ova.close() meta_data = { 'component': "Kemp", '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 create_router(username, machine_name, image, requested_networks, logger): """Deploy a new instance of Router :Returns: Dictionary :param username: The name of the user who wants to create a new Router :type username: String :param machine_name: The name of the new instance of Router :type machine_name: String :param image: The image/version of Router to create :type image: String :param requested_networks: The name of the networks to connect the new Router instance up to :type requested_networks: List :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) try: ova = Ova(os.path.join(const.VLAB_ROUTER_IMAGES_DIR, image_name)) except FileNotFoundError: error = "Invalid version of Router supplied: {}".format(image) raise ValueError(error) try: networks = map_networks(ova.networks, requested_networks, vcenter.networks) the_vm = virtual_machine.deploy_from_ova(vcenter, ova, networks, username, machine_name, logger) finally: ova.close() meta_data = { 'component': "Router", '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) return {the_vm.name: info}
def show_inventory(username): """Return some basic information about all VMs a user owns :Returns: Dictionary :param username: The name of the user to create a folder for :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) vms = {} for entity in folder.childEntity: info = virtual_machine.get_info(vcenter, entity, username) vms[entity.name] = info return vms
def show_windows(username): """Obtain basic information about Windows :Returns: Dictionary :param username: The user requesting info about their Windows :type username: String """ windows_vms = {} 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 vm in folder.childEntity: info = virtual_machine.get_info(vcenter, vm, username) if info['meta']['component'] == 'Windows': windows_vms[vm.name] = info return windows_vms
def show_gateway(username): """Obtain basic information about the defaultGateway :Returns: Dictionary :param username: The user requesting info about their defaultGateway :type username: String """ info = {} 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 vm in folder.childEntity: if vm.name == COMPONENT_NAME: info = virtual_machine.get_info(vcenter, vm, username) break return info
def show_deployment(username): """Obtain basic information about Deployment :Returns: Dictionary :param username: The user requesting info about their Deployment :type username: String """ info = {} 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) deployment_vms = {} for vm in folder.childEntity: info = virtual_machine.get_info(vcenter, vm, username) if info['meta'].get('deployment', False) == True: deployment_vms[vm.name] = info return deployment_vms
def _check_for_deployment(username): """For many reasons, only 1 deployment per lab is allowed. This function checks if a deployment already exists. :Returns: String :param username: The name of the user who wants to create a new Deployment :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) current_deployment = '' for vm in folder.childEntity: info = virtual_machine.get_info(vcenter, vm, username) if info['meta'].get('deployment', False): current_deployment = info['meta']['component'] break return current_deployment
def create_gateway(username, wan, lan, logger, image_name='defaultgateway-IPAM.ova'): """Deploy the defaultGateway from an OVA :Returns: None :param username: The user who wants to create a new defaultGateway :type username: String :param wan: The name of the network to use in vCenter for the WAN network :type wan: String :param lan: The name of the network to use in vCenter for the LAN network :type lan: String :param image_name: The of the OVA to deploy :type image_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: ova = Ova(os.path.join(const.VLAB_GATEWAY_IMAGES_DIR, image_name)) try: network_map = _create_network_map(vcenter, ova, wan, lan, logger) the_vm = virtual_machine.deploy_from_ova(vcenter, ova, network_map, username, COMPONENT_NAME, logger) finally: ova.close() _setup_gateway(vcenter, the_vm, username, gateway_version='1.0.0', logger=logger) return virtual_machine.get_info(vcenter, the_vm, username, ensure_ip=True)
def destroy_vms(user, vcenter): """Delete enough VMs to resolve the soft-quota violation. The VMs deleted are randomly chosen, and this function returns a list of VM names that were deleted. :Returns: List :param user: The user that's getting some VMs deleted :type user: String :param vcenter: An object for interacting with the vCenter API. :type vcenter: vlab_inf_common.vmaware.vCenter """ user_folder = vcenter.get_by_name(name=user, vimtype=vim.Folder) user_vms = set( [x for x in user_folder.childEntity if not x.name == 'defaultGateway']) deleted_vms = [] while len(user_vms) > const.VLAB_QUOTA_LIMIT: unlucky_vm = random.sample(user_vms, 1)[0] # b/c random.sample returns a list vm_info = virtual_machine.get_info(vcenter, unlucky_vm, user) vm_name = unlucky_vm.name if vm_info['meta']['component'] == 'Unknown': log.info( "Skipping VM %s owned by %s: VM cannot be deleted at this time", vm_name, user) else: _delete_portmap_rules(user, vm_name) log.info("Delete portmapping rules for VM %s owned by %s", vm_name, user) _delete_vm(user, vm_name, vm_info['meta']['component'].lower()) deleted_vms.append(vm_name) log.info("Deleted VM %s, owned by %s", vm_name, user) # Removing the VM from the set *only* if we delete it avoids an # edge case where a user is over by 1 VM, and the one we randomly # choose to delete is either deploying or a failed deployment. # While this could potentially create an infinite loop, if it did # we'd probably have "bigger problems" going on, and fixing those # "bigger problems" would resolve the infinite loop. user_vms.discard(unlucky_vm) return deleted_vms
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 create_winserver(username, machine_name, image, network, ip_config, logger): """Deploy a new instance of WinServer :Returns: Dictionary :param username: The name of the user who wants to create a new WinServer :type username: String :param machine_name: The name of the new instance of WinServer :type machine_name: String :param image: The image/version of WinServer to create :type image: String :param network: The name of the network to connect the new WinServer instance up to :type network: String :param ip_config: The IPv4 network configuration for the WinServer instance :type ip_config: Dictionary :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) try: ova = Ova(os.path.join(const.VLAB_WINSERVER_IMAGES_DIR, image_name)) except FileNotFoundError: error = 'Invalid version of Windows Server 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) finally: ova.close() if ip_config['static-ip']: # Hack - The VM will walk through the C:\unattend.xml answer file # and then reboot. We wont have valid login creds until after the # reboot. Trying to *notice* the reboot is a race condition nightmare time.sleep(300) virtual_machine.config_static_ip(vcenter, the_vm, ip_config['static-ip'], ip_config['default-gateway'], ip_config['netmask'], ip_config['dns'], user='******', password='******', logger=logger, os='windows') meta_data = {'component' : "WinServer", '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 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}
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_dns(username, machine_name, image, network, static_ip, default_gateway, netmask, dns, logger): """Deploy a new instance of Dns :Returns: Dictionary :param username: The name of the user who wants to create a new Dns :type username: String :param machine_name: The name of the new instance of Dns :type machine_name: String :param image: The image/version of Dns to create :type image: String :param network: The name of the network to connect the new Dns 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 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_DNS_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, ova, [network_map], username, machine_name, logger) finally: ova.close() meta_data = { 'component': "Dns", 'created': time.time(), 'version': image, 'configured': False, 'generation': 1 } virtual_machine.set_meta(the_vm, meta_data) if image.lower().startswith('windows'): vm_user, vm_password, the_os = const.VLAB_DNS_WINDOWS_ADMIN, const.VLAB_DNS_WINDOWS_PW, 'windows' else: vm_user, vm_password, the_os = const.VLAB_DNS_BIND9_ADMIN, const.VLAB_DNS_BIND9_PW, 'centos8' virtual_machine.config_static_ip(vcenter, the_vm, static_ip, default_gateway, netmask, dns, vm_user, vm_password, logger, os=the_os) if the_os == 'centos8': _finish_bind_config(vcenter, the_vm, static_ip, logger) info = virtual_machine.get_info(vcenter, the_vm, username, ensure_ip=True) return {the_vm.name: info}