- Rename get_repo_image to get_repo_image_extended and get_repo_image_directly to get_repo_image

- Remove the configure call from CloseForLongOperation
- Other small fixes

data/model/legacy.py

@@ -1034,18 +1034,18 @@ def get_repository(namespace_name, repository_name):
     return None
 
 
-def get_repo_image_directly(namespace_name, repository_name, docker_image_id):
+def get_repo_image(namespace_name, repository_name, docker_image_id):
   def limit_to_image_id(query):
     return query.where(Image.docker_image_id == docker_image_id).limit(1)
 
-  query = _get_repository_images_directly(namespace_name, repository_name, limit_to_image_id)
+  query = _get_repository_images(namespace_name, repository_name, limit_to_image_id)
   try:
     return query.get()
   except Image.DoesNotExist:
     return None
 
 
-def get_repo_image(namespace_name, repository_name, docker_image_id):
+def get_repo_image_extended(namespace_name, repository_name, docker_image_id):
   def limit_to_image_id(query):
     return query.where(Image.docker_image_id == docker_image_id).limit(1)
 
@@ -1156,7 +1156,8 @@ def __translate_ancestry(old_ancestry, translations, repository, username, prefe
 
   # Select all the ancestor Docker IDs in a single query.  
   old_ids = [int(id_str) for id_str in old_ancestry.split('/')[1:-1]]
-  old_images = {i.id: i.docker_image_id for i in Image.select().where(Image.id << old_ids)}
+  query = Image.select(Image.id, Image.docker_image_id).where(Image.id << old_ids)
+  old_images = {i.id: i.docker_image_id for i in  query}
 
   # Translate the old images into new ones.
   new_ids = [str(translate_id(old_id, old_images[old_id])) for old_id in old_ids]
@@ -1176,8 +1177,8 @@ def _find_or_link_image(existing_image, repository, username, translations, pref
   # it instead be done under a set of transactions?
   with config.app_config['DB_TRANSACTION_FACTORY'](db):
     # Check for an existing image, under the transaction, to make sure it doesn't already exist.
-    repo_image = get_repo_image_directly(repository.namespace_user.username, repository.name,
-                                         existing_image.docker_image_id)
+    repo_image = get_repo_image(repository.namespace_user.username, repository.name,
+                                existing_image.docker_image_id)
     if repo_image:
       return repo_image
 
@@ -1210,8 +1211,8 @@ def find_create_or_link_image(docker_image_id, repository, username, translation
                               preferred_location):
 
   # First check for the image existing in the repository. If found, we simply return it.
-  repo_image = get_repo_image_directly(repository.namespace_user.username, repository.name,
-                                       docker_image_id)
+  repo_image = get_repo_image(repository.namespace_user.username, repository.name,
+                              docker_image_id)
   if repo_image:
     return repo_image
 
@@ -1250,8 +1251,8 @@ def find_create_or_link_image(docker_image_id, repository, username, translation
   # Otherwise, create a new storage directly.
   with config.app_config['DB_TRANSACTION_FACTORY'](db):
     # Final check for an existing image, under the transaction.
-    repo_image = get_repo_image_directly(repository.namespace_user.username, repository.name,
-                                         docker_image_id)
+    repo_image = get_repo_image(repository.namespace_user.username, repository.name,
+                                docker_image_id)
     if repo_image:
       return repo_image
 
@@ -1374,7 +1375,7 @@ def set_image_metadata(docker_image_id, namespace_name, repository_name, created
     fetched.storage.save()
     return fetched
 
-def _get_repository_images_directly(namespace_name, repository_name, query_modifier):
+def _get_repository_images(namespace_name, repository_name, query_modifier):
   query = (Image
            .select()
            .join(Repository)
@@ -1420,12 +1421,12 @@ def _get_repository_images_base(namespace_name, repository_name, query_modifier)
 
 
 def lookup_repository_images(namespace_name, repository_name, docker_image_ids):
-  repo = get_repository(namespace_name, repository_name)
-  if repo is None:
-    return []
-
-  return Image.select().where(Image.repository == repo, Image.docker_image_id << docker_image_ids)
-
+  return (Image
+          .select()
+          .join(Repository)
+          .join(Namespace, on=(Repository.namespace_user == Namespace.id))
+          .where(Repository.name == repository_name, Namespace.username == namespace_name,
+                 Image.docker_image_id << docker_image_ids))
 
 def get_matching_repository_images(namespace_name, repository_name, docker_image_ids):
   def modify_query(q):
@@ -1472,7 +1473,7 @@ def garbage_collect_repository(namespace_name, repository_name):
       referenced_anscestors = referenced_anscestors.union(set(ancestor_list))
       referenced_anscestors.add(tag.image.id)
 
-    all_repo_images = _get_repository_images_directly(namespace_name, repository_name, lambda q: q)
+    all_repo_images = _get_repository_images(namespace_name, repository_name, lambda q: q)
     all_images = {int(img.id): img for img in all_repo_images}
     to_remove = set(all_images.keys()).difference(referenced_anscestors)
 
@@ -1585,7 +1586,7 @@ def get_tag_image(namespace_name, repository_name, tag_name):
 
 
 def get_image_by_id(namespace_name, repository_name, docker_image_id):
-  image = get_repo_image(namespace_name, repository_name, docker_image_id)
+  image = get_repo_image_extended(namespace_name, repository_name, docker_image_id)
   if not image:
     raise DataModelException('Unable to find image \'%s\' for repo \'%s/%s\'' %
                              (docker_image_id, namespace_name, repository_name))
@@ -1816,11 +1817,10 @@ def get_repository_delegate_tokens(namespace_name, repository_name):
 
 def get_repo_delegate_token(namespace_name, repository_name, code):
   repo_query = get_repository_delegate_tokens(namespace_name, repository_name)
-  found = list(repo_query.where(AccessToken.code == code).limit(1))
 
-  if found:
-    return found[0]
-  else:
+  try:
+    return repo_query.where(AccessToken.code == code).get()
+  except AccessToken.DoesNotExist:
     raise InvalidTokenException('Unable to find token with code: %s' % code)