Starts an interrogation hunt on all available clients.
345440
def StartInterrogationHunt(self):
    """"""
    flow_name = compatibility.GetName(flows_discovery.Interrogate)
    flow_args = flows_discovery.InterrogateArgs(lightweight=False)
    description = "Interrogate run by cron to keep host info fresh."

    if data_store.RelationalDBEnabled():
      hunt_id = hunt.CreateAndStartHunt(
          flow_name,
          flow_args,
          self.token.username,
          client_limit=0,
          client_rate=50,
          crash_limit=config.CONFIG["Cron.interrogate_crash_limit"],
          description=description,
          duration=rdfvalue.Duration("1w"),
          output_plugins=self.GetOutputPlugins())
      self.Log("Started hunt %s.", hunt_id)
    else:
      with hunts_implementation.StartHunt(
          hunt_name=hunts_standard.GenericHunt.__name__,
          client_limit=0,
          flow_runner_args=rdf_flow_runner.FlowRunnerArgs(flow_name=flow_name),
          flow_args=flow_args,
          output_plugins=self.GetOutputPlugins(),
          crash_limit=config.CONFIG["Cron.interrogate_crash_limit"],
          client_rate=50,
          expiry_time=rdfvalue.Duration("1w"),
          description=description,
          token=self.token) as hunt_obj:

        hunt_obj.GetRunner().Start()
        self.Log("Started hunt %s.", hunt_obj.urn)
753107
def request_check_all(self, wait_time=5):
        """"""
        with self._lock:
            self._request_check_all()
            self._condition.wait(wait_time)
925169
def recruit(spy)
      raise AlreadyStubbedError if @spies[spy.object_id]
      check_spy!(spy)
      @spies[spy.object_id] = spy
    end
1065782
def recruit(self, n=1):
        """"""
        logger.info("Recruiting {} CLI participants".format(n))
        urls = []
        template = "{}/ad?recruiter={}&assignmentId={}&hitId={}&workerId={}&mode={}"
        for i in range(n):
            ad_url = template.format(
                get_base_url(),
                self.nickname,
                generate_random_id(),
                generate_random_id(),
                generate_random_id(),
                self._get_mode(),
            )
            logger.info("{} {}".format(NEW_RECRUIT_LOG_PREFIX, ad_url))
            urls.append(ad_url)

        return urls
807197
def _EnsureRequesterStarted(self):
    """"""
    if not self._analyzer_started:
      self._analyzer.start()
      self._analyzer_started = True
199931
public function start()
    {
        foreach ($this->callbacks as $event => $callback) {
            $this->client->on($event, $callback);
        }
        $this->connect();
    }
596280
def _handle(self, nick, target, message, **kwargs):
        
        for regex, (func, pattern) in self.routes.items():
            match = regex.match(message)
            if match:
                self.client.loop.create_task(
                    func(nick, target, message, match, **kwargs))
615460
public function startup()
	{
		$this->out(__d('Auditable', 'Cake Auditable Shell'));
		$this->hr();

		if (!empty($this->params['connection']))
			$this->connection = $this->params['connection'];
	}
376229
def recruit_participants(self, n=1, exp=None):
        """"""
        for i in xrange(n):
            newcomer = exp.agent_type()
            exp.newcomer_arrival_trigger(newcomer)
89063
protected function startQuery()
    {
        $sessionOK = $this->initialiseSession();
        if ($sessionOK) {
            $searchReplyString = $this->fetchURL($this->pazpar2SearchURL());
            $searchReply = GeneralUtility::xml2array($searchReplyString);

            if ($searchReply) {
                $status = $searchReply['status'];
                if ($status === 'OK') {
                    $this->queryIsRunning = true;
                } else {
                    GeneralUtility::devLog('pazpar2 search command status is not "OK" but "' . $status . '"', 'pazpar2', 3);
                }
            } else {
                GeneralUtility::devLog('could not parse pazpar2 search reply', 'pazpar2', 3);
            }
        }
    }
270971
def tick_clients(self):
        """"""
        if not self._ticker:
            self._create_ticker()

        for client in self.clients.values():
            self._ticker.tick(client)
854634
def start(self):
        """"""
        self.agent.submit(self._start())
        self.is_running = True
63870
def build_and_start(query, directory):
    """"""

    Async(target=grep, args=[query, directory]).start()
794247
def Start(self):
    """"""
    self.CallClient(
        server_stubs.PlistQuery,
        request=self.args.request,
        next_state="Receive")
1276679
public function startup() {
        if ($this->_blacklist) {
            return;
        }

        // Load files from config paths
        foreach ($this->getParser()->getPaths() as $path) {
            foreach (glob($path . 'censored.*') as $file) {
                $this->addLoader(new FileLoader($file));
            }
        }

        // Load the contents into the blacklist
        foreach ($this->getLoaders() as $loader) {
            $loader->setParser($this->getParser());

            if ($blacklist = $loader->load()) {
                $this->blacklist($blacklist);
            }
        }
    }
332758
def start(self):
        """"""
        self.zap_socket = self.context.socket(zmq.REP)
        self.zap_socket.linger = 1
        zapLoc = 'inproc://zeromq.zap.{}'.format(MultiZapAuthenticator.count)
        self.zap_socket.bind(zapLoc)
        self.log.debug('Starting ZAP at {}'.format(zapLoc))
550464
@Override
    protected void doStart() {
        log.info("{}: Starting.", this.traceObjectId);

        Services.startAsync(this.durableLog, this.executor)
                .thenComposeAsync(v -> startWhenDurableLogOnline(), this.executor)
                .whenComplete((v, ex) -> {
                    if (ex == null) {
                        // We are started and ready to accept requests when DurableLog starts. All other (secondary) services
                        // are not required for accepting new operations and can still start in the background.
                        notifyStarted();
                    } else {
                        doStop(ex);
                    }
                });
    }