Handle the probe.
337263
public void run() {

    ResponseWrapper response = null;

    LOGGER.info("Received probe id: " + probe.getProbeId());

    // Only handle probes that we haven't handled before
    // The Probe Generator needs to send a stream of identical UDP packets
    // to compensate for UDP reliability issues. Therefore, the Responder
    // will likely get more than 1 identical probe. We should ignore
    // duplicates.
    if (!isProbeHandled(probe.getProbeId())) {

      if (this.noBrowser && probe.isNaked()) {
        LOGGER.warn("Responder set to noBrowser mode. Discarding naked probe with id [" + probe.getProbeId() + "]");
      } else {

        for (ProbeHandlerPlugin handler : handlers) {
          response = handler.handleProbeEvent(probe);
          if (!response.isEmpty()) {
            LOGGER.debug("Response to probe [" + probe.getProbeId() + "] includes " + response.numberOfServices());
            Iterator<RespondToURL> respondToURLs = probe.getRespondToURLs().iterator();

            if (probe.getRespondToURLs().isEmpty())
              LOGGER.warn("Processed probe [" + probe.getProbeId() + "] with no respondTo address. That's odd.");

            if (respondToURLs.hasNext()) {
              RespondToURL respondToURL = respondToURLs.next();
              // we are ignoring the label for now
              boolean success = sendResponse(respondToURL.url, probe.getRespondToPayloadType(), response);
              if (!success) {
                LOGGER.warn("Issue sending probe [" + probe.getProbeId() + "] response to [" + respondToURL.url + "]");
              }
            }

          } else {
            LOGGER.error("Response to probe [" + probe.getProbeId() + "] is empty.  Not sending empty response.");
          }
        }

      }

      markProbeAsHandled(probe.getProbeId());

      responder.probeProcessed();

    } else {
      LOGGER.info("Discarding duplicate/handled probe with id: " + probe.getProbeId());
    }
  }
249881
def handle(self, msg):
        """"""
        debug_msg = ': {!r}'.format(msg) if self.debug else ''
        log.debug('request: %d bytes%s', len(msg), debug_msg)
        buf = io.BytesIO(msg)
        code, = util.recv(buf, '>B')
        if code not in self.methods:
            log.warning('Unsupported command: %s (%d)', msg_name(code), code)
            return failure()

        method = self.methods[code]
        log.debug('calling %s()', method.__name__)
        reply = method(buf=buf)
        debug_reply = ': {!r}'.format(reply) if self.debug else ''
        log.debug('reply: %d bytes%s', len(reply), debug_reply)
        return reply
349662
def handle(self):
        
        self.output = PyStratumStyle(self.input, self.output)

        command = self.get_application().find('constants')
        ret = command.execute(self.input, self.output)
        if ret:
            return ret

        command = self.get_application().find('loader')
        ret = command.execute(self.input, self.output)
        if ret:
            return ret

        command = self.get_application().find('wrapper')
        ret = command.execute(self.input, self.output)

        self.output.writeln('')

        return ret
1093801
def handle(self):
        """"""
        data = cPickle.load(self.rfile)  # pylint: disable=E1101
        method = data.pop('method')
        try:
            retval = getattr(self, 'do_{0}'.format(method))(**data)
        except Exception as e:
            # All exceptions should be passed to the client
            retval = e
        cPickle.dump(retval, self.wfile,  # pylint: disable=E1101
                     cPickle.HIGHEST_PROTOCOL)
1093683
private void handleBrowse() {
		ContainerSelectionDialog dialog = new ContainerSelectionDialog(
				getShell(), ResourcesPlugin.getWorkspace().getRoot(), false,
				"Select new file container");
		if (dialog.open() == ContainerSelectionDialog.OK) {
			Object[] result = dialog.getResult();
			if (result.length == 1) {
				projectText.setText(((Path) result[0]).toString());
			}
		}
	}
899202
public void handleSuccess ()
    {
        if (_listener instanceof InvocationService.ConfirmListener) {
            reportRequestProcessed();
        } else if (_listener instanceof InvocationService.ResultListener && _resultSet) {
            reportRequestProcessed(_result);
        }
    }
957369
def handle(self, addrport='', *args, **options):
        """"""
        server = WebserverThread(addrport, *args, **options)
        server.start()
        options['camera'] = 'djcelery.snapshot.Camera'
        options['prog_name'] = 'djcelerymon'
        ev.run(*args, **options)
410448
function Probe(connection, done) {
  if (!(this instanceof Probe)) {
    return new Probe(connection, done);
  }

  if (typeof connection === 'string') {
    connection = Connection.from(
      Deployment.getId(connection));
  }
  debug('connection is `%j`', connection);

  this.deployment = new Deployment({
    _id: Instance.getId(connection.getId()),
    name: connection.name
  });

  this.connection = connection;

  this.db = null;
  this.metadata = null;

  if (typeof done === 'function') {
    this.exec(done);
  }
}
1105107
def handle(self):
        
        while True:
            toRead = select.select([self.local, self.remote], [], [], 0.1)[0]
            if self.local in toRead:
                data = os.read(self.local, 4096)
                self.sock.sendall(data)
                continue
            if self.remote in toRead or self.rawq:
                buf = self.read_eager()
                os.write(self.local, buf)
                continue
1195994
def handle(self, *args, **kwargs):
        """"""
        listener = ExecutorListener(redis_params=getattr(settings, 'FLOW_MANAGER', {}).get('REDIS_CONNECTION', {}))

        def _killer(signum, frame):
            """Kill the listener on receipt of a signal."""
            listener.terminate()
        signal(SIGINT, _killer)
        signal(SIGTERM, _killer)

        async def _runner():
            """Run the listener instance."""
            if kwargs['clear_queue']:
                await listener.clear_queue()
            async with listener:
                pass

        loop = asyncio.new_event_loop()
        loop.run_until_complete(_runner())
        loop.close()
361172
def handle_signal(self, sig, frame):
        """"""
        if sig in [signal.SIGINT]:
            log.warning("Ctrl-C pressed, shutting down...")
        if sig in [signal.SIGTERM]:
            log.warning("SIGTERM received, shutting down...")
        self.cleanup()
        sys.exit(-sig)
1258715
def handle(self):
        """"""
        rv = None
        try:
            rv = BaseHTTPRequestHandler.handle(self)
        except (_ConnectionError, socket.timeout) as e:
            self.connection_dropped(e)
        except Exception as e:
            if self.server.ssl_context is None or not is_ssl_error(e):
                raise
        if self.server.shutdown_signal:
            self.initiate_shutdown()
        return rv
1067796
public function handle()
    {
        if (! $this->confirmToProceed()) {
            return;
        }

        $this->resolver->setDefaultConnection($this->getDatabase());

        Model::unguarded(function () {
            $this->getSeeder()->__invoke();
        });

        $this->info('Database seeding completed successfully.');
    }
1115716
def handle(self):
    """"""
    # Get and verify mr state.
    mr_id = self.request.get("mapreduce_id")
    # Log the mr_id since this is started in an unnamed task
    logging.info("Processing kickoff for job %s", mr_id)
    state = model.MapreduceState.get_by_job_id(mr_id)
    if not self._check_mr_state(state, mr_id):
      return

    # Create input readers.
    readers, serialized_readers_entity = self._get_input_readers(state)
    if readers is None:
      # We don't have any data. Finish map.
      logging.warning("Found no mapper input data to process.")
      state.active = False
      state.result_status = model.MapreduceState.RESULT_SUCCESS
      ControllerCallbackHandler._finalize_job(
          state.mapreduce_spec, state)
      return False

    # Create output writers.
    self._setup_output_writer(state)

    # Save states and make sure we use the saved input readers for
    # subsequent operations.
    result = self._save_states(state, serialized_readers_entity)
    if result is None:
      readers, _ = self._get_input_readers(state)
    elif not result:
      return

    queue_name = self.request.headers.get("X-AppEngine-QueueName")
    KickOffJobHandler._schedule_shards(state.mapreduce_spec, readers,
                                       queue_name,
                                       state.mapreduce_spec.params["base_path"],
                                       state)

    ControllerCallbackHandler.reschedule(
        state, state.mapreduce_spec, serial_id=0, queue_name=queue_name)
827062
public function handle()
    {
        try {
            $options = array(
                'server' => $this->option('server'),
                'repo' => $this->option('repo')
            );

            $maneuver = new Maneuver($options);
            $maneuver->mode(Maneuver::MODE_LIST);
            $maneuver->start();
        }
        catch (Exception $e) {
            $this->error($e->getMessage());
        }
    }
823593
public function handle()
    {
        $queue = trim($this->argument('queue'));

        $this->listener = $this->di->get(Listener::class, [$queue]);

        $this->listenForEvents();

        $this->runWorker();
    }
336133
public function handle()
    {
        $this->migrator->setVerbose($this->option('debug'));
        $this->migrator->migrate($this->argument('filters'));
    }