download.py 14.9 KB
Newer Older
1
# Copyright (c) 2009 Google Inc. All rights reserved.
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# Copyright (c) 2009 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
# 
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
# 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import os

32
import webkitpy.tool.steps as steps
33

34
35
from webkitpy.common.checkout.changelog import ChangeLog
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
46
47
48
49
50
51
52
53
54
55
class Clean(AbstractSequencedCommand):
    name = "clean"
    help_text = "Clean the working copy"
    steps = [
        steps.CleanWorkingDirectory,
    ]

    def _prepare_state(self, options, args, tool):
        options.force_clean = True


56
57
58
59
60
61
62
63
64
class Update(AbstractSequencedCommand):
    name = "update"
    help_text = "Update working copy (used internally)"
    steps = [
        steps.CleanWorkingDirectory,
        steps.Update,
    ]


65
class Build(AbstractSequencedCommand):
66
67
68
    name = "build"
    help_text = "Update working copy and build"
    steps = [
69
70
71
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.Build,
72
73
    ]

74
75
76
    def _prepare_state(self, options, args, tool):
        options.build = True

77

78
class BuildAndTest(AbstractSequencedCommand):
79
80
81
    name = "build-and-test"
    help_text = "Update working copy, build, and run the tests"
    steps = [
82
83
84
85
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.Build,
        steps.RunTests,
86
87
88
    ]


89
class Land(AbstractSequencedCommand):
90
    name = "land"
91
92
    help_text = "Land the current working directory diff and updates the associated bug if any"
    argument_names = "[BUGID]"
93
    show_in_main_help = True
94
    steps = [
95
96
        steps.EnsureBuildersAreGreen,
        steps.UpdateChangeLogsWithReviewer,
97
        steps.ValidateReviewer,
98
        steps.ValidateChangeLogs, # We do this after UpdateChangeLogsWithReviewer to avoid not having to cache the diff twice.
99
100
101
102
        steps.Build,
        steps.RunTests,
        steps.Commit,
        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
112
            "changed_files": changed_files,
            "bug_id": (args and args[0]) or tool.checkout().bug_id_for_this_commit(options.git_commit, changed_files),
113
114
115
        }


116
117
118
119
120
121
122
123
124
125
126
127
128
class LandCowboy(AbstractSequencedCommand):
    name = "land-cowboy"
    help_text = "Prepares a ChangeLog and lands the current working directory diff."
    steps = [
        steps.PrepareChangeLog,
        steps.EditChangeLog,
        steps.ConfirmDiff,
        steps.Build,
        steps.RunTests,
        steps.Commit,
    ]


129
class AbstractPatchProcessingCommand(AbstractDeclarativeCommand):
130
131
132
133
134
    # Subclasses must implement the methods below.  We don't declare them here
    # because we want to be able to implement them with mix-ins.
    #
    # def _fetch_list_of_patches_to_process(self, options, args, tool):
    # def _prepare_to_process(self, options, args, tool):
135
136
137
138
139

    @staticmethod
    def _collect_patches_by_bug(patches):
        bugs_to_patches = {}
        for patch in patches:
140
            bugs_to_patches[patch.bug_id()] = bugs_to_patches.get(patch.bug_id(), []) + [patch]
141
142
143
144
145
146
147
148
149
150
151
152
153
154
        return bugs_to_patches

    def execute(self, options, args, tool):
        self._prepare_to_process(options, args, tool)
        patches = self._fetch_list_of_patches_to_process(options, args, tool)

        # It's nice to print out total statistics.
        bugs_to_patches = self._collect_patches_by_bug(patches)
        log("Processing %s from %s." % (pluralize("patch", len(patches)), pluralize("bug", len(bugs_to_patches))))

        for patch in patches:
            self._process_patch(patch, options, args, tool)


155
156
157
class AbstractPatchSequencingCommand(AbstractPatchProcessingCommand):
    prepare_steps = None
    main_steps = None
158

159
    def __init__(self):
160
        options = []
161
162
163
        self._prepare_sequence = StepSequence(self.prepare_steps)
        self._main_sequence = StepSequence(self.main_steps)
        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
171
        state = { "patch" : patch }
        self._main_sequence.run_and_handle_errors(tool, options, state)
172
173


174
175
class ProcessAttachmentsMixin(object):
    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
180
181
182


class ProcessBugsMixin(object):
    def _fetch_list_of_patches_to_process(self, options, args, tool):
        all_patches = []
        for bug_id in args:
183
184
185
            patches = tool.bugs.fetch_bug(bug_id).reviewed_patches()
            log("%s found on bug %s." % (pluralize("reviewed patch", len(patches)), bug_id))
            all_patches += patches
186
187
188
189
        return all_patches


class CheckStyle(AbstractPatchSequencingCommand, ProcessAttachmentsMixin):
190
    name = "check-style"
191
192
    help_text = "Run check-webkit-style on the specified attachments"
    argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
193
    main_steps = [
194
195
196
197
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.ApplyPatch,
        steps.CheckStyle,
198
    ]
199
200


201
class BuildAttachment(AbstractPatchSequencingCommand, ProcessAttachmentsMixin):
202
    name = "build-attachment"
203
204
    help_text = "Apply and build patches from bugzilla"
    argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
205
    main_steps = [
206
207
208
209
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.ApplyPatch,
        steps.Build,
210
    ]
211

212

213
214
215
216
217
218
219
220
221
222
223
224
225
class BuildAndTestAttachment(AbstractPatchSequencingCommand, ProcessAttachmentsMixin):
    name = "build-and-test-attachment"
    help_text = "Apply, build, and test patches from bugzilla"
    argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
    main_steps = [
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.ApplyPatch,
        steps.Build,
        steps.RunTests,
    ]


226
227
class AbstractPatchApplyingCommand(AbstractPatchSequencingCommand):
    prepare_steps = [
228
229
230
        steps.EnsureLocalCommitIfNeeded,
        steps.CleanWorkingDirectoryWithLocalCommits,
        steps.Update,
231
232
    ]
    main_steps = [
233
        steps.ApplyPatchWithLocalCommit,
234
    ]
235
236
    long_help = """Updates the working copy.
Downloads and applies the patches, creating local commits if necessary."""
237
238


239
class ApplyAttachment(AbstractPatchApplyingCommand, ProcessAttachmentsMixin):
240
    name = "apply-attachment"
241
242
    help_text = "Apply an attachment to the local working directory"
    argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
243
244
245
    show_in_main_help = True


246
247
class ApplyFromBug(AbstractPatchApplyingCommand, ProcessBugsMixin):
    name = "apply-from-bug"
248
249
    help_text = "Apply reviewed patches from provided bugs to the local working directory"
    argument_names = "BUGID [BUGIDS]"
250
251
252
    show_in_main_help = True


253
254
class AbstractPatchLandingCommand(AbstractPatchSequencingCommand):
    prepare_steps = [
255
        steps.EnsureBuildersAreGreen,
256
257
    ]
    main_steps = [
258
259
260
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.ApplyPatch,
261
        steps.ValidateChangeLogs,
262
        steps.ValidateReviewer,
263
264
265
266
267
        steps.Build,
        steps.RunTests,
        steps.Commit,
        steps.ClosePatch,
        steps.CloseBug,
268
    ]
269
270
271
272
273
274
275
276
    long_help = """Checks to make sure builders are green.
Updates the working copy.
Applies the patch.
Builds.
Runs the layout tests.
Commits the patch.
Clears the flags on the patch.
Closes the bug if no patches are marked for review."""
277
278


279
class LandAttachment(AbstractPatchLandingCommand, ProcessAttachmentsMixin):
280
    name = "land-attachment"
281
282
    help_text = "Land patches from bugzilla, optionally building and testing them first"
    argument_names = "ATTACHMENT_ID [ATTACHMENT_IDS]"
283
    show_in_main_help = True
284
285


286
287
class LandFromBug(AbstractPatchLandingCommand, ProcessBugsMixin):
    name = "land-from-bug"
288
289
    help_text = "Land all patches on the given bugs, optionally building and testing them first"
    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
300
301
302
303
            # Note: Don't print a bug URL here because it will confuse the
            #       SheriffBot because the SheriffBot just greps the output
            #       of create-rollout for bug URLs.  It should do better
            #       parsing instead.
            log("Preparing rollout for bug %s." % commit_info.bug_id())
304
305
306
        else:
            log("Unable to parse bug number from diff.")
        return commit_info
307
308

    def _prepare_state(self, options, args, tool):
309
310
311
312
313
314
315
316
317
318
319
        revision_list = []
        for revision in str(args[0]).split():
            if revision.isdigit():
                revision_list.append(int(revision))
            else:
                raise ScriptError(message="Invalid svn revision number: " + revision)
        revision_list.sort()

        # We use the earliest revision for the bug info
        earliest_revision = revision_list[0]
        commit_info = self._commit_info(earliest_revision)
320
321
322
        cc_list = sorted([party.bugzilla_email()
                          for party in commit_info.responsible_parties()
                          if party.bugzilla_email()])
323
        return {
324
325
            "revision": earliest_revision,
            "revision_list": revision_list,
326
327
328
329
            "bug_id": commit_info.bug_id(),
            # FIXME: We should used the list as the canonical representation.
            "bug_cc": ",".join(cc_list),
            "reason": args[1],
330
331
332
333
334
        }


class PrepareRollout(AbstractRolloutPrepCommand):
    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
339
340
341
342
343
344
345
346
Creates an appropriate rollout ChangeLog, including a trac link and bug link.
"""
    steps = [
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.RevertRevision,
        steps.PrepareChangeLogForRevert,
    ]

347

348
349
class CreateRollout(AbstractRolloutPrepCommand):
    name = "create-rollout"
350
    help_text = "Creates a bug to track the broken SVN revision(s) and uploads a rollout patch."
351
352
353
    steps = [
        steps.CleanWorkingDirectory,
        steps.Update,
354
355
        steps.RevertRevision,
        steps.CreateBug,
356
357
358
        steps.PrepareChangeLogForRevert,
        steps.PostDiffForRevert,
    ]
359

360
361
362
363
364
365
366
367
368
369
370
    def _prepare_state(self, options, args, tool):
        state = AbstractRolloutPrepCommand._prepare_state(self, options, args, tool)
        # Currently, state["bug_id"] points to the bug that caused the
        # regression.  We want to create a new bug that blocks the old bug
        # so we move state["bug_id"] to state["bug_blocked"] and delete the
        # old state["bug_id"] so that steps.CreateBug will actually create
        # the new bug that we want (and subsequently store its bug id into
        # state["bug_id"])
        state["bug_blocked"] = state["bug_id"]
        del state["bug_id"]
        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
373
374
375
376
377
378
379
380
381
382
        # FIXME: If we had more context here, we could link to other open bugs
        #        that mention the test that regressed.
        if options.parent_command == "sheriff-bot":
            state["bug_description"] += """

This is an automatic bug report generated by the sheriff-bot. If this bug
report was created because of a flaky test, please file a bug for the flaky
test (if we don't already have one on file) and dup this bug against that bug
so that we can track how often these flaky tests case pain.

"Only you can prevent forest fires." -- Smokey the Bear
383
"""
384
385
        return state

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
392
393
394
395
396
    long_help = """Updates the working copy.
Applies the inverse diff for the provided revision.
Creates an appropriate rollout ChangeLog, including a trac link and bug link.
Opens the generated ChangeLogs in $EDITOR.
Shows the prepared diff for confirmation.
Commits the revert and updates the bug (including re-opening the bug if necessary)."""
397
    steps = [
398
399
400
401
        steps.CleanWorkingDirectory,
        steps.Update,
        steps.RevertRevision,
        steps.PrepareChangeLogForRevert,
402
403
        steps.EditChangeLog,
        steps.ConfirmDiff,
404
405
406
        steps.Build,
        steps.Commit,
        steps.ReopenBugAfterRollout,
407
    ]