def start_client(self, mode=UserAgentMode(is_single_user=True)):
self._initialize()
self._mode = mode
self._test_account = AppTestAccount(self.ACCOUNT, self._tmp_dir.name)
yield self._test_account.start()
self.cleanup = lambda: self._tmp_dir.dissolve()
# copy fields for single user tests
self.soledad = self._test_account.soledad
self.search_engine = self._test_account.search_engine
self.keymanager = self._test_account.keymanager
self.mail_sender = self._test_account.mail_sender
self.mail_store = self._test_account.mail_store
self.attachment_store = self._test_account.attachment_store
self.draft_service = self._test_account.draft_service
self.leap_session = self._test_account.leap_session
self.feedback_service = self._test_account.feedback_service
self.mail_service = self._test_account.mail_service
self.account = self._test_account.account
if mode.is_single_user:
self.service_factory = SingleUserServicesFactory(mode)
services = self._test_account.services
self.service_factory.add_session('someuserid', services)
self.resource = RootResource(self.service_factory)
self.resource.initialize()
else:
self.service_factory = StubServicesFactory(self.accounts, mode)
provider = mock()
provider.config = LeapConfig(self._tmp_dir.name)
self.resource = set_up_protected_resources(RootResource(self.service_factory), provider, self.service_factory, checker=StubSRPChecker(provider))
def create_app(app, args, leap_session):
app.resource = RootResource()
init_app(app, args.home, leap_session)
if args.sslkey and args.sslcert:
listen_with_ssl(app, args)
else:
listen_without_ssl(app, args)
def start_client(self):
soledad_test_folder = self._generate_soledad_test_folder_name()
SearchEngine.DEFAULT_INDEX_HOME = soledad_test_folder
self.cleanup = lambda: shutil.rmtree(soledad_test_folder)
PixelatedMail.from_email_address = self.MAIL_ADDRESS
self.soledad = initialize_soledad(tempdir=soledad_test_folder)
self.soledad_querier = self._create_soledad_querier(
self.soledad, self.INDEX_KEY)
self.keymanager = mock()
self.search_engine = SearchEngine(self.soledad_querier,
agent_home=soledad_test_folder)
self.mail_sender = self._create_mail_sender()
self.account = SoledadBackedAccount(self.ACCOUNT, self.soledad,
MagicMock())
self.mailboxes = Mailboxes(self.account, self.soledad_querier,
self.search_engine)
self.draft_service = DraftService(self.mailboxes)
self.mail_service = self._create_mail_service(self.mailboxes,
self.mail_sender,
self.soledad_querier,
self.search_engine)
self.search_engine.index_mails(self.mail_service.all_mails())
self.app = App()
self.app.resource = RootResource()
self.app.resource.initialize(self.soledad_querier, self.keymanager,
self.search_engine, self.mail_service,
self.draft_service)
def start_pixelated_user_agent(userid, soledad, keymanager, account):
try:
leap_session = LeapSessionAdapter(userid, soledad, keymanager, account)
except Exception as exc:
log.error("Got error! %r" % exc)
config = Config()
leap_home = os.path.join(get_path_prefix(), 'leap')
config.leap_home = leap_home
leap_session.config = config
services_factory = SingleUserServicesFactory(
UserAgentMode(is_single_user=True))
if getattr(sys, 'frozen', False):
# we are running in a |PyInstaller| bundle
static_folder = os.path.join(sys._MEIPASS, 'leap', 'pixelated_www')
else:
static_folder = os.path.abspath(leap.pixelated_www.__path__[0])
set_static_folder(static_folder)
resource = RootResource(services_factory, static_folder=static_folder)
config.host = 'localhost'
config.port = 9090
config.sslkey = None
config.sslcert = None
config.manhole = False
d = leap_session.account.callWhenReady(
lambda _: _start_in_single_user_mode(leap_session, config, resource,
services_factory))
return d
def start_client(self):
soledad_test_folder = self._generate_soledad_test_folder_name()
SearchEngine.DEFAULT_INDEX_HOME = soledad_test_folder
self.cleanup = lambda: shutil.rmtree(soledad_test_folder)
self.soledad = yield initialize_soledad(tempdir=soledad_test_folder)
self.keymanager = mock()
self.search_engine = SearchEngine(self.INDEX_KEY,
agent_home=soledad_test_folder)
self.mail_sender = self._create_mail_sender()
self.mail_store = SearchableMailStore(LeapMailStore(self.soledad),
self.search_engine)
account_ready_cb = defer.Deferred()
self.account = IMAPAccount(self.ACCOUNT, self.soledad,
account_ready_cb)
yield account_ready_cb
self.draft_service = DraftService(self.mail_store)
self.leap_session = mock()
self.feedback_service = FeedbackService(self.leap_session)
self.mail_service = self._create_mail_service(self.mail_sender,
self.mail_store,
self.search_engine)
mails = yield self.mail_service.all_mails()
self.search_engine.index_mails(mails)
self.resource = RootResource()
self.resource.initialize(self.keymanager, self.search_engine,
self.mail_service, self.draft_service,
self.feedback_service)
def initialize():
args = arguments.parse_user_agent_args()
logger.init(debug=args.debug)
resource = RootResource()
start_site(args, resource)
deferred = initialize_leap(args.leap_provider_cert,
args.leap_provider_cert_fingerprint,
args.credentials_file, args.organization_mode,
args.leap_home)
deferred.addCallback(lambda leap_session: start_user_agent(
resource, args.leap_home, leap_session))
def _quit_on_error(failure):
failure.printTraceback()
reactor.stop()
def _register_shutdown_on_token_expire(leap_session):
register(events.SOLEDAD_INVALID_AUTH_TOKEN, lambda _: reactor.stop())
return leap_session
deferred.addCallback(_register_shutdown_on_token_expire)
deferred.addErrback(_quit_on_error)
reactor.run()
def __init__(self, soledad_test_folder='/tmp/soledad-test/test'):
self.soledad = initialize_soledad(tempdir=soledad_test_folder)
self.mail_address = "*****@*****.**"
# setup app
PixelatedMail.from_email_address = self.mail_address
SearchEngine.DEFAULT_INDEX_HOME = soledad_test_folder
self.app = App()
self.soledad_querier = SoledadQuerier(self.soledad)
self.soledad_querier.get_index_masterkey = lambda: self.INDEX_KEY
self.account = SoledadBackedAccount('test', self.soledad, MagicMock())
self.mailboxes = Mailboxes(self.account, self.soledad_querier)
self.mail_sender = Mock()
self.tag_service = TagService()
self.draft_service = DraftService(self.mailboxes)
self.mail_service = MailService(self.mailboxes, self.mail_sender,
self.tag_service, self.soledad_querier)
self.search_engine = SearchEngine(self.soledad_querier)
self.search_engine.index_mails(self.mail_service.all_mails())
self.app.resource = RootResource()
self.app.resource.initialize(self.soledad_querier, self.search_engine,
self.mail_service, self.draft_service)
def initialize():
log.info('Starting the Pixelated user agent')
args = arguments.parse_user_agent_args()
logger.init(debug=args.debug)
services_factory = _create_service_factory(args)
resource = RootResource(services_factory)
start_async = _start_mode(args, resource, services_factory)
add_top_level_system_callbacks(start_async, services_factory)
log.info('Running the reactor')
reactor.run()
def start_client(self, mode=UserAgentMode(is_single_user=True)):
self._initialize()
self._test_account = AppTestAccount('test', self._tmp_dir.name)
yield self._test_account.start()
self.cleanup = lambda: self._test_account.cleanup()
self.soledad = self._test_account.soledad
self.service_factory = ServicesFactory(UserAgentMode(is_single_user=False))
root_resource = RootResource(self.service_factory)
leap_provider = mock()
self.resource = set_up_protected_resources(root_resource, leap_provider, self.service_factory)
def setUp(self):
self.mail_service = mock()
self.services_factory = mock()
self.services_factory.mode = UserAgentMode(is_single_user=True)
self.services = mock()
self.services.mail_service = self.mail_service
self.services_factory._services_by_user = {'someuserid': self.mail_service}
when(self.services_factory).services(ANY()).thenReturn(self.services)
self.mail_service.account_email = self.MAIL_ADDRESS
root_resource = RootResource(self.services_factory)
root_resource._html_template = "<html><head><title>$account_email</title></head></html>"
root_resource._mode = root_resource
self.web = DummySite(root_resource)
self.root_resource = root_resource
def start_user_agent(loading_app, host, port, sslkey, sslcert, leap_home, leap_session):
yield loading_app.stopListening()
services = Services(leap_home, leap_session)
yield services.setup(leap_home, leap_session)
resource = RootResource()
resource.initialize(
services.keymanager,
services.search_engine,
services.mail_service,
services.draft_service)
if sslkey and sslcert:
reactor.listenSSL(port, Site(resource), _ssl_options(sslkey, sslcert), interface=host)
else:
reactor.listenTCP(port, Site(resource), interface=host)
# soledad needs lots of threads
reactor.threadpool.adjustPoolsize(5, 15)
def initialize():
log.info('Starting the Pixelated user agent')
args = arguments.parse_user_agent_args()
logger.init(debug=args.debug)
services_factory = _create_service_factory(args)
resource = RootResource(services_factory)
deferred = _start_mode(args, resource, services_factory)
def _quit_on_error(failure):
failure.printTraceback()
reactor.stop()
def _register_shutdown_on_token_expire(leap_session):
register(events.SOLEDAD_INVALID_AUTH_TOKEN,
lambda *unused: reactor.stop())
return leap_session
deferred.addCallback(_register_shutdown_on_token_expire)
deferred.addErrback(_quit_on_error)
log.info('Running the reactor')
reactor.run()
def setUp(self):
root_resource = RootResource()
root_resource._mode = root_resource
root_resource.account_email = self.MAIL_ADDRESS
root_resource._html_template = "<html><head><title>$account_email</title></head></html>"
self.web = DummySite(root_resource)