def start(logfile=None, application_name="ooniprobe"): daily_logfile = None if not logfile: logfile = config.basic.logfile log_folder = os.path.dirname(logfile) log_filename = os.path.basename(logfile) daily_logfile = DailyLogFile(log_filename, log_folder) txlog.msg( "Starting %s on %s (%s UTC)" % (application_name, otime.prettyDateNow(), otime.utcPrettyDateNow())) logging.basicConfig() python_logging = txlog.PythonLoggingObserver(application_name) if config.advanced.debug: python_logging.logger.setLevel(logging.DEBUG) else: python_logging.logger.setLevel(logging.INFO) txlog.startLoggingWithObserver(python_logging.emit) txlog.addObserver(txlog.FileLogObserver(daily_logfile).emit)
def createApplication(): appName = getAppConfig('app_name') apiServerIp = getAppConfig('api_server.bind_address') apiServerPort = int(getAppConfig('api_server.port')) games = getAppConfig('games').split(",") application = service.Application(name=appName) # log.msg(orderServerOption.get('nodaemon')) # log.msg(orderServerOption.keys()) # log.msg(orderServerOption.values()) # if orderServerOption.get('nodaemon') != 0: logDir = os.path.realpath(os.path.dirname(getAppConfig('logdir'))) logName = "%s.log" % ( appName, ) logFile = logfile.DailyLogFile(logName, logDir) #log.msg(logDir) application.setComponent(log.ILogObserver, log.FileLogObserver(logFile).emit) log.msg("load application: ", appName) log.msg("load games:", games) appSrv = service.IServiceCollection(application) _apiService = apiService(bindAddress=apiServerIp, port=apiServerPort, games=games) _apiService.setServiceParent(appSrv) _consumerService = consumerService(games=games) _consumerService.setServiceParent(appSrv) return application
def set_log_file(logFile, setStdout=True, start=True): """Set up twisted log files in a standard way. This borrows functionality from the twisted.application.app AppLogger.start() method, which in turn uses the twisted.scripts._twistd_unix.UnixAppLogger._getLogObserver method. That method returns a FileLog that is hard-coded to set a log rotation of 1 MB. While we're here anyway, overriding that as well to remove the rotation size. We rotate logs with an external logrotate command that sends SIGUSR1 to tell the broker to reopen the log file. """ log_file = logfile.LogFile.fromFullPath(logFile, rotateLength=0) observer = log.FileLogObserver(log_file).emit try: import signal except ImportError: pass else: # Override if signal is set to None or SIG_DFL (0) if not signal.getsignal(signal.SIGUSR1): def restartLog(signal, frame): log_file.flush() try: log_file.close() except: pass log_file._openFile() signal.signal(signal.SIGUSR1, restartLog) if start: log.startLoggingWithObserver(observer, setStdout=setStdout) return observer
def _run_core(self): # Add an observer to trap all logged errors. self.case.reactor = self._reactor error_observer = _log_observer full_log = StringIO() full_observer = log.FileLogObserver(full_log) spinner = self._make_spinner() successful, unhandled = run_with_log_observers( [error_observer.gotEvent, full_observer.emit], self._blocking_run_deferred, spinner) self.case.addDetail('twisted-log', text_content(full_log.getvalue())) logged_errors = error_observer.flushErrors() for logged_error in logged_errors: successful = False self._got_user_failure(logged_error, tb_label='logged-error') if unhandled: successful = False for debug_info in unhandled: f = debug_info.failResult info = debug_info._getDebugTracebacks() if info: self.case.addDetail('unhandled-error-in-deferred-debug', text_content(info)) self._got_user_failure(f, 'unhandled-error-in-deferred') junk = spinner.clear_junk() if junk: successful = False self._log_user_exception(UncleanReactorError(junk)) if successful: self.result.addSuccess(self.case, details=self.case.getDetails())
def _setUp(self): logs = StringIO() full_observer = log.FileLogObserver(logs) self.useFixture(_TwistedLogObservers([full_observer.emit])) self.addDetail( self.LOG_DETAIL_NAME, Content(UTF8_TEXT, lambda: [logs.getvalue().encode("utf-8")]))
def build(self): """Main build function of the Kivy application.""" # # Setup logging. # if not os.path.exists(gs.AUVSI_BASE_FOLDER): os.makedirs(gs.AUVSI_BASE_FOLDER) log.startLogging(stdout) log.addObserver( log.FileLogObserver( file(os.path.join(gs.AUVSI_BASE_FOLDER, 'controller.log'), 'a+')).emit) self.settings_cls = SettingsWithTabbedPanel # # Start up the local server. # self.connect_to_server() # # Load previously saved data # self.populateGalleryLists()
def test_emitPrefix(self): """ FileLogObserver.emit() will add a timestamp and system prefix to its file output. """ output = StringIO() flo = log.FileLogObserver(output) events = [] def observer(event): # Capture the event for reference and pass it along to flo events.append(event) flo.emit(event) publisher = log.LogPublisher() publisher.addObserver(observer) publisher.msg("Hello!") self.assertEqual(len(events), 1) event = events[0] result = output.getvalue() prefix = "{time} [{system}] ".format( time=flo.formatTime(event["time"]), system=event["system"], ) self.assertTrue( result.startswith(prefix), "{0!r} does not start with {1!r}".format(result, prefix) )
def main(): log_file = logfile.LogFile.fromFullPath('log/serverlog.log') log.addObserver(log.FileLogObserver(log_file).emit) print("===== PSO2Proxy vGIT %s =====" % config.proxy_ver) time_string = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) print("[ServerStart] Trying to start server at %s" % time_string) if myIp == "0.0.0.0": print("==== ERROR 001 ====") print("You have NOT configured the IP address for PSO2Proxy!") print( "Please edit cfg/pso2proxy.config.yml and change myIpAddr to your IP public IP address " "(Not LAN address if you're on a LAN!) ") print("After you fix this, please restart PSO2Proxy.") sys.exit(0) if bindIp == "0.0.0.0": interface_ip = myIp else: interface_ip = bindIp if not os.path.isfile("keys/myKey.pem"): print("==== ERROR 002 ====") print("You do NOT have your local RSA private key installed to 'keys/myKey.pem'!") print("Please see README.md's section on RSA keys for more information.") print("After you fix this, please restart PSO2Proxy.") sys.exit(0) if not os.path.isfile("keys/SEGAKey.pem"): print("==== ERROR 003 ====") print("You do NOT have a SEGA RSA public key installed to 'keys/SEGAKey.pem'!") print("Please see README.md's section on RSA keys for more information.") print("After you fix this, please restart PSO2Proxy.") sys.exit(0) for shipNum in range(0, 10): # PSO2 Checks all ships round robin, so sadly for max compatibility we have to open these no matter what ships are enabled... ship_endpoint = endpoints.TCP4ServerEndpoint(reactor, 12099 + (100 * shipNum), interface=interface_ip) ship_endpoint.listen(ShipAdvertiserFactory()) for shipNum in config.globalConfig.get_key('enabledShips'): query_endpoint = endpoints.TCP4ServerEndpoint(reactor, 12000 + (100 * shipNum), interface=interface_ip) query_endpoint.listen(BlockScraperFactory()) print("[ShipProxy] Bound port %i for ship %i query server!" % ((12000 + (100 * shipNum)), shipNum)) query_endpoint = endpoints.TCP4ServerEndpoint(reactor, 13000, interface=interface_ip) query_endpoint.listen(BlockScraperFactory()) stdio.StandardIO(ServerConsole()) print("[ShipProxy] Loading plugins...") import glob for plug in glob.glob("plugins/*.py"): plug = plug[:-3] plug = plug.replace(os.sep, '.') print("[ShipProxy] Importing %s..." % plug) __import__(plug) for f in plugin_manager.onStart: f() reactor.suggestThreadPoolSize(30) reactor.run() data.clients.dbManager.close_db() for f in plugin_manager.onStop: f()
def main(): log.startLogging(sys.stdout, setStdout=True) logFile = logfile.LogFile.fromFullPath('twistedLog.log') log.addObserver(log.FileLogObserver(logFile).emit) s = Server() s.run()
def setup_log(self, name): try: self.log_file = open(name, 'a') self.log_observer = log.FileLogObserver(self.log_file) log.startLoggingWithObserver(self.log_observer.emit) except: msg = "Error in setup_log:\n%s" % traceback.format_exc() print msg mail.error(msg)
def _setUpLogFile(self): self._tearDownLogFile() if self.logfile == "-": logFile = sys.stdout else: logFile = util.openTestLog(filepath.FilePath(self.logfile)) self._logFileObject = logFile self._logFileObserver = log.FileLogObserver(logFile) log.startLoggingWithObserver(self._logFileObserver.emit, 0)
def _setUpLogFile(self): self._tearDownLogFile() if self.logfile == "-": logFile = sys.stdout else: logFile = open(self.logfile, "a") self._logFileObject = logFile self._logFileObserver = log.FileLogObserver(logFile) log.startLoggingWithObserver(self._logFileObserver.emit, 0)
def run(self, serverLogFilename: str = 'twistedLog.log', timeout: Optional[float] = None, callOnTimer: Optional[Callable[[], None]] = None): ''' Run the server. This method will not return until the server is ended by an Exception like ^C. Timeout is useful when actions need to be triggered on a timer, with timout being a float representing the seconds between calls. If `callOnTimer` is set, it will be called every time the timer triggers. Additionally, any game implementing the `AbstractTimeGame` will have its `onTimer` method be called. ''' log.startLogging(sys.stdout, setStdout=True) logFile = logfile.LogFile.fromFullPath(serverLogFilename) log.addObserver(log.FileLogObserver(logFile).emit) if callOnTimer is not None and not callable(callOnTimer): raise TypeError( f'Func specified, but it is not callable: "{type(callOnTimer)}"' ) def loopCall() -> None: if callOnTimer: callOnTimer() gDB = self.__requestProcessor.gameDatabase gameIDs = gDB.getAllGameIDs() for gID in gameIDs: game = gDB.getGame(gID) if game and isinstance(game, AbstractTimeGame): result = game.onTimer() if result is None: continue if isinstance(result, interactions.TimerResponse): self.server.handleTimerResponse(result) else: raise TypeError( f'Method onTimer did not return Optional[ResponseSuccess] but instead "{type(result)}" in game "{type(game)}"' ) try: if timeout: loop = task.LoopingCall(loopCall) loop.start(timeout) # start listening for and handling connections reactor.run() # pylint: disable=no-member except KeyboardInterrupt: print('KeyboardInterrupt') finally: self.logFile.close()
def _getLogObserver(self): """ Create a log observer to be added to the logging system before running this application. """ if self._logfilename == '-' or not self._logfilename: logFile = sys.stdout else: logFile = logfile.LogFile.fromFullPath(self._logfilename) return log.FileLogObserver(logFile).emit
def setUp(self): # F**k you Python. reload(sys) self._origEncoding = sys.getdefaultencoding() sys.setdefaultencoding('ascii') self.out = FakeFile() self.lp = log.LogPublisher() self.flo = log.FileLogObserver(self.out) self.lp.addObserver(self.flo.emit)
def start(self, application): logging.basicConfig() python_logging = txlog.PythonLoggingObserver() if config.debug: python_logging.logger.setLevel(logging.DEBUG) else: python_logging.logger.setLevel(logging.INFO) txlog.startLoggingWithObserver(python_logging.emit) txlog.addObserver(txlog.FileLogObserver(daily_logfile).emit)
def on_load(self): config = self.server.config.base logfile = config.log_name if config.rotate_daily: create_file_path(logfile) logging_file = DailyLogFile(logfile, '.') else: logging_file = open_create(logfile, 'a') self.file_observer = log.FileLogObserver(logging_file) log.addObserver(self.file_observer.emit) log.msg('cuwo server started on %s' % time.strftime('%c')) self.observer = log.startLogging(sys.stdout) # force twisted logging
def _getLogObserver(logfilename, sysLog, prefix, nodaemon): """ Create and return a suitable log observer for the given configuration. The observer will go to syslog using the prefix C{prefix} if C{sysLog} is true. Otherwise, it will go to the file named C{logfilename} or, if C{nodaemon} is true and C{logfilename} is C{"-"}, to stdout. @type logfilename: C{str} @param logfilename: The name of the file to which to log, if other than the default. @type sysLog: C{bool} @param sysLog: A flag indicating whether to use syslog instead of file logging. @type prefix: C{str} @param prefix: If C{sysLog} is C{True}, the string prefix to use for syslog messages. @type nodaemon: C{bool} @param nodaemon: A flag indicating the process will not be daemonizing. @return: An object suitable to be passed to C{log.addObserver}. """ if sysLog: observer = syslog.SyslogObserver(prefix).emit else: if logfilename == '-': if not nodaemon: print 'daemons cannot log to stdout' os._exit(1) logFile = sys.stdout elif nodaemon and not logfilename: logFile = sys.stdout else: logFile = logfile.LogFile.fromFullPath(logfilename or 'twistd.log') try: import signal except ImportError: pass else: def rotateLog(signal, frame): from twisted.internet import reactor reactor.callFromThread(logFile.rotate) signal.signal(signal.SIGUSR1, rotateLog) observer = log.FileLogObserver(logFile).emit return observer
def main(): if len(sys.argv) < 2: print("Usage: %s <config dir>" % sys.argv[0]) sys.exit(1) transportobj = transport.Transport() boss = pluginbase.PluginBoss(sys.argv[1], transportobj) observer = log.FileLogObserver(sys.stdout) observer.timeFormat = "%Y-%m-%d %H:%M:%S" log.startLoggingWithObserver(observer.emit) log.msg("Abbott starting up!") boss.load_all_plugins() reactor.run()
def updated_application_run(self): """Patch for twisted.application.app.ApplicationRunner.run(). We really want logging to start up before the app does. This has needed to change in every upgrade from 8.1.0 -> 8.2.0 -> 10.2.0. The difference for 8.2.0 is that self.logger.start() is exploded to remove the requirement that the application exists and the application created afterwards. In 10.2.0 the logger.start() implementation changed. The logic structure has been modified to enable set_log_file as a separate method. The exploded start() uses twisted.scripts._twistd_unix.UnixAppLogger's _getLogObserver method as a base. """ self.preApplication() if self.logger._syslog: self.logger._observer = syslog.SyslogObserver(self._syslogPrefix).emit elif self.logger._logfilename == '-': if not self.logger._nodaemon: sys.exit('Daemons cannot log to stdout, exiting!') self.logger._observer = log.FileLogObserver(sys.stdout).emit elif self.logger._nodaemon and not self.logger._logfilename: self.logger._observer = log.FileLogObserver(sys.stdout).emit else: if not self.logger._logfilename: self.logger._logfilename = 'twistd.log' self.logger._observer = set_log_file(self.logger._logfilename, start=False) log.startLoggingWithObserver(self.logger._observer) self.logger._initialLog() self.application = self.createOrGetApplication() self.postApplication() self.logger.stop()
def logger(): try: if 'ANCHORE_LOGFILE' in os.environ: thefile = os.environ['ANCHORE_LOGFILE'] else: thefile = "anchore-general.log" except: thefile = "anchore-general.log" f = logfile.LogFile(thefile, '/var/log/', rotateLength=10000000, maxRotatedFiles=10) log_observer = log.FileLogObserver(f) return log_observer.emit
def CanvasApp(nginx=False): application = service.Application("Canvas") web_server = CanvasTCPServer() web_server.setServiceParent(application) log_file = logfile.LogFile( name="twistd.log", directory="/var/canvas/website/run", maxRotatedFiles=100, ) application.setComponent(log.ILogObserver, log.FileLogObserver(log_file).emit) return application
def start(logfile=None, application_name="ooniprobe"): daily_logfile = None if not logfile: logfile = config.basic.logfile log_folder = os.path.dirname(logfile) log_filename = os.path.basename(logfile) daily_logfile = DailyLogFile(log_filename, log_folder) txlog.msg("Starting %s on %s (%s UTC)" % (application_name, otime.prettyDateNow(), otime.utcPrettyDateNow())) txlog.startLoggingWithObserver(LogWithNoPrefix(sys.stdout).emit) txlog.addObserver(txlog.FileLogObserver(daily_logfile).emit)
def test_emitNewline(self): """ FileLogObserver.emit() will append a newline to its file output. """ output = StringIO() flo = log.FileLogObserver(output) publisher = log.LogPublisher() publisher.addObserver(flo.emit) publisher.msg("Hello!") result = output.getvalue() suffix = "Hello!\n" self.assertTrue(result.endswith(suffix), "{0!r} does not end with {1!r}".format(result, suffix))
def __init__(self, env, log_file): self.env = env if log_file: log_path = os.path.join(env.getInstancePath(), 'logs') # clear log files if env.config.getbool('seishub', 'clear_logs_on_startup'): log_base = os.path.splitext(log_file)[0] for file in iglob(os.path.join(log_path, log_base + '.*')): try: os.remove(file) except: pass # new log file daily_log_file = logfile.DailyLogFile(log_file, log_path) env.app.setComponent(log.ILogObserver, log.FileLogObserver(daily_log_file).emit) self.start()
def getLogObserver(verbosity): baseObserver = log.FileLogObserver(sys.stderr) if verbosity == 'none': return lambda ign: None elif verbosity == 'success': categories = {'success', 'error'} elif verbosity == 'error': categories = {'error'} else: raise ValueError('invalid verbosity', verbosity) def observer(event): if event['isError'] or event.get('category') in categories: baseObserver.emit(event) return observer
def _getLogObserver(logfilename): """ Create and return a suitable log observer for the given configuration. The observer will go to stdout if C{logfilename} is empty or equal to C{"-"}. Otherwise, it will go to a file with that name. @type logfilename: C{str} @param logfilename: The name of the file to which to log, if other than the default. @return: An object suitable to be passed to C{log.addObserver}. """ if logfilename == '-' or not logfilename: logFile = sys.stdout else: logFile = logfile.LogFile.fromFullPath(logfilename) return log.FileLogObserver(logFile).emit
def setUp(self): """ Add a log observer which records log events in C{self.out}. Also, make sure the default string encoding is ASCII so that L{testSingleUnicode} can test the behavior of logging unencodable unicode messages. """ self.out = FakeFile() self.lp = log.LogPublisher() self.flo = log.FileLogObserver(self.out) self.lp.addObserver(self.flo.emit) try: str('\N{VULGAR FRACTION ONE HALF}') except UnicodeEncodeError: pass # This is the behavior we want - don't change anything. self._origEncoding = None
def _getLogObserver(self): """ Create and return a suitable log observer for the given configuration. The observer will go to syslog using the prefix C{_syslogPrefix} if C{_syslog} is true. Otherwise, it will go to the file named C{_logfilename} or, if C{_nodaemon} is true and C{_logfilename} is C{"-"}, to stdout. @return: An object suitable to be passed to C{log.addObserver}. """ if self._syslog: # FIXME: Requires twisted.python.syslog to be ported to Py3 # https://twistedmatrix.com/trac/ticket/7957 from twisted.python import syslog return syslog.SyslogObserver(self._syslogPrefix).emit if self._logfilename == '-': if not self._nodaemon: sys.exit('Daemons cannot log to stdout, exiting!') logFile = sys.stdout elif self._nodaemon and not self._logfilename: logFile = sys.stdout else: # FIXME: Requires twisted.python.logfile to be ported to Py3 # https://twistedmatrix.com/trac/ticket/6749 from twisted.python import logfile if not self._logfilename: self._logfilename = 'twistd.log' logFile = logfile.LogFile.fromFullPath(self._logfilename) try: import signal except ImportError: pass else: # Override if signal is set to None or SIG_DFL (0) if not signal.getsignal(signal.SIGUSR1): def rotateLog(signal, frame): from twisted.internet import reactor reactor.callFromThread(logFile.rotate) signal.signal(signal.SIGUSR1, rotateLog) return log.FileLogObserver(logFile).emit
def setup(self, daemon, log_syslog, log_file, debug=False): observer = None if log_syslog: observer = syslog.SyslogObserver('siptrackd').emit elif log_file: if log_file == '-': if daemon: raise SiptrackError('Daemons can\'t log to stdout') log_fd = sys.stdout else: log_fd = logfile.LogFile.fromFullPath(log_file) observer = log.FileLogObserver(log_fd).emit else: raise SiptrackError('No logging method selected') log.startLoggingWithObserver(observer) sys.stdout.flush() self.debug_logging = debug self.setup_complete = True return True