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

appengine/swarming/server/task_result.py

 # Copyright 2014 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.
 
 """Task execution result models.
 
 This module doesn't do the scheduling itself. It only describes the entities to
 store tasks results.
 
 - TaskResultSummary represents the overall result for the TaskRequest taking in
@@ skipping 45 matching lines @@
     |TaskOutputChunk|  |TaskOutputChunk| ...
     |id=1           |  |id=2           |
     +---------------+  +---------------+
 """
 
 import datetime
 import logging
 import random
 
 from google.appengine.api import datastore_errors
-from google.appengine.api import search
 from google.appengine.datastore import datastore_query
 from google.appengine.ext import ndb
 
 from components import datastore_utils
 from components import utils
 from server import large
 from server import task_pack
 from server import task_request
 
 # Amount of time after which a bot is considered dead. In short, if a bot has
@@ skipping 963 matching lines @@
 
   if state == 'bot_died':
     return query.filter(cls.state == State.BOT_DIED)
 
   if state == 'canceled':
     return query.filter(cls.state == State.CANCELED)
 
   raise ValueError('Invalid state')
 
 
-def _search_by_name(word, cursor_str, limit):
-  """Returns TaskResultSummary in -created_ts order containing the word."""
-  cursor = search.Cursor(web_safe_string=cursor_str, per_result=True)
-  index = search.Index(name='requests')
-
-  def item_to_id(item):
-    for field in item.fields:
-      if field.name == 'id':
-        return field.value
-
-  # The code is structured to handle incomplete entities but still return
-  # 'limit' items. This is done by fetching a few more entities than necessary,
-  # then keeping track of the cursor per item so the right cursor can be
-  # returned.
-  opts = search.QueryOptions(limit=limit + 5, cursor=cursor)
-  results = index.search(search.Query('name:%s' % word, options=opts))
-  result_summary_keys = []
-  cursors = []
-  for item in results.results:
-    value = item_to_id(item)
-    if value:
-      result_summary_keys.append(task_pack.unpack_result_summary_key(value))
-      cursors.append(item.cursor)
-
-  # Handle None result value. See make_request() for details about how this can
-  # happen.
-  tasks = []
-  cursor = None
-  for task, c in zip(ndb.get_multi(result_summary_keys), cursors):
-    if task:
-      cursor = c
-      tasks.append(task)
-      if len(tasks) == limit:
-        # Drop the rest.
-        break
-  else:
-    if len(cursors) == limit + 5:
-      while len(tasks) < limit:
-        # Go into the slow path, seems like we got a lot of corrupted items.
-        opts = search.QueryOptions(limit=limit-len(tasks) + 5, cursor=cursor)
-        results = index.search(search.Query('name:%s' % word, options=opts))
-        if not results.results:
-          # Nothing else.
-          cursor = None
-          break
-        for item in results.results:
-          value = item_to_id(item)
-          if value:
-            cursor = item.cursor
-            task = task_pack.unpack_result_summary_key(value).get()
-            if task:
-              tasks.append(task)
-              if len(tasks) == limit:
-                break
-
-  cursor_str = cursor.web_safe_string if cursor else None
-  return tasks, cursor_str
-
-
 ### Public API.
 
 
 def state_to_string(state_obj):
   """Returns a user-readable string representing a State."""
   if state_obj.deduped_from:
     return 'Deduped'
   out = State.to_string(state_obj.state)
   if state_obj.failure:
     out += ' (failed)'
@@ skipping 36 matching lines @@
   """Yields all the TaskRunResult ndb.Key where the bot died recently.
 
   In practice it is returning a ndb.QueryIterator but this is equivalent.
   """
   # If a bot didn't ping recently, it is considered dead.
   deadline = utils.utcnow() - BOT_PING_TOLERANCE
   q = TaskRunResult.query().filter(TaskRunResult.modified_ts < deadline)
   return q.filter(TaskRunResult.state == State.RUNNING).iter(keys_only=True)
 
 
-def get_tasks(limit, cursor_str, sort, state, tags, task_name):
-  """Returns TaskResultSummary entities for this query.
-
-  This function is synchronous.
-
-  Arguments:
-    limit: Maximum number of items to return.
-    cursor_str: query-dependent string encoded cursor to continue a previous
-        search.
-    sort: Order to use. Must default to 'created_ts' to use the default.
-    state: State to filter on.
-    tags: List of search for one or multiple task tags.
-    task_name: search for task name whole word.
-
-  Returns:
-    tuple(list of tasks, str encoded cursor, updated sort, updated state)
-  """
-  if task_name:
-    # Task name based word based search. Override the flags.
-    sort = 'created_ts'
-    state = 'all'
-    tasks, cursor_str = _search_by_name(task_name, cursor_str, limit)
-  else:
-    # Normal listing.
-    if tags:
-      # Add TaskResultSummary indexes if desired.
-      sort = 'created_ts'
-    query = get_result_summaries_query(None, None, sort, state, tags)
-    tasks, cursor_str = datastore_utils.fetch_page(
-        query, limit, cursor_str)
-
-  return tasks, cursor_str, sort, state
-
-
 def get_run_results_query(start, end, sort, state, bot_id):
   """Returns TaskRunResult.query() with these filters.
 
   Arguments:
     start: Earliest creation date of retrieved tasks.
     end: Most recent creation date of retrieved tasks, normally None.
     sort: Order to use. Must default to 'created_ts' to use the default. Cannot
         be used along start and end.
     state: One of State enum value as str. Use 'all' to get all tasks.
     bot_id: (required) bot id to filter on.
@@ skipping 20 matching lines @@
   if tags:
     # Add TaskResultSummary indexes if desired.
     if sort != 'created_ts':
       raise ValueError(
           'Add needed indexes for sort:%s and tags if desired' % sort)
     tags_filter = TaskResultSummary.tags == tags[0]
     for tag in tags[1:]:
       tags_filter = ndb.AND(tags_filter, TaskResultSummary.tags == tag)
     query = query.filter(tags_filter)
   return _filter_query(TaskResultSummary, query, start, end, sort, state)