def vb_wait_for_network_address(timeout,
step=None,
machine_name=None,
machine=None,
wait_for_pattern=None):
"""
Wait until a machine has a network address to return or quit after the timeout
@param timeout: in seconds
@type timeout: float
@param step: How regularly we want to check for ips (in seconds)
@type step: float
@param machine_name:
@type machine_name: str
@param machine:
@type machine: IMachine
@type wait_for_pattern: str
@param wait_for_pattern:
@type machine: str
@return:
@rtype: list
"""
kwargs = {
"machine_name": machine_name,
"machine": machine,
"wait_for_pattern": wait_for_pattern,
}
return wait_for(
vb_get_network_addresses,
timeout=timeout,
step=step,
default=[],
func_kwargs=kwargs,
)
def test_wait_for_custom_kwargs(self):
kwargs_after_1s = return_kwargs_after(1)
kwargs = {"one": 1, "two": 2}
ret = wait_for(kwargs_after_1s,
timeout=2,
step=0.5,
func_kwargs=kwargs)
self.assertEqual(ret, kwargs)
def vb_wait_for_session_state(xp_session, state='Unlocked', timeout=10, step=None):
'''
Waits until a session state has been reached, checking at regular intervals.
@param xp_session:
@type xp_session: ISession from the Virtualbox API
@param state: The constant descriptor according to the docs
@type state: str
@param timeout: in seconds
@type timeout: int | float
@param step: Intervals at which the value is checked
@type step: int | float
@return: Did we reach the state?
@rtype: bool
'''
args = (xp_session, state)
wait_for(_check_session_state, timeout=timeout, step=step, default=False, func_args=args)
def vb_start_vm(name=None, timeout=10000, **kwargs):
"""
Tells Virtualbox to start up a VM.
Blocking function!
@param name:
@type name: str
@param timeout: Maximum time in milliseconds to wait or -1 to wait indefinitely
@type timeout: int
@return untreated dict of started VM
"""
# Time tracking
start_time = time.time()
timeout_in_seconds = timeout / 1000
max_time = start_time + timeout_in_seconds
vbox = vb_get_box()
machine = vbox.findMachine(name)
session = _virtualboxManager.getSessionObject(vbox)
log.info("Starting machine %s in state %s", name,
vb_machinestate_to_str(machine.state))
try:
# Keep trying to start a machine
args = (machine, session)
progress = wait_for(_start_machine,
timeout=timeout_in_seconds,
func_args=args)
if not progress:
progress = machine.launchVMProcess(session, "", "")
# We already waited for stuff, don't push it
time_left = max_time - time.time()
progress.waitForCompletion(time_left * 1000)
finally:
_virtualboxManager.closeMachineSession(session)
# The session state should best be unlocked otherwise subsequent calls might cause problems
time_left = max_time - time.time()
vb_wait_for_session_state(session, timeout=time_left)
log.info("Started machine %s", name)
return vb_xpcom_to_attribute_dict(machine, "IMachine")
def vb_wait_for_network_address(timeout, step=None, machine_name=None, machine=None):
'''
Wait until a machine has a network address to return or quit after the timeout
@param timeout: in seconds
@type timeout: float
@param step: How regularly we want to check for ips (in seconds)
@type step: float
@param machine_name:
@type machine_name: str
@param machine:
@type machine: IMachine
@return:
@rtype: list
'''
kwargs = {
'machine_name': machine_name,
'machine': machine
}
return wait_for(vb_get_network_addresses, timeout=timeout, step=step, default=[], func_kwargs=kwargs)
def create(vm_info):
"""
Creates a virtual machine from the given VM information.
This is what is used to request a virtual machine to be created by the
cloud provider, wait for it to become available,
and then (optionally) log in and install Salt on it.
Fires:
"starting create" : This event is tagged salt/cloud/<vm name>/creating.
The payload contains the names of the VM, profile and provider.
@param vm_info
{
name: <str>
profile: <dict>
driver: <provider>:<profile>
clonefrom: <vm_name>
}
@type vm_info dict
@return dict of resulting vm. !!!Passwords can and should be included!!!
"""
try:
# Check for required profile parameters before sending any API calls.
if vm_info['profile'] and config.is_profile_configured(
__opts__, __active_provider_name__ or 'virtualbox',
vm_info['profile']) is False:
return False
except AttributeError:
pass
vm_name = vm_info["name"]
deploy = config.get_cloud_config_value('deploy',
vm_info,
__opts__,
search_global=False,
default=True)
wait_for_ip_timeout = config.get_cloud_config_value('wait_for_ip_timeout',
vm_info,
__opts__,
default=60)
boot_timeout = config.get_cloud_config_value('boot_timeout',
vm_info,
__opts__,
default=60 * 1000)
power = config.get_cloud_config_value('power_on',
vm_info,
__opts__,
default=False)
key_filename = config.get_cloud_config_value('private_key',
vm_info,
__opts__,
search_global=False,
default=None)
log.debug("Going to fire event: starting create")
# to create the virtual machine.
request_kwargs = {
'name': vm_info['name'],
'clone_from': vm_info['clonefrom']
}
vb_stop_vm(vm_info['clonefrom'])
vb_clone_vm(vm_info['name'], vm_info['clonefrom'])
# Booting and deploying if needed
if power:
vb_start_vm(vm_info['name'])
ip = wait_for(vb_get_vm_address,
timeout=60,
step=1,
default=[],
func_kwargs={'name': vm_info['name']})
log.info("[ {0} ] IPv4 is: {1}".format(vm_info['name'], ip))
# ssh or smb using ip and install salt only if deploy is True
if deploy:
vm_info['ssh_host'] = ip
ret = __utils__['cloud.bootstrap'](vm_info, __opts__)
return ret
def test_wait_for_custom_args(self):
args_after_1s = return_args_after(1)
args = ("one", "two")
ret = wait_for(args_after_1s, timeout=2, step=0.5, func_args=args)
self.assertEqual(ret, args)
def test_wait_for_with_big_step(self):
ret = wait_for(self.true_after_1s, timeout=1.5, step=2)
self.assertTrue(ret)
def test_wait_for_too_long(self):
ret = wait_for(self.true_after_1s,
timeout=0.5,
step=0.1,
default=False)
self.assertFalse(ret)
def test_wait_for_self(self):
ret = wait_for(self.self_after_1s, timeout=2, step=0.5)
self.assertEqual(ret, self)
def test_wait_for_self(self):
ret = wait_for(self.self_after_1s, timeout=2, step=0.5)
self.assertEqual(ret, self)
def test_wait_for_custom_kwargs(self):
kwargs_after_1s = return_kwargs_after(1)
kwargs = {"one": 1, "two": 2}
ret = wait_for(kwargs_after_1s, timeout=2, step=0.5, func_kwargs=kwargs)
self.assertEqual(ret, kwargs)
def test_wait_for_custom_args(self):
args_after_1s = return_args_after(1)
args = ("one", "two")
ret = wait_for(args_after_1s, timeout=2, step=0.5, func_args=args)
self.assertEqual(ret, args)
def test_wait_for_with_big_step(self):
ret = wait_for(self.true_after_1s, timeout=1.5, step=2)
self.assertTrue(ret)
def test_wait_for_too_long(self):
ret = wait_for(self.true_after_1s, timeout=0.5, step=0.1, default=False)
self.assertFalse(ret)
def test_wait_for_true(self):
ret = wait_for(self.true_after_1s, timeout=2, step=0.5)
self.assertTrue(ret)
def test_wait_for_true(self):
ret = wait_for(self.true_after_1s, timeout=2, step=0.5)
self.assertTrue(ret)
