caches: ensure we don't use non-ascii characters in cache keys.

- this could before lead to problems in beaker cache implementation.

rhodecode/lib/auth.py

@@ -1045,8 +1045,8 b' class AuthUser(object):'
             default_ips = UserIpMap.query().filter(
                 UserIpMap.user == User.get_default_user(cache=True))
             if cache:
-                default_ips = default_ips.options(FromCache("sql_cache_short",
-                                                  "get_user_ips_default"))
+                default_ips = default_ips.options(
+                    FromCache("sql_cache_short", "get_user_ips_default"))
 
             # populate from default user
             for ip in default_ips:
@@ -1059,8 +1059,8 b' class AuthUser(object):'
 
         user_ips = UserIpMap.query().filter(UserIpMap.user_id == user_id)
         if cache:
-            user_ips = user_ips.options(FromCache("sql_cache_short",
-                                                  "get_user_ips_%s" % user_id))
+            user_ips = user_ips.options(
+                FromCache("sql_cache_short", "get_user_ips_%s" % user_id))
 
         for ip in user_ips:
             try:

rhodecode/model/db.py

@@ -761,9 +761,9 b' class User(Base, BaseModel):'
                 if val:
                     return val
             else:
+                cache_key = "get_user_by_name_%s" % _hash_key(username)
                 q = q.options(
-                    FromCache("sql_cache_short",
-                              "get_user_by_name_%s" % _hash_key(username)))
+                    FromCache("sql_cache_short", cache_key))
 
         return q.scalar()
 
@@ -774,8 +774,8 b' class User(Base, BaseModel):'
             .filter(or_(UserApiKeys.expires == -1,
                         UserApiKeys.expires >= time.time()))
         if cache:
-            q = q.options(FromCache("sql_cache_short",
-                                    "get_auth_token_%s" % auth_token))
+            q = q.options(
+                FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
 
         match = q.first()
         if match:
@@ -790,9 +790,10 b' class User(Base, BaseModel):'
         else:
             q = cls.query().filter(cls.email == email)
 
+        email_key = _hash_key(email)
         if cache:
-            q = q.options(FromCache("sql_cache_short",
-                                    "get_email_key_%s" % _hash_key(email)))
+            q = q.options(
+                FromCache("sql_cache_short", "get_email_key_%s" % email_key))
 
         ret = q.scalar()
         if ret is None:
@@ -804,8 +805,8 b' class User(Base, BaseModel):'
                 q = q.filter(UserEmailMap.email == email)
             q = q.options(joinedload(UserEmailMap.user))
             if cache:
-                q = q.options(FromCache("sql_cache_short",
-                                        "get_email_map_key_%s" % email))
+                q = q.options(
+                    FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))
             ret = getattr(q.scalar(), 'user', None)
 
         return ret
@@ -1195,17 +1196,16 b' class UserGroup(Base, BaseModel):'
         else:
             q = cls.query().filter(cls.users_group_name == group_name)
         if cache:
-            q = q.options(FromCache(
-                            "sql_cache_short",
-                            "get_group_%s" % _hash_key(group_name)))
+            q = q.options(
+                FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))
         return q.scalar()
 
     @classmethod
     def get(cls, user_group_id, cache=False):
         user_group = cls.query()
         if cache:
-            user_group = user_group.options(FromCache("sql_cache_short",
-                                    "get_users_group_%s" % user_group_id))
+            user_group = user_group.options(
+                FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
         return user_group.get(user_group_id)
 
     def permissions(self, with_admins=True, with_owner=True):
@@ -1546,9 +1546,9 b' class Repository(Base, BaseModel):'
                 if val:
                     return val
             else:
+                cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
                 q = q.options(
-                    FromCache("sql_cache_short",
-                              "get_repo_by_name_%s" % _hash_key(repo_name)))
+                    FromCache("sql_cache_short", cache_key))
 
         return q.scalar()
 
@@ -2204,9 +2204,9 b' class RepoGroup(Base, BaseModel):'
         else:
             gr = cls.query().filter(cls.group_name == group_name)
         if cache:
-            gr = gr.options(FromCache(
-                            "sql_cache_short",
-                            "get_group_%s" % _hash_key(group_name)))
+            name_key = _hash_key(group_name)
+            gr = gr.options(
+                FromCache("sql_cache_short", "get_group_%s" % name_key))
         return gr.scalar()
 
     @classmethod

rhodecode/model/integration.py

@@ -200,14 +200,14 b' class IntegrationModel(BaseModel):'
             query = query.filter(or_(*clauses))
 
             if cache:
-                query = query.options(FromCache(
-                    "sql_cache_short",
-                    "get_enabled_repo_integrations_%i" % event.repo.repo_id))
+                cache_key = "get_enabled_repo_integrations_%i" % event.repo.repo_id
+                query = query.options(
+                    FromCache("sql_cache_short", cache_key))
         else: # only global integrations
             query = query.filter(global_integrations_filter)
             if cache:
-                query = query.options(FromCache(
-                    "sql_cache_short", "get_enabled_global_integrations"))
+                query = query.options(
+                    FromCache("sql_cache_short", "get_enabled_global_integrations"))
 
         result = query.all()
         return result
  No newline at end of file

rhodecode/model/repo.py

@@ -44,7 +44,7 b' from rhodecode.lib.utils2 import ('
     get_current_rhodecode_user, safe_int, datetime_to_time, action_logger_generic)
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.model import BaseModel
-from rhodecode.model.db import (
+from rhodecode.model.db import (_hash_key,
     Repository, UserRepoToPerm, UserGroupRepoToPerm, UserRepoGroupToPerm,
     UserGroupRepoGroupToPerm, User, Permission, Statistics, UserGroup,
     RepoGroup, RepositoryField)
@@ -99,8 +99,8 b' class RepoModel(BaseModel):'
             .filter(Repository.repo_id == repo_id)
 
         if cache:
-            repo = repo.options(FromCache("sql_cache_short",
-                                          "get_repo_%s" % repo_id))
+            repo = repo.options(
+                FromCache("sql_cache_short", "get_repo_%s" % repo_id))
         return repo.scalar()
 
     def get_repo(self, repository):
@@ -111,8 +111,9 b' class RepoModel(BaseModel):'
             .filter(Repository.repo_name == repo_name)
 
         if cache:
-            repo = repo.options(FromCache("sql_cache_short",
-                                          "get_repo_%s" % repo_name))
+            name_key = _hash_key(repo_name)
+            repo = repo.options(
+                FromCache("sql_cache_short", "get_repo_%s" % name_key))
         return repo.scalar()
 
     def _extract_id_from_repo_name(self, repo_name):

rhodecode/model/repo_group.py

@@ -35,7 +35,7 b' from zope.cachedescriptors.property impo'
 
 from rhodecode import events
 from rhodecode.model import BaseModel
-from rhodecode.model.db import (
+from rhodecode.model.db import (_hash_key,
     RepoGroup, UserRepoGroupToPerm, User, Permission, UserGroupRepoGroupToPerm,
     UserGroup, Repository)
 from rhodecode.model.settings import VcsSettingsModel, SettingsModel
@@ -73,8 +73,9 b' class RepoGroupModel(BaseModel):'
             .filter(RepoGroup.group_name == repo_group_name)
 
         if cache:
-            repo = repo.options(FromCache(
-                "sql_cache_short", "get_repo_group_%s" % repo_group_name))
+            name_key = _hash_key(repo_group_name)
+            repo = repo.options(
+                FromCache("sql_cache_short", "get_repo_group_%s" % name_key))
         return repo.scalar()
 
     def get_default_create_personal_repo_group(self):

rhodecode/model/user.py

@@ -40,7 +40,7 b' from rhodecode.lib.utils2 import ('
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.model import BaseModel
 from rhodecode.model.auth_token import AuthTokenModel
-from rhodecode.model.db import (
+from rhodecode.model.db import (_hash_key,
     or_, joinedload, User, UserToPerm, UserEmailMap, UserIpMap, UserLog)
 from rhodecode.lib.exceptions import (
     DefaultUserException, UserOwnsReposException, UserOwnsRepoGroupsException,
@@ -58,8 +58,8 b' class UserModel(BaseModel):'
     def get(self, user_id, cache=False):
         user = self.sa.query(User)
         if cache:
-            user = user.options(FromCache("sql_cache_short",
-                                          "get_user_%s" % user_id))
+            user = user.options(
+                FromCache("sql_cache_short", "get_user_%s" % user_id))
         return user.get(user_id)
 
     def get_user(self, user):
@@ -112,8 +112,9 b' class UserModel(BaseModel):'
             user = self.sa.query(User)\
                 .filter(User.username == username)
         if cache:
-            user = user.options(FromCache("sql_cache_short",
-                                          "get_user_%s" % username))
+            name_key = _hash_key(username)
+            user = user.options(
+                FromCache("sql_cache_short", "get_user_%s" % name_key))
         return user.scalar()
 
     def get_by_email(self, email, cache=False, case_insensitive=False):

rhodecode/tests/lib/middleware/test_simplevcs.py

@@ -87,8 +87,8 b' def vcscontroller(pylonsapp, config_stub'
 def _remove_default_user_from_query_cache():
     user = User.get_default_user(cache=True)
     query = Session().query(User).filter(User.username == user.username)
-    query = query.options(FromCache(
-        "sql_cache_short", "get_user_%s" % _hash_key(user.username)))
+    query = query.options(
+        FromCache("sql_cache_short", "get_user_%s" % _hash_key(user.username)))
     query.invalidate()
     Session().expire(user)