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_())
