swarming: IsolatedOperation -> OperationStats

appengine/swarming/server/task_result.py

 # Copyright 2014 The LUCI Authors. All rights reserved.
 # Use of this source code is governed by the Apache v2.0 license 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 229 matching lines @@
   # gaps is a series of 2 integer pairs, which specifies the part that are
   # invalid. Normally it should be empty. All values are relative to the start
   # of this chunk offset.
   gaps = ndb.IntegerProperty(repeated=True, indexed=False)
 
   @property
   def chunk_number(self):
     return self.key.integer_id() - 1
 
 
-class IsolatedOperation(ndb.Model):
+class OperationStats(ndb.Model):
   """Statistics for an isolated operation.

[M-A Ruel, 2016/04/28 21:03:29]

s/isolated //

[nodir, 2016/04/28 21:10:17]

Done.

 
   This entity is not stored in the DB. It is only embedded in PerformanceStats.
   """
   # Duration of the isolation operation in seconds.
   duration = ndb.FloatProperty(indexed=False)
   # Initial cache size, if applicable.
   initial_number_items = ndb.IntegerProperty(indexed=False)
   initial_size = ndb.IntegerProperty(indexed=False)
   # Items operated on.
   # These buffers are compressed as deflate'd delta-encoded varints. See
@@ skipping 21 matching lines @@
   it is generally operating on data that is used across multiple different
   tasks.
 
   This entity only exist for isolated tasks. For "raw command task", this entity
   is not stored, since there's nothing to note.
   """
   # Miscellaneous overhead in second, in addition to the overhead from
   # isolated_download.duration and isolated_upload.duration.
   bot_overhead = ndb.FloatProperty(indexed=False)
   # Runtime dependencies download operation before the task.
-  isolated_download = ndb.LocalStructuredProperty(IsolatedOperation)
+  isolated_download = ndb.LocalStructuredProperty(OperationStats)
   # Results uploading operation after the task.
-  isolated_upload = ndb.LocalStructuredProperty(IsolatedOperation)
+  isolated_upload = ndb.LocalStructuredProperty(OperationStats)
 
   @property
   def is_valid(self):
     return self.bot_overhead is not None
 
   def _pre_put_hook(self):
     if self.bot_overhead is None:
       raise datastore_errors.BadValueError(
           'PerformanceStats.bot_overhead is required')
 
@@ skipping 131 matching lines @@
 
     Returns an empty instance if none is available.
     """
     # Keeps a cache. It's still paying the full latency cost of a DB fetch.
     if not hasattr(self, '_performance_stats_cache'):
       key = None if self.deduped_from else self.performance_stats_key
       # pylint: disable=attribute-defined-outside-init
       self._performance_stats_cache = (
           (key.get() if key else None) or
           PerformanceStats(
-              isolated_download=IsolatedOperation(),
-              isolated_upload=IsolatedOperation()))
+              isolated_download=OperationStats(),
+              isolated_upload=OperationStats()))
     return self._performance_stats_cache
 
   @property
   def overhead_isolated_inputs(self):
     """Returns the overhead from isolated setup in timedelta."""
     perf = self.performance_stats
     if perf.isolated_download.duration is not None:
       return datetime.timedelta(seconds=perf.isolated_download.duration)
 
   @property
@@ skipping 770 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)