merge

mercurial_keyring.py

@@ -54,10 +54,21 b' import socket'
 import os
 import sys
 
+# pylint:disable=invalid-name
+
+###########################################################################
+# Specific import trickery
+###########################################################################
+
+
 def import_meu():
-    """Imports and returns mercurial_extension_utils module.
-    Workaround for TortoiseHg/Win environment, where this module
-    can'b be easily put on PYTHONPATH"""
+    """
+    Convoluted import of mercurial_extension_utils, which helps
+    TortoiseHg/Win setups. This routine and it's use below
+    performs equivalent of
+        from mercurial_extension_utils import monkeypatch_method
+    but looks for some non-path directories.
+    """
     try:
         import mercurial_extension_utils
     except ImportError:
@@ -86,7 +97,8 b' monkeypatch_method = meu.monkeypatch_met'
 def import_keyring():
     """
     Importing keyring happens to be costly if wallet is slow, so we delay it
-    until really needed.
+    until it is really needed. The routine below also works around various
+    demandimport-related problems.
     """
     if 'keyring' in sys.modules:
         return sys.modules['keyring']
@@ -116,6 +128,8 b' def import_keyring():'
     ]:
         if blocked_module not in demandimport.ignore:
             demandimport.ignore.append(blocked_module)
+
+    # Various attempts to define is_demandimport_enabled 
     try:
         is_demandimport_enabled = demandimport.isenabled
     except AttributeError:
@@ -124,6 +138,7 b' def import_keyring():'
             orig_demandimport = demandimport.demandimport
         except AttributeError:
             orig_demandimport = demandimport._demandimport
+
         def is_demandimport_enabled():
             """Checks whether demandimport is enabled at the moment"""
             return __import__ == orig_demandimport
@@ -148,9 +163,12 b' def import_keyring():'
         import keyring
     return keyring
 
+#################################################################
+# Actual implementation
+#################################################################
+
 KEYRING_SERVICE = "Mercurial"
 
-############################################################
 
 class PasswordStore(object):
     """
@@ -222,17 +240,26 b' class PasswordStore(object):'
 
 password_store = PasswordStore()
 
+
+############################################################
+# Tiny utils
 ############################################################
 
 def _debug(ui, msg):
+    """Generic debug message"""
     ui.debug("keyring: " + msg + "\n")
 
+
 def _debug_reply(ui, msg, url, user, pwd):
+    """Debugging used to note info about data given"""
     _debug(ui, "%s. Url: %s, user: %s, passwd: %s" % (
             msg, url, user, pwd and '*' * len(pwd) or 'not set'))
 
 
 ############################################################
+# Mercurial modifications
+############################################################
+
 
 class HTTPPasswordHandler(object):
     """
@@ -245,6 +272,16 b' class HTTPPasswordHandler(object):'
         self.pwd_cache = {}
         self.last_reply = None
 
+    def _return_pwd(self, ui, msg, base_url, realm, authuri, user, req, pwd):
+        """
+        Internal helper. Saves info about auth-data obtained, preserves them in last_reply
+        and returns pair user,pwd
+        """
+        _debug_reply(ui, _(msg), base_url, user, pwd)
+        self.last_reply = dict(realm=realm, authuri=authuri,
+                               user=user, req=req)
+        return user, pwd
+
     def find_auth(self, pwmgr, realm, authuri, req):
         """
         Actual implementation of find_user_password - different
@@ -256,9 +293,9 b' class HTTPPasswordHandler(object):'
         # request, then the previously returned auth must have been
         # wrong. So we note this to force password prompt (and avoid
         # reusing bad password indifinitely).
-        after_bad_auth = (self.last_reply \
-                          and (self.last_reply['realm'] == realm) \
-                          and (self.last_reply['authuri'] == authuri) \
+        after_bad_auth = (self.last_reply
+                          and (self.last_reply['realm'] == realm)
+                          and (self.last_reply['authuri'] == authuri)
                           and (self.last_reply['req'] == req))
         if after_bad_auth:
             _debug(ui, _("Working after bad authentication, cached passwords not used %s") % str(self.last_reply))
@@ -271,11 +308,8 b' class HTTPPasswordHandler(object):'
         user, pwd = urllib2.HTTPPasswordMgrWithDefaultRealm.find_user_password(
             pwmgr, realm, authuri)
         if user and pwd:
-            _debug_reply(ui, _("Auth data found in repository URL"),
-                         base_url, user, pwd)
-            self.last_reply = dict(
-                realm=realm, authuri=authuri, user=user,req=req)
-            return user, pwd
+            return self._return_pwd(ui, "Auth data present in repository URL", base_url,
+                                    realm, authuri, user, req, pwd)
 
         # Loading .hg/hgrc [auth] section contents. If prefix is given,
         # it will be used as a key to lookup password in the keyring.
@@ -292,10 +326,8 b' class HTTPPasswordHandler(object):'
             cached_auth = self.pwd_cache.get(cache_key)
             if cached_auth:
                 user, pwd = cached_auth
-                _debug_reply(ui, _("Cached auth data found"),
-                             base_url, user, pwd)
-                self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
-                return user, pwd
+                return self._return_pwd(ui, "Cached auth data found", base_url,
+                                        realm, authuri, user, req, pwd)
 
         if auth_user:
             if user and (user != auth_user):
@@ -303,10 +335,8 b' class HTTPPasswordHandler(object):'
             user = auth_user
             if pwd:
                 self.pwd_cache[cache_key] = user, pwd
-                _debug_reply(ui, _("Auth data set in .hg/hgrc"),
-                             base_url, user, pwd)
-                self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
-                return user, pwd
+                return self._return_pwd(ui, "Auth data set in .hg/hgrc", base_url,
+                                        realm, authuri, user, req, pwd)
             else:
                 _debug(ui, _("Username found in .hg/hgrc: %s") % user)
 
@@ -318,10 +348,8 b' class HTTPPasswordHandler(object):'
             pwd = password_store.get_http_password(keyring_url, user)
             if pwd:
                 self.pwd_cache[cache_key] = user, pwd
-                _debug_reply(ui, _("Keyring password found"),
-                             base_url, user, pwd)
-                self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
-                return user, pwd
+                return self._return_pwd(ui, "Password found in keyring", base_url,
+                                        realm, authuri, user, req, pwd)
             else:
                 _debug(ui, _("Password not present in the keyring"))
 
@@ -354,10 +382,8 b' class HTTPPasswordHandler(object):'
         # Saving password to the memory cache
         self.pwd_cache[cache_key] = user, pwd
 
-        _debug_reply(ui, _("Manually entered password"),
-                     base_url, user, pwd)
-        self.last_reply = dict(realm=realm,authuri=authuri,user=user,req=req)
-        return user, pwd
+        return self._return_pwd(ui, "Manually entered password", base_url,
+                                realm, authuri, user, req, pwd)
 
     def load_hgrc_auth(self, ui, base_url, user):
         """
@@ -367,11 +393,9 b' class HTTPPasswordHandler(object):'
         element can be None)
         """
         # Theoretically 3 lines below should do:
-
         #auth_token = self.readauthtoken(base_url)
         #if auth_token:
         #   user, pwd = auth.get('username'), auth.get('password')
-
         # Unfortunately they do not work, readauthtoken always return
         # None. Why? Because ui (self.ui of passwordmgr) describes the
         # *remote* repository, so does *not* contain any option from
@@ -445,6 +469,9 b' class HTTPPasswordHandler(object):'
                               parsed_url.path)
 
 ############################################################
+# Monkeypatching
+############################################################
+
 
 @monkeypatch_method(passwordmgr)
 def find_user_password(self, realm, authuri):
@@ -466,6 +493,7 b' def find_user_password(self, realm, auth'
 
     return self._pwd_handler.find_auth(self, realm, authuri, req)
 
+
 @monkeypatch_method(urllib2.AbstractBasicAuthHandler, "http_error_auth_reqed")
 def basic_http_error_auth_reqed(self, authreq, host, req, headers):
     self.passwd._http_req = req
@@ -474,6 +502,7 b' def basic_http_error_auth_reqed(self, au'
     finally:
         self.passwd._http_req = None
 
+
 @monkeypatch_method(urllib2.AbstractDigestAuthHandler, "http_error_auth_reqed")
 def digest_http_error_auth_reqed(self, authreq, host, req, headers):
     self.passwd._http_req = req
@@ -483,6 +512,9 b' def digest_http_error_auth_reqed(self, a'
         self.passwd._http_req = None
 
 ############################################################
+# SMTP support
+############################################################
+
 
 def try_smtp_login(ui, smtp_obj, username, password):
     """
@@ -511,6 +543,7 b' def try_smtp_login(ui, smtp_obj, usernam'
         else:
             raise util.Abort(inst)
 
+
 def keyring_supported_smtp(ui, username):
     """
     keyring-integrated replacement for mercurial.mail._smtp
@@ -590,8 +623,9 b' def keyring_supported_smtp(ui, username)'
     return send
 
 ############################################################
+# SMTP monkeypatching
+############################################################
 
-orig_smtp = mail._smtp
 
 @monkeypatch_method(mail)
 def _smtp(ui):
@@ -608,4 +642,4 b' def _smtp(ui):'
     if username and not password:
         return keyring_supported_smtp(ui, username)
     else:
-        return orig_smtp(ui)
+        return _smtp.orig(ui)