buildbucket: add retry API.

appengine/cr-buildbucket/service.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import datetime
 import logging
 import urlparse
 
 from google.appengine.api import taskqueue
 from google.appengine.api import modules
@@ skipping 76 matching lines @@
 def current_identity_cannot(action_format, *args):
   action = action_format % args
   msg = 'User %s cannot %s' % (auth.get_current_identity().to_bytes(), action)
   logging.warning(msg)
   raise auth.AuthorizationError(msg)
 
 
 @ndb.tasklet
 def add_async(
     bucket, tags=None, parameters=None, lease_expiration_date=None,
-    client_operation_id=None, pubsub_callback=None):
+    client_operation_id=None, pubsub_callback=None, retry_of=None):
   """Adds the build entity to the build bucket.
 
   Requires the current user to have permissions to add builds to the
   |bucket|.
 
   Args:
     bucket (str): destination bucket. Required.
     tags (model.Tags): build tags.
     parameters (dict): arbitrary build parameters. Cannot be changed after
       build creation.
     lease_expiration_date (datetime.datetime): if not None, the build is
       created as leased and its lease_key is not None.
-    pubsub_callback (model.PubsubCallback): callback parameters.
     client_operation_id (str): client-supplied operation id. If an
       a build with the same client operation id was added during last minute,
       it will be returned instead.
+    pubsub_callback (model.PubsubCallback): callback parameters.
+    retry_of (int): value for model.Build.retry_of attribute.
 
   Returns:
     A new Build.
   """
   if client_operation_id is not None:
     if not isinstance(client_operation_id, basestring):  # pragma: no cover
       raise errors.InvalidInputError('client_operation_id must be string')
     if '/' in client_operation_id:  # pragma: no cover
       raise errors.InvalidInputError('client_operation_id must not contain /')
   validate_bucket_name(bucket)
@@ skipping 20 matching lines @@
 
   build = model.Build(
     id=model.new_build_id(),
     bucket=bucket,
     tags=tags,
     parameters=parameters,
     status=model.BuildStatus.SCHEDULED,
     created_by=identity,
     never_leased=lease_expiration_date is None,
     pubsub_callback=pubsub_callback,
+    retry_of=retry_of,
   )
   if lease_expiration_date is not None:
     build.lease_expiration_date = lease_expiration_date
     build.leasee = auth.get_current_identity()
     build.regenerate_lease_key()
 
   for_swarming = yield swarming.is_for_swarming_async(build)
   if for_swarming:  # pragma: no cover
     yield swarming.create_task_async(build)
 
@@ skipping 11 matching lines @@
   if client_operation_id is not None:
     yield ctx.memcache_set(client_operation_cache_key, build.key.id(), 60)
   raise ndb.Return(build)
 
 
 def add(*args, **kwargs):
   """Sync version of add_async."""
   return add_async(*args, **kwargs).get_result()
 
 
+def retry(
+    build_id, lease_expiration_date=None, client_operation_id=None,
+    pubsub_callback=None):
+  """Adds a build with same bucket, parameters and tags as the given one."""
+  build = model.Build.get_by_id(build_id)
+  if not build:
+    raise errors.BuildNotFoundError('Build %s not found' % build_id)
+  return add(
+    build.bucket,
+    tags=build.tags,
+    parameters=build.parameters,
+    lease_expiration_date=lease_expiration_date,
+    client_operation_id=client_operation_id,
+    pubsub_callback=pubsub_callback,
+    retry_of=build_id,
+  )
+
+
 def get(build_id):
   """Gets a build by |build_id|.
 
   Requires the current user to have permissions to view the build.
   """
   build = model.Build.get_by_id(build_id)
   if not build:
     return None
   if not acl.can_view_build(build):
     raise current_identity_cannot('view build %s', build.key.id())
@@ skipping 38 matching lines @@
     validate_bucket_name(bucket)
 
   for bucket in buckets:
     if not acl.can_search_builds(bucket):
       raise current_identity_cannot('search builds in bucket %s', bucket)
 
 
 def search(
     buckets=None, tags=None,
     status=None, result=None, failure_reason=None, cancelation_reason=None,
-    created_by=None, max_builds=None, start_cursor=None):
+    created_by=None, max_builds=None, start_cursor=None,
+    retry_of=None):
   """Searches for builds.
 
   Args:
     buckets (list of str): a list of buckets to search in.
       A build must be in one of the buckets.
     tags (list of str): a list of tags that a build must have.
       All of the |tags| must be present in a build.
     status (model.BuildStatus): build status.
     result (model.BuildResult): build result.
     failure_reason (model.FailureReason): failure reason.
     cancelation_reason (model.CancelationReason): build cancelation reason.
     created_by (str): identity who created a build.
     max_builds (int): maximum number of builds to return.
     start_cursor (string): a value of "next" cursor returned by previous
       search_by_tags call. If not None, return next builds in the query.
+    retry_of (int): value of retry_of attribute.
 
   Returns:
     A tuple:
       builds (list of Build): query result.
       next_cursor (string): cursor for the next page.
         None if there are no more builds.
   """
   if buckets is not None and not isinstance(buckets, list):
     raise errors.InvalidInputError('Buckets must be a list or None')
   validate_tags(tags)
   tags = tags or []
   max_builds = fix_max_builds(max_builds)
   created_by = parse_identity(created_by)
 
   if buckets:
     _check_search_acls(buckets)
+  elif retry_of:
+    retry_of_build = model.Build.get_by_id(retry_of)
+    if retry_of_build:
+      buckets = [retry_of_build.bucket]
   else:
     buckets = acl.get_available_buckets()
     if buckets is not None and len(buckets) == 0:
       return [], None
   if buckets:
     buckets = set(buckets)
   assert buckets is None or buckets
 
-  check_buckets_locally = False
+  check_buckets_locally = retry_of is not None
   q = model.Build.query()
   for t in tags:
     if t.startswith('buildset:'):
       check_buckets_locally = True
     q = q.filter(model.Build.tags == t)
   filter_if = lambda p, v: q if v is None else q.filter(p == v)
   q = filter_if(model.Build.status, status)
   q = filter_if(model.Build.result, result)
   q = filter_if(model.Build.failure_reason, failure_reason)
   q = filter_if(model.Build.cancelation_reason, cancelation_reason)
   q = filter_if(model.Build.created_by, created_by)
+  q = filter_if(model.Build.retry_of, retry_of)
   # buckets is None if the current identity has access to ALL buckets.
   if buckets and not check_buckets_locally:
     q = q.filter(model.Build.bucket.IN(buckets))
   q = q.order(model.Build.key)
 
   local_predicate = None
 
   def local_status_and_bucket_check(build):
     if status is not None and build.status != status:  # pragma: no coverage
       return False
@@ skipping 472 matching lines @@
   if isinstance(identity, basestring):
     if not identity:  # pragma: no cover
       return None
     if ':' not in identity:  # pragma: no branch
       identity = 'user:%s' % identity
     try:
       identity = auth.Identity.from_bytes(identity)
     except ValueError as ex:
       raise errors.InvalidInputError('Invalid identity identity: %s' % ex)
   return identity