Resumes normal operation

        Parameters:
            reason (str): Reason of enabling
        Returns:
            bool: ``True`` on success
497662
async def enable(self, reason=None):
        
        params = {"enable": False, "reason": reason}
        response = await self._api.put("/v1/agent/maintenance", params=params)
        return response.status == 200
1047393
def resume(instance_id, profile=None, **kwargs):
    '''
    

    '''
    conn = _auth(profile, **kwargs)
    return conn.resume(instance_id)
1367017
def can_resume(self):
        """"""
        # TOCHECK relies on generator.gi_frame
        # Equivalent to `inspect.getgeneratorstate(self.generator) in
        # (inspect.GEN_CREATED, inspect.GEN_SUSPENDED)`,
        # which is only available starting 3.2.
        gen = self.generator
        return (gen is not None
                and not gen.gi_running
                and gen.gi_frame is not None)
1357128
def reactivate(self):
        
        self._protocol.connectionLost(None)
        self._protocol = None
        self.terminal.reset()
        self._window.filthy()
        self._window.repaint()
353151
def pause_resume(self):
        """"""
        if self.is_paused():
            urlopen(self.url + "&mode=resume")
        else:
            urlopen(self.url + "&mode=pause")
411039
def resume(self, unique_id, configs=None):
    
    self._send_signal(unique_id, signal.SIGCONT,configs)
274551
def restart(ctx, **kwargs):
    
    update_context(ctx, kwargs)

    daemon = mk_daemon(ctx)
    daemon.stop()
    daemon.start()
1227070
def enable_disable(self):
        
        if self.enabled:
            self.update(enabled=False)
        else:
            self.update(enabled=True)
474976
async def trigger(self, event, kwargs):
        
        await self._queue.put((event, kwargs))
        self._resume_processing.set()
183051
def enable(name, **kwargs):
    '''
    
    '''
    if _service_is_upstart(name):
        return _upstart_enable(name)
    executable = _get_service_exec()
    cmd = '{0} -f {1} defaults'.format(executable, name)
    return not __salt__['cmd.retcode'](cmd, python_shell=False)
366718
def on_ok(self):
        
        if self.dir_select.value:
            npyscreen.notify_wait('In the process of restoring',
                                  title='Restoring...')
            status = self.restore(self.dirs[self.dir_select.value[0]])
            if status[0]:
                npyscreen.notify_confirm('Status of restore:\n' +
                                         status[1])
            else:
                npyscreen.notify_confirm(status[1])
            self.quit()
        else:
            npyscreen.notify_confirm('Choose a version to restore from')
234103
def reset(self):
        
        self._options = {}
        self.save(force=True)
        self._success = True
611031
def resume_trial(self, trial):
        """"""

        assert trial.status == Trial.PAUSED, trial.status
        self.start_trial(trial)
142814
def resume(self, trigger_duration=0):
        """"""
        if trigger_duration != 0:
            self._mq.send("t%d" % trigger_duration, True, type=1)
        else:
            self._mq.send("r", True, type=1)
        self._paused = False
798640
def _resume(self):
        """"""
        try:
            self._cursor.close()
        except PyMongoError:
            pass
        self._cursor = self._create_cursor()
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))
736056
def reset(self, mode=InputMode.INSERT):
        
        # Go back to insert mode.
        self.input_mode = mode

        self.waiting_for_digraph = False
        self.operator_func = None
        self.operator_arg = None