Remove use of search API; effectively remove support to search for task by name.

appengine/swarming/handlers_frontend.py

 # Copyright 2013 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
 """Main entry point for Swarming service.
 
 This file contains the URL handlers for all the Swarming service URLs,
 implemented using the webapp2 framework.
 """
 
 import collections
 import datetime
 import itertools
 import os
 import re
 
 import webapp2
 
 from google.appengine import runtime
-from google.appengine.api import search
 from google.appengine.api import users
 from google.appengine.datastore import datastore_query
 from google.appengine.ext import ndb
 
 import handlers_bot
 import handlers_backend
 import mapreduce_jobs
 import template
 from components import auth
+from components import datastore_utils
 from components import utils
 from server import acl
 from server import bot_code
 from server import bot_management
 from server import config
 from server import stats_gviz
 from server import task_pack
 from server import task_request
 from server import task_result
 from server import task_scheduler
@@ skipping 365 matching lines @@
         'Using this order resets order to \'Created\'.'),
       ('canceled', 'Canceled',
         'The task was explictly canceled by a user before it started '
         'executing. Using this order resets order to \'Created\'.'),
     ],
   ]
 
   @auth.autologin
   @auth.require(acl.is_user)
   def get(self):
-    """Handles both ndb.Query searches and search.Index().search() queries.
-
-    If |task_name| is set or not affects the meaning of |cursor|. When set, the
-    cursor is for search.Index, otherwise the cursor is for a ndb.Query.
-    """
     cursor_str = self.request.get('cursor')
     limit = int(self.request.get('limit', 100))
     sort = self.request.get('sort', self.SORT_CHOICES[0][0])
     state = self.request.get('state', self.STATE_CHOICES[0][0][0])
-    task_name = self.request.get('task_name', '').strip()
     counts = self.request.get('counts', '').strip()
     task_tags = [
       line for line in self.request.get('task_tag', '').splitlines() if line
     ]
 
     if not any(sort == i[0] for i in self.SORT_CHOICES):
       self.abort(400, 'Invalid sort')
     if not any(any(state == i[0] for i in j) for j in self.STATE_CHOICES):
       self.abort(400, 'Invalid state')
 
     if sort != 'created_ts':
       # Zap all filters in this case to reduce the number of required indexes.
       # Revisit according to the user requests.
       state = 'all'
 
     now = utils.utcnow()
     # "Temporarily" disable the count. This is too slow on the prod server
     # (>10s). The fix is to have the web page do a XHR query to get the values
     # asynchronously.
     counts_future = None
     if counts == 'true':
       counts_future = self._get_counts_future(now)
 
-    # This call is synchronous.
     try:
-      tasks, cursor_str, sort, state = task_result.get_tasks(
-          limit, cursor_str, sort, state, task_tags, task_name)
+      if task_tags:
+        # Enforce created_ts when tags are used.
+        sort = 'created_ts'
+      query = task_result.get_result_summaries_query(
+          None, None, sort, state, task_tags)
+      tasks, cursor_str = datastore_utils.fetch_page(query, limit, cursor_str)
 
       # Prefetch the TaskRequest all at once, so that ndb's in-process cache has
       # it instead of fetching them one at a time indirectly when using
       # TaskResultSummary.request_key.get().
       futures = ndb.get_multi_async(t.request_key for t in tasks)
 
       # Evaluate the counts to print the filtering columns with the associated
       # numbers.
       state_choices = self._get_state_choices(counts_future)
-    except (search.QueryError, ValueError) as e:
+    except ValueError as e:
       self.abort(400, str(e))
 
     def safe_sum(items):
       return sum(items, datetime.timedelta())
 
     def avg(items):
       if not items:
         return 0.
       return safe_sum(items) / len(items)
 
@@ skipping 35 matching lines @@
       'limit': limit,
       'now': now,
       'pending_average': avg(pendings),
       'pending_median': median(pendings),
       'pending_sum': safe_sum(pendings),
       'show_footer': bool(pendings or durations),
       'sort': sort,
       'sort_choices': self.SORT_CHOICES,
       'state': state,
       'state_choices': state_choices,
-      'task_name': task_name,
       'task_tag': '\n'.join(task_tags),
       'tasks': tasks,
       'total_cost_usd': total_cost_usd,
       'total_cost_saved_usd': total_cost_saved_usd,
       'total_saved': total_saved,
       'total_saved_percent': total_saved_percent,
       'xsrf_token': self.generate_xsrf_token(),
     }
     # TODO(maruel): If admin or if the user is task's .user, show the Cancel
     # button. Do not show otherwise.
@@ skipping 260 matching lines @@
   # If running on a local dev server, allow bots to connect without prior
   # groups configuration. Useful when running smoke test.
   if utils.is_local_dev_server():
     acl.bootstrap_dev_server_acls()
 
   # TODO(maruel): Split backend into a separate module. For now add routes here.
   routes.extend(handlers_backend.get_routes())
   routes.extend(handlers_bot.get_routes())
 
   return webapp2.WSGIApplication(routes, debug=debug)