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}
