Runs the process.
179646
def run(self):
    """"""
    # Prevent the KeyboardInterrupt being raised inside the process.
    # This will prevent a process from generating a traceback when interrupted.
    signal.signal(signal.SIGINT, signal.SIG_IGN)

    # A SIGTERM signal handler is necessary to make sure IPC is cleaned up
    # correctly on terminate.
    signal.signal(signal.SIGTERM, self._SigTermHandler)

    # A SIGSEGV signal handler is necessary to try to indicate where
    # worker failed.
    # WARNING the SIGSEGV handler will deadlock the process on a real segfault.
    if self._enable_sigsegv_handler:
      self._original_sigsegv_handler = signal.signal(
          signal.SIGSEGV, self._SigSegvHandler)

    self._pid = os.getpid()
    self._process_information = process_info.ProcessInfo(self._pid)

    # We need to set the is running status explicitly to True in case
    # the process completes before the engine is able to determine
    # the status of the process, e.g. in the unit tests.
    self._status_is_running = True

    # Logging needs to be configured before the first output otherwise we
    # mess up the logging of the parent process.
    loggers.ConfigureLogging(
        debug_output=self._debug_output, filename=self._log_filename,
        quiet_mode=self._quiet_mode)

    logger.debug(
        'Process: {0!s} (PID: {1:d}) started'.format(self._name, self._pid))

    self._StartProcessStatusRPCServer()

    self._Main()

    self._StopProcessStatusRPCServer()

    logger.debug(
        'Process: {0!s} (PID: {1:d}) stopped'.format(self._name, self._pid))

    # Make sure log files are cleanly closed.
    logging.shutdown()

    self._status_is_running = False
289584
def run(self):
        
        self.main_task.thread.start()
        self.main_task.thread.join()
503532
public function run()
	{
		$this->style->getCharacter()->setIsUnderline(
			$this->parameter === null || (bool) $this->parameter
		);
		
		return;
	}
1348880
static public function run()
  {
    foreach (self::$dbs as $db) {
      $db->execute(self::files());
    }

    foreach (self::$writers as $writer) {
      $writer->execute(self::files());
    }
  }
502619
public function run(): void
    {
        foreach ($this->seed as $key => $value) {
            $this->call($this->each, $value, $key);
        }
    }
843359
def run(self):
        

        self._prepare()

        while self.running:
            if self._run() is False:
                break
            time.sleep(self._sleep_period)

        self.shutdown()
878372
public static void run(Process process) {
    try {
      LOG.info("Starting {}.", process);
      process.start();
      LOG.info("Stopping {}.", process);
      System.exit(0);
    } catch (Throwable t) {
      LOG.error("Uncaught exception while running {}, stopping it and exiting.", process, t);
      try {
        process.stop();
      } catch (Throwable t2) {
        // continue to exit
        LOG.error("Uncaught exception while stopping {}, simply exiting.", process, t2);
      }
      System.exit(-1);
    }
  }
1203092
public function run(): void
    {
        $request = $this->kernel->getRequest();

        $response = $this->handle($request);

        $this->emit($response);
    }
834131
def run(self):
        """"""
        if win_based:
            raise NotImplementedError("Please run main_loop, "
                                      "backgrounding not supported on Windows")
        self.background_process = mp.Process(target=self.main_loop)
        self.background_process.start()
1373186
def run(self):
        
        while True:
            path, params = self.path_queue.get()
            errors = run(path, **params)
            self.result_queue.put(errors)
            self.path_queue.task_done()
454086
public function run()
	{
		$this->style->getCharacter()->setIsVisible(
			$this->parameter === null || (bool) $this->parameter
		);
		
		return;
	}
126795
public function run()
    {
        $body = $this->body;
        $content_type = $this->content_type;
        if (!empty($body) && isset($content_type)) {

            if ($this->contentType == $content_type) {
                $this->decode();
            }
        }
    }
588314
def run(self):
        
        try:
            self._loop()
        except Exception:
            # Send the exception through the exc_queue, so the parent
            # process can check it.
            typ, val, tb = sys.exc_info()
            tb_lines = traceback.format_exception(typ, val, tb)
            self.exc_queue.put((val, tb_lines))
354281
public function run()
    {
        if ($data = BotApi::jsonValidate($this->getRawBody(), true)) {
            $this->handle([Update::fromResponse($data)]);
        }
    }
186209
public function run()
    {
        $this->running = true;

        do {
            $hasEvents = $this->tick(true);
        } while ($this->running && $hasEvents);
        $this->running = false;
    }
737978
public function run()
    {
        $process = $this->getProcessExecutor();
        $process->setCommandLine($this->getCommand());

        $logger = function ($error, $line) {
            call_user_func_array(array($this, 'logLine'), array($error, $line));
        };

        return $process->run($logger);
    }
304944
public function run()
    {
        $events = $this->dueEvents(EventReposity::getEvents());

        foreach ($events as $event) {
            $event->execute();
        }
    }