def test_session(disconnect, connect):
connection(
vcdriver_username='******', vcdriver_password='******',
vcdriver_host='something', vcdriver_port='something'
)
connection(
vcdriver_username='******', vcdriver_password='******',
vcdriver_host='something', vcdriver_port='something'
)
id()
close()
close()
assert connect.call_count == 1
assert disconnect.call_count == 1
def refresh(self):
""" Close session and create a new session """
if self._vm_object:
close()
# Refresh object with updated data (connection id changed)
self._vm_object = get_vcenter_object_by_name(
connection(), vim.VirtualMachine, self.name)
def create(self, **kwargs):
""" Create the virtual machine and update the vm object """
conn = connection()
if not self._vm_object:
data_store_name = kwargs['vcdriver_data_store']
data_store = get_vcenter_object_by_name(conn, vim.Datastore,
data_store_name)
capacity = float(data_store.summary.capacity)
free_space = float(data_store.summary.freeSpace)
free_percentage = 100 * free_space / capacity
threshold = kwargs['vcdriver_data_store_threshold']
if free_percentage < float(threshold):
raise NotEnoughDiskSpace(data_store_name, threshold,
free_percentage)
self._vm_object = wait_for_vcenter_task(
get_vcenter_object_by_name(
conn, vim.VirtualMachine, self.template).CloneVM_Task(
folder=get_vcenter_object_by_name(
conn, vim.Folder, kwargs['vcdriver_folder']),
name=self.name,
spec=vim.vm.CloneSpec(location=vim.vm.RelocateSpec(
datastore=data_store,
pool=get_vcenter_object_by_name(
conn, vim.ResourcePool,
kwargs['vcdriver_resource_pool'])),
powerOn=True,
template=False)),
'Create virtual machine "{}" from template "{}"'.format(
self.name, self.template), self.timeout)
def _schedule_vcenter_task_on_vm(self, task, task_name, delay_by):
"""
:param task: A vcenter task method
:param task_description: The task description
:param delay_by: if specified, it has to be a timedelta that indicates
when in the future this task will be executed.
"""
if not isinstance(delay_by, datetime.timedelta):
raise TypeError(
"Invalid type for delay_by. Expected datetime.timedelta.")
spec = vim.scheduler.ScheduledTaskSpec()
spec.name = task_name
spec.description = ""
spec.scheduler = vim.scheduler.OnceTaskScheduler()
# it seems that CreateScheduledTask will add timezone without
# converting it, so if you use utcnow here you may end up to
# scheduling 1 hour in the past when BST is active
spec.scheduler.runAt = datetime.datetime.now() + delay_by
spec.action = vim.action.MethodAction()
spec.action.name = task
spec.enabled = True
conn = connection()
conn.content.scheduledTaskManager.CreateScheduledTask(
self._vm_object, spec)
def get_all_virtual_machines():
"""
Get all the virtual machines from your Vcenter Instance.
It will update both the internal _vm_object and the name.
:return: A list with all the VirtualMachine objects
"""
machines = []
for vm_object in get_all_vcenter_objects(connection(), vim.VirtualMachine):
machine = VirtualMachine()
machine.__setattr__('_vm_object', vm_object)
machine.name = vm_object.summary.config.name
machines.append(machine)
return machines
def destroy_virtual_machines(folder_name, timeout=600):
"""
Destroy all the virtual machines in the folder with the given name
:param folder_name: The folder name
:param timeout: The timeout for vcenter tasks in seconds
:return: A list with the destroyed vms
"""
folder = get_vcenter_object_by_name(connection(), vim.Folder, folder_name)
destroyed_vms = []
for entity in folder.childEntity:
if isinstance(entity, vim.VirtualMachine):
vm = VirtualMachine(name=entity.summary.config.name,
timeout=timeout)
vm.__setattr__('_vm_object', entity)
vm.destroy()
destroyed_vms.append(vm)
return destroyed_vms
def find(self):
""" Find and update the vm object based on the name """
if not self._vm_object:
self._vm_object = get_vcenter_object_by_name(
connection(), vim.VirtualMachine, self.name)