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