[Rietveld] Add support for patchset dependencies

appengine/chromium_rietveld/codereview/views.py

 # Copyright 2008 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 60 matching lines @@
 from oauth2client.appengine import _safe_html
 from oauth2client.appengine import CredentialsNDBModel
 from oauth2client.appengine import StorageByKeyName
 from oauth2client.appengine import xsrf_secret_key
 from oauth2client.client import AccessTokenRefreshError
 from oauth2client.client import OAuth2WebServerFlow
 from oauth2client import xsrfutil
 
 from codereview import auth_utils
 from codereview import buildbucket
+from codereview import dependency_utils
 from codereview import engine
 from codereview import library
 from codereview import models
 from codereview import models_chromium
 from codereview import net
 from codereview import notify_xmpp
 from codereview import patching
 from codereview import utils
 from codereview import common
 from codereview.exceptions import FetchError
@@ skipping 83 matching lines @@
 class UploadForm(forms.Form):
 
   subject = forms.CharField(max_length=MAX_SUBJECT)
   description = forms.CharField(max_length=MAX_DESCRIPTION, required=False)
   project = forms.CharField(required=False)
   content_upload = forms.BooleanField(required=False)
   separate_patches = forms.BooleanField(required=False)
   base = forms.CharField(max_length=MAX_URL, required=False)
   target_ref = forms.CharField(max_length=MAX_URL, required=False)
   cq_dry_run = forms.BooleanField(required=False)
+  depends_on_patchset = forms.CharField(required=False)
   data = forms.FileField(required=False)
   issue = forms.IntegerField(required=False)
   reviewers = forms.CharField(max_length=MAX_REVIEWERS, required=False)
   cc = forms.CharField(max_length=MAX_CC, required=False)
   private = forms.BooleanField(required=False, initial=False)
   send_mail = forms.BooleanField(required=False)
   base_hashes = forms.CharField(required=False)
   commit = forms.BooleanField(required=False)
   repo_guid = forms.CharField(required=False, max_length=MAX_URL)
 
@@ skipping 823 matching lines @@
     return HttpResponseBadRequest(
         'Only the issue owner can edit patchset titles')
 
   patchset = request.patchset
   patchset.message = request.POST.get('patchset_title')
   patchset.put()
 
   return HttpResponse('OK', content_type='text/plain')
 
 
+@deco.access_control_allow_origin_star
+@deco.require_methods('POST')
+@deco.patchset_required
+@deco.json_response
+def get_depends_on_patchset(request):
+  """/<issue>/get_depends_on_patchset- The patchset this patchset depends on."""
+  response = {}
+  if request.patchset.depends_on_patchset:
+    # Verify that the depended upon issue is not closed.
+    tokens = dependency_utils.get_dependency_tokens(
+        request.patchset.depends_on_patchset)
+    depends_on_issue = models.Issue.get_by_id(int(tokens[0]))
+    if depends_on_issue and not depends_on_issue.closed:
+      response = {
+          'issue': tokens[0],
+          'patchset': tokens[1],
+      }
+  return response
+
+
 @deco.admin_required
 @deco.user_key_required
 @deco.xsrf_required
 def block_user(request):
   """/user/<user>/block - Blocks a specific user."""
   account = models.Account.get_account_for_user(request.user_to_show)
   if request.method == 'POST':
     form = BlockForm(request.POST)
     if form.is_valid():
       account.blocked = form.cleaned_data['blocked']
@@ skipping 393 matching lines @@
   issue.put()
 
   if cq_dry_run:
     commit_checked_msg = 'The CQ bit was checked by %s to run a CQ dry run' % (
         cq_dry_run_triggered_by)
     make_message(request, issue, commit_checked_msg, send_mail=False,
                  auto_generated=True).put()
 
   first_ps_id, _ = models.PatchSet.allocate_ids(1, parent=issue.key)
   ps_key = ndb.Key(models.PatchSet, first_ps_id, parent=issue.key)
+  depends_on_patchset = (
+      dependency_utils.mark_as_dependent_and_get_dependency_str(
+          form.cleaned_data.get('depends_on_patchset'), issue.key.id(),
+          ps_key.id()))
   patchset = models.PatchSet(
-    issue_key=issue.key, data=data, url=url, key=ps_key)
+    issue_key=issue.key, data=data, url=url, key=ps_key,
+    depends_on_patchset=depends_on_patchset)
   patchset.put()
 
   if not separate_patches:
     try:
       patches = engine.ParsePatchSet(patchset)
     except Exception:
       # catch all exceptions happening in engine.ParsePatchSet,
       # engine_utils.SplitPatch. With malformed diffs a variety of exceptions
       # could happen there.
       logging.exception('Exception during patch parsing')
@@ skipping 73 matching lines @@
   account = models.Account.get_account_for_user(request.user)
   if account.blocked:
     return None
   if not issue.edit_allowed:
     # This check is done at each call site but check again as a safety measure.
     return None
   data, url, separate_patches = data_url
   message = form.cleaned_data[message_key]
   first_id, _ = models.PatchSet.allocate_ids(1, parent=issue.key)
   ps_key = ndb.Key(models.PatchSet, first_id, parent=issue.key)
+
+  depends_on_patchset = (
+      dependency_utils.mark_as_dependent_and_get_dependency_str(
+          form.cleaned_data.get('depends_on_patchset'), issue.key.id(),
+          ps_key.id()))
   patchset = models.PatchSet(
-    issue_key=issue.key, message=message, data=data, url=url, key=ps_key)
+    issue_key=issue.key, message=message, data=data, url=url, key=ps_key,
+    depends_on_patchset=depends_on_patchset)
   patchset.put()
 
   if not separate_patches:
     try:
       patches = engine.ParsePatchSet(patchset)
     except Exception:
       logging.exception('Exception during patchset parsing')
       patches = []
     if not patches:
       patchset.key.delete()
@@ skipping 503 matching lines @@
     logging.info("Updating %d patches", len(patches))
     ndb.put_multi(patches)
 
 
 @deco.require_methods('POST')
 @deco.issue_editor_required
 @deco.xsrf_required
 def delete(request):
   """/<issue>/delete - Delete an issue.  There is no way back."""
   issue = request.issue
+  # Update the dependents to remove dependency on this issue.
+  dependency_utils.remove_dependencies_from_all_patchsets(issue)
+  # Remove this issue as a dependent.
+  dependency_utils.remove_all_patchsets_as_dependents(issue)
+
   tbd = [issue]
   for cls in [models.PatchSet, models.Patch, models.Comment,
               models.Message, models.Content, models.TryJobResult]:
     tbd += cls.query(ancestor=issue.key)
   ndb.delete_multi(entity.key for entity in tbd)
   return HttpResponseRedirect(reverse(mine))
 
 
 @deco.require_methods('POST')
 @deco.patchset_editor_required
 @deco.xsrf_required
 def delete_patchset(request):
   """/<issue>/patch/<patchset>/delete - Delete a patchset.
 
   There is no way back.
   """
   # Log patchset deletion.
   patchset_num = 0
   for patchset in list(request.issue.patchsets):
     patchset_num += 1
     if patchset.key.id() == request.patchset.key.id():
       break
   delete_msg = 'Patchset #%s (id:%s) has been deleted' % (
       patchset_num, request.patchset.key.id())
   make_message(request, request.issue, delete_msg, send_mail=False,
                auto_generated=True).put()
+  # Update all dependents of this patchset.
+  dependency_utils.remove_dependencies(request.patchset)
+  # Remove this patchset as a dependent.
+  dependency_utils.remove_as_dependent(request.patchset)
   # Delete the patchset.
   request.patchset.nuke()
   return HttpResponseRedirect(reverse(show, args=[request.issue.key.id()]))
 
 
 @deco.require_methods('POST')
 @deco.issue_editor_required
 @deco.xsrf_required
 def close(request):
   """/<issue>/close - Close an issue."""
@@ skipping 267 matching lines @@
   values = {
     'patchset': patchset.key.id(),
     'issue': issue.key.id(),
     'owner': library.get_nickname(issue.owner, True, request),
     'owner_email': issue.owner.email(),
     'message': patchset.message,
     'url': patchset.url,
     'created': str(patchset.created),
     'modified': str(patchset.modified),
     'num_comments': patchset.num_comments,
+    'depends_on_patchset': patchset.depends_on_patchset,
+    'dependent_patchsets': patchset.dependent_patchsets,
     'files': {},
   }
   if (try_jobs):
     values['try_job_results'] = [
         t.to_dict() for t in patchset.try_job_results]
 
   all_no_base_file_keys_future = models.Content.query(
       models.Content.file_too_large == True,
       ancestor=patchset.key).fetch_async(10000, keys_only=True, batch_size=1000)
   patches_future = models.Patch.query(ancestor=patchset.key).fetch_async(
@@ skipping 3005 matching lines @@
     return HttpResponseNotFound()
   tops = []
   shame = []
   for i in data:
     if i.score == models.AccountStatsBase.NULL_SCORE:
       shame.append(i)
     else:
       tops.append(i)
   return respond(
       request, 'leaderboard.html', {'tops': tops, 'shame': shame, 'when': when})