Run the DCell application in the background
777625
def run!
      Directory[id].actors = local_actors
      Directory[id].pubkey = crypto ? crypto_keys[:pubkey] : nil
      DCell::SupervisionGroup.run!
    end
453895
def start(self):
        """'"""
        self._process = threading.Thread(target=self._background_runner)
        self._process.start()
1141436
def run(self, oneshot=False):
        
        if not self.xbee:
            raise ValueError("Either a serial port or an XBee must be provided \
                             to __init__ to execute run()")

        while True:
            self.dispatch(self.xbee.wait_read_frame())

            if oneshot:
                break
1348738
async def runCmdLoop(self):
        '''
        
        '''
        while not self.isfini:

            # FIXME completion

            self.cmdtask = None

            try:

                line = await self.prompt()
                if not line:
                    continue

                line = line.strip()
                if not line:
                    continue

                coro = self.runCmdLine(line)
                self.cmdtask = self.schedCoro(coro)
                await self.cmdtask

            except KeyboardInterrupt:

                if self.isfini:
                    return

                self.printf('<ctrl-c>')

            except (s_exc.CliFini, EOFError):
                await self.fini()

            except Exception:
                s = traceback.format_exc()
                self.printf(s)

            finally:
                if self.cmdtask is not None:
                    self.cmdtask.cancel()
                    try:
                        self.cmdtask.result()
                    except asyncio.CancelledError:
                        # Wait a beat to let any remaining nodes to print out before we print the prompt
                        await asyncio.sleep(1)
                    except Exception:
                        pass
1297877
def start_app(self, bundle_id):
        '''
        
        '''
        idevicedebug = must_look_exec('idevicedebug')

        # run in background
        kwargs = {'stdout': subprocess.PIPE, 'stderr': subprocess.PIPE}
        if sys.platform != 'darwin':
            kwargs['close_fds'] = True
        return subprocess.Popen([idevicedebug, "--udid", self.udid, 'run', bundle_id], **kwargs)
1157129
def run_locally(self):
        """"""
        self.thread = threading.Thread(target=self.execute_locally)
        self.thread.daemon = True # So that they die when we die
        self.thread.start()
361277
def run(self, background=False):
        """"""
        if self.__bgthread:
            raise Exception('run has already been called (since last stop)')
        self.__shutdown.clear()
        if background:
            self.__bgthread = Thread(target=self.__run, name=('bg_' + self.__client.agent_id))
            self.__bgthread.daemon = True
            self.__bgthread.start()
        else:
            self.__run()
1266511
def run(config):
    ""
    app = make_app(config=config)

    app.run(
            host=app.config.get("HOST", '127.0.0.1'),
            port=app.config.get("PORT", 5000),
            use_reloader=True,
            )
1197244
def run_local(self, commands):
        
        process = subprocess.Popen(
            commands.get('cli_command'),
            shell=self.shell,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
        )

        out, err = process.communicate()

        # display app output
        self.run_display_app_output(out)
        self.run_display_app_errors(err)

        # Exit Code
        return self.run_exit_code(process.returncode)
170703
def run(self):
        """"""
        try:
            while not self.stopped:
                scraperobj = jobs.get(False)
                self.setName(scraperobj.getName())
                try:
                    self.getStrips(scraperobj)
                finally:
                    jobs.task_done()
                    self.setName(self.origname)
        except Empty:
            pass
        except KeyboardInterrupt:
            thread.interrupt_main()
886772
public function runInBackgroundCommand(): void
    {
        $script = '<?php print_r($_SERVER); ?>';
        $ret = Sys::execInBackground("php $script");

        if ($ret === false) {
            $this->output->liteError('current env is not support process create.');
        }
    }
814951
protected function runCommandInBackground()
    {
        $this->callBeforeCallbacks();

        (new Process(
            $this->buildCommand(), base_path(), null, null, null
        ))->run();
    }
1072801
def run_foreground(self, *args, **kwargs):
        
        return self.run_via_binary(foreground=True, default_options=[], *args, **kwargs)
383379
def _run_command(self, cmdline):
        """"""
        try:
            if self.verbose:
                print(cmdline)
            subprocess.check_call(cmdline, shell=True)
        except subprocess.CalledProcessError:
            print('when running: ', cmdline)
            raise
1097246
def run(self):
        
        self._stop = False
        while not self._stop:
            have_sources = self._timers or self._readers or self._writers
            if not self._processor.pending and not have_sources:
                break
            events = QEventLoop.AllEvents
            if not self._processor.pending:
                events |= QEventLoop.WaitForMoreEvents
            self._qapp.processEvents(events)
            if self._processor.pending:
                self._processor.run()
1299095
def run(self):
        """"""
        self.state = True
        self.hm.KeyAll = self.handler
        self.hm.HookKeyboard()
        while self.state:
            time.sleep(0.01)
            pythoncom.PumpWaitingMessages()
710164
def run(self, data_cb):
        """"""
        if self._error:
            err = self._error
            if isinstance(self._error, KeyboardInterrupt):
                # KeyboardInterrupt is not destructive(it may be used in
                # the REPL).
                # After throwing KeyboardInterrupt, cleanup the _error field
                # so the loop may be started again
                self._error = None
            raise err
        self._on_data = data_cb
        if threading.current_thread() == main_thread:
            self._setup_signals([signal.SIGINT, signal.SIGTERM])
        debug('Entering event loop')
        self._run()
        debug('Exited event loop')
        if threading.current_thread() == main_thread:
            self._teardown_signals()
            signal.signal(signal.SIGINT, default_int_handler)
        self._on_data = None