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