Resumes this QEMU VM.
8205
def resume(self):
        

        vm_status = yield from self._get_vm_status()
        if vm_status is None:
            raise QemuError("Resuming a QEMU VM is not supported")
        elif vm_status == "paused":
            yield from self._control_vm("cont")
            log.debug("QEMU VM has been resumed")
        else:
            log.info("QEMU VM is not paused to be resumed, current status is {}".format(vm_status))
1056671
def stop_vm(self):
        
        if self.vagrant is not None:
            if self.destroy:
                self.vagrant.destroy()
                shutil.rmtree(self.vagrant.root, ignore_errors=True)
                self.vagrant = None
            else:
                self.vagrant.halt()
942781
def resume(name, call=None, session=None):
    '''
    

    '''
    if call == 'function':
        raise SaltCloudException(
            'The show_instnce function must be called with -a or --action.'
        )
    if session is None:
        session = _get_session()
    log.info('Resuming VM %s', name)
    vm = _get_vm(name, session)
    task = session.xenapi.Async.VM.resume(vm, False, True)
    _run_async_task(task, session)
    return show_instance(name)
584141
def guest_reboot(self, userid):
        """"""
        LOG.info("Begin to reboot vm %s", userid)
        self._smtclient.guest_reboot(userid)
        LOG.info("Complete reboot vm %s", userid)
399883
def resume(self, vehID):
        
        self._connection._beginMessage(
            tc.CMD_SET_VEHICLE_VARIABLE, tc.CMD_RESUME, vehID, 1 + 4)
        self._connection._string += struct.pack("!Bi", tc.TYPE_COMPOUND, 0)
        self._connection._sendExact()
1047393
def resume(instance_id, profile=None, **kwargs):
    '''
    

    '''
    conn = _auth(profile, **kwargs)
    return conn.resume(instance_id)
733369
def resume(jid, state_id=None):
    '''
    
    '''
    minion = salt.minion.MasterMinion(__opts__)
    minion.functions['state.resume'](jid, state_id)
762256
def suspend(self):
        

        if self.is_running():
            vm_status = yield from self._get_vm_status()
            if vm_status is None:
                raise QemuError("Suspending a QEMU VM is not supported")
            elif vm_status == "running" or vm_status == "prelaunch":
                yield from self._control_vm("stop")
                self.status = "suspended"
                log.debug("QEMU VM has been suspended")
            else:
                log.info("QEMU VM is not running to be suspended, current status is {}".format(vm_status))
611031
def resume_trial(self, trial):
        """"""

        assert trial.status == Trial.PAUSED, trial.status
        self.start_trial(trial)
310014
def resume(self, mask, filename, port, pos):
        """"""
        self.connections['send']['masks'][mask][port].offset = pos
        message = 'DCC ACCEPT %s %d %d' % (filename, port, pos)
        self.bot.ctcp(mask, message)
518326
def reboot(name, call=None, session=None):
    '''
    

    '''
    if call == 'function':
        raise SaltCloudException(
            'The show_instnce function must be called with -a or --action.'
        )
    if session is None:
        session = _get_session()
    log.info('Starting VM %s', name)
    vm = _get_vm(name, session)
    power_state = session.xenapi.VM.get_power_state(vm)
    if power_state == 'Running':
        task = session.xenapi.Async.VM.clean_reboot(vm)
        _run_async_task(task, session)
        return show_instance(name)
    else:
        return '{} is not running to be rebooted'.format(name)
708662
def start(name):
    '''
    
    '''
    ret = {}
    cmd = '{0} startvm {1}'.format(vboxcmd(), name)
    ret = salt.modules.cmdmod.run(cmd).splitlines()
    return ret
361645
def restart(self, *args, **kw):
        """"""
        self.stop()
        self.start(*args, **kw)
1197085
def start(self):
        # type: (SyncCopy) -> None
        
        try:
            blobxfer.operations.progress.output_parameters(
                self._general_options, self._spec)
            self._run()
        except (KeyboardInterrupt, Exception) as ex:
            if isinstance(ex, KeyboardInterrupt):
                logger.info(
                    'KeyboardInterrupt detected, force terminating '
                    'processes and threads (this may take a while)...')
            else:
                logger.exception(ex)
            self._wait_for_transfer_threads(terminate=True)
        finally:
            # close resume file
            if self._resume is not None:
                self._resume.close()
629591
function resume() {
  this._paused = false;
  if(this.client._qbuf.length) {
    this.data(this.client._qbuf);
    this.client._qbuf = new Buffer(0);
  }
}
1268784
function resume (instance, state) {
  if (instance.__hibernated) {
    instance.__hibernated = false
  } else {
    // initialize memory
    const mem = instance.exports[`${state.symbol}memory`]
    if (mem) {
      (new Uint32Array(mem.buffer)).set(state.memory, 0)
    }

    // initialize table
    if (instance.exports._table) {
      for (const index in state.table) {
        const funcIndex = state.table[index]
        instance.exports._table.set(index, instance.exports[`${state.symbol}func_${funcIndex}`])
      }
    }

    // initialize globals
    for (const index in state.globals) {
      const val = state.globals[index]
      if (val !== undefined) {
        if (Array.isArray(val)) {
          instance.exports[`${state.symbol}global_setter_i64_${index}`](val[1], val[0])
        } else {
          instance.exports[`${state.symbol}global_setter_i32_${index}`](val)
        }
      }
    }
  }
  return instance
}
378978
def reset(vm_):
    '''
    
    '''
    with _get_xapi_session() as xapi:
        vm_uuid = _get_label_uuid(xapi, 'VM', vm_)
        if vm_uuid is False:
            return False
        try:
            xapi.VM.hard_reboot(vm_uuid)
            return True
        except Exception:
            return False