77b3a2190b137b73852e4e67bc6b3ff76ab47bc5
[WebKit-https.git] / WebKitTools / Scripts / modules / scm.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 # Python module for interacting with an SCM system (like SVN or Git)
31
32 import os
33 import re
34 import subprocess
35
36 # Import WebKit-specific modules.
37 from modules.logging import error, log
38
39 def detect_scm_system(path):
40     if SVN.in_working_directory(path):
41         return SVN(cwd=path)
42     
43     if Git.in_working_directory(path):
44         return Git(cwd=path)
45     
46     return None
47
48 def first_non_empty_line_after_index(lines, index=0):
49     first_non_empty_line = index
50     for line in lines[index:]:
51         if re.match("^\s*$", line):
52             first_non_empty_line += 1
53         else:
54             break
55     return first_non_empty_line
56
57
58 class CommitMessage:
59     def __init__(self, message):
60         self.message_lines = message[first_non_empty_line_after_index(message, 0):]
61
62     def body(self, lstrip=False):
63         lines = self.message_lines[first_non_empty_line_after_index(self.message_lines, 1):]
64         if lstrip:
65             lines = [line.lstrip() for line in lines]
66         return "\n".join(lines) + "\n"
67
68     def description(self, lstrip=False, strip_url=False):
69         line = self.message_lines[0]
70         if lstrip:
71             line = line.lstrip()
72         if strip_url:
73             line = re.sub("^(\s*)<.+> ", "\1", line)
74         return line
75
76     def message(self):
77         return "\n".join(self.message_lines) + "\n"
78
79
80 class ScriptError(Exception):
81     def __init__(self, message=None, script_args=None, exit_code=None, output=None, cwd=None):
82         if not message:
83             message = 'Failed to run "%s"' % script_args
84             if exit_code:
85                 message += " exit_code: %d" % exit_code
86             if cwd:
87                 message += " cwd: %s" % cwd
88
89         Exception.__init__(self, message)
90         self.script_args = script_args # 'args' is already used by Exception
91         self.exit_code = exit_code
92         self.output = output
93         self.cwd = cwd
94
95     def message_with_output(self, output_limit=500):
96         if self.output:
97             if len(self.output) > output_limit:
98                  return "%s\nLast %s characters of output:\n%s" % (self, output_limit, self.output[-output_limit:])
99             return "%s\n%s" % (self, self.output)
100         return str(self)
101
102
103 class CheckoutNeedsUpdate(ScriptError):
104     def __init__(self, script_args, exit_code, output, cwd):
105         ScriptError.__init__(self, script_args=script_args, exit_code=exit_code, output=output, cwd=cwd)
106
107
108 def default_error_handler(error):
109     raise error
110
111 def commit_error_handler(error):
112     if re.search("resource out of date", error.output):
113         raise CheckoutNeedsUpdate(script_args=error.script_args, exit_code=error.exit_code, output=error.output, cwd=error.cwd)
114     default_error_handler(error)
115
116 def ignore_error(error):
117     pass
118
119 class SCM:
120     def __init__(self, cwd, dryrun=False):
121         self.cwd = cwd
122         self.checkout_root = self.find_checkout_root(self.cwd)
123         self.dryrun = dryrun
124
125     @staticmethod
126     def run_command(args, cwd=None, input=None, error_handler=default_error_handler, return_exit_code=False, return_stderr=False):
127         if hasattr(input, 'read'): # Check if the input is a file.
128             stdin = input
129             string_to_communicate = None
130         else:
131             stdin = subprocess.PIPE if input else None
132             string_to_communicate = input
133         if return_stderr:
134             stderr = subprocess.STDOUT
135         else:
136             stderr = None
137         process = subprocess.Popen(args, stdin=stdin, stdout=subprocess.PIPE, stderr=stderr, cwd=cwd)
138         output = process.communicate(string_to_communicate)[0]
139         exit_code = process.wait()
140         if exit_code:
141             script_error = ScriptError(script_args=args, exit_code=exit_code, output=output, cwd=cwd)
142             error_handler(script_error)
143         if return_exit_code:
144             return exit_code
145         return output
146
147     def scripts_directory(self):
148         return os.path.join(self.checkout_root, "WebKitTools", "Scripts")
149
150     def script_path(self, script_name):
151         return os.path.join(self.scripts_directory(), script_name)
152
153     def ensure_clean_working_directory(self, force_clean):
154         if not force_clean and not self.working_directory_is_clean():
155             print self.run_command(self.status_command(), error_handler=ignore_error)
156             raise ScriptError(message="Working directory has modifications, pass --force-clean or --no-clean to continue.")
157         
158         log("Cleaning working directory")
159         self.clean_working_directory()
160     
161     def ensure_no_local_commits(self, force):
162         if not self.supports_local_commits():
163             return
164         commits = self.local_commits()
165         if not len(commits):
166             return
167         if not force:
168             error("Working directory has local commits, pass --force-clean to continue.")
169         self.discard_local_commits()
170
171     def apply_patch(self, patch, force=False):
172         # It's possible that the patch was not made from the root directory.
173         # We should detect and handle that case.
174         curl_process = subprocess.Popen(['curl', '--location', '--silent', '--show-error', patch['url']], stdout=subprocess.PIPE)
175         args = [self.script_path('svn-apply')]
176         if patch.get('reviewer'):
177             args += ['--reviewer', patch['reviewer']]
178         if force:
179             args.append('--force')
180
181         self.run_command(args, input=curl_process.stdout)
182
183     def run_status_and_extract_filenames(self, status_command, status_regexp):
184         filenames = []
185         for line in self.run_command(status_command).splitlines():
186             match = re.search(status_regexp, line)
187             if not match:
188                 continue
189             # status = match.group('status')
190             filename = match.group('filename')
191             filenames.append(filename)
192         return filenames
193
194     def strip_r_from_svn_revision(self, svn_revision):
195         match = re.match("^r(?P<svn_revision>\d+)", svn_revision)
196         if (match):
197             return match.group('svn_revision')
198         return svn_revision
199
200     def svn_revision_from_commit_text(self, commit_text):
201         match = re.search(self.commit_success_regexp(), commit_text, re.MULTILINE)
202         return match.group('svn_revision')
203
204     # ChangeLog-specific code doesn't really belong in scm.py, but this function is very useful.
205     def modified_changelogs(self):
206         changelog_paths = []
207         paths = self.changed_files()
208         for path in paths:
209             if os.path.basename(path) == "ChangeLog":
210                 changelog_paths.append(path)
211         return changelog_paths
212
213     @staticmethod
214     def in_working_directory(path):
215         raise NotImplementedError, "subclasses must implement"
216
217     @staticmethod
218     def find_checkout_root(path):
219         raise NotImplementedError, "subclasses must implement"
220
221     @staticmethod
222     def commit_success_regexp():
223         raise NotImplementedError, "subclasses must implement"
224
225     def working_directory_is_clean(self):
226         raise NotImplementedError, "subclasses must implement"
227
228     def clean_working_directory(self):
229         raise NotImplementedError, "subclasses must implement"
230
231     def update_webkit(self):
232         raise NotImplementedError, "subclasses must implement"
233
234     def status_command(self):
235         raise NotImplementedError, "subclasses must implement"
236
237     def changed_files(self):
238         raise NotImplementedError, "subclasses must implement"
239
240     def display_name(self):
241         raise NotImplementedError, "subclasses must implement"
242
243     def create_patch(self):
244         raise NotImplementedError, "subclasses must implement"
245
246     def diff_for_revision(self, revision):
247         raise NotImplementedError, "subclasses must implement"
248
249     def apply_reverse_diff(self, revision):
250         raise NotImplementedError, "subclasses must implement"
251
252     def revert_files(self, file_paths):
253         raise NotImplementedError, "subclasses must implement"
254
255     def commit_with_message(self, message):
256         raise NotImplementedError, "subclasses must implement"
257
258     def svn_commit_log(self, svn_revision):
259         raise NotImplementedError, "subclasses must implement"
260
261     def last_svn_commit_log(self):
262         raise NotImplementedError, "subclasses must implement"
263
264     # Subclasses must indicate if they support local commits,
265     # but the SCM baseclass will only call local_commits methods when this is true.
266     @staticmethod
267     def supports_local_commits():
268         raise NotImplementedError, "subclasses must implement"
269
270     def create_patch_from_local_commit(self, commit_id):
271         error("Your source control manager does not support creating a patch from a local commit.")
272
273     def create_patch_since_local_commit(self, commit_id):
274         error("Your source control manager does not support creating a patch from a local commit.")
275
276     def commit_locally_with_message(self, message):
277         error("Your source control manager does not support local commits.")
278
279     def discard_local_commits(self):
280         pass
281
282     def local_commits(self):
283         return []
284
285
286 class SVN(SCM):
287     def __init__(self, cwd, dryrun=False):
288         SCM.__init__(self, cwd, dryrun)
289         self.cached_version = None
290     
291     @staticmethod
292     def in_working_directory(path):
293         return os.path.isdir(os.path.join(path, '.svn'))
294     
295     @classmethod
296     def find_uuid(cls, path):
297         if not cls.in_working_directory(path):
298             return None
299         return cls.value_from_svn_info(path, 'Repository UUID')
300
301     @classmethod
302     def value_from_svn_info(cls, path, field_name):
303         svn_info_args = ['svn', 'info', path]
304         info_output = cls.run_command(svn_info_args).rstrip()
305         match = re.search("^%s: (?P<value>.+)$" % field_name, info_output, re.MULTILINE)
306         if not match:
307             raise ScriptError(script_args=svn_info_args, message='svn info did not contain a %s.' % field_name)
308         return match.group('value')
309
310     @staticmethod
311     def find_checkout_root(path):
312         uuid = SVN.find_uuid(path)
313         # If |path| is not in a working directory, we're supposed to return |path|.
314         if not uuid:
315             return path
316         # Search up the directory hierarchy until we find a different UUID.
317         last_path = None
318         while True:
319             if uuid != SVN.find_uuid(path):
320                 return last_path
321             last_path = path
322             (path, last_component) = os.path.split(path)
323             if last_path == path:
324                 return None
325
326     @staticmethod
327     def commit_success_regexp():
328         return "^Committed revision (?P<svn_revision>\d+)\.$"
329
330     def svn_version(self):
331         if not self.cached_version:
332             self.cached_version = self.run_command(['svn', '--version', '--quiet'])
333         
334         return self.cached_version
335
336     def working_directory_is_clean(self):
337         return self.run_command(['svn', 'diff']) == ""
338
339     def clean_working_directory(self):
340         self.run_command(['svn', 'revert', '-R', '.'])
341
342     def update_webkit(self):
343         self.run_command(self.script_path("update-webkit"))
344
345     def status_command(self):
346         return ['svn', 'status']
347
348     def changed_files(self):
349         if self.svn_version() > "1.6":
350             status_regexp = "^(?P<status>[ACDMR]).{6} (?P<filename>.+)$"
351         else:
352             status_regexp = "^(?P<status>[ACDMR]).{5} (?P<filename>.+)$"
353         return self.run_status_and_extract_filenames(self.status_command(), status_regexp)
354
355     @staticmethod
356     def supports_local_commits():
357         return False
358
359     def display_name(self):
360         return "svn"
361
362     def create_patch(self):
363         return self.run_command(self.script_path("svn-create-patch"), cwd=self.checkout_root)
364
365     def diff_for_revision(self, revision):
366         return self.run_command(['svn', 'diff', '-c', str(revision)])
367
368     def _repository_url(self):
369         return self.value_from_svn_info(self.checkout_root, 'URL')
370
371     def apply_reverse_diff(self, revision):
372         # '-c -revision' applies the inverse diff of 'revision'
373         svn_merge_args = ['svn', 'merge', '--non-interactive', '-c', '-%s' % revision, self._repository_url()]
374         log("WARNING: svn merge has been known to take more than 10 minutes to complete.  It is recommended you use git for rollouts.")
375         log("Running '%s'" % " ".join(svn_merge_args))
376         self.run_command(svn_merge_args)
377
378     def revert_files(self, file_paths):
379         self.run_command(['svn', 'revert'] + file_paths)
380
381     def commit_with_message(self, message):
382         if self.dryrun:
383             # Return a string which looks like a commit so that things which parse this output will succeed.
384             return "Dry run, no commit.\nCommitted revision 0."
385         return self.run_command(['svn', 'commit', '-m', message], error_handler=commit_error_handler)
386
387     def svn_commit_log(self, svn_revision):
388         svn_revision = self.strip_r_from_svn_revision(str(svn_revision))
389         return self.run_command(['svn', 'log', '--non-interactive', '--revision', svn_revision]);
390
391     def last_svn_commit_log(self):
392         # BASE is the checkout revision, HEAD is the remote repository revision
393         # http://svnbook.red-bean.com/en/1.0/ch03s03.html
394         return self.svn_commit_log('BASE')
395
396 # All git-specific logic should go here.
397 class Git(SCM):
398     def __init__(self, cwd, dryrun=False):
399         SCM.__init__(self, cwd, dryrun)
400
401     @classmethod
402     def in_working_directory(cls, path):
403         return cls.run_command(['git', 'rev-parse', '--is-inside-work-tree'], cwd=path, error_handler=ignore_error).rstrip() == "true"
404
405     @classmethod
406     def find_checkout_root(cls, path):
407         # "git rev-parse --show-cdup" would be another way to get to the root
408         (checkout_root, dot_git) = os.path.split(cls.run_command(['git', 'rev-parse', '--git-dir'], cwd=path))
409         # If we were using 2.6 # checkout_root = os.path.relpath(checkout_root, path)
410         if not os.path.isabs(checkout_root): # Sometimes git returns relative paths
411             checkout_root = os.path.join(path, checkout_root)
412         return checkout_root
413     
414     @staticmethod
415     def commit_success_regexp():
416         return "^Committed r(?P<svn_revision>\d+)$"
417
418
419     def discard_local_commits(self):
420         self.run_command(['git', 'reset', '--hard', 'trunk'])
421     
422     def local_commits(self):
423         return self.run_command(['git', 'log', '--pretty=oneline', 'HEAD...trunk']).splitlines()
424
425     def rebase_in_progress(self):
426         return os.path.exists(os.path.join(self.checkout_root, '.git/rebase-apply'))
427
428     def working_directory_is_clean(self):
429         return self.run_command(['git', 'diff-index', 'HEAD']) == ""
430
431     def clean_working_directory(self):
432         # Could run git clean here too, but that wouldn't match working_directory_is_clean
433         self.run_command(['git', 'reset', '--hard', 'HEAD'])
434         # Aborting rebase even though this does not match working_directory_is_clean
435         if self.rebase_in_progress():
436             self.run_command(['git', 'rebase', '--abort'])
437
438     def update_webkit(self):
439         # FIXME: Call update-webkit once https://bugs.webkit.org/show_bug.cgi?id=27162 is fixed.
440         log("Updating working directory")
441         self.run_command(['git', 'svn', 'rebase'])
442
443     def status_command(self):
444         return ['git', 'status']
445
446     def changed_files(self):
447         status_command = ['git', 'diff', '-r', '--name-status', '-C', '-M', 'HEAD']
448         status_regexp = '^(?P<status>[ADM])\t(?P<filename>.+)$'
449         return self.run_status_and_extract_filenames(status_command, status_regexp)
450     
451     @staticmethod
452     def supports_local_commits():
453         return True
454
455     def display_name(self):
456         return "git"
457
458     def create_patch(self):
459         return self.run_command(['git', 'diff', '--binary', 'HEAD'])
460
461     @classmethod
462     def git_commit_from_svn_revision(cls, revision):
463         # git svn find-rev always exits 0, even when the revision is not found.
464         return cls.run_command(['git', 'svn', 'find-rev', 'r%s' % revision]).rstrip()
465
466     def diff_for_revision(self, revision):
467         git_commit = self.git_commit_from_svn_revision(revision)
468         return self.create_patch_from_local_commit(git_commit)
469
470     def apply_reverse_diff(self, revision):
471         # Assume the revision is an svn revision.
472         git_commit = self.git_commit_from_svn_revision(revision)
473         if not git_commit:
474             raise ScriptError(message='Failed to find git commit for revision %s, git svn log output: "%s"' % (revision, git_commit))
475
476         # I think this will always fail due to ChangeLogs.
477         # FIXME: We need to detec specific failure conditions and handle them.
478         self.run_command(['git', 'revert', '--no-commit', git_commit], error_handler=ignore_error)
479
480         # Fix any ChangeLogs if necessary.
481         changelog_paths = self.modified_changelogs()
482         if len(changelog_paths):
483             self.run_command([self.script_path('resolve-ChangeLogs')] + changelog_paths)
484
485     def revert_files(self, file_paths):
486         self.run_command(['git', 'checkout', 'HEAD'] + file_paths)
487
488     def commit_with_message(self, message):
489         self.commit_locally_with_message(message)
490         return self.push_local_commits_to_server()
491
492     def svn_commit_log(self, svn_revision):
493         svn_revision = self.strip_r_from_svn_revision(svn_revision)
494         return self.run_command(['git', 'svn', 'log', '-r', svn_revision])
495
496     def last_svn_commit_log(self):
497         return self.run_command(['git', 'svn', 'log', '--limit=1'])
498
499     # Git-specific methods:
500
501     def create_patch_from_local_commit(self, commit_id):
502         return self.run_command(['git', 'diff', '--binary', commit_id + "^.." + commit_id])
503
504     def create_patch_since_local_commit(self, commit_id):
505         return self.run_command(['git', 'diff', '--binary', commit_id])
506
507     def commit_locally_with_message(self, message):
508         self.run_command(['git', 'commit', '--all', '-F', '-'], input=message)
509         
510     def push_local_commits_to_server(self):
511         if self.dryrun:
512             # Return a string which looks like a commit so that things which parse this output will succeed.
513             return "Dry run, no remote commit.\nCommitted r0"
514         return self.run_command(['git', 'svn', 'dcommit'], error_handler=commit_error_handler)
515
516     # This function supports the following argument formats:
517     # no args : rev-list trunk..HEAD
518     # A..B    : rev-list A..B
519     # A...B   : error!
520     # A B     : [A, B]  (different from git diff, which would use "rev-list A..B")
521     def commit_ids_from_commitish_arguments(self, args):
522         if not len(args):
523             # FIXME: trunk is not always the remote branch name, need a way to detect the name.
524             args.append('trunk..HEAD')
525
526         commit_ids = []
527         for commitish in args:
528             if '...' in commitish:
529                 raise ScriptError(message="'...' is not supported (found in '%s'). Did you mean '..'?" % commitish)
530             elif '..' in commitish:
531                 commit_ids += reversed(self.run_command(['git', 'rev-list', commitish]).splitlines())
532             else:
533                 # Turn single commits or branch or tag names into commit ids.
534                 commit_ids += self.run_command(['git', 'rev-parse', '--revs-only', commitish]).splitlines()
535         return commit_ids
536
537     def commit_message_for_local_commit(self, commit_id):
538         commit_lines = self.run_command(['git', 'cat-file', 'commit', commit_id]).splitlines()
539
540         # Skip the git headers.
541         first_line_after_headers = 0
542         for line in commit_lines:
543             first_line_after_headers += 1
544             if line == "":
545                 break
546         return CommitMessage(commit_lines[first_line_after_headers:])
547
548     def files_changed_summary_for_commit(self, commit_id):
549         return self.run_command(['git', 'diff-tree', '--shortstat', '--no-commit-id', commit_id])