def run_frontend(options, flags_dict, backend_pid): """ Run the GUI for the application. :param options: a dict of options parsed from the command line. :type options: dict :param flags_dict: a dict containing the flag values set on app start. :type flags_dict: dict """ dict_to_flags(flags_dict) start_hidden = options["start_hidden"] # We force the style if on KDE so that it doesn't load all the kde # libs, which causes a compatibility issue in some systems. # For more info, see issue #3194 if flags.STANDALONE and os.environ.get("KDE_SESSION_UID") is not None: sys.argv.append("-style") sys.argv.append("Cleanlooks") qApp = QtGui.QApplication(sys.argv) # To test: # $ LANG=es ./app.py locale = QtCore.QLocale.system().name() qtTranslator = QtCore.QTranslator() if qtTranslator.load("qt_%s" % locale, ":/translations"): qApp.installTranslator(qtTranslator) appTranslator = QtCore.QTranslator() if appTranslator.load("%s.qm" % locale[:2], ":/translations"): qApp.installTranslator(appTranslator) # Needed for initializing qsettings it will write # .config/leap/leap.conf top level app settings in a platform # independent way qApp.setOrganizationName("leap") qApp.setApplicationName("leap") qApp.setOrganizationDomain("leap.se") # HACK: # We need to do some 'python work' once in a while, otherwise, no python # code will be called and the Qt event loop will prevent the signal # handlers for SIGINT/SIGTERM to be called. # see: http://stackoverflow.com/a/4939113/687989 timer = QtCore.QTimer() timer.start(500) # You may change this if you wish. timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms. window = MainWindow(start_hidden=start_hidden, backend_pid=backend_pid) my_pid = os.getpid() sig_handler = partial(signal_handler, window, my_pid) signal.signal(signal.SIGINT, sig_handler) signal.signal(signal.SIGTERM, sig_handler) sys.exit(qApp.exec_())
def run_backend(bypass_checks, flags_dict): """ Run the backend for the application. :param bypass_checks: whether we should bypass the checks or not :type bypass_checks: bool :param flags_dict: a dict containing the flag values set on app start. :type flags_dict: dict """ # ignore SIGINT since app.py takes care of signaling SIGTERM to us. signal.signal(signal.SIGINT, signal.SIG_IGN) signal.signal(signal.SIGTERM, signal_handler) dict_to_flags(flags_dict) backend = LeapBackend(bypass_checks=bypass_checks) backend.run()
def run_backend(bypass_checks=False, flags_dict=None, frontend_pid=None): """ Run the backend for the application. :param bypass_checks: whether we should bypass the checks or not :type bypass_checks: bool :param flags_dict: a dict containing the flag values set on app start. :type flags_dict: dict """ # In the backend, we want all the components to log into logbook # that is: logging handlers and twisted logs from logbook.compat import redirect_logging from twisted.python.log import PythonLoggingObserver redirect_logging() observer = PythonLoggingObserver() observer.start() # NOTE: this needs to be used here, within the call since this function is # executed in a different process and it seems that the process/thread # identification isn't working 100% logger = get_logger() # noqa # The backend is the one who always creates the certificates. Either if it # is run separately or in a process in the same app as the frontend. if flags.ZMQ_HAS_CURVE: generate_zmq_certificates() # ignore SIGINT since app.py takes care of signaling SIGTERM to us. signal.signal(signal.SIGINT, signal.SIG_IGN) signal.signal(signal.SIGTERM, signal_handler) if flags_dict is not None: dict_to_flags(flags_dict) # HACK we should be able to run the ensure_server anyway but right now it # breaks if we run it twice. if not flags.STANDALONE: # start the events server # This is not needed for the standalone bundle since the launcher takes # care of it. event_server.ensure_server() backend = LeapBackend(bypass_checks=bypass_checks, frontend_pid=frontend_pid) backend.run()
def run_backend(bypass_checks=False, flags_dict=None, frontend_pid=None): """ Run the backend for the application. This is called from the main app.py entrypoint, and is run in a child subprocess. :param bypass_checks: whether we should bypass the checks or not :type bypass_checks: bool :param flags_dict: a dict containing the flag values set on app start. :type flags_dict: dict """ # In the backend, we want all the components to log into logbook # that is: logging handlers and twisted logs from logbook.compat import redirect_logging from twisted.python.log import PythonLoggingObserver redirect_logging() observer = PythonLoggingObserver() observer.start() if flags_dict is not None: dict_to_flags(flags_dict) common_flags.STANDALONE = flags.STANDALONE # NOTE: this needs to be used here, within the call since this function is # executed in a different process and it seems that the process/thread # identification isn't working 100% logger = get_logger() # noqa # The backend is the one who always creates the certificates. Either if it # is run separately or in a process in the same app as the frontend. if flags.ZMQ_HAS_CURVE: generate_zmq_certificates() # ignore SIGINT since app.py takes care of signaling SIGTERM to us. signal.signal(signal.SIGINT, signal.SIG_IGN) signal.signal(signal.SIGTERM, signal_handler) reactor.callWhenRunning(start_events_and_updater, logger) backend = LeapBackend(bypass_checks=bypass_checks, frontend_pid=frontend_pid) backend.run()
def run_backend(bypass_checks=False, flags_dict=None, frontend_pid=None): """ Run the backend for the application. :param bypass_checks: whether we should bypass the checks or not :type bypass_checks: bool :param flags_dict: a dict containing the flag values set on app start. :type flags_dict: dict """ # The backend is the one who always creates the certificates. Either if it # is run separately or in a process in the same app as the frontend. generate_zmq_certificates() # ignore SIGINT since app.py takes care of signaling SIGTERM to us. signal.signal(signal.SIGINT, signal.SIG_IGN) signal.signal(signal.SIGTERM, signal_handler) if flags_dict is not None: dict_to_flags(flags_dict) backend = LeapBackend(bypass_checks=bypass_checks, frontend_pid=frontend_pid) backend.run()
def run_frontend(options, flags_dict, backend_pid=None): """ Run the GUI for the application. :param options: a dict of options parsed from the command line. :type options: dict :param flags_dict: a dict containing the flag values set on app start. :type flags_dict: dict """ dict_to_flags(flags_dict) logger = get_logger() start_hidden = options["start_hidden"] # We force the style if on KDE so that it doesn't load all the kde # libs, which causes a compatibility issue in some systems. # For more info, see issue #3194 if flags.STANDALONE and os.environ.get("KDE_SESSION_UID") is not None: sys.argv.append("-style") sys.argv.append("Cleanlooks") qApp = QtGui.QApplication(sys.argv) # To test the app in other language you can do: # shell> LANG=es bitmask # or in some rare case if the code above didn't work: # shell> LC_ALL=es LANG=es bitmask locale = QtCore.QLocale.system().name() # en_US, es_AR, ar_SA, etc locale_short = locale[:2] # en, es, ar, etc rtl_languages = ('ar', ) # right now tested on 'arabic' only. systemQtTranslator = QtCore.QTranslator() if systemQtTranslator.load("qt_%s" % locale, ":/translations"): qApp.installTranslator(systemQtTranslator) bitmaskQtTranslator = QtCore.QTranslator() if bitmaskQtTranslator.load("%s.qm" % locale_short, ":/translations"): qApp.installTranslator(bitmaskQtTranslator) if locale_short in rtl_languages: qApp.setLayoutDirection(QtCore.Qt.LayoutDirection.RightToLeft) # Needed for initializing qsettings it will write # .config/leap/leap.conf top level app settings in a platform # independent way qApp.setOrganizationName("leap") qApp.setApplicationName("leap") qApp.setOrganizationDomain("leap.se") # HACK: # We need to do some 'python work' once in a while, otherwise, no python # code will be called and the Qt event loop will prevent the signal # handlers for SIGINT/SIGTERM to be called. # see: http://stackoverflow.com/a/4939113/687989 timer = QtCore.QTimer() timer.start(500) # You may change this if you wish. timer.timeout.connect(lambda: None) # Let the interpreter run each 500 ms. window = MainWindow(start_hidden=start_hidden, backend_pid=backend_pid) my_pid = os.getpid() sig_handler = partial(signal_handler, window, my_pid, logger) signal.signal(signal.SIGINT, sig_handler) signal.signal(signal.SIGTERM, sig_handler) sys.exit(qApp.exec_())