Refactor provider_bootstrapper out of mainwindow

2 files changed, 115 insertions, 92 deletions

diff --git a/src/leap/bitmask/gui/mainwindow.py b/src/leap/bitmask/gui/mainwindow.py
index 75a16eb9..7dcb9908 100644
--- a/src/leap/bitmask/gui/mainwindow.py
+++ b/src/leap/bitmask/gui/mainwindow.py
@@ -18,9 +18,9 @@
 Main window for Bitmask.
 """
 import logging
-import os
 
 from PySide import QtCore, QtGui
+from functools import partial
 from twisted.internet import threads
 from zope.proxy import ProxyBase, setProxiedObject
 
@@ -42,9 +42,10 @@ from leap.bitmask.gui.systray import SysTray
 from leap.bitmask import provider
 from leap.bitmask.platform_init import IS_WIN, IS_MAC
 from leap.bitmask.platform_init.initializers import init_platform
-from leap.bitmask.provider.providerbootstrapper import ProviderBootstrapper
 
-from leap.bitmask.services import get_service_display_name, EIP_SERVICE
+from leap.bitmask import backend
+
+from leap.bitmask.services import get_service_display_name
 
 from leap.bitmask.services.mail import conductor as mail_conductor
 
@@ -138,6 +139,9 @@ class MainWindow(QtGui.QMainWindow):
         self.ui = Ui_MainWindow()
         self.ui.setupUi(self)
 
+        self._backend = backend.Backend(bypass_checks)
+        self._backend.start()
+
         self._settings = LeapSettings()
 
         self._login_widget = LoginWidget(
@@ -180,7 +184,10 @@ class MainWindow(QtGui.QMainWindow):
 
         # This is loaded only once, there's a bug when doing that more
         # than once
-        self._provider_config = ProviderConfig()
+        # XXX HACK!! But we need it as long as we are using
+        # provider_config in here
+        self._provider_config = (
+            self._backend._components["provider"]._provider_config)
         # Used for automatic start of EIP
         self._provisional_provider_config = ProviderConfig()
         self._eip_config = eipconfig.EIPConfig()
@@ -191,25 +198,7 @@ class MainWindow(QtGui.QMainWindow):
         self._srp_auth = None
         self._logged_user = None
 
-        # This thread is always running, although it's quite
-        # lightweight when it's done setting up provider
-        # configuration and certificate.
-        self._provider_bootstrapper = ProviderBootstrapper(bypass_checks)
-
-        # Intermediate stages, only do something if there was an error
-        self._provider_bootstrapper.name_resolution.connect(
-            self._intermediate_stage)
-        self._provider_bootstrapper.https_connection.connect(
-            self._intermediate_stage)
-        self._provider_bootstrapper.download_ca_cert.connect(
-            self._intermediate_stage)
-
-        # Important stages, loads the provider config and checks
-        # certificates
-        self._provider_bootstrapper.download_provider_info.connect(
-            self._load_provider_config)
-        self._provider_bootstrapper.check_api_certificate.connect(
-            self._provider_config_loaded)
+        self._backend_connect()
 
         # This thread is similar to the provider bootstrapper
         self._eip_bootstrapper = EIPBootstrapper()
@@ -349,7 +338,9 @@ class MainWindow(QtGui.QMainWindow):
 
         if self._first_run():
             self._wizard_firstrun = True
-            self._wizard = Wizard(bypass_checks=bypass_checks)
+            self._backend_disconnect()
+            self._wizard = Wizard(backend=self._backend,
+                                  bypass_checks=bypass_checks)
             # Give this window time to finish init and then show the wizard
             QtCore.QTimer.singleShot(1, self._launch_wizard)
             self._wizard.accepted.connect(self._finish_init)
@@ -359,6 +350,47 @@ class MainWindow(QtGui.QMainWindow):
             # so this has to be done after eip_machine is started
             self._finish_init()
 
+    def _backend_connect(self):
+        """
+        Helper to connect to backend signals
+        """
+        self._backend.signaler.prov_name_resolution.connect(
+            self._intermediate_stage)
+        self._backend.signaler.prov_https_connection.connect(
+            self._intermediate_stage)
+        self._backend.signaler.prov_download_ca_cert.connect(
+            self._intermediate_stage)
+
+        self._backend.signaler.prov_download_provider_info.connect(
+            self._load_provider_config)
+        self._backend.signaler.prov_check_api_certificate.connect(
+            self._provider_config_loaded)
+
+        # Only used at login, no need to disconnect this like we do
+        # with the other
+        self._backend.signaler.prov_problem_with_provider.connect(
+            partial(self._login_widget.set_status,
+                    self.tr("Unable to login: Problem with provider")))
+
+    def _backend_disconnect(self):
+        """
+        Helper to disconnect from backend signals.
+
+        Some signals are emitted from the wizard, and we want to
+        ignore those.
+        """
+        self._backend.signaler.prov_name_resolution.disconnect(
+            self._intermediate_stage)
+        self._backend.signaler.prov_https_connection.disconnect(
+            self._intermediate_stage)
+        self._backend.signaler.prov_download_ca_cert.disconnect(
+            self._intermediate_stage)
+
+        self._backend.signaler.prov_download_provider_info.disconnect(
+            self._load_provider_config)
+        self._backend.signaler.prov_check_api_certificate.disconnect(
+            self._provider_config_loaded)
+
     def _rejected_wizard(self):
         """
         SLOT
@@ -379,6 +411,7 @@ class MainWindow(QtGui.QMainWindow):
             # This happens if the user finishes the provider
             # setup but does not register
             self._wizard = None
+            self._backend_connect()
             self._finish_init()
 
     def _launch_wizard(self):
@@ -394,7 +427,9 @@ class MainWindow(QtGui.QMainWindow):
         there.
         """
         if self._wizard is None:
-            self._wizard = Wizard(bypass_checks=self._bypass_checks)
+            self._backend_disconnect()
+            self._wizard = Wizard(backend=self._backend,
+                                  bypass_checks=self._bypass_checks)
             self._wizard.accepted.connect(self._finish_init)
             self._wizard.rejected.connect(self._wizard.close)
 
@@ -628,6 +663,7 @@ class MainWindow(QtGui.QMainWindow):
                 self.eip_needs_login.emit()
 
             self._wizard = None
+            self._backend_connect()
         else:
             self._try_autostart_eip()
 
@@ -856,14 +892,12 @@ class MainWindow(QtGui.QMainWindow):
         # XXX should rename this provider, name clash.
         provider = self._login_widget.get_selected_provider()
 
-        pb = self._provider_bootstrapper
-        d = pb.run_provider_select_checks(provider, download_if_needed=True)
-        self._download_provider_defer = d
+        self._backend.setup_provider(provider)
 
     def _load_provider_config(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.download_provider_info
+        TRIGGER: self._backend.signaler.prov_download_provider_info
 
         Once the provider config has been downloaded, this loads the
         self._provider_config instance with it and starts the second
@@ -873,31 +907,13 @@ class MainWindow(QtGui.QMainWindow):
         run_provider_select_checks
         :type data: dict
         """
-        if data[self._provider_bootstrapper.PASSED_KEY]:
-            # XXX should rename this provider, name clash.
-            provider = self._login_widget.get_selected_provider()
-
-            # If there's no loaded provider or
-            # we want to connect to other provider...
-            if (not self._provider_config.loaded() or
-                    self._provider_config.get_domain() != provider):
-                self._provider_config.load(
-                    os.path.join("leap", "providers",
-                                 provider, "provider.json"))
-
-            if self._provider_config.loaded():
-                self._provider_bootstrapper.run_provider_setup_checks(
-                    self._provider_config,
-                    download_if_needed=True)
-            else:
-                self._login_widget.set_status(
-                    self.tr("Unable to login: Problem with provider"))
-                logger.error("Could not load provider configuration.")
-                self._login_widget.set_enabled(True)
+        if data[self._backend.PASSED_KEY]:
+            selected_provider = self._login_widget.get_selected_provider()
+            self._backend.provider_bootstrap(selected_provider)
         else:
             self._login_widget.set_status(
                 self.tr("Unable to login: Problem with provider"))
-            logger.error(data[self._provider_bootstrapper.ERROR_KEY])
+            logger.error(data[self._backend.ERROR_KEY])
             self._login_widget.set_enabled(True)
 
     def _login(self):
@@ -939,14 +955,14 @@ class MainWindow(QtGui.QMainWindow):
     def _provider_config_loaded(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.check_api_certificate
+        TRIGGER: self._backend.signaler.prov_check_api_certificate
 
         Once the provider configuration is loaded, this starts the SRP
         authentication
         """
         leap_assert(self._provider_config, "We need a provider config!")
 
-        if data[self._provider_bootstrapper.PASSED_KEY]:
+        if data[self._backend.PASSED_KEY]:
             username = self._login_widget.get_user()
             password = self._login_widget.get_password()
 
@@ -964,7 +980,7 @@ class MainWindow(QtGui.QMainWindow):
         else:
             self._login_widget.set_status(
                 "Unable to login: Problem with provider")
-            logger.error(data[self._provider_bootstrapper.ERROR_KEY])
+            logger.error(data[self._backend.ERROR_KEY])
             self._login_widget.set_enabled(True)
 
     def _authentication_finished(self, ok, message):
@@ -1538,11 +1554,11 @@ class MainWindow(QtGui.QMainWindow):
         This is used for intermediate bootstrapping stages, in case
         they fail.
         """
-        passed = data[self._provider_bootstrapper.PASSED_KEY]
+        passed = data[self._backend.PASSED_KEY]
         if not passed:
             self._login_widget.set_status(
                 self.tr("Unable to connect: Problem with provider"))
-            logger.error(data[self._provider_bootstrapper.ERROR_KEY])
+            logger.error(data[self._backend.ERROR_KEY])
             self._already_started_eip = False
 
     # end of EIP methods ---------------------------------------------
@@ -1615,21 +1631,21 @@ class MainWindow(QtGui.QMainWindow):
         """
         SLOT
         TRIGGERS:
-          self._provider_bootstrapper.name_resolution
-          self._provider_bootstrapper.https_connection
-          self._provider_bootstrapper.download_ca_cert
+          self._backend.signaler.prov_name_resolution
+          self._backend.signaler.prov_https_connection
+          self._backend.signaler.prov_download_ca_cert
           self._eip_bootstrapper.download_config
 
         If there was a problem, displays it, otherwise it does nothing.
         This is used for intermediate bootstrapping stages, in case
         they fail.
         """
-        passed = data[self._provider_bootstrapper.PASSED_KEY]
+        passed = data[self._backend.PASSED_KEY]
         if not passed:
             self._login_widget.set_enabled(True)
             self._login_widget.set_status(
                 self.tr("Unable to connect: Problem with provider"))
-            logger.error(data[self._provider_bootstrapper.ERROR_KEY])
+            logger.error(data[self._backend.ERROR_KEY])
 
     #
     # window handling methods
@@ -1719,6 +1735,7 @@ class MainWindow(QtGui.QMainWindow):
         # Set this in case that the app is hidden
         QtGui.QApplication.setQuitOnLastWindowClosed(True)
 
+        self._backend.stop()
         self._cleanup_and_quit()
 
         self._really_quit = True
diff --git a/src/leap/bitmask/gui/wizard.py b/src/leap/bitmask/gui/wizard.py
index ad0565e4..ec007110 100644
--- a/src/leap/bitmask/gui/wizard.py
+++ b/src/leap/bitmask/gui/wizard.py
@@ -30,7 +30,6 @@ from twisted.internet import threads
 from leap.bitmask.config.leapsettings import LeapSettings
 from leap.bitmask.config.providerconfig import ProviderConfig
 from leap.bitmask.crypto.srpregister import SRPRegister
-from leap.bitmask.provider.providerbootstrapper import ProviderBootstrapper
 from leap.bitmask.services import get_service_display_name, get_supported
 from leap.bitmask.util.request_helpers import get_content
 from leap.bitmask.util.keyring_helpers import has_keyring
@@ -55,12 +54,15 @@ class Wizard(QtGui.QWizard):
 
     BARE_USERNAME_REGEX = r"^[A-Za-z\d_]+$"
 
-    def __init__(self, bypass_checks=False):
+    def __init__(self, backend, bypass_checks=False):
         """
         Constructor for the main Wizard.
 
+        :param backend: Backend being used
+        :type backend: Backend
         :param bypass_checks: Set to true if the app should bypass
-        first round of checks for CA certificates at bootstrap
+                              first round of checks for CA
+                              certificates at bootstrap
         :type bypass_checks: bool
         """
         QtGui.QWizard.__init__(self)
@@ -68,6 +70,8 @@ class Wizard(QtGui.QWizard):
         self.ui = Ui_Wizard()
         self.ui.setupUi(self)
 
+        self._backend = backend
+
         self.setPixmap(QtGui.QWizard.LogoPixmap,
                        QtGui.QPixmap(":/images/mask-icon.png"))
 
@@ -86,23 +90,25 @@ class Wizard(QtGui.QWizard):
         self.ui.btnCheck.clicked.connect(self._check_provider)
         self.ui.lnProvider.returnPressed.connect(self._check_provider)
 
-        self._provider_bootstrapper = ProviderBootstrapper(bypass_checks)
-        self._provider_bootstrapper.name_resolution.connect(
+        self._backend.signaler.prov_name_resolution.connect(
             self._name_resolution)
-        self._provider_bootstrapper.https_connection.connect(
+        self._backend.signaler.prov_https_connection.connect(
             self._https_connection)
-        self._provider_bootstrapper.download_provider_info.connect(
+        self._backend.signaler.prov_download_provider_info.connect(
             self._download_provider_info)
 
-        self._provider_bootstrapper.download_ca_cert.connect(
+        self._backend.signaler.prov_download_ca_cert.connect(
             self._download_ca_cert)
-        self._provider_bootstrapper.check_ca_fingerprint.connect(
+        self._backend.signaler.prov_check_ca_fingerprint.connect(
             self._check_ca_fingerprint)
-        self._provider_bootstrapper.check_api_certificate.connect(
+        self._backend.signaler.prov_check_api_certificate.connect(
             self._check_api_certificate)
 
         self._domain = None
-        self._provider_config = ProviderConfig()
+        # HACK!! We need provider_config for the time being, it'll be
+        # removed
+        self._provider_config = (
+            self._backend._components["provider"]._provider_config)
 
         # We will store a reference to the defers for eventual use
         # (eg, to cancel them) but not doing anything with them right now.
@@ -385,8 +391,8 @@ class Wizard(QtGui.QWizard):
         self._domain = self.ui.lnProvider.text()
 
         self.ui.lblNameResolution.setPixmap(self.QUESTION_ICON)
-        self._provider_select_defer = self._provider_bootstrapper.\
-            run_provider_select_checks(self._domain)
+        self._provider_select_defer = self._backend.\
+            setup_provider(self._domain)
 
     def _skip_provider_checks(self, skip):
         """
@@ -423,8 +429,8 @@ class Wizard(QtGui.QWizard):
         :param complete_page: page id to complete
         :type complete_page: int
         """
-        passed = data[self._provider_bootstrapper.PASSED_KEY]
-        error = data[self._provider_bootstrapper.ERROR_KEY]
+        passed = data[self._backend.PASSED_KEY]
+        error = data[self._backend.ERROR_KEY]
         if passed:
             label.setPixmap(self.OK_ICON)
             if complete:
@@ -437,13 +443,13 @@ class Wizard(QtGui.QWizard):
     def _name_resolution(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.name_resolution
+        TRIGGER: self._backend.signaler.prov_name_resolution
 
         Sets the status for the name resolution check
         """
         self._complete_task(data, self.ui.lblNameResolution)
         status = ""
-        passed = data[self._provider_bootstrapper.PASSED_KEY]
+        passed = data[self._backend.PASSED_KEY]
         if not passed:
             status = self.tr("<font color='red'><b>Non-existent "
                              "provider</b></font>")
@@ -456,16 +462,16 @@ class Wizard(QtGui.QWizard):
     def _https_connection(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.https_connection
+        TRIGGER: self._backend.signaler.prov_https_connection
 
         Sets the status for the https connection check
         """
         self._complete_task(data, self.ui.lblHTTPS)
         status = ""
-        passed = data[self._provider_bootstrapper.PASSED_KEY]
+        passed = data[self._backend.PASSED_KEY]
         if not passed:
             status = self.tr("<font color='red'><b>%s</b></font>") \
-                % (data[self._provider_bootstrapper.ERROR_KEY])
+                % (data[self._backend.ERROR_KEY])
             self.ui.lblProviderSelectStatus.setText(status)
         else:
             self.ui.lblProviderInfo.setPixmap(self.QUESTION_ICON)
@@ -475,7 +481,7 @@ class Wizard(QtGui.QWizard):
     def _download_provider_info(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.download_provider_info
+        TRIGGER: self._backend.signaler.prov_download_provider_info
 
         Sets the status for the provider information download
         check. Since this check is the last of this set, it also
@@ -490,14 +496,14 @@ class Wizard(QtGui.QWizard):
             self._provider_checks_ok = True
         else:
             new_data = {
-                self._provider_bootstrapper.PASSED_KEY: False,
-                self._provider_bootstrapper.ERROR_KEY:
+                self._backend.PASSED_KEY: False,
+                self._backend.ERROR_KEY:
                 self.tr("Unable to load provider configuration")
             }
             self._complete_task(new_data, self.ui.lblProviderInfo)
 
         status = ""
-        if not data[self._provider_bootstrapper.PASSED_KEY]:
+        if not data[self._backend.PASSED_KEY]:
             status = self.tr("<font color='red'><b>Not a valid provider"
                              "</b></font>")
             self.ui.lblProviderSelectStatus.setText(status)
@@ -507,31 +513,31 @@ class Wizard(QtGui.QWizard):
     def _download_ca_cert(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.download_ca_cert
+        TRIGGER: self._backend.signaler.prov_download_ca_cert
 
         Sets the status for the download of the CA certificate check
         """
         self._complete_task(data, self.ui.lblDownloadCaCert)
-        passed = data[self._provider_bootstrapper.PASSED_KEY]
+        passed = data[self._backend.PASSED_KEY]
         if passed:
             self.ui.lblCheckCaFpr.setPixmap(self.QUESTION_ICON)
 
     def _check_ca_fingerprint(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.check_ca_fingerprint
+        TRIGGER: self._backend.signaler.prov_check_ca_fingerprint
 
         Sets the status for the CA fingerprint check
         """
         self._complete_task(data, self.ui.lblCheckCaFpr)
-        passed = data[self._provider_bootstrapper.PASSED_KEY]
+        passed = data[self._backend.PASSED_KEY]
         if passed:
             self.ui.lblCheckApiCert.setPixmap(self.QUESTION_ICON)
 
     def _check_api_certificate(self, data):
         """
         SLOT
-        TRIGGER: self._provider_bootstrapper.check_api_certificate
+        TRIGGER: self._backend.signaler.prov_check_api_certificate
 
         Sets the status for the API certificate check. Also finishes
         the provider bootstrapper thread since it's not needed anymore
@@ -612,8 +618,8 @@ class Wizard(QtGui.QWizard):
                 sub_title = sub_title.format(self._provider_config.get_name())
                 self.page(pageId).setSubTitle(sub_title)
                 self.ui.lblDownloadCaCert.setPixmap(self.QUESTION_ICON)
-                self._provider_setup_defer = self._provider_bootstrapper.\
-                    run_provider_setup_checks(self._provider_config)
+                self._provider_setup_defer = self._backend.\
+                    provider_bootstrap(self._domain)
 
         if pageId == self.PRESENT_PROVIDER_PAGE:
             self.page(pageId).setSubTitle(self.tr("Description of services "