Tools/Scripts/webkitpy/tool/commands/download.py

   1 # Copyright (c) 2009 Google Inc. All rights reserved.
   2 # Copyright (c) 2009 Apple Inc. All rights reserved.
   3 #
   4 # Redistribution and use in source and binary forms, with or without
   5 # modification, are permitted provided that the following conditions are
   6 # met:
   7 #
   8 #     * Redistributions of source code must retain the above copyright
   9 # notice, this list of conditions and the following disclaimer.
  10 #     * Redistributions in binary form must reproduce the above
  11 # copyright notice, this list of conditions and the following disclaimer
  12 # in the documentation and/or other materials provided with the
  13 # distribution.
  14 #     * Neither the name of Google Inc. nor the names of its
  15 # contributors may be used to endorse or promote products derived from
  16 # this software without specific prior written permission.
  17 #
  18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 import os
  31
  32 from webkitpy.tool import steps
  33
  34 from webkitpy.common.checkout.changelog import ChangeLog
  35 from webkitpy.common.config import urls
  36 from webkitpy.common.system.executive import ScriptError
  37 from webkitpy.tool.commands.abstractsequencedcommand import AbstractSequencedCommand
  38 from webkitpy.tool.commands.stepsequence import StepSequence
  39 from webkitpy.tool.comments import bug_comment_from_commit_text
  40 from webkitpy.tool.grammar import pluralize
  41 from webkitpy.tool.multicommandtool import AbstractDeclarativeCommand
  42 from webkitpy.common.system.deprecated_logging import error, log
  43
  44
  45 class Clean(AbstractSequencedCommand):
  46     name = "clean"
  47     help_text = "Clean the working copy"
  48     steps = [
  49         steps.CleanWorkingDirectory,
  50     ]
  51
  52     def _prepare_state(self, options, args, tool):
  53         options.force_clean = True
  54
  55
  56 class Update(AbstractSequencedCommand):
  57     name = "update"
  58     help_text = "Update working copy (used internally)"
  59     steps = [
  60         steps.CleanWorkingDirectory,
  61         steps.Update,
  62     ]
  63
  64
  65 class Build(AbstractSequencedCommand):
  66     name = "build"
  67     help_text = "Update working copy and build"
  68     steps = [
  69         steps.CleanWorkingDirectory,
  70         steps.Update,
  71         steps.Build,
  72     ]
  73
  74     def _prepare_state(self, options, args, tool):
  75         options.build = True
  76
  77
  78 class BuildAndTest(AbstractSequencedCommand):
  79     name = "build-and-test"
  80     help_text = "Update working copy, build, and run the tests"
  81     steps = [
  82         steps.CleanWorkingDirectory,
  83         steps.Update,
  84         steps.Build,
  85         steps.RunTests,
  86     ]
  87
  88
  89 class Land(AbstractSequencedCommand):
  90     name = "land"
  91     help_text = "Land the current working directory diff and updates the associated bug if any"
  92     argument_names = "[BUGID]"
  93     show_in_main_help = True
  94     steps = [
  95         steps.EnsureBuildersAreGreen,
  96         steps.UpdateChangeLogsWithReviewer,
  97         steps.ValidateReviewer,
  98         steps.ValidateChangeLogs, # We do this after UpdateChangeLogsWithReviewer to avoid not having to cache the diff twice.
  99         steps.Build,
 100         steps.RunTests,
 101         steps.Commit,
 102         steps.CloseBugForLandDiff,
 103     ]
 104     long_help = """land commits the current working copy diff (just as svn or git commit would).
 105 land will NOT build and run the tests before committing, but you can use the --build option for that.
 106 If a bug id is provided, or one can be found in the ChangeLog land will update the bug after committing."""
 107
 108     def _prepare_state(self, options, args, tool):
 109         changed_files = self._tool.scm().changed_files(options.git_commit)
 110         return {
 111             "changed_files": changed_files,
 112             "bug_id": (args and args[0]) or tool.checkout().bug_id_for_this_commit(options.git_commit, changed_files),
 113         }
 114
 115
 116 class LandCowboy(AbstractSequencedCommand):
 117     name = "land-cowboy"
 118     help_text = "Prepares a ChangeLog and lands the current working directory diff."
 119     steps = [
 120         steps.PrepareChangeLog,
 121         steps.EditChangeLog,
 122         steps.ConfirmDiff,
 123         steps.Build,
 124         steps.RunTests,
 125         steps.Commit,
 126     ]
 127
 128
 129 class AbstractPatchProcessingCommand(AbstractDeclarativeCommand):
 130     # Subclasses must implement the methods below.  We don't declare them here
 131     # because we want to be able to implement them with mix-ins.
 132     #
 133     # def _fetch_list_of_patches_to_process(self, options, args, tool):
 134     # def _prepare_to_process(self, options, args, tool):
 135
 136     @staticmethod
 137     def _collect_patches_by_bug(patches):
 138         bugs_to_patches = {}
 139         for patch in patches:
 140             bugs_to_patches[patch.bug_id()] = bugs_to_patches.get(patch.bug_id(), []) + [patch]
 141         return bugs_to_patches
 142
 143     def execute(self, options, args, tool):
 144         self._prepare_to_process(options, args, tool)
 145         patches = self._fetch_list_of_patches_to_process(options, args, tool)
 146
 147         # It's nice to print out total statistics.
 148         bugs_to_patches = self._collect_patches_by_bug(patches)
 149         log("Processing %s from %s." % (pluralize("patch", len(patches)), pluralize("bug", len(bugs_to_patches))))
 150
 151         for patch in patches:
 152             self._process_patch(patch, options, args, tool)
 153
 154
 155 class AbstractPatchSequencingCommand(AbstractPatchProcessingCommand):
 156     prepare_steps = None
 157     main_steps = None
 158
 159     def __init__(self):
 160         options = []
 161         self._prepare_sequence = StepSequence(self.prepare_steps)
 162         self._main_sequence = StepSequence(self.main_steps)
 163         options = sorted(set(self._prepare_sequence.options() + self._main_sequence.options()))
 164         AbstractPatchProcessingCommand.__init__(self, options)
 165
 166     def _prepare_to_process(self, options, args, tool):
 167         self._prepare_sequence.run_and_handle_errors(tool, options)
 168
 169     def _process_patch(self, patch, options, args, tool):
 170         state = { "patch" : patch }
 171         self._main_sequence.run_and_handle_errors(tool, options, state)
 172
 173
 174 class ProcessAttachmentsMixin(object):
 175     def _fetch_list_of_patches_to_process(self, options, args, tool):
 176         return map(lambda patch_id: tool.bugs.fetch_attachment(patch_id), args)
 177
 178
 179 class ProcessBugsMixin(object):
 180     def _fetch_list_of_patches_to_process(self, options, args, tool):
 181         all_patches = []
 182         for bug_id in args:
 183             patches = tool.bugs.fetch_bug(bug_id).reviewed_patches()
 184             log("%s found on bug %s." % (pluralize("reviewed patch", len(patches)), bug_id))
 185             all_patches += patches
 186         return all_patches
 187
 188
 189 class CheckStyle(AbstractPatchSequencingCommand, ProcessAttachmentsMixin):
 190     name = "check-style"
 191     help_text = "Run check-webkit-style on the specified attachments"
 192     argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
 193     main_steps = [
 194         steps.CleanWorkingDirectory,
 195         steps.Update,
 196         steps.ApplyPatch,
 197         steps.CheckStyle,
 198     ]
 199
 200
 201 class BuildAttachment(AbstractPatchSequencingCommand, ProcessAttachmentsMixin):
 202     name = "build-attachment"
 203     help_text = "Apply and build patches from bugzilla"
 204     argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
 205     main_steps = [
 206         steps.CleanWorkingDirectory,
 207         steps.Update,
 208         steps.ApplyPatch,
 209         steps.Build,
 210     ]
 211
 212
 213 class BuildAndTestAttachment(AbstractPatchSequencingCommand, ProcessAttachmentsMixin):
 214     name = "build-and-test-attachment"
 215     help_text = "Apply, build, and test patches from bugzilla"
 216     argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
 217     main_steps = [
 218         steps.CleanWorkingDirectory,
 219         steps.Update,
 220         steps.ApplyPatch,
 221         steps.Build,
 222         steps.RunTests,
 223     ]
 224
 225
 226 class AbstractPatchApplyingCommand(AbstractPatchSequencingCommand):
 227     prepare_steps = [
 228         steps.EnsureLocalCommitIfNeeded,
 229         steps.CleanWorkingDirectoryWithLocalCommits,
 230         steps.Update,
 231     ]
 232     main_steps = [
 233         steps.ApplyPatchWithLocalCommit,
 234     ]
 235     long_help = """Updates the working copy.
 236 Downloads and applies the patches, creating local commits if necessary."""
 237
 238
 239 class ApplyAttachment(AbstractPatchApplyingCommand, ProcessAttachmentsMixin):
 240     name = "apply-attachment"
 241     help_text = "Apply an attachment to the local working directory"
 242     argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
 243     show_in_main_help = True
 244
 245
 246 class ApplyFromBug(AbstractPatchApplyingCommand, ProcessBugsMixin):
 247     name = "apply-from-bug"
 248     help_text = "Apply reviewed patches from provided bugs to the local working directory"
 249     argument_names = "BUGID [BUGIDS]"
 250     show_in_main_help = True
 251
 252
 253 class AbstractPatchLandingCommand(AbstractPatchSequencingCommand):
 254     prepare_steps = [
 255         steps.EnsureBuildersAreGreen,
 256     ]
 257     main_steps = [
 258         steps.CleanWorkingDirectory,
 259         steps.Update,
 260         steps.ApplyPatch,
 261         steps.ValidateChangeLogs,
 262         steps.ValidateReviewer,
 263         steps.Build,
 264         steps.RunTests,
 265         steps.Commit,
 266         steps.ClosePatch,
 267         steps.CloseBug,
 268     ]
 269     long_help = """Checks to make sure builders are green.
 270 Updates the working copy.
 271 Applies the patch.
 272 Builds.
 273 Runs the layout tests.
 274 Commits the patch.
 275 Clears the flags on the patch.
 276 Closes the bug if no patches are marked for review."""
 277
 278
 279 class LandAttachment(AbstractPatchLandingCommand, ProcessAttachmentsMixin):
 280     name = "land-attachment"
 281     help_text = "Land patches from bugzilla, optionally building and testing them first"
 282     argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
 283     show_in_main_help = True
 284
 285
 286 class LandFromBug(AbstractPatchLandingCommand, ProcessBugsMixin):
 287     name = "land-from-bug"
 288     help_text = "Land all patches on the given bugs, optionally building and testing them first"
 289     argument_names = "BUGID [BUGIDS]"
 290     show_in_main_help = True
 291
 292
 293 class AbstractRolloutPrepCommand(AbstractSequencedCommand):
 294     argument_names = "REVISION [REVISIONS] REASON"
 295
 296     def _commit_info(self, revision):
 297         commit_info = self._tool.checkout().commit_info_for_revision(revision)
 298         if commit_info and commit_info.bug_id():
 299             # Note: Don't print a bug URL here because it will confuse the
 300             #       SheriffBot because the SheriffBot just greps the output
 301             #       of create-rollout for bug URLs.  It should do better
 302             #       parsing instead.
 303             log("Preparing rollout for bug %s." % commit_info.bug_id())
 304         else:
 305             log("Unable to parse bug number from diff.")
 306         return commit_info
 307
 308     def _prepare_state(self, options, args, tool):
 309         revision_list = []
 310         for revision in str(args[0]).split():
 311             if revision.isdigit():
 312                 revision_list.append(int(revision))
 313             else:
 314                 raise ScriptError(message="Invalid svn revision number: " + revision)
 315         revision_list.sort()
 316
 317         # We use the earliest revision for the bug info
 318         earliest_revision = revision_list[0]
 319         commit_info = self._commit_info(earliest_revision)
 320         cc_list = sorted([party.bugzilla_email()
 321                           for party in commit_info.responsible_parties()
 322                           if party.bugzilla_email()])
 323         return {
 324             "revision": earliest_revision,
 325             "revision_list": revision_list,
 326             "bug_id": commit_info.bug_id(),
 327             # FIXME: We should used the list as the canonical representation.
 328             "bug_cc": ",".join(cc_list),
 329             "reason": args[1],
 330         }
 331
 332
 333 class PrepareRollout(AbstractRolloutPrepCommand):
 334     name = "prepare-rollout"
 335     help_text = "Revert the given revision(s) in the working copy and prepare ChangeLogs with revert reason"
 336     long_help = """Updates the working copy.
 337 Applies the inverse diff for the provided revision(s).
 338 Creates an appropriate rollout ChangeLog, including a trac link and bug link.
 339 """
 340     steps = [
 341         steps.CleanWorkingDirectory,
 342         steps.Update,
 343         steps.RevertRevision,
 344         steps.PrepareChangeLogForRevert,
 345     ]
 346
 347
 348 class CreateRollout(AbstractRolloutPrepCommand):
 349     name = "create-rollout"
 350     help_text = "Creates a bug to track the broken SVN revision(s) and uploads a rollout patch."
 351     steps = [
 352         steps.CleanWorkingDirectory,
 353         steps.Update,
 354         steps.RevertRevision,
 355         steps.CreateBug,
 356         steps.PrepareChangeLogForRevert,
 357         steps.PostDiffForRevert,
 358     ]
 359
 360     def _prepare_state(self, options, args, tool):
 361         state = AbstractRolloutPrepCommand._prepare_state(self, options, args, tool)
 362         # Currently, state["bug_id"] points to the bug that caused the
 363         # regression.  We want to create a new bug that blocks the old bug
 364         # so we move state["bug_id"] to state["bug_blocked"] and delete the
 365         # old state["bug_id"] so that steps.CreateBug will actually create
 366         # the new bug that we want (and subsequently store its bug id into
 367         # state["bug_id"])
 368         state["bug_blocked"] = state["bug_id"]
 369         del state["bug_id"]
 370         state["bug_title"] = "REGRESSION(r%s): %s" % (state["revision"], state["reason"])
 371         state["bug_description"] = "%s broke the build:\n%s" % (urls.view_revision_url(state["revision"]), state["reason"])
 372         # FIXME: If we had more context here, we could link to other open bugs
 373         #        that mention the test that regressed.
 374         if options.parent_command == "sheriff-bot":
 375             state["bug_description"] += """
 376
 377 This is an automatic bug report generated by the sheriff-bot. If this bug
 378 report was created because of a flaky test, please file a bug for the flaky
 379 test (if we don't already have one on file) and dup this bug against that bug
 380 so that we can track how often these flaky tests case pain.
 381
 382 "Only you can prevent forest fires." -- Smokey the Bear
 383 """
 384         return state
 385
 386
 387 class Rollout(AbstractRolloutPrepCommand):
 388     name = "rollout"
 389     show_in_main_help = True
 390     help_text = "Revert the given revision(s) in the working copy and optionally commit the revert and re-open the original bug"
 391     long_help = """Updates the working copy.
 392 Applies the inverse diff for the provided revision.
 393 Creates an appropriate rollout ChangeLog, including a trac link and bug link.
 394 Opens the generated ChangeLogs in $EDITOR.
 395 Shows the prepared diff for confirmation.
 396 Commits the revert and updates the bug (including re-opening the bug if necessary)."""
 397     steps = [
 398         steps.CleanWorkingDirectory,
 399         steps.Update,
 400         steps.RevertRevision,
 401         steps.PrepareChangeLogForRevert,
 402         steps.EditChangeLog,
 403         steps.ConfirmDiff,
 404         steps.Build,
 405         steps.Commit,
 406         steps.ReopenBugAfterRollout,
 407     ]