Logs a message warning a routing process had end.
484935
protected function logRouteCompletion()
    {
        $executionTime = microtime(true) - $this->executionStart;

        $logger = Strata::app()->getLogger();
        if ($logger) {
            $logger->logContextEnd(sprintf("Done in %s seconds", round($executionTime, 4)), "<green>Route</green>");
        }
    }
967092
def _termination_callback(self, returncode):
        

        log.info("uBridge process has stopped, return code: %d", returncode)
        if returncode != 0:
            self._project.emit("log.error", {"message": "uBridge process has stopped, return code: {}\n{}".format(returncode, self.read_stdout())})
701454
def parse_band_request_termination(self, message):
        """"""
        self.log.debug("Service requests termination")
        self._terminate_service()
        if not self.restart_service:
            self.shutdown = True
1374536
def end_step(self, lineno, timestamp=None, result_code=None):
        """"""
        self.state = self.STATES['step_finished']
        step_errors = self.sub_parser.get_artifact()
        step_error_count = len(step_errors)
        if step_error_count > settings.PARSER_MAX_STEP_ERROR_LINES:
            step_errors = step_errors[:settings.PARSER_MAX_STEP_ERROR_LINES]
            self.artifact["errors_truncated"] = True
        self.current_step.update({
            "finished": timestamp,
            "finished_linenumber": lineno,
            # Whilst the result code is present on both the start and end buildbot-style step
            # markers, for Taskcluster logs the start marker line lies about the result, since
            # the log output is unbuffered, so Taskcluster does not know the real result at
            # that point. As such, we only set the result when ending a step.
            "result": self.RESULT_DICT.get(result_code, "unknown"),
            "errors": step_errors
        })
        # reset the sub_parser for the next step
        self.sub_parser.clear()
228950
def die(*messages):
    
    sys.stderr.write("%s.%s: " % get_caller_info(trace=True))
    sys.stderr.write(' '.join(map(str, messages)))
    sys.stderr.write('\n')
    sys.exit(1)
78027
def _handle_terminate(self, signal_number, _):
        """"""
        signal_names = {
            signal.SIGINT: 'SIGINT',
            signal.SIGQUIT: 'SIGQUIT',
            signal.SIGTERM: 'SIGTERM',
        }
        message = 'Terminated by {name} ({number})'.format(
            name=signal_names[signal_number], number=signal_number)
        self._shutdown(message, code=128+signal_number)
280521
def end_log_task(task, logger=logging, level='info'):
    
    getattr(logger, level)(END_TASK_TRIGGER_MSG % task)
455855
def _process_outgoing_msg(self, sink_iter):
        
        LOG.debug('NetworkController processing outgoing request list.')
        # TODO(PH): We should try not to sent routes from bgp peer that is not
        # in established state.
        from ryu.services.protocols.bgp.model import (
            FlexinetOutgoingRoute)
        while self.is_connected:
            # sink iter is Sink instance and next is blocking so this isn't
            # active wait.
            for outgoing_msg in sink_iter:
                if not self.is_connected:
                    self._socket.close()
                    return
                if isinstance(outgoing_msg, FlexinetOutgoingRoute):
                    rpc_msg = _create_prefix_notification(outgoing_msg, self)
                else:
                    raise NotImplementedError(
                        'Do not handle out going message of type %s' %
                        outgoing_msg.__class__)
                if rpc_msg:
                    self._sendall(rpc_msg)
            self.pause(0)

        # Stop incoming connection.
        if self.green_in:
            self.green_in.kill()
1182109
def final():
    """"""
    if DEBUG:
        print("Cleaning up message queues", queues)
        print("Cleaning up processes", procs)
    for q in queues:
        q.remove()
    for proc in procs:
        proc.terminate()
911036
def log_message(self, kind, alert):
        """"""
        if kind == 'ERROR':
            logging.error(alert)
        else:
            logging.warning(alert)
        return
100332
def finished(cls, jobid):
        """"""
        output = subprocess.check_output(
            [SACCT, '-n', '-X', '-o', "end", '-j', str(jobid)]
        )
        end = output.strip().decode()
        return end not in {'Unknown', ''}
564957
def ending_long_process(self, message=""):
        
        QApplication.restoreOverrideCursor()
        self.show_message(message, timeout=2000)
        QApplication.processEvents()
547622
def processEnded(self, status):
        
        self.cleanup()

        if status.value.exitCode is None:
            if self._did_timeout:
                err = RuntimeError("Timeout waiting for Tor launch.")
            else:
                err = RuntimeError(
                    "Tor was killed (%s)." % status.value.signal)
        else:
            err = RuntimeError(
                "Tor exited with error-code %d" % status.value.exitCode)

        # hmmm, this log() should probably go away...not always an
        # error (e.g. .quit()
        log.err(err)
        self._maybe_notify_connected(Failure(err))
941168
public void markSendFailed() {
    overall_stats.put(QueryStat.TOTAL_TIME, DateTime.nanoTime() - query_start_ns);
    LOG.info("Completing query=" + JSON.serializeToString(this));
    QUERY_LOG.info(this.toString());
  }
262226
def log (self, msg, prefix=None):
    """"""
    if prefix:
      if not prefix.strip().endswith(':'):
        prefix += ': '
      msg = prefix + msg
    self.messages.append(msg)
1114942
def end_log_output(self, **kwargs):
        """"""
        kwargs.update(dict(
            downloaded_bytes=self.downloaded_bytes,
            num_urls = len(self.result_cache),
        ))
        self.logger.end_log_output(**kwargs)
1332298
def ended(self):
        """"""
        self._end_time = time.time()

        if setting(key='memory_profile', expected_type=bool):
            self._end_memory = get_free_memory()