Started deferring leap session creation #759

Started adapting get_leap_session to deferreds

Soledad and keymanager setup calls will now
happen in deferreds and leap session creation
itself is a deferred with callbacks

This is a start in breaking the big blocking
calls we were doing on the main thread, this
was done without changing code inside the
leap libraries yet so things can be further
optimized

This breaks the ~4 seconds get_leap_session
piece into smaller 1 seconds one, that can be
further optimized and deferred to even smaller
calls

There are requests calls happening on the main
thread that should get this number even further
down

Also moved some pieces from bitmask libraries
to our bootstrap, because they are not bitmask
libraries anymore and that was causing confusion

2 files changed, 164 insertions, 4 deletions

diff --git a/service/test/unit/config/test_leap.py b/service/test/unit/config/test_leap.py
index 5576cca8..b87065d2 100644
--- a/service/test/unit/config/test_leap.py
+++ b/service/test/unit/config/test_leap.py
@@ -9,7 +9,7 @@ class TestAuth(unittest.TestCase):
 
     @patch('pixelated.config.leap.LeapSessionFactory')
     @defer.inlineCallbacks
-    def test_create_leap_session_calls_initinal_sync(self, session_factory__ctor_mock):
+    def test_create_leap_session_calls_initial_sync(self, session_factory__ctor_mock):
         session_factory_mock = session_factory__ctor_mock.return_value
         provider_mock = MagicMock()
         auth_mock = MagicMock()
@@ -19,7 +19,7 @@ class TestAuth(unittest.TestCase):
 
         yield create_leap_session(provider_mock, 'username', 'password', auth=auth_mock)
 
-        session.initial_sync.assert_called_with()
+        session.first_required_sync.assert_called_with()
 
     @patch('pixelated.config.leap.LeapSessionFactory')
     @defer.inlineCallbacks
@@ -29,10 +29,10 @@ class TestAuth(unittest.TestCase):
         auth_mock = MagicMock()
         session = MagicMock()
 
-        session.initial_sync.side_effect = [InvalidAuthTokenError, defer.succeed(None)]
+        session.first_required_sync.side_effect = [InvalidAuthTokenError, defer.succeed(None)]
         session_factory_mock.create.return_value = session
 
         yield create_leap_session(provider_mock, 'username', 'password', auth=auth_mock)
 
         session.close.assert_called_with()
-        self.assertEqual(2, session.initial_sync.call_count)
+        self.assertEqual(2, session.first_required_sync.call_count)
diff --git a/service/test/unit/config/test_sessions.py b/service/test/unit/config/test_sessions.py
new file mode 100644
index 00000000..be418a73
--- /dev/null
+++ b/service/test/unit/config/test_sessions.py
@@ -0,0 +1,160 @@
+#
+# Copyright (c) 2014 ThoughtWorks, Inc.
+#
+# Pixelated is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Pixelated is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with Pixelated. If not, see <http://www.gnu.org/licenses/>.
+
+from mock import patch
+from mock import MagicMock
+from twisted.internet import defer
+from pixelated.config.sessions import LeapSession, SessionCache
+
+from test.unit.bitmask_libraries.test_abstract_leap import AbstractLeapTest
+from leap.common.events.catalog import KEYMANAGER_FINISHED_KEY_GENERATION
+
+
+class SessionTest(AbstractLeapTest):
+
+    def setUp(self):
+        super(SessionTest, self).setUp()
+        self.smtp_mock = MagicMock()
+
+    @patch('pixelated.config.sessions.register')
+    @patch('pixelated.config.sessions.Account')
+    @defer.inlineCallbacks
+    def test_background_jobs_are_started_during_initial_sync(self, *unused):
+        mailFetcherMock = MagicMock()
+        with patch('pixelated.config.sessions.reactor.callFromThread', new=_execute_func) as _:
+            with patch.object(LeapSession, '_create_incoming_mail_fetcher', return_value=mailFetcherMock) as _:
+                session = self._create_session()
+                yield session.first_required_sync()
+                mailFetcherMock.startService.assert_called_once()
+
+    @patch('pixelated.config.sessions.register')
+    @patch('pixelated.config.sessions.unregister')
+    @patch('pixelated.config.sessions.Account')
+    @defer.inlineCallbacks
+    def test_that_close_stops_background_jobs(self, *unused):
+        with patch('pixelated.config.sessions.reactor.callFromThread', new=_execute_func) as _:
+            with patch('pixelated.config.sessions.LeapSession._create_incoming_mail_fetcher') as mail_fetcher_mock:
+                session = self._create_session()
+                yield session.first_required_sync()
+                session.close()
+                mail_fetcher_mock.stopService.assert_called_once()
+
+    def test_that_sync_defers_to_soledad(self):
+        with patch('pixelated.config.sessions.reactor.callFromThread', new=_execute_func) as _:
+            with patch('pixelated.config.sessions.LeapSession._create_incoming_mail_fetcher') as mail_fetcher_mock:
+                session = self._create_session()
+                yield session.sync()
+                self.soledad_session.sync.assert_called_once()
+
+    def test_session_registers_to_generated_keys(self):
+        email = 'someone@somedomain.tld'
+        self.provider.address_for.return_value = email
+        with patch('pixelated.config.sessions.register') as register_mock:
+            session = self._create_session()
+
+            register_mock.assert_called_once_with(KEYMANAGER_FINISHED_KEY_GENERATION, session._set_fresh_account, uid=email)
+
+    @patch('pixelated.config.sessions.register')
+    def test_close_unregisters_from_generate_keys_events(self, _):
+        email = 'someone@somedomain.tld'
+        self.provider.address_for.return_value = email
+        session = self._create_session()
+
+        with patch('pixelated.config.sessions.unregister') as unregister_mock:
+            session.close()
+
+            unregister_mock.assert_called_once_with(KEYMANAGER_FINISHED_KEY_GENERATION, uid=email)
+
+    @patch('pixelated.config.sessions.register')
+    def test_close_stops_soledad(self, _):
+        email = 'someone@somedomain.tld'
+        self.provider.address_for.return_value = email
+        session = self._create_session()
+
+        with patch('pixelated.config.sessions.unregister') as unregister_mock:
+            session.close()
+
+        self.soledad_session.close.assert_called_once_with()
+
+    @patch('pixelated.config.sessions.register')
+    def test_close_removes_session_from_cache(self, _):
+        email = 'someone@somedomain.tld'
+        self.provider.address_for.return_value = email
+        session = self._create_session()
+
+        key = SessionCache.session_key(self.provider, self.auth.username)
+        SessionCache.remember_session(key, session)
+
+        self.assertEqual(session, SessionCache.lookup_session(key))
+
+        with patch('pixelated.config.sessions.unregister') as unregister_mock:
+            session.close()
+
+        self.assertIsNone(SessionCache.lookup_session(key))
+
+    @patch('pixelated.config.sessions.register')
+    def test_close_ends_account_session(self, _):
+        account_mock = MagicMock()
+        email = 'someone@somedomain.tld'
+        self.provider.address_for.return_value = email
+        session = self._create_session()
+        session.account = account_mock
+
+        with patch('pixelated.config.sessions.unregister') as unregister_mock:
+            session.close()
+
+        account_mock.end_session.assert_called_once_with()
+
+    @patch('pixelated.config.sessions.register')
+    def test_session_fresh_is_initially_false(self, _):
+        session = self._create_session()
+
+        self.assertFalse(session.fresh_account)
+
+    @patch('pixelated.config.sessions.register')
+    def test_session_sets_status_to_fresh_on_key_generation_event(self, _):
+        session = self._create_session()
+        self.provider.address_for.return_value = 'someone@somedomain.tld'
+
+        session._set_fresh_account(None, 'someone@somedomain.tld')
+
+        self.assertTrue(session.fresh_account)
+
+    @patch('pixelated.config.sessions.register')
+    def test_closed_session_not_reused(self, _):
+        session = self._create_session()
+        SessionCache.remember_session('somekey', session)
+        session._is_closed = True
+
+        result = SessionCache.lookup_session('somekey')
+
+        self.assertIsNone(result)
+
+    @patch('pixelated.config.sessions.register')
+    def test_session_does_not_set_status_fresh_for_unkown_emails(self, _):
+        session = self._create_session()
+        self.provider.address_for.return_value = 'someone@somedomain.tld'
+
+        session._set_fresh_account(None, 'another_email@somedomain.tld')
+
+        self.assertFalse(session.fresh_account)
+
+    def _create_session(self):
+        return LeapSession(self.provider, self.auth, self.mail_store, self.soledad_session, self.keymanager, self.smtp_mock)
+
+
+def _execute_func(func):
+    func()