def initialize_leap(leap_provider_cert,
leap_provider_cert_fingerprint,
credentials_file,
organization_mode,
leap_home,
initial_sync=True):
init_monkeypatches()
events_server.ensure_server()
register(events.KEYMANAGER_FINISHED_KEY_GENERATION,
set_fresh_account)
provider, username, password = credentials.read(organization_mode,
credentials_file)
LeapCertificate.set_cert_and_fingerprint(leap_provider_cert,
leap_provider_cert_fingerprint)
config = LeapConfig(leap_home=leap_home, start_background_jobs=True)
provider = LeapProvider(provider, config)
LeapCertificate(provider).setup_ca_bundle()
leap_session = LeapSessionFactory(provider).create(username, password)
if initial_sync:
leap_session = yield leap_session.initial_sync()
global fresh_account
if fresh_account:
add_welcome_mail(leap_session.mail_store)
defer.returnValue(leap_session)
def _setup_multi_user(args, root_resource, services_factory):
if args.provider is None:
raise ValueError('Multi-user mode: provider name is required')
init_monkeypatches()
events_server.ensure_server()
config, provider = initialize_leap_provider(args.provider, args.leap_provider_cert, args.leap_provider_cert_fingerprint, args.leap_home)
protected_resource = set_up_protected_resources(root_resource, provider, services_factory, banner=args.banner)
return protected_resource
def start_events_and_updater(logger):
event_server.ensure_server()
if flags.STANDALONE:
try:
from leap.bitmask.updater import Updater
updater = Updater()
updater.start()
except ImportError:
logger.error("Updates are not enabled in this distribution.")
def start_events_and_updater(logger):
event_server.ensure_server()
if flags.STANDALONE:
try:
from leap.bitmask.updater import Updater
updater = Updater()
updater.start()
except ImportError:
logger.error("Updates are not enabled in this distribution.")
def _mock_user_agent(context):
ensure_server()
PixelatedSite.disable_csp_requests()
FeaturesResource.DISABLED_FEATURES.append('autoRefresh')
context.single_user_url = _define_url(8889)
context.single_user_client = _start_user_agent(8889, is_single_user=True)
context.multi_user_url = _define_url(4568)
context.multi_user_client = _start_user_agent(4568, is_single_user=False)
def _mock_user_agent(context):
ensure_server()
PixelatedSite.disable_csp_requests()
FeaturesResource.DISABLED_FEATURES.append('autoRefresh')
context.single_user_url = _define_url(8889)
context.single_user_client = _start_user_agent(8889, is_single_user=True)
context.multi_user_url = _define_url(4568)
context.multi_user_client = _start_user_agent(4568, is_single_user=False)
def _start_in_multi_user_mode(args, root_resource, services_factory):
if args.provider is None:
raise ValueError('provider name is required')
init_monkeypatches()
events_server.ensure_server()
config, provider = initialize_leap_provider(args.provider, args.leap_provider_cert, args.leap_provider_cert_fingerprint, args.leap_home)
protected_resource = set_up_protected_resources(root_resource, provider, services_factory, banner=args.banner)
start_site(args, protected_resource)
reactor.getThreadPool().adjustPoolsize(5, 15)
return defer.succeed(None)
def _start_in_multi_user_mode(args, root_resource, services_factory):
if args.provider is None:
raise ValueError('provider name is required')
init_monkeypatches()
events_server.ensure_server()
config, provider = initialize_leap_provider(args.provider, args.leap_provider_cert, args.leap_provider_cert_fingerprint, args.leap_home)
protected_resource = set_up_protected_resources(root_resource, provider, services_factory)
start_site(args, protected_resource)
reactor.getThreadPool().adjustPoolsize(5, 15)
return defer.succeed(None)
def _setup_multi_user(args, root_resource, services_factory):
if args.provider is None:
raise ValueError('Multi-user mode: provider name is required')
init_monkeypatches()
events_server.ensure_server()
provider = initialize_leap_provider(args.provider, args.leap_provider_cert,
args.leap_provider_cert_fingerprint,
args.leap_home)
protected_resource = set_up_protected_resources(root_resource,
provider,
services_factory,
banner=args.banner)
return protected_resource
def before_all(context):
ensure_server()
logging.disable('INFO')
PixelatedSite.disable_csp_requests()
client = AppTestClient()
start_app_test_client(client, UserAgentMode(is_single_user=True))
client.listenTCP(port=8889)
FeaturesResource.DISABLED_FEATURES.append('autoRefresh')
context.client = client
multi_user_client = AppTestClient()
start_app_test_client(multi_user_client, UserAgentMode(is_single_user=False))
multi_user_client.listenTCP(port=MULTI_USER_PORT)
context.multi_user_client = multi_user_client
def before_all(context):
ensure_server()
logging.disable('INFO')
PixelatedSite.disable_csp_requests()
client = AppTestClient()
start_app_test_client(client, UserAgentMode(is_single_user=True))
client.listenTCP(port=8889)
FeaturesResource.DISABLED_FEATURES.append('autoRefresh')
context.client = client
multi_user_client = AppTestClient()
start_app_test_client(multi_user_client, UserAgentMode(is_single_user=False))
multi_user_client.listenTCP(port=MULTI_USER_PORT)
context.multi_user_client = multi_user_client
def initialize_leap_single_user(
leap_provider_cert, leap_provider_cert_fingerprint, credentials_file, leap_home, initial_sync=True
):
init_monkeypatches()
events_server.ensure_server()
provider, username, password = credentials.read(credentials_file)
config, provider = initialize_leap_provider(provider, leap_provider_cert, leap_provider_cert_fingerprint, leap_home)
leap_session = yield authenticate_user(provider, username, password, initial_sync=initial_sync)
defer.returnValue(leap_session)
def pytest_collection_modifyitems(items, config):
for item in items:
bench = item.get_marker("benchmark")
if bench and bench.kwargs.get('group'):
group = bench.kwargs['group']
marker = getattr(pytest.mark, 'benchmark_' + group)
item.add_marker(marker)
subdir = config.getoption('subdir')
if subdir == 'benchmarks':
# we have to manually setup the events server in order to be able to
# signal events. This is usually done by the enclosing application
# using soledad client (i.e. bitmask client).
from leap.common.events import server
server.ensure_server()
def initialize_leap(leap_provider_cert,
leap_provider_cert_fingerprint,
credentials_file,
organization_mode,
leap_home):
init_monkeypatches()
events_server.ensure_server(random.randrange(8000, 11999))
provider, username, password = credentials.read(organization_mode, credentials_file)
LeapCertificate.set_cert_and_fingerprint(leap_provider_cert, leap_provider_cert_fingerprint)
config = LeapConfig(leap_home=leap_home, start_background_jobs=True)
provider = LeapProvider(provider, config)
LeapCertificate(provider).setup_ca_bundle()
leap_session = LeapSessionFactory(provider).create(username, password)
return leap_session
def setUp(self):
self._server = server.ensure_server(
emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0")
self._client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % self._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % self._server.pub_port)
def _init_events(cls):
if flags.EVENTS_ENABLED:
cls._server = events_server.ensure_server(
emit_addr="tcp://127.0.0.1", reg_addr="tcp://127.0.0.1")
events_client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % cls._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % cls._server.pub_port)
def before_all(context):
ensure_server()
logging.disable('INFO')
PixelatedSite.disable_csp_requests()
client = AppTestClient()
start_app_test_client(client, UserAgentMode(is_single_user=True))
client.listenTCP()
proxy = Proxy(proxy_port='8889', app_port='4567')
FeaturesResource.DISABLED_FEATURES.append('autoRefresh')
context.client = client
context.call_to_terminate_proxy = proxy.run_on_a_thread()
multi_user_client = AppTestClient()
start_app_test_client(multi_user_client, UserAgentMode(is_single_user=False))
multi_user_client.listenTCP(port=MULTI_USER_PORT)
context.multi_user_client = multi_user_client
def _init_events(cls):
cls._server = events_server.ensure_server(
emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0")
events_client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % cls._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % cls._server.pub_port)
def initialize_leap_single_user(leap_provider_cert,
leap_provider_cert_fingerprint,
credentials_file,
leap_home):
init_monkeypatches()
events_server.ensure_server()
provider, username, password = credentials.read(credentials_file)
provider = initialize_leap_provider(provider, leap_provider_cert, leap_provider_cert_fingerprint, leap_home)
auth = yield Authenticator(provider).authenticate(username, password)
leap_session = yield create_leap_session(provider, username, password, auth)
defer.returnValue(leap_session)
def _init_events(cls):
if flags.EVENTS_ENABLED:
cls._server = events_server.ensure_server(
emit_addr="tcp://127.0.0.1",
reg_addr="tcp://127.0.0.1")
events_client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % cls._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % cls._server.pub_port)
def initialize_leap(leap_provider_cert, leap_provider_cert_fingerprint,
credentials_file, organization_mode, leap_home):
init_monkeypatches()
events_server.ensure_server()
provider, username, password = credentials.read(organization_mode,
credentials_file)
LeapCertificate.set_cert_and_fingerprint(leap_provider_cert,
leap_provider_cert_fingerprint)
config = LeapConfig(leap_home=leap_home, start_background_jobs=True)
provider = LeapProvider(provider, config)
LeapCertificate(provider).setup_ca_bundle()
leap_session = LeapSessionFactory(provider).create(username, password)
yield leap_session.initial_sync()
defer.returnValue(leap_session)
def setUp(self):
flags.set_events_enabled(True)
self._server = server.ensure_server(
emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0")
self._client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % self._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % self._server.pub_port)
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 setup():
try:
args = input_args.parse()
debug_enabled = args.debug or os.environ.get('DEBUG', False)
reactor_manager.start_reactor(logging=debug_enabled)
crochet.setup()
events_server.ensure_server(port=8090)
app.config.from_pyfile(args.config)
if args.register:
server_name = app.config['LEAP_SERVER_NAME']
leap_register.register_new_user(args.register, server_name)
else:
app_factory.create_app(debug_enabled, app)
finally:
reactor_manager.stop_reactor_on_exit()
def initialize_leap_single_user(leap_provider_cert,
leap_provider_cert_fingerprint,
credentials_file, leap_home):
init_monkeypatches()
events_server.ensure_server()
provider, username, password = credentials.read(credentials_file)
provider = initialize_leap_provider(provider, leap_provider_cert,
leap_provider_cert_fingerprint,
leap_home)
auth = yield Authenticator(provider).authenticate(username, password)
leap_session = yield create_leap_session(provider, username, password,
auth)
defer.returnValue(leap_session)
def initialize_leap_single_user(leap_provider_cert,
leap_provider_cert_fingerprint,
credentials_file,
leap_home,
initial_sync=True):
init_monkeypatches()
events_server.ensure_server()
provider, username, password = credentials.read(credentials_file)
config, provider = initialize_leap_provider(
provider, leap_provider_cert, leap_provider_cert_fingerprint,
leap_home)
leap_session = yield authenticate_user(provider,
username,
password,
initial_sync=initial_sync)
defer.returnValue(leap_session)
def initialize_leap_single_user(leap_provider_cert,
leap_provider_cert_fingerprint,
credentials_file, leap_home):
init_monkeypatches()
events_server.ensure_server()
provider, username, password = credentials.read(credentials_file)
config, provider = initialize_leap_provider(
provider, leap_provider_cert, leap_provider_cert_fingerprint,
leap_home)
try:
auth = yield authenticate(provider, username, password)
except SRPAuthenticationError:
raise UnauthorizedLogin()
leap_session = yield create_leap_session(provider, username, password,
auth)
defer.returnValue(leap_session)
def setUp(self):
flags.set_events_enabled(True)
self.factory = ZmqFactory()
self._server = server.ensure_server(emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0",
factory=self.factory,
enable_curve=False)
self._client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % self._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % self._server.pub_port,
factory=self.factory,
enable_curve=False)
def setUp(self):
flags.set_events_enabled(True)
self.factory = ZmqFactory()
self._server = server.ensure_server(
emit_addr="tcp://127.0.0.1:0",
reg_addr="tcp://127.0.0.1:0",
factory=self.factory,
enable_curve=False)
self._client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % self._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % self._server.pub_port,
factory=self.factory, enable_curve=False)
password,
leap_home,
provider_cert,
provider_cert_fingerprint):
if not password:
password = getpass.getpass('Please enter password for %s: ' % username)
try:
validate_username(username)
validate_password(password)
except ValueError, e:
print(e.message)
sys.exit(1)
events_server.ensure_server()
LeapCertificate.set_cert_and_fingerprint(provider_cert, provider_cert_fingerprint)
config = LeapConfig(leap_home=leap_home)
provider = LeapProvider(server_name, config)
LeapCertificate(provider).setup_ca_bundle()
srp_auth = SRPAuth(provider.api_uri, LeapCertificate(provider).provider_api_cert)
if srp_auth.register(username, password):
LeapSessionFactory(provider).create(username, password)
else:
logger.error("Register failed")
def validate_username(username):
accepted_characters = '^[a-z0-9\-\_\.]*$'
if (not re.match(accepted_characters, username)):
import requests import srp._pysrp as srp import binascii import logging import json import time from twisted.internet import reactor from twisted.internet.defer import inlineCallbacks from leap.soledad.client import Soledad from leap.keymanager import KeyManager from leap.keymanager.openpgp import OpenPGPKey from leap.common.events import server server.ensure_server() from util import ValidateUserHandle """ Script to give access to client-side Soledad database. This is mainly used for tests, but can also be used to recover data from a Soledad database (public/private keys, export documents, etc). To speed up testing/debugging, this script can dump the auth data after logging in. Use the --export-auth-data option to export auth data to a file. The contents of the file is a json dictionary containing the uuid, server_url, cert_file and token, which is enough info to instantiate a soledad client without having to interact with the webapp again. Use the --use-auth-data option to use the auth data stored in a file.
def start_services(bind_address):
events_server.ensure_server(port=8090)
app_factory.create_app(app, bind_address)
def main():
"""
Starts the main event loop and launches the main window.
"""
# Parse arguments and store them
opts = leap_argparse.get_options()
do_display_version(opts)
bypass_checks = opts.danger
start_hidden = opts.start_hidden
flags.STANDALONE = opts.standalone
flags.OFFLINE = opts.offline
flags.MAIL_LOGFILE = opts.mail_log_file
flags.APP_VERSION_CHECK = opts.app_version_check
flags.API_VERSION_CHECK = opts.api_version_check
flags.OPENVPN_VERBOSITY = opts.openvpn_verb
flags.SKIP_WIZARD_CHECKS = opts.skip_wizard_checks
flags.CA_CERT_FILE = opts.ca_cert_file
replace_stdout = True
if opts.repair or opts.import_maildir:
# We don't want too much clutter on the comand mode
# this could be more generic with a Command class.
replace_stdout = False
logger = create_logger(opts.debug, opts.log_file, replace_stdout)
# ok, we got logging in place, we can satisfy mail plumbing requests
# and show logs there. it normally will exit there if we got that path.
do_mail_plumbing(opts)
try:
event_server.ensure_server(event_server.SERVER_PORT)
except Exception as e:
# We don't even have logger configured in here
print "Could not ensure server: %r" % (e,)
PLAY_NICE = os.environ.get("LEAP_NICE")
if PLAY_NICE and PLAY_NICE.isdigit():
nice = os.nice(int(PLAY_NICE))
logger.info("Setting NICE: %s" % nice)
# TODO move to a different module: commands?
if not we_are_the_one_and_only():
# Bitmask is already running
logger.warning("Tried to launch more than one instance "
"of Bitmask. Raising the existing "
"one instead.")
sys.exit(1)
check_requirements()
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Bitmask version %s', VERSION)
logger.info('leap.mail version %s', MAIL_VERSION)
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Starting app')
# 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")
app = 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"):
app.installTranslator(qtTranslator)
appTranslator = QtCore.QTranslator()
if appTranslator.load("%s.qm" % locale[:2], ":/translations"):
app.installTranslator(appTranslator)
# Needed for initializing qsettings it will write
# .config/leap/leap.conf top level app settings in a platform
# independent way
app.setOrganizationName("leap")
app.setApplicationName("leap")
app.setOrganizationDomain("leap.se")
# XXX ---------------------------------------------------------
# In quarantine, looks like we don't need it anymore.
# This dummy timer ensures that control is given to the outside
# loop, so we can hook our sigint handler.
#timer = QtCore.QTimer()
#timer.start(500)
#timer.timeout.connect(lambda: None)
# XXX ---------------------------------------------------------
window = MainWindow(bypass_checks=bypass_checks,
start_hidden=start_hidden)
sigint_window = partial(sigint_handler, window, logger=logger)
signal.signal(signal.SIGINT, sigint_window)
# callable used in addSystemEventTrigger to handle SIGTERM
sigterm_window = partial(sigterm_handler, window, logger=logger)
l = LoopingCall(QtCore.QCoreApplication.processEvents, 0, 10)
l.start(0.01)
# SIGTERM can't be handled the same way SIGINT is, since it's
# caught by twisted. See _handleSignals method in
# twisted/internet/base.py#L1150. So, addSystemEventTrigger
# reactor's method is used.
reactor.addSystemEventTrigger('before', 'shutdown', sigterm_window)
reactor.run()
"updates")
args = [
"--repo=repo/",
"--install",
bundles_per_platform[platform.system()]
]
thandy_update(args)
except Exception as e:
print "ERROR:", e
finally:
# TODO: Make this delay configurable
time.sleep(60)
if __name__ == "__main__":
server.ensure_server(port=8090)
config = ConfigParser.ConfigParser()
config.read("launcher.conf")
launch_thandy = False
try:
launch_thandy = config.getboolean(GENERAL_SECTION, UPDATES_KEY)
except ConfigParser.NoSectionError as ns:
pass
except ConfigParser.NoOptionError as no:
pass
if launch_thandy:
thandy_thread = Thandy()
thandy_thread.daemon = True
def init_events_server():
events_server.ensure_server(port=8090)
group = txclient_parser.add_mutually_exclusive_group(required=True)
group.add_argument('--reg', help="register an event")
group.add_argument('--emit', help="send an event")
txclient_parser.add_argument(
'--content', help="the content of the event", default=None)
return parser.parse_args()
args = _parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
if args.command == "server":
# run server
server.ensure_server(emit_addr=args.emit_addr, reg_addr=args.reg_addr)
from twisted.internet import reactor
reactor.run()
elif args.command == "client":
if args.reg:
event = getattr(catalog, args.reg)
# run client and register to a signal
register(event, _echo)
# make sure we stop on CTRL+C
import signal
signal.signal(
signal.SIGINT, lambda sig, frame: client.shutdown())
# wait until client thread dies
import time
while client.EventsClientThread.instance().is_alive():
time.sleep(0.1)
def start_app():
"""
Starts the main event loop and launches the main window.
"""
# Ignore the signals since we handle them in the subprocesses
# signal.signal(signal.SIGINT, signal.SIG_IGN)
# Parse arguments and store them
opts = leap_argparse.get_options()
do_display_version(opts)
options = {
'start_hidden': opts.start_hidden,
'debug': opts.debug,
'log_file': opts.log_file,
}
flags.STANDALONE = opts.standalone
flags.OFFLINE = opts.offline
flags.MAIL_LOGFILE = opts.mail_log_file
flags.APP_VERSION_CHECK = opts.app_version_check
flags.API_VERSION_CHECK = opts.api_version_check
flags.OPENVPN_VERBOSITY = opts.openvpn_verb
flags.SKIP_WIZARD_CHECKS = opts.skip_wizard_checks
flags.CA_CERT_FILE = opts.ca_cert_file
replace_stdout = True
if opts.repair or opts.import_maildir:
# We don't want too much clutter on the comand mode
# this could be more generic with a Command class.
replace_stdout = False
logger = create_logger(opts.debug, opts.log_file, replace_stdout)
# ok, we got logging in place, we can satisfy mail plumbing requests
# and show logs there. it normally will exit there if we got that path.
do_mail_plumbing(opts)
try:
event_server.ensure_server(event_server.SERVER_PORT)
except Exception as e:
# We don't even have logger configured in here
print "Could not ensure server: %r" % (e,)
PLAY_NICE = os.environ.get("LEAP_NICE")
if PLAY_NICE and PLAY_NICE.isdigit():
nice = os.nice(int(PLAY_NICE))
logger.info("Setting NICE: %s" % nice)
# TODO move to a different module: commands?
if not we_are_the_one_and_only():
# Bitmask is already running
logger.warning("Tried to launch more than one instance "
"of Bitmask. Raising the existing "
"one instead.")
sys.exit(1)
check_requirements()
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Bitmask version %s', VERSION)
logger.info('leap.mail version %s', MAIL_VERSION)
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Starting app')
generate_certificates()
flags_dict = flags_to_dict()
backend = lambda: run_backend(opts.danger, flags_dict)
backend_process = multiprocessing.Process(target=backend, name='Backend')
backend_process.daemon = True
backend_process.start()
run_frontend(options, flags_dict)
def start_app():
"""
Starts the main event loop and launches the main window.
"""
# Ignore the signals since we handle them in the subprocesses
# signal.signal(signal.SIGINT, signal.SIG_IGN)
# Parse arguments and store them
opts = leap_argparse.get_options()
do_display_version(opts)
options = {
'start_hidden': opts.start_hidden,
'debug': opts.debug,
'log_file': opts.log_file,
}
flags.STANDALONE = opts.standalone
# XXX Disabled right now since it's not tested after login refactor
# flags.OFFLINE = opts.offline
flags.OFFLINE = False
flags.MAIL_LOGFILE = opts.mail_log_file
flags.APP_VERSION_CHECK = opts.app_version_check
flags.API_VERSION_CHECK = opts.api_version_check
flags.OPENVPN_VERBOSITY = opts.openvpn_verb
flags.SKIP_WIZARD_CHECKS = opts.skip_wizard_checks
flags.CA_CERT_FILE = opts.ca_cert_file
replace_stdout = True
if opts.repair or opts.import_maildir:
# We don't want too much clutter on the comand mode
# this could be more generic with a Command class.
replace_stdout = False
logger = create_logger(opts.debug, opts.log_file, replace_stdout)
# ok, we got logging in place, we can satisfy mail plumbing requests
# and show logs there. it normally will exit there if we got that path.
do_mail_plumbing(opts)
try:
event_server.ensure_server(event_server.SERVER_PORT)
except Exception as e:
# We don't even have logger configured in here
print "Could not ensure server: %r" % (e, )
PLAY_NICE = os.environ.get("LEAP_NICE")
if PLAY_NICE and PLAY_NICE.isdigit():
nice = os.nice(int(PLAY_NICE))
logger.info("Setting NICE: %s" % nice)
# TODO move to a different module: commands?
if not we_are_the_one_and_only():
# Bitmask is already running
logger.warning("Tried to launch more than one instance "
"of Bitmask. Raising the existing "
"one instead.")
sys.exit(1)
check_requirements()
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Bitmask version %s', VERSION)
logger.info('leap.mail version %s', MAIL_VERSION)
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Starting app')
backend_running = BackendProxy().check_online()
logger.debug("Backend online: {0}".format(backend_running))
flags_dict = flags_to_dict()
backend_pid = None
if not backend_running:
frontend_pid = os.getpid()
backend = lambda: run_backend(opts.danger, flags_dict, frontend_pid)
backend_process = multiprocessing.Process(target=backend,
name='Backend')
# we don't set the 'daemon mode' since we need to start child processes
# in the backend
# backend_process.daemon = True
backend_process.start()
backend_pid = backend_process.pid
run_frontend(options, flags_dict, backend_pid=backend_pid)
def register(server_name, username, password, leap_home, provider_cert,
provider_cert_fingerprint):
if not password:
password = getpass.getpass('Please enter password for %s: ' % username)
try:
validate_username(username)
validate_password(password)
except ValueError, e:
print(e.message)
sys.exit(1)
events_server.ensure_server()
LeapCertificate.set_cert_and_fingerprint(provider_cert,
provider_cert_fingerprint)
config = LeapConfig(leap_home=leap_home)
provider = LeapProvider(server_name, config)
LeapCertificate(provider).setup_ca_bundle()
srp_auth = SRPAuth(provider.api_uri,
LeapCertificate(provider).provider_api_cert)
if srp_auth.register(username, password):
LeapSessionFactory(provider).create(username, password)
else:
logger.error("Register failed")
def validate_username(username):
'confined_target_dirs': ['']
}
def _set_permissions(self, target):
file_permissions_str = target["fileinfo"]["custom"]["file_permissions"]
file_permissions = int(file_permissions_str, 8)
filepath = target['filepath']
if filepath[0] == '/':
filepath = filepath[1:]
file_path = os.path.join(self.dest_path, filepath)
os.chmod(file_path, file_permissions)
def _repo_path(self):
system = platform.system() + "-" + platform.machine()
if system not in bundles_per_platform:
raise NotImplementedError("Platform %s not supported" % (system, ))
return bundles_per_platform[system]
if __name__ == "__main__":
server.ensure_server(port=8090)
config = ConfigParser.ConfigParser()
config.read("launcher.conf")
tuf_thread = TUF(config)
tuf_thread.daemon = True
tuf_thread.start()
bitmask_client()
def start_services(bind_address, bind_port):
events_server.ensure_server(port=8090)
app_factory.create_app(app, bind_address, bind_port)
def _init_events(cls):
cls._server = events_server.ensure_server(
emit_addr="tcp://127.0.0.1:0", reg_addr="tcp://127.0.0.1:0")
events_client.configure_client(
emit_addr="tcp://127.0.0.1:%d" % cls._server.pull_port,
reg_addr="tcp://127.0.0.1:%d" % cls._server.pub_port)
def start_app_test_client(client):
ensure_server()
return client.start_client()
def init_events(self):
event_server.ensure_server()
def main():
"""
Starts the main event loop and launches the main window.
"""
_, opts = leap_argparse.init_leapc_args()
if opts.version:
print "Bitmask version: %s" % (VERSION,)
sys.exit(0)
standalone = opts.standalone
bypass_checks = getattr(opts, 'danger', False)
debug = opts.debug
logfile = opts.log_file
openvpn_verb = opts.openvpn_verb
try:
event_server.ensure_server(event_server.SERVER_PORT)
except Exception as e:
# We don't even have logger configured in here
print "Could not ensure server: %r" % (e,)
#############################################################
# Given how paths and bundling works, we need to delay the imports
# of certain parts that depend on this path settings.
# So first we set all the places where standalone might be queried.
from leap.bitmask.config import flags
from leap.common.config.baseconfig import BaseConfig
flags.STANDALONE = standalone
BaseConfig.standalone = standalone
logger = add_logger_handlers(debug, logfile)
replace_stdout_stderr_with_logging(logger)
# And then we import all the other stuff
from leap.bitmask.gui import locale_rc
from leap.bitmask.gui import twisted_main
from leap.bitmask.gui.mainwindow import MainWindow
from leap.bitmask.platform_init import IS_MAC
from leap.bitmask.platform_init.locks import we_are_the_one_and_only
from leap.bitmask.util.requirement_checker import check_requirements
# pylint: avoid unused import
assert(locale_rc)
if not we_are_the_one_and_only():
# Bitmask is already running
logger.warning("Tried to launch more than one instance "
"of Bitmask. Raising the existing "
"one instead.")
sys.exit(1)
check_requirements()
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Bitmask version %s', VERSION)
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Starting app')
# 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")
app = QtGui.QApplication(sys.argv)
# install the qt4reactor.
install_qtreactor(logger)
# To test:
# $ LANG=es ./app.py
locale = QtCore.QLocale.system().name()
qtTranslator = QtCore.QTranslator()
if qtTranslator.load("qt_%s" % locale, ":/translations"):
app.installTranslator(qtTranslator)
appTranslator = QtCore.QTranslator()
if appTranslator.load("%s.qm" % locale[:2], ":/translations"):
app.installTranslator(appTranslator)
# Needed for initializing qsettings it will write
# .config/leap/leap.conf top level app settings in a platform
# independent way
app.setOrganizationName("leap")
app.setApplicationName("leap")
app.setOrganizationDomain("leap.se")
# XXX ---------------------------------------------------------
# In quarantine, looks like we don't need it anymore.
# This dummy timer ensures that control is given to the outside
# loop, so we can hook our sigint handler.
#timer = QtCore.QTimer()
#timer.start(500)
#timer.timeout.connect(lambda: None)
# XXX ---------------------------------------------------------
window = MainWindow(
lambda: twisted_main.quit(app),
openvpn_verb=openvpn_verb,
bypass_checks=bypass_checks)
sigint_window = partial(sigint_handler, window, logger=logger)
signal.signal(signal.SIGINT, sigint_window)
if IS_MAC:
window.raise_()
# This was a good idea, but for this to work as intended we
# should centralize the start of all services in there.
#tx_app = leap_services()
#assert(tx_app)
# Run main loop
twisted_main.start(app)
def init_events(self):
event_server.ensure_server()
group = txclient_parser.add_mutually_exclusive_group(required=True)
group.add_argument('--reg', help="register an event")
group.add_argument('--emit', help="send an event")
txclient_parser.add_argument(
'--content', help="the content of the event", default=None)
return parser.parse_args()
args = _parse_args()
if args.debug:
logging.basicConfig(level=logging.DEBUG)
if args.command == "server":
# run server
server.ensure_server(emit_addr=args.emit_addr, reg_addr=args.reg_addr)
from twisted.internet import reactor
reactor.run()
elif args.command == "client":
if args.reg:
event = getattr(catalog, args.reg)
# run client and register to a signal
register(event, _echo)
# make sure we stop on CTRL+C
import signal
signal.signal(
signal.SIGINT, lambda sig, frame: client.shutdown())
# wait until client thread dies
import time
while client.EventsClientThread.instance().is_alive():
time.sleep(0.1)
def start_app_test_client(client):
ensure_server()
return client.start_client()
def main():
"""
Starts the main event loop and launches the main window.
"""
# TODO move boilerplate outa here!
_, opts = leap_argparse.init_leapc_args()
do_display_version(opts)
standalone = opts.standalone
offline = opts.offline
bypass_checks = getattr(opts, 'danger', False)
debug = opts.debug
logfile = opts.log_file
mail_logfile = opts.mail_log_file
openvpn_verb = opts.openvpn_verb
#############################################################
# Given how paths and bundling works, we need to delay the imports
# of certain parts that depend on this path settings.
# So first we set all the places where standalone might be queried.
from leap.bitmask.config import flags
from leap.common.config.baseconfig import BaseConfig
flags.STANDALONE = standalone
flags.OFFLINE = offline
flags.MAIL_LOGFILE = mail_logfile
flags.APP_VERSION_CHECK = opts.app_version_check
flags.API_VERSION_CHECK = opts.api_version_check
flags.CA_CERT_FILE = opts.ca_cert_file
BaseConfig.standalone = standalone
replace_stdout = True
if opts.repair or opts.import_maildir:
# We don't want too much clutter on the comand mode
# this could be more generic with a Command class.
replace_stdout = False
logger = add_logger_handlers(debug, logfile, replace_stdout)
# ok, we got logging in place, we can satisfy mail plumbing requests
# and show logs there. it normally will exit there if we got that path.
do_mail_plumbing(opts)
try:
event_server.ensure_server(event_server.SERVER_PORT)
except Exception as e:
# We don't even have logger configured in here
print "Could not ensure server: %r" % (e,)
PLAY_NICE = os.environ.get("LEAP_NICE")
if PLAY_NICE and PLAY_NICE.isdigit():
nice = os.nice(int(PLAY_NICE))
logger.info("Setting NICE: %s" % nice)
# And then we import all the other stuff
# I think it's safe to import at the top by now -- kali
from leap.bitmask.gui import locale_rc
from leap.bitmask.gui import twisted_main
from leap.bitmask.gui.mainwindow import MainWindow
from leap.bitmask.platform_init import IS_MAC
from leap.bitmask.platform_init.locks import we_are_the_one_and_only
from leap.bitmask.util.requirement_checker import check_requirements
# pylint: avoid unused import
assert(locale_rc)
# TODO move to a different module: commands?
if not we_are_the_one_and_only():
# Bitmask is already running
logger.warning("Tried to launch more than one instance "
"of Bitmask. Raising the existing "
"one instead.")
sys.exit(1)
check_requirements()
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Bitmask version %s', VERSION)
logger.info('leap.mail version %s', MAIL_VERSION)
logger.info('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
logger.info('Starting app')
# 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")
app = 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"):
app.installTranslator(qtTranslator)
appTranslator = QtCore.QTranslator()
if appTranslator.load("%s.qm" % locale[:2], ":/translations"):
app.installTranslator(appTranslator)
# Needed for initializing qsettings it will write
# .config/leap/leap.conf top level app settings in a platform
# independent way
app.setOrganizationName("leap")
app.setApplicationName("leap")
app.setOrganizationDomain("leap.se")
# XXX ---------------------------------------------------------
# In quarantine, looks like we don't need it anymore.
# This dummy timer ensures that control is given to the outside
# loop, so we can hook our sigint handler.
#timer = QtCore.QTimer()
#timer.start(500)
#timer.timeout.connect(lambda: None)
# XXX ---------------------------------------------------------
window = MainWindow(
lambda: twisted_main.quit(app),
openvpn_verb=openvpn_verb,
bypass_checks=bypass_checks)
sigint_window = partial(sigint_handler, window, logger=logger)
signal.signal(signal.SIGINT, sigint_window)
if IS_MAC:
window.raise_()
# This was a good idea, but for this to work as intended we
# should centralize the start of all services in there.
#tx_app = leap_services()
#assert(tx_app)
l = LoopingCall(QtCore.QCoreApplication.processEvents, 0, 10)
l.start(0.01)
reactor.run()
