Fix references to LogEntry model used and add support for a maximum page of results on the logs API

data/model/log.py

@@ -16,7 +16,7 @@ ACTIONS_ALLOWED_WITHOUT_AUDIT_LOGGING = ['pull_repo']
 
 
 def _logs_query(selections, start_time=None, end_time=None, performer=None, repository=None,
-                namespace=None, ignore=None, model=LogEntry, id_range=None):
+                namespace=None, ignore=None, model=LogEntry2, id_range=None):
   """ Returns a query for selecting logs from the table, with various options and filters. """
   # TODO(LogMigrate): Remove the branch once we're back on LogEntry only.
   assert (start_time is not None and end_time is not None) or (id_range is not None)
@@ -64,7 +64,7 @@ def _get_log_entry_kind(name):
 
 
 def get_aggregated_logs(start_time, end_time, performer=None, repository=None, namespace=None,
-                        ignore=None, model=LogEntry):
+                        ignore=None, model=LogEntry2):
   """ Returns the count of logs, by kind and day, for the logs matching the given filters. """
   # TODO(LogMigrate): Remove the branch once we're back on LogEntry only.
   date = db.extract_date('day', model.datetime)
@@ -75,7 +75,7 @@ def get_aggregated_logs(start_time, end_time, performer=None, repository=None, n
 
 
 def get_logs_query(start_time=None, end_time=None, performer=None, repository=None, namespace=None,
-                   ignore=None, model=LogEntry, id_range=None):
+                   ignore=None, model=LogEntry2, id_range=None):
   """ Returns the logs matching the given filters. """
   # TODO(LogMigrate): Remove the branch once we're back on LogEntry only.
   Performer = User.alias()
@@ -205,49 +205,52 @@ def get_repositories_action_sums(repository_ids):
   return action_count_map
 
 
-def get_minimum_id_for_logs(start_time, repository_id=None, namespace_id=None):
+def get_minimum_id_for_logs(start_time, repository_id=None, namespace_id=None, model=LogEntry2):
   """ Returns the minimum ID for logs matching the given repository or namespace in
       the logs table, starting at the given start time.
   """
   # First try bounded by a day. Most repositories will meet this criteria, and therefore
   # can make a much faster query.
   day_after = start_time + timedelta(days=1)
-  result = _get_bounded_id(fn.Min, LogEntry.datetime >= start_time,
-                           repository_id, namespace_id, LogEntry.datetime < day_after)
+  result = _get_bounded_id(fn.Min, model.datetime >= start_time,
+                           repository_id, namespace_id, model.datetime < day_after, model=model)
   if result is not None:
     return result
 
-  return _get_bounded_id(fn.Min, LogEntry.datetime >= start_time, repository_id, namespace_id)
+  return _get_bounded_id(fn.Min, model.datetime >= start_time, repository_id, namespace_id,
+                         model=model)
 
 
-def get_maximum_id_for_logs(end_time, repository_id=None, namespace_id=None):
+def get_maximum_id_for_logs(end_time, repository_id=None, namespace_id=None, model=LogEntry2):
   """ Returns the maximum ID for logs matching the given repository or namespace in
       the logs table, ending at the given end time.
   """
   # First try bounded by a day. Most repositories will meet this criteria, and therefore
   # can make a much faster query.
   day_before = end_time - timedelta(days=1)
-  result = _get_bounded_id(fn.Max, LogEntry.datetime <= end_time,
-                           repository_id, namespace_id, LogEntry.datetime > day_before)
+  result = _get_bounded_id(fn.Max, model.datetime <= end_time,
+                           repository_id, namespace_id, model.datetime > day_before, model=model)
   if result is not None:
     return result
 
-  return _get_bounded_id(fn.Max, LogEntry.datetime <= end_time, repository_id, namespace_id)
+  return _get_bounded_id(fn.Max, model.datetime <= end_time, repository_id, namespace_id,
+                         model=model)
 
 
-def _get_bounded_id(fn, filter_clause, repository_id, namespace_id, reduction_clause=None):
+def _get_bounded_id(fn, filter_clause, repository_id, namespace_id, reduction_clause=None,
+                    model=LogEntry2):
   assert (namespace_id is not None) or (repository_id is not None)
-  query = (LogEntry
-           .select(fn(LogEntry.id))
+  query = (model
+           .select(fn(model.id))
            .where(filter_clause))
 
   if reduction_clause is not None:
     query = query.where(reduction_clause)
 
   if repository_id is not None:
-    query = query.where(LogEntry.repository == repository_id)
+    query = query.where(model.repository == repository_id)
   else:
-    query = query.where(LogEntry.account == namespace_id)
+    query = query.where(model.account == namespace_id)
 
   row = query.tuples()[0]
   if not row:

data/model/modelutil.py

@@ -1,6 +1,7 @@
 from peewee import SQL
 
-def paginate(query, model, descending=False, page_token=None, limit=50, id_alias=None):
+def paginate(query, model, descending=False, page_token=None, limit=50, id_alias=None,
+             max_page=None):
   """ Paginates the given query using an ID range, starting at the optional page_token.
       Returns a *list* of matching results along with an unencrypted page_token for the
       next page, if any. If descending is set to True, orders by the ID descending rather
@@ -27,7 +28,12 @@ def paginate(query, model, descending=False, page_token=None, limit=50, id_alias
       query = query.where(model.id >= start_id)
 
   query = query.limit(limit + 1)
-  return paginate_query(query, limit=limit, id_alias=id_alias)
+
+  page_number = (page_token.get('page_number') or None) if page_token else None
+  if page_number is not None and max_page is not None and page_number > max_page:
+    return [], None
+
+  return paginate_query(query, limit=limit, id_alias=id_alias, page_number=page_number)
 
 
 def pagination_start(page_token=None):
@@ -38,7 +44,7 @@ def pagination_start(page_token=None):
   return None
 
 
-def paginate_query(query, limit=50, id_alias=None):
+def paginate_query(query, limit=50, id_alias=None, page_number=None):
   """ Executes the given query and returns a page's worth of results, as well as the page token
       for the next page (if any).
   """
@@ -47,7 +53,8 @@ def paginate_query(query, limit=50, id_alias=None):
   if len(results) > limit:
     start_id = getattr(results[limit], id_alias or 'id')
     page_token = {
-      'start_id': start_id
+      'start_id': start_id,
+      'page_number': page_number + 1 if page_number else 1,
     }
 
   return results[0:limit], page_token

data/model/test/test_log.py

@@ -1,6 +1,6 @@
 import pytest
 
-from data.database import LogEntry, User
+from data.database import LogEntry2, User
 from data.model import config as _config
 from data.model.log import log_action
 
@@ -21,8 +21,8 @@ def logentry_kind():
 
 @pytest.fixture()
 def logentry(logentry_kind):
-  with patch('data.database.LogEntry.create', spec=True):
-    yield LogEntry
+  with patch('data.database.LogEntry2.create', spec=True):
+    yield LogEntry2
 
 @pytest.fixture()
 def user():