Start the command process loop.
432060
def start(self):
        """"""
        self.loop.create_task(self._read_line())
        self.loop.create_task(self._greeting())
1065511
def start(self):
		""""""
		if self._send_greenlet is None:
			self._send_greenlet = gevent.spawn(self._send_loop)
1159248
def start(self):
        """"""
        self.run_task = self.pyvlx.loop.create_task(
            self.loop())
857637
def start(self):
        
        if self.pid is not None:

            LOG.error(
                "The process is already running with pid {0}.".format(self.pid)
            )
            sys.exit(exit.ALREADY_RUNNING)

        self.daemonize()

        LOG.info("Beginning run loop for process.")
        try:

            self.run()

        except Exception:

            LOG.exception("Uncaught exception in the daemon run() method.")
            self.stop()
            sys.exit(exit.RUN_FAILURE)
849235
def start(self):
        '''
        
        '''
        # invoke the appropriate sub-command as requested from command-line
        try:
            self.args.func()
        except SystemExit as e:
            if e.code != 0:
                raise
        except KeyboardInterrupt:
            self.log.warning("exited via keyboard interrupt")
        except:
            self.log.exception("exited start function")
            # set exit code so we know it did not end successfully
            # TODO different exit codes based on signals ?
        finally:
            self._flush_metrics_q.put(None, block=True)
            self._flush_metrics_q.put(None, block=True, timeout=1)

        self.log.debug("exited_successfully")
1087980
def _run_cmd(cmds):
    """"""
    if not isinstance(cmds, str):
        cmds = "".join(cmds)
    print("Execute \"%s\"" % cmds)
    try:
        subprocess.check_call(cmds, shell=True)
    except subprocess.CalledProcessError as err:
        print(err)
        raise err
54056
void startProcess(boolean squelch) throws IOException {
        LOGGER.entering(squelch);

        if (!squelch) {
            LOGGER.fine("Executing command " + cmdLine.toString());
        }

        watchdog.reset();
        DefaultExecutor executor = new DefaultExecutor();
        executor.setWatchdog(watchdog);
        executor.setStreamHandler(new PumpStreamHandler());
        executor.setProcessDestroyer(new ShutdownHookProcessDestroyer());
        handler = new DefaultExecuteResultHandler();
        executor.execute(cmdLine, handler);

        LOGGER.exiting();
    }
794247
def Start(self):
    """"""
    self.CallClient(
        server_stubs.PlistQuery,
        request=self.args.request,
        next_state="Receive")
1237740
def run_loop(self):
        
        self.root_command.prog = ''
        history_file = self.load_history()
        rendering.vtmlprint(self.intro)
        try:
            self.loop()
        finally:
            readline.write_history_file(history_file)
899696
public function start()
    {
        $pipes = [];

        $this->process = call_user_func_array(
            $this->resourceOpen,
            [$this->executable, self::$descriptorspec, &$pipes]
        );

        // make output and error streams non-blocking streams
        stream_set_blocking($pipes[1], 0);
        stream_set_blocking($pipes[2], 0);

        $this->pipes = $pipes;
        $this->started = true;
    }
930399
def execute(self, command):
        '''
        
        '''
        process = Popen(command, stdout=PIPE, stderr=STDOUT, universal_newlines=True)
        while True:
            if process.poll() is not None:
                self.returncode = process.returncode  # pylint: disable=W0201
                break
            yield process.stdout.readline()
942953
public void startListening() {
        if (listenForCommands) {
            listeningThread = new Thread("kernel-command-listener") {
                @Override
                public void run() {
                    while (listenForCommands && acceptAndExecuteCommand()) {
                        //loop intentionally empty
                    }
                }
            };
            listeningThread.start();
        }
    }
248251
public function start()
    {
        $cmd = 'app/console ' . $this->workerCommand;
        if ($this->tube != '') {
            $cmd .= ' --use-tube=' . escapeshellarg($this->tube);
        }
        if ($this->parent->isVerbose()) {
            $cmd .= ' -vvvv';
        }
        $this->startTime = time();
        $this->parent->verboseOutput('<info>Starting:</info>' . $cmd);
        $this->process = new Process('exec ' . $cmd, $this->consolePath, null, null, null);
        $this->process->start();
        if ($this->process->isRunning()) {
            $this->status = ChildProcessContainer::STATUS_ALIVE;
        } else {
            $this->status = ChildProcessContainer::STATUS_DEAD;
        }
    }
311826
def run_cmd(command, verbose=True, shell='/bin/bash'):
    """"""
    process = Popen(command, shell=True, stdout=PIPE, stderr=STDOUT, executable=shell)
    output = process.stdout.read().decode().strip().split('\n')
    if verbose:
        # return full output including empty lines
        return output
    return [line for line in output if line.strip()]
843407
def start_program(self, turn_on_load=True):
        
        self.__set_buffer_start(self.CMD_START_PROG)
        self.__set_checksum()
        self.__send_buffer()
        # Turn on Load if not on
        if turn_on_load and not self.load_on:
            self.load_on = True
425155
def _start(self, request_id, docs):
        """"""
        cmd = self.command.copy()
        cmd[self.field] = docs
        self.listeners.publish_command_start(
            cmd, self.db_name,
            request_id, self.sock_info.address, self.op_id)
        return cmd
750751
def loop_start(self):
        
        if self._thread is not None:
            return MQTT_ERR_INVAL

        self._thread_terminate = False
        self._thread = threading.Thread(target=self._thread_main)
        self._thread.daemon = True
        self._thread.start()