def delete_inventory(username, logger): """Destroy a user's inventory :Returns: Dictionary :param username: The owner of the inventory to delete :type username: String :param everything: Optionally destroy all the VMs associated with the user :type everything: Boolean :param logger: An object for logging messages :type logger: logging.LoggerAdapter """ error = None vcenter = vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, password=const.INF_VCENTER_PASSWORD) try: folder = vcenter.get_by_name(name=username, vimtype=vim.Folder) nuke_folder(folder) except vim.fault.InvalidState as doh: # Some VM isn't powered off... error = '{}'.format(doh.msg) except FileNotFoundError: error = 'User {} has no folder'.format(username) except RuntimeError as doh: error = '{}'.format(doh) logger.error(error) finally: vcenter.close() return error
def main(logger): """Entry point logic for deleting expired snapshots :Returns: None :param logger: Handles logging messages while the reaper runs :type logger: logging.Logger """ logger.info('Snapshot Reaper starting') keep_running = True while keep_running: logger.info("Connecting to vCenter {} as {}".format( const.INF_VCENTER_SERVER, const.INF_VCENTER_USER)) with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, password=const.INF_VCENTER_PASSWORD) as vcenter: try: start_loop = time.time() reap_snapshots(vcenter, logger) except Exception as doh: logger.exception(doh) keep_running = False else: ran_for = int(time.time() - start_loop) logger.debug( 'Took {} seconds to check all snapshots'.format(ran_for)) loop_delta = LOOP_INTERVAL - ran_for sleep_for = max(0, loop_delta) time.sleep(sleep_for)
def show_snapshot(username): """Obtain information about snapshot of virtual machines in a user's lab :Returns: Dictionary :param username: The name of the user who wants info about snapshots in their lab :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) snapshot_vms = {} for vm in folder.childEntity: snapshot_vms[vm.name] = [] if vm.snapshot: for snap in _get_snapshots(vm.snapshot.rootSnapshotList): snap_data = snap.name.split('_') snap_id = snap_data[const.VLAB_SNAP_ID] snap_created = snap_data[const.VLAB_SNAP_CREATED] snap_exp = snap_data[const.VLAB_SNAP_EXPIRES] snapshot_vms[vm.name].append({ 'id': snap_id, 'created': int(snap_created), 'expires': int(snap_exp) }) return snapshot_vms
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_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 _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 create_network(name, vlan_id, switch_name): """Create a new network for VMs. :Returns: String (error message) :param name: The name of the new distributed virtual portgroup :type name: String :param vlan_id: The vLAN tag id of the new dv portgroup :type vlan_id: Integer :param switch_name: The name of the switch to add the new vLAN network to :type switch_name: String """ with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER,\ password=const.INF_VCENTER_PASSWORD) as vcenter: try: switch = vcenter.dv_switches[switch_name] except KeyError: available = list(vcenter.dv_switches.keys()) msg = 'No such switch: {}, Available: {}'.format( switch_name, available) raise ValueError(msg) spec = get_dv_portgroup_spec(name, vlan_id) task = switch.AddDVPortgroup_Task([spec]) try: consume_task(task, timeout=300) error = '' except RuntimeError as doh: error = '{}'.format(doh) return error
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_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 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 main(influx_server, influx_user, influx_password, vcenter_server, vcenter_user, vcenter_password, unity_server, unity_user, unity_password): """"Entry point for collecting stats from VMWare""" log = get_logger('main') log.info('Starting Infrastructure stat collection') log.info('Collecting from vCenter: {}'.format(vcenter_server)) log.info('Collecting from Unity SAN: {}'.format(unity_server)) log.info('Writing to Influx: {}'.format(influx_server)) vcenter = vCenter(host=vcenter_server, user=vcenter_user, password=vcenter_password) influx = InfluxDB(server=influx_server, user=influx_user, password=influx_password, measurement='system') unity = Unity(unity_server, unity_user, unity_password) collectors = {'vms': {}, 'esxi_hosts': {}, 'unity': {}} while True: loop_start = time.time() collectors = create_collectors(vcenter, influx, unity, collectors, log) collectors = respawn_collectors(vcenter, influx, unity, collectors, log) loop_time = time.time() - loop_start # Avoids sub-second, negative, and values greater than the loop interval sleep_for = min(CHECK_INTERVAL, int(abs(loop_time - CHECK_INTERVAL))) time.sleep(sleep_for)
def main(): """Entry point for vLab Quota enforcement""" log.info('Quota Soft Limit: %s', const.VLAB_QUOTA_LIMIT) log.info('Quota Grace Period: %s seconds', const.QUOTA_GRACE_PERIOD) log.info('vSphere Server: %s', const.INF_VCENTER_SERVER) log.info('LDAP Server: %s', const.AUTH_LDAP_URL) log.info('LDAP User: %s', const.AUTH_BIND_USER) log.info('SMTP Server: %s', const.QUOTA_EMAIL_SERVER) log.info('Loop interval: %s', LOOP_INTERVAL) vcenter = vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, password=const.INF_VCENTER_PASSWORD) atexit.register(vcenter.close) db = Database() atexit.register(db.close) ldap_conn = _get_ldap_conn() atexit.register(ldap_conn.unbind) users_in_violation = set() while True: start_loop = int(time.time()) current_users_in_violation = _enforce_quotas(vcenter, db, ldap_conn) _cleanup_reconciled_users(current_users_in_violation, users_in_violation, db) users_in_violation = current_users_in_violation loop_ran_for = max(0, int(time.time()) - start_loop) sleep_delta = max(0, (LOOP_INTERVAL - loop_ran_for)) time.sleep(sleep_delta)
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_inventory(username): """Create a folder in vCenter for storing user's VMs :Returns: None :param username: The name of the user to create a folder for :type username: String """ location = '{}/{}'.format(const.INF_VCENTER_TOP_LVL_DIR, username) with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, password=const.INF_VCENTER_PASSWORD) as vcenter: vcenter.create_vm_folder(location)
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 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 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 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 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 _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 update_meta(username, vm_name, new_meta): """Connect to vSphere and update the VM meta data :Returns: None :param username: The user who owns the OneFS node :type username: String :param vm_name: The name of the VM to update the meta data on :type vm_name: String :param new_meta: The new meta data to overwrite the old meta data with :type new_meta: Dictionary """ 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 == vm_name: virtual_machine.set_meta(vm, new_meta)
def delete_snapshot(username, snap_id, machine_name, logger): """Destroy a snapshot :Returns: None :param username: The user who wants to delete their jumpbox :type username: String :param snap_id: The snapshot to destroy :type snap_id: Integer :param machine_name: The name of the virtual machine which owns the snapshot :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: if entity.snapshot: for snap in _get_snapshots( entity.snapshot.rootSnapshotList): snap_data = snap.name.split('_') if snap_data[const.VLAB_SNAP_ID] == snap_id: logger.info('Deleting snapshot {} from {}'.format( snap.name, machine_name)) consume_task( snap.snapshot.RemoveSnapshot_Task( removeChildren=False)) # return exits nested for-loop; break just stop immediate parent loop return None else: error = 'VM has no snapshot by ID {}'.format(snap_id) raise ValueError(error) else: error = 'No VM named {} found in inventory'.format(machine_name) logger.info(error) raise ValueError(error)
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 delete_network(name): """Destroy a vLAN network :Returns: None :Raises: ValueError :param name: The name of the network to destroy :type name: String """ with vCenter(host=const.INF_VCENTER_SERVER, user=const.INF_VCENTER_USER, \ password=const.INF_VCENTER_PASSWORD) as vcenter: try: network = vcenter.networks[name] except KeyError: msg = 'No such vLAN exists: {}'.format(name) raise ValueError(msg) try: task = network.Destroy_Task() consume_task(task, timeout=300) except RuntimeError: msg = "Network {} in use. Must delete VMs using network before deleting network.".format( name) raise ValueError(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}