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_true(self): ret = wait_for(self.true_after_1s, timeout=2, step=0.5) self.assertTrue(ret)