Remove cont_auth from auth_handler

letsencrypt/auth_handler.py

@@ -25,10 +25,6 @@ class AuthHandler(object):
         :class:`~acme.challenges.DVChallenge` types
     :type dv_auth: :class:`letsencrypt.interfaces.IAuthenticator`
 
-    :ivar cont_auth: Authenticator capable of solving
-        :class:`~acme.challenges.ContinuityChallenge` types
-    :type cont_auth: :class:`letsencrypt.interfaces.IAuthenticator`
-
     :ivar acme.client.Client acme: ACME client API.
 
     :ivar account: Client's Account
@@ -38,13 +34,10 @@ class AuthHandler(object):
         and values are :class:`acme.messages.AuthorizationResource`
     :ivar list dv_c: DV challenges in the form of
         :class:`letsencrypt.achallenges.AnnotatedChallenge`
-    :ivar list cont_c: Continuity challenges in the
-        form of :class:`letsencrypt.achallenges.AnnotatedChallenge`
 
     """
-    def __init__(self, dv_auth, cont_auth, acme, account):
+    def __init__(self, dv_auth, acme, account):
         self.dv_auth = dv_auth
-        self.cont_auth = cont_auth
         self.acme = acme
 
         self.account = account
@@ -52,7 +45,6 @@ class AuthHandler(object):
 
         # List must be used to keep responses straight.
         self.dv_c = []
-        self.cont_c = []
 
     def get_authorizations(self, domains, best_effort=False):
         """Retrieve all authorizations for challenges.
@@ -76,12 +68,12 @@ class AuthHandler(object):
         self._choose_challenges(domains)
 
         # While there are still challenges remaining...
-        while self.dv_c or self.cont_c:
+        while self.dv_c:
-            cont_resp, dv_resp = self._solve_challenges()
+            dv_resp = self._solve_challenges()
             logger.info("Waiting for verification...")
 
-            # Send all Responses - this modifies dv_c and cont_c
+            # Send all Responses - this modifies dv_c
-            self._respond(cont_resp, dv_resp, best_effort)
+            self._respond(dv_resp, best_effort)
 
         # Just make sure all decisions are complete.
         self.verify_authzr_complete()
@@ -98,19 +90,15 @@ class AuthHandler(object):
                 self._get_chall_pref(dom),
                 self.authzr[dom].body.combinations)
 
-            dom_cont_c, dom_dv_c = self._challenge_factory(
+            dom_dv_c = self._challenge_factory(
                 dom, path)
             self.dv_c.extend(dom_dv_c)
-            self.cont_c.extend(dom_cont_c)
 
     def _solve_challenges(self):
         """Get Responses for challenges from authenticators."""
-        cont_resp = []
         dv_resp = []
         with error_handler.ErrorHandler(self._cleanup_challenges):
             try:
-                if self.cont_c:
-                    cont_resp = self.cont_auth.perform(self.cont_c)
                 if self.dv_c:
                     dv_resp = self.dv_auth.perform(self.dv_c)
             except errors.AuthorizationError:
@@ -118,12 +106,11 @@ class AuthHandler(object):
                 logger.info("Attempting to clean up outstanding challenges...")
                 raise
 
-        assert len(cont_resp) == len(self.cont_c)
         assert len(dv_resp) == len(self.dv_c)
 
-        return cont_resp, dv_resp
+        return dv_resp
 
-    def _respond(self, cont_resp, dv_resp, best_effort):
+    def _respond(self, dv_resp, best_effort):
         """Send/Receive confirmation of all challenges.
 
         .. note:: This method also cleans up the auth_handler state.
@@ -134,14 +121,12 @@ class AuthHandler(object):
         active_achalls = []
         active_achalls.extend(
             self._send_responses(self.dv_c, dv_resp, chall_update))
-        active_achalls.extend(
-            self._send_responses(self.cont_c, cont_resp, chall_update))
 
         # Check for updated status...
         try:
             self._poll_challenges(chall_update, best_effort)
         finally:
-            # This removes challenges from self.dv_c and self.cont_c
+            # This removes challenges from self.dv_c
             self._cleanup_challenges(active_achalls)
 
     def _send_responses(self, achalls, resps, chall_update):
@@ -255,7 +240,6 @@ class AuthHandler(object):
         """
         # Make sure to make a copy...
         chall_prefs = []
-        chall_prefs.extend(self.cont_auth.get_chall_pref(domain))
         chall_prefs.extend(self.dv_auth.get_chall_pref(domain))
         return chall_prefs
 
@@ -269,21 +253,14 @@ class AuthHandler(object):
 
         if achall_list is None:
             dv_c = self.dv_c
-            cont_c = self.cont_c
         else:
             dv_c = [achall for achall in achall_list
                     if isinstance(achall.chall, challenges.DVChallenge)]
-            cont_c = [achall for achall in achall_list if isinstance(
-                achall.chall, challenges.ContinuityChallenge)]
 
         if dv_c:
             self.dv_auth.cleanup(dv_c)
             for achall in dv_c:
                 self.dv_c.remove(achall)
-        if cont_c:
-            self.cont_auth.cleanup(cont_c)
-            for achall in cont_c:
-                self.cont_c.remove(achall)
 
     def verify_authzr_complete(self):
         """Verifies that all authorizations have been decided.
@@ -306,15 +283,12 @@ class AuthHandler(object):
 
         :returns: dv_chall, list of DVChallenge type
             :class:`letsencrypt.achallenges.Indexed`
-            cont_chall, list of ContinuityChallenge type
+        :rtype: list
-            :class:`letsencrypt.achallenges.Indexed`
-        :rtype: tuple
 
         :raises .errors.Error: if challenge type is not recognized
 
         """
         dv_chall = []
-        cont_chall = []
 
         for index in path:
             challb = self.authzr[domain].body.challenges[index]
@@ -322,12 +296,10 @@ class AuthHandler(object):
 
             achall = challb_to_achall(challb, self.account.key, domain)
 
-            if isinstance(chall, challenges.ContinuityChallenge):
+            if isinstance(chall, challenges.DVChallenge):
-                cont_chall.append(achall)
-            elif isinstance(chall, challenges.DVChallenge):
                 dv_chall.append(achall)
 
-        return cont_chall, dv_chall
+        return dv_chall
 
 
 def challb_to_achall(challb, account_key, domain):

letsencrypt/client.py

@@ -17,7 +17,6 @@ from letsencrypt import account
 from letsencrypt import auth_handler
 from letsencrypt import configuration
 from letsencrypt import constants
-from letsencrypt import continuity_auth
 from letsencrypt import crypto_util
 from letsencrypt import errors
 from letsencrypt import error_handler
@@ -188,10 +187,8 @@ class Client(object):
         # standalone (then default is False, otherwise default is True)
 
         if dv_auth is not None:
-            cont_auth = continuity_auth.ContinuityAuthenticator(config,
-                                                                installer)
             self.auth_handler = auth_handler.AuthHandler(
-                dv_auth, cont_auth, self.acme, self.account)
+                dv_auth, self.acme, self.account)
         else:
             self.auth_handler = None
 

letsencrypt/tests/auth_handler_test.py

@@ -23,8 +23,7 @@ class ChallengeFactoryTest(unittest.TestCase):
         from letsencrypt.auth_handler import AuthHandler
 
         # Account is mocked...
-        self.handler = AuthHandler(
+        self.handler = AuthHandler(None, None, mock.Mock(key="mock_key"))
-            None, None, None, mock.Mock(key="mock_key"))
 
         self.dom = "test"
         self.handler.authzr[self.dom] = acme_util.gen_authzr(
@@ -32,19 +31,15 @@ class ChallengeFactoryTest(unittest.TestCase):
             [messages.STATUS_PENDING] * 6, False)
 
     def test_all(self):
-        cont_c, dv_c = self.handler._challenge_factory(
+        dv_c = self.handler._challenge_factory(
             self.dom, range(0, len(acme_util.CHALLENGES)))
 
-        self.assertEqual(
-            [achall.chall for achall in cont_c], acme_util.CONT_CHALLENGES)
         self.assertEqual(
             [achall.chall for achall in dv_c], acme_util.DV_CHALLENGES)
 
-    def test_one_dv_one_cont(self):
+    def test_one_dv(self):
-        cont_c, dv_c = self.handler._challenge_factory(self.dom, [1, 3])
+        dv_c = self.handler._challenge_factory(self.dom, [1, 3])
 
-        self.assertEqual(
-            [achall.chall for achall in cont_c], [acme_util.RECOVERY_CONTACT])
         self.assertEqual([achall.chall for achall in dv_c], [acme_util.TLSSNI01])
 
     def test_unrecognized(self):
@@ -68,21 +63,16 @@ class GetAuthorizationsTest(unittest.TestCase):
         from letsencrypt.auth_handler import AuthHandler
 
         self.mock_dv_auth = mock.MagicMock(name="ApacheConfigurator")
-        self.mock_cont_auth = mock.MagicMock(name="ContinuityAuthenticator")
 
         self.mock_dv_auth.get_chall_pref.return_value = [challenges.TLSSNI01]
-        self.mock_cont_auth.get_chall_pref.return_value = [
-            challenges.RecoveryContact]
 
-        self.mock_cont_auth.perform.side_effect = gen_auth_resp
         self.mock_dv_auth.perform.side_effect = gen_auth_resp
 
         self.mock_account = mock.Mock(key=le_util.Key("file_path", "PEM"))
         self.mock_net = mock.MagicMock(spec=acme_client.Client)
 
         self.handler = AuthHandler(
-            self.mock_dv_auth, self.mock_cont_auth,
+            self.mock_dv_auth, self.mock_net, self.mock_account)
-            self.mock_net, self.mock_account)
 
         logging.disable(logging.CRITICAL)
 
@@ -106,7 +96,6 @@ class GetAuthorizationsTest(unittest.TestCase):
         self.assertEqual(len(chall_update.values()), 1)
 
         self.assertEqual(self.mock_dv_auth.cleanup.call_count, 1)
-        self.assertEqual(self.mock_cont_auth.cleanup.call_count, 0)
         # Test if list first element is TLSSNI01, use typ because it is an achall
         self.assertEqual(
             self.mock_dv_auth.cleanup.call_args[0][0][0].typ, "tls-sni-01")
@@ -114,29 +103,28 @@ class GetAuthorizationsTest(unittest.TestCase):
         self.assertEqual(len(authzr), 1)
 
     @mock.patch("letsencrypt.auth_handler.AuthHandler._poll_challenges")
-    def test_name3_tls_sni_01_3_rectok_3(self, mock_poll):
+    def test_name3_tls_sni_01_3(self, mock_poll):
         self.mock_net.request_domain_challenges.side_effect = functools.partial(
-            gen_dom_authzr, challs=acme_util.CHALLENGES)
+            gen_dom_authzr, challs=acme_util.DV_CHALLENGES)
 
         mock_poll.side_effect = self._validate_all
 
         authzr = self.handler.get_authorizations(["0", "1", "2"])
 
-        self.assertEqual(self.mock_net.answer_challenge.call_count, 6)
+        self.assertEqual(self.mock_net.answer_challenge.call_count, 3)
 
         # Check poll call
         self.assertEqual(mock_poll.call_count, 1)
         chall_update = mock_poll.call_args[0][0]
         self.assertEqual(len(chall_update.keys()), 3)
         self.assertTrue("0" in chall_update.keys())
-        self.assertEqual(len(chall_update["0"]), 2)
+        self.assertEqual(len(chall_update["0"]), 1)
         self.assertTrue("1" in chall_update.keys())
-        self.assertEqual(len(chall_update["1"]), 2)
+        self.assertEqual(len(chall_update["1"]), 1)
         self.assertTrue("2" in chall_update.keys())
-        self.assertEqual(len(chall_update["2"]), 2)
+        self.assertEqual(len(chall_update["2"]), 1)
 
         self.assertEqual(self.mock_dv_auth.cleanup.call_count, 1)
-        self.assertEqual(self.mock_cont_auth.cleanup.call_count, 1)
 
         self.assertEqual(len(authzr), 3)
 
@@ -170,7 +158,7 @@ class PollChallengesTest(unittest.TestCase):
         # Account and network are mocked...
         self.mock_net = mock.MagicMock()
         self.handler = AuthHandler(
-            None, None, self.mock_net, mock.Mock(key="mock_key"))
+            None, self.mock_net, mock.Mock(key="mock_key"))
 
         self.doms = ["0", "1", "2"]
         self.handler.authzr[self.doms[0]] = acme_util.gen_authzr(