| #!/usr/bin/env python |
| # Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| # Copyright (C) 2008 Evan Martin <[email protected]> |
| |
| """A git-command for integrating reviews on Rietveld.""" |
| |
| import errno |
| import logging |
| import optparse |
| import os |
| import re |
| import subprocess |
| import sys |
| import tempfile |
| import textwrap |
| import urlparse |
| import urllib2 |
| |
| try: |
| import readline # pylint: disable=F0401,W0611 |
| except ImportError: |
| pass |
| |
| try: |
| import simplejson as json # pylint: disable=F0401 |
| except ImportError: |
| try: |
| import json # pylint: disable=F0401 |
| except ImportError: |
| # Fall back to the packaged version. |
| sys.path.append(os.path.join(os.path.dirname(__file__), 'third_party')) |
| import simplejson as json # pylint: disable=F0401 |
| |
| |
| from third_party import upload |
| import breakpad # pylint: disable=W0611 |
| import fix_encoding |
| import presubmit_support |
| import rietveld |
| import scm |
| import watchlists |
| |
| |
| |
| DEFAULT_SERVER = 'http://codereview.appspot.com' |
| POSTUPSTREAM_HOOK_PATTERN = '.git/hooks/post-cl-%s' |
| DESCRIPTION_BACKUP_FILE = '~/.git_cl_description_backup' |
| |
| |
| def DieWithError(message): |
| print >> sys.stderr, message |
| sys.exit(1) |
| |
| |
| def Popen(cmd, **kwargs): |
| """Wrapper for subprocess.Popen() that logs and watch for cygwin issues""" |
| logging.debug('Popen: ' + ' '.join(cmd)) |
| try: |
| return subprocess.Popen(cmd, **kwargs) |
| except OSError, e: |
| if e.errno == errno.EAGAIN and sys.platform == 'cygwin': |
| DieWithError( |
| 'Visit ' |
| 'http://code.google.com/p/chromium/wiki/CygwinDllRemappingFailure to ' |
| 'learn how to fix this error; you need to rebase your cygwin dlls') |
| raise |
| |
| |
| def RunCommand(cmd, error_ok=False, error_message=None, |
| redirect_stdout=True, swallow_stderr=False, **kwargs): |
| if redirect_stdout: |
| stdout = subprocess.PIPE |
| else: |
| stdout = None |
| if swallow_stderr: |
| stderr = subprocess.PIPE |
| else: |
| stderr = None |
| proc = Popen(cmd, stdout=stdout, stderr=stderr, **kwargs) |
| output = proc.communicate()[0] |
| if not error_ok and proc.returncode != 0: |
| DieWithError('Command "%s" failed.\n' % (' '.join(cmd)) + |
| (error_message or output or '')) |
| return output |
| |
| |
| def RunGit(args, **kwargs): |
| cmd = ['git'] + args |
| return RunCommand(cmd, **kwargs) |
| |
| |
| def RunGitWithCode(args): |
| proc = Popen(['git'] + args, stdout=subprocess.PIPE) |
| output = proc.communicate()[0] |
| return proc.returncode, output |
| |
| |
| def usage(more): |
| def hook(fn): |
| fn.usage_more = more |
| return fn |
| return hook |
| |
| |
| def ask_for_data(prompt): |
| try: |
| return raw_input(prompt) |
| except KeyboardInterrupt: |
| # Hide the exception. |
| sys.exit(1) |
| |
| |
| def FixUrl(server): |
| """Fix a server url to defaults protocol to http:// if none is specified.""" |
| if not server: |
| return server |
| if not re.match(r'[a-z]+\://.*', server): |
| return 'http://' + server |
| return server |
| |
| |
| def MatchSvnGlob(url, base_url, glob_spec, allow_wildcards): |
| """Return the corresponding git ref if |base_url| together with |glob_spec| |
| matches the full |url|. |
| |
| If |allow_wildcards| is true, |glob_spec| can contain wildcards (see below). |
| """ |
| fetch_suburl, as_ref = glob_spec.split(':') |
| if allow_wildcards: |
| glob_match = re.match('(.+/)?(\*|{[^/]*})(/.+)?', fetch_suburl) |
| if glob_match: |
| # Parse specs like "branches/*/src:refs/remotes/svn/*" or |
| # "branches/{472,597,648}/src:refs/remotes/svn/*". |
| branch_re = re.escape(base_url) |
| if glob_match.group(1): |
| branch_re += '/' + re.escape(glob_match.group(1)) |
| wildcard = glob_match.group(2) |
| if wildcard == '*': |
| branch_re += '([^/]*)' |
| else: |
| # Escape and replace surrounding braces with parentheses and commas |
| # with pipe symbols. |
| wildcard = re.escape(wildcard) |
| wildcard = re.sub('^\\\\{', '(', wildcard) |
| wildcard = re.sub('\\\\,', '|', wildcard) |
| wildcard = re.sub('\\\\}$', ')', wildcard) |
| branch_re += wildcard |
| if glob_match.group(3): |
| branch_re += re.escape(glob_match.group(3)) |
| match = re.match(branch_re, url) |
| if match: |
| return re.sub('\*$', match.group(1), as_ref) |
| |
| # Parse specs like "trunk/src:refs/remotes/origin/trunk". |
| if fetch_suburl: |
| full_url = base_url + '/' + fetch_suburl |
| else: |
| full_url = base_url |
| if full_url == url: |
| return as_ref |
| return None |
| |
| class Settings(object): |
| def __init__(self): |
| self.default_server = None |
| self.cc = None |
| self.root = None |
| self.is_git_svn = None |
| self.svn_branch = None |
| self.tree_status_url = None |
| self.viewvc_url = None |
| self.updated = False |
| |
| def LazyUpdateIfNeeded(self): |
| """Updates the settings from a codereview.settings file, if available.""" |
| if not self.updated: |
| cr_settings_file = FindCodereviewSettingsFile() |
| if cr_settings_file: |
| LoadCodereviewSettingsFromFile(cr_settings_file) |
| self.updated = True |
| |
| def GetDefaultServerUrl(self, error_ok=False): |
| if not self.default_server: |
| self.LazyUpdateIfNeeded() |
| self.default_server = FixUrl(self._GetConfig('rietveld.server', |
| error_ok=True)) |
| if error_ok: |
| return self.default_server |
| if not self.default_server: |
| error_message = ('Could not find settings file. You must configure ' |
| 'your review setup by running "git cl config".') |
| self.default_server = FixUrl(self._GetConfig( |
| 'rietveld.server', error_message=error_message)) |
| return self.default_server |
| |
| def GetRoot(self): |
| if not self.root: |
| self.root = os.path.abspath(RunGit(['rev-parse', '--show-cdup']).strip()) |
| return self.root |
| |
| def GetIsGitSvn(self): |
| """Return true if this repo looks like it's using git-svn.""" |
| if self.is_git_svn is None: |
| # If you have any "svn-remote.*" config keys, we think you're using svn. |
| self.is_git_svn = RunGitWithCode( |
| ['config', '--get-regexp', r'^svn-remote\.'])[0] == 0 |
| return self.is_git_svn |
| |
| def GetSVNBranch(self): |
| if self.svn_branch is None: |
| if not self.GetIsGitSvn(): |
| DieWithError('Repo doesn\'t appear to be a git-svn repo.') |
| |
| # Try to figure out which remote branch we're based on. |
| # Strategy: |
| # 1) iterate through our branch history and find the svn URL. |
| # 2) find the svn-remote that fetches from the URL. |
| |
| # regexp matching the git-svn line that contains the URL. |
| git_svn_re = re.compile(r'^\s*git-svn-id: (\S+)@', re.MULTILINE) |
| |
| # We don't want to go through all of history, so read a line from the |
| # pipe at a time. |
| # The -100 is an arbitrary limit so we don't search forever. |
| cmd = ['git', 'log', '-100', '--pretty=medium'] |
| proc = Popen(cmd, stdout=subprocess.PIPE) |
| url = None |
| for line in proc.stdout: |
| match = git_svn_re.match(line) |
| if match: |
| url = match.group(1) |
| proc.stdout.close() # Cut pipe. |
| break |
| |
| if url: |
| svn_remote_re = re.compile(r'^svn-remote\.([^.]+)\.url (.*)$') |
| remotes = RunGit(['config', '--get-regexp', |
| r'^svn-remote\..*\.url']).splitlines() |
| for remote in remotes: |
| match = svn_remote_re.match(remote) |
| if match: |
| remote = match.group(1) |
| base_url = match.group(2) |
| fetch_spec = RunGit( |
| ['config', 'svn-remote.%s.fetch' % remote], |
| error_ok=True).strip() |
| if fetch_spec: |
| self.svn_branch = MatchSvnGlob(url, base_url, fetch_spec, False) |
| if self.svn_branch: |
| break |
| branch_spec = RunGit( |
| ['config', 'svn-remote.%s.branches' % remote], |
| error_ok=True).strip() |
| if branch_spec: |
| self.svn_branch = MatchSvnGlob(url, base_url, branch_spec, True) |
| if self.svn_branch: |
| break |
| tag_spec = RunGit( |
| ['config', 'svn-remote.%s.tags' % remote], |
| error_ok=True).strip() |
| if tag_spec: |
| self.svn_branch = MatchSvnGlob(url, base_url, tag_spec, True) |
| if self.svn_branch: |
| break |
| |
| if not self.svn_branch: |
| DieWithError('Can\'t guess svn branch -- try specifying it on the ' |
| 'command line') |
| |
| return self.svn_branch |
| |
| def GetTreeStatusUrl(self, error_ok=False): |
| if not self.tree_status_url: |
| error_message = ('You must configure your tree status URL by running ' |
| '"git cl config".') |
| self.tree_status_url = self._GetConfig('rietveld.tree-status-url', |
| error_ok=error_ok, |
| error_message=error_message) |
| return self.tree_status_url |
| |
| def GetViewVCUrl(self): |
| if not self.viewvc_url: |
| self.viewvc_url = self._GetConfig('rietveld.viewvc-url', error_ok=True) |
| return self.viewvc_url |
| |
| def GetDefaultCCList(self): |
| return self._GetConfig('rietveld.cc', error_ok=True) |
| |
| def _GetConfig(self, param, **kwargs): |
| self.LazyUpdateIfNeeded() |
| return RunGit(['config', param], **kwargs).strip() |
| |
| |
| settings = Settings() |
| |
| |
| did_migrate_check = False |
| def CheckForMigration(): |
| """Migrate from the old issue format, if found. |
| |
| We used to store the branch<->issue mapping in a file in .git, but it's |
| better to store it in the .git/config, since deleting a branch deletes that |
| branch's entry there. |
| """ |
| |
| # Don't run more than once. |
| global did_migrate_check |
| if did_migrate_check: |
| return |
| |
| gitdir = RunGit(['rev-parse', '--git-dir']).strip() |
| storepath = os.path.join(gitdir, 'cl-mapping') |
| if os.path.exists(storepath): |
| print "old-style git-cl mapping file (%s) found; migrating." % storepath |
| store = open(storepath, 'r') |
| for line in store: |
| branch, issue = line.strip().split() |
| RunGit(['config', 'branch.%s.rietveldissue' % ShortBranchName(branch), |
| issue]) |
| store.close() |
| os.remove(storepath) |
| did_migrate_check = True |
| |
| |
| def ShortBranchName(branch): |
| """Convert a name like 'refs/heads/foo' to just 'foo'.""" |
| return branch.replace('refs/heads/', '') |
| |
| |
| class Changelist(object): |
| def __init__(self, branchref=None): |
| # Poke settings so we get the "configure your server" message if necessary. |
| settings.GetDefaultServerUrl() |
| self.branchref = branchref |
| if self.branchref: |
| self.branch = ShortBranchName(self.branchref) |
| else: |
| self.branch = None |
| self.rietveld_server = None |
| self.upstream_branch = None |
| self.has_issue = False |
| self.issue = None |
| self.has_description = False |
| self.description = None |
| self.has_patchset = False |
| self.patchset = None |
| self._rpc_server = None |
| self.cc = None |
| self.watchers = () |
| |
| def GetCCList(self): |
| """Return the users cc'd on this CL. |
| |
| Return is a string suitable for passing to gcl with the --cc flag. |
| """ |
| if self.cc is None: |
| base_cc = settings .GetDefaultCCList() |
| more_cc = ','.join(self.watchers) |
| self.cc = ','.join(filter(None, (base_cc, more_cc))) or '' |
| return self.cc |
| |
| def SetWatchers(self, watchers): |
| """Set the list of email addresses that should be cc'd based on the changed |
| files in this CL. |
| """ |
| self.watchers = watchers |
| |
| def GetBranch(self): |
| """Returns the short branch name, e.g. 'master'.""" |
| if not self.branch: |
| self.branchref = RunGit(['symbolic-ref', 'HEAD']).strip() |
| self.branch = ShortBranchName(self.branchref) |
| return self.branch |
| |
| def GetBranchRef(self): |
| """Returns the full branch name, e.g. 'refs/heads/master'.""" |
| self.GetBranch() # Poke the lazy loader. |
| return self.branchref |
| |
| def FetchUpstreamTuple(self): |
| """Returns a tuple containg remote and remote ref, |
| e.g. 'origin', 'refs/heads/master' |
| """ |
| remote = '.' |
| branch = self.GetBranch() |
| upstream_branch = RunGit(['config', 'branch.%s.merge' % branch], |
| error_ok=True).strip() |
| if upstream_branch: |
| remote = RunGit(['config', 'branch.%s.remote' % branch]).strip() |
| else: |
| upstream_branch = RunGit(['config', 'rietveld.upstream-branch'], |
| error_ok=True).strip() |
| if upstream_branch: |
| remote = RunGit(['config', 'rietveld.upstream-remote']).strip() |
| else: |
| # Fall back on trying a git-svn upstream branch. |
| if settings.GetIsGitSvn(): |
| upstream_branch = settings.GetSVNBranch() |
| else: |
| # Else, try to guess the origin remote. |
| remote_branches = RunGit(['branch', '-r']).split() |
| if 'origin/master' in remote_branches: |
| # Fall back on origin/master if it exits. |
| remote = 'origin' |
| upstream_branch = 'refs/heads/master' |
| elif 'origin/trunk' in remote_branches: |
| # Fall back on origin/trunk if it exists. Generally a shared |
| # git-svn clone |
| remote = 'origin' |
| upstream_branch = 'refs/heads/trunk' |
| else: |
| DieWithError("""Unable to determine default branch to diff against. |
| Either pass complete "git diff"-style arguments, like |
| git cl upload origin/master |
| or verify this branch is set up to track another (via the --track argument to |
| "git checkout -b ...").""") |
| |
| return remote, upstream_branch |
| |
| def GetUpstreamBranch(self): |
| if self.upstream_branch is None: |
| remote, upstream_branch = self.FetchUpstreamTuple() |
| if remote is not '.': |
| upstream_branch = upstream_branch.replace('heads', 'remotes/' + remote) |
| self.upstream_branch = upstream_branch |
| return self.upstream_branch |
| |
| def GetRemoteUrl(self): |
| """Return the configured remote URL, e.g. 'git://example.org/foo.git/'. |
| |
| Returns None if there is no remote. |
| """ |
| remote = self.FetchUpstreamTuple()[0] |
| if remote == '.': |
| return None |
| return RunGit(['config', 'remote.%s.url' % remote], error_ok=True).strip() |
| |
| def GetIssue(self): |
| if not self.has_issue: |
| CheckForMigration() |
| issue = RunGit(['config', self._IssueSetting()], error_ok=True).strip() |
| if issue: |
| self.issue = issue |
| self.rietveld_server = FixUrl(RunGit( |
| ['config', self._RietveldServer()], error_ok=True).strip()) |
| else: |
| self.issue = None |
| if not self.rietveld_server: |
| self.rietveld_server = settings.GetDefaultServerUrl() |
| self.has_issue = True |
| return self.issue |
| |
| def GetRietveldServer(self): |
| self.GetIssue() |
| return self.rietveld_server |
| |
| def GetIssueURL(self): |
| """Get the URL for a particular issue.""" |
| return '%s/%s' % (self.GetRietveldServer(), self.GetIssue()) |
| |
| def GetDescription(self, pretty=False): |
| if not self.has_description: |
| if self.GetIssue(): |
| self.description = self.RpcServer().get_description( |
| int(self.GetIssue())).strip() |
| self.has_description = True |
| if pretty: |
| wrapper = textwrap.TextWrapper() |
| wrapper.initial_indent = wrapper.subsequent_indent = ' ' |
| return wrapper.fill(self.description) |
| return self.description |
| |
| def GetPatchset(self): |
| if not self.has_patchset: |
| patchset = RunGit(['config', self._PatchsetSetting()], |
| error_ok=True).strip() |
| if patchset: |
| self.patchset = patchset |
| else: |
| self.patchset = None |
| self.has_patchset = True |
| return self.patchset |
| |
| def SetPatchset(self, patchset): |
| """Set this branch's patchset. If patchset=0, clears the patchset.""" |
| if patchset: |
| RunGit(['config', self._PatchsetSetting(), str(patchset)]) |
| else: |
| RunGit(['config', '--unset', self._PatchsetSetting()], |
| swallow_stderr=True, error_ok=True) |
| self.has_patchset = False |
| |
| def GetPatchSetDiff(self, issue): |
| patchset = self.RpcServer().get_issue_properties( |
| int(issue), False)['patchsets'][-1] |
| return self.RpcServer().get( |
| '/download/issue%s_%s.diff' % (issue, patchset)) |
| |
| def SetIssue(self, issue): |
| """Set this branch's issue. If issue=0, clears the issue.""" |
| if issue: |
| RunGit(['config', self._IssueSetting(), str(issue)]) |
| if self.rietveld_server: |
| RunGit(['config', self._RietveldServer(), self.rietveld_server]) |
| else: |
| RunGit(['config', '--unset', self._IssueSetting()]) |
| self.SetPatchset(0) |
| self.has_issue = False |
| |
| def RunHook(self, committing, upstream_branch, may_prompt, verbose, author): |
| """Calls sys.exit() if the hook fails; returns a HookResults otherwise.""" |
| root = RunCommand(['git', 'rev-parse', '--show-cdup']).strip() or '.' |
| absroot = os.path.abspath(root) |
| |
| # We use the sha1 of HEAD as a name of this change. |
| name = RunCommand(['git', 'rev-parse', 'HEAD']).strip() |
| # Need to pass a relative path for msysgit. |
| files = scm.GIT.CaptureStatus([root], upstream_branch) |
| |
| issue = ConvertToInteger(self.GetIssue()) |
| patchset = ConvertToInteger(self.GetPatchset()) |
| if issue: |
| description = self.GetDescription() |
| else: |
| # If the change was never uploaded, use the log messages of all commits |
| # up to the branch point, as git cl upload will prefill the description |
| # with these log messages. |
| description = RunCommand(['git', 'log', '--pretty=format:%s%n%n%b', |
| '%s...' % (upstream_branch)]).strip() |
| |
| if not author: |
| author = RunGit(['config', 'user.email']).strip() or None |
| change = presubmit_support.GitChange( |
| name, |
| description, |
| absroot, |
| files, |
| issue, |
| patchset, |
| author) |
| |
| # Apply watchlists on upload. |
| if not committing: |
| watchlist = watchlists.Watchlists(change.RepositoryRoot()) |
| files = [f.LocalPath() for f in change.AffectedFiles()] |
| self.SetWatchers(watchlist.GetWatchersForPaths(files)) |
| |
| try: |
| output = presubmit_support.DoPresubmitChecks(change, committing, |
| verbose=verbose, output_stream=sys.stdout, input_stream=sys.stdin, |
| default_presubmit=None, may_prompt=may_prompt, |
| rietveld_obj=self.RpcServer()) |
| except presubmit_support.PresubmitFailure, e: |
| DieWithError( |
| ('%s\nMaybe your depot_tools is out of date?\n' |
| 'If all fails, contact maruel@') % e) |
| |
| # TODO(dpranke): We should propagate the error out instead of calling |
| # exit(). |
| if not output.should_continue(): |
| sys.exit(1) |
| |
| return output |
| |
| def CloseIssue(self): |
| """Updates the description and closes the issue.""" |
| issue = int(self.GetIssue()) |
| self.RpcServer().update_description(issue, self.description) |
| return self.RpcServer().close_issue(issue) |
| |
| def SetFlag(self, flag, value): |
| """Patchset must match.""" |
| if not self.GetPatchset(): |
| DieWithError('The patchset needs to match. Send another patchset.') |
| try: |
| return self.RpcServer().set_flag( |
| int(self.GetIssue()), int(self.GetPatchset()), flag, value) |
| except urllib2.HTTPError, e: |
| if e.code == 404: |
| DieWithError('The issue %s doesn\'t exist.' % self.GetIssue()) |
| if e.code == 403: |
| DieWithError( |
| ('Access denied to issue %s. Maybe the patchset %s doesn\'t ' |
| 'match?') % (self.GetIssue(), self.GetPatchset())) |
| raise |
| |
| def RpcServer(self): |
| """Returns an upload.RpcServer() to access this review's rietveld instance. |
| """ |
| if not self._rpc_server: |
| self.GetIssue() |
| self._rpc_server = rietveld.Rietveld(self.rietveld_server, None, None) |
| return self._rpc_server |
| |
| def _IssueSetting(self): |
| """Return the git setting that stores this change's issue.""" |
| return 'branch.%s.rietveldissue' % self.GetBranch() |
| |
| def _PatchsetSetting(self): |
| """Return the git setting that stores this change's most recent patchset.""" |
| return 'branch.%s.rietveldpatchset' % self.GetBranch() |
| |
| def _RietveldServer(self): |
| """Returns the git setting that stores this change's rietveld server.""" |
| return 'branch.%s.rietveldserver' % self.GetBranch() |
| |
| |
| def GetCodereviewSettingsInteractively(): |
| """Prompt the user for settings.""" |
| server = settings.GetDefaultServerUrl(error_ok=True) |
| prompt = 'Rietveld server (host[:port])' |
| prompt += ' [%s]' % (server or DEFAULT_SERVER) |
| newserver = ask_for_data(prompt + ':') |
| if not server and not newserver: |
| newserver = DEFAULT_SERVER |
| if newserver and newserver != server: |
| RunGit(['config', 'rietveld.server', newserver]) |
| |
| def SetProperty(initial, caption, name): |
| prompt = caption |
| if initial: |
| prompt += ' ("x" to clear) [%s]' % initial |
| new_val = ask_for_data(prompt + ':') |
| if new_val == 'x': |
| RunGit(['config', '--unset-all', 'rietveld.' + name], error_ok=True) |
| elif new_val and new_val != initial: |
| RunGit(['config', 'rietveld.' + name, new_val]) |
| |
| SetProperty(settings.GetDefaultCCList(), 'CC list', 'cc') |
| SetProperty(settings.GetTreeStatusUrl(error_ok=True), 'Tree status URL', |
| 'tree-status-url') |
| SetProperty(settings.GetViewVCUrl(), 'ViewVC URL', 'viewvc-url') |
| |
| # TODO: configure a default branch to diff against, rather than this |
| # svn-based hackery. |
| |
| |
| class ChangeDescription(object): |
| """Contains a parsed form of the change description.""" |
| def __init__(self, subject, log_desc, reviewers): |
| self.subject = subject |
| self.log_desc = log_desc |
| self.reviewers = reviewers |
| self.description = self.log_desc |
| |
| def Update(self): |
| initial_text = """# Enter a description of the change. |
| # This will displayed on the codereview site. |
| # The first line will also be used as the subject of the review. |
| """ |
| initial_text += self.description |
| if 'R=' not in self.description and self.reviewers: |
| initial_text += '\nR=' + self.reviewers |
| if 'BUG=' not in self.description: |
| initial_text += '\nBUG=' |
| if 'TEST=' not in self.description: |
| initial_text += '\nTEST=' |
| self._ParseDescription(UserEditedLog(initial_text)) |
| |
| def _ParseDescription(self, description): |
| if not description: |
| self.description = description |
| return |
| |
| parsed_lines = [] |
| reviewers_regexp = re.compile('\s*R=(.+)') |
| reviewers = '' |
| subject = '' |
| for l in description.splitlines(): |
| if not subject: |
| subject = l |
| matched_reviewers = reviewers_regexp.match(l) |
| if matched_reviewers: |
| reviewers = matched_reviewers.group(1) |
| parsed_lines.append(l) |
| |
| self.description = '\n'.join(parsed_lines) + '\n' |
| self.subject = subject |
| self.reviewers = reviewers |
| |
| def IsEmpty(self): |
| return not self.description |
| |
| |
| def FindCodereviewSettingsFile(filename='codereview.settings'): |
| """Finds the given file starting in the cwd and going up. |
| |
| Only looks up to the top of the repository unless an |
| 'inherit-review-settings-ok' file exists in the root of the repository. |
| """ |
| inherit_ok_file = 'inherit-review-settings-ok' |
| cwd = os.getcwd() |
| root = os.path.abspath(RunGit(['rev-parse', '--show-cdup']).strip()) |
| if os.path.isfile(os.path.join(root, inherit_ok_file)): |
| root = '/' |
| while True: |
| if filename in os.listdir(cwd): |
| if os.path.isfile(os.path.join(cwd, filename)): |
| return open(os.path.join(cwd, filename)) |
| if cwd == root: |
| break |
| cwd = os.path.dirname(cwd) |
| |
| |
| def LoadCodereviewSettingsFromFile(fileobj): |
| """Parse a codereview.settings file and updates hooks.""" |
| keyvals = {} |
| for line in fileobj.read().splitlines(): |
| if not line or line.startswith("#"): |
| continue |
| k, v = line.split(": ", 1) |
| keyvals[k] = v |
| |
| def SetProperty(name, setting, unset_error_ok=False): |
| fullname = 'rietveld.' + name |
| if setting in keyvals: |
| RunGit(['config', fullname, keyvals[setting]]) |
| else: |
| RunGit(['config', '--unset-all', fullname], error_ok=unset_error_ok) |
| |
| SetProperty('server', 'CODE_REVIEW_SERVER') |
| # Only server setting is required. Other settings can be absent. |
| # In that case, we ignore errors raised during option deletion attempt. |
| SetProperty('cc', 'CC_LIST', unset_error_ok=True) |
| SetProperty('tree-status-url', 'STATUS', unset_error_ok=True) |
| SetProperty('viewvc-url', 'VIEW_VC', unset_error_ok=True) |
| |
| if 'PUSH_URL_CONFIG' in keyvals and 'ORIGIN_URL_CONFIG' in keyvals: |
| #should be of the form |
| #PUSH_URL_CONFIG: url.ssh://gitrw.chromium.org.pushinsteadof |
| #ORIGIN_URL_CONFIG: http://src.chromium.org/git |
| RunGit(['config', keyvals['PUSH_URL_CONFIG'], |
| keyvals['ORIGIN_URL_CONFIG']]) |
| |
| |
| @usage('[repo root containing codereview.settings]') |
| def CMDconfig(parser, args): |
| """edit configuration for this tree""" |
| |
| _, args = parser.parse_args(args) |
| if len(args) == 0: |
| GetCodereviewSettingsInteractively() |
| return 0 |
| |
| url = args[0] |
| if not url.endswith('codereview.settings'): |
| url = os.path.join(url, 'codereview.settings') |
| |
| # Load code review settings and download hooks (if available). |
| LoadCodereviewSettingsFromFile(urllib2.urlopen(url)) |
| return 0 |
| |
| |
| def CMDstatus(parser, args): |
| """show status of changelists""" |
| parser.add_option('--field', |
| help='print only specific field (desc|id|patch|url)') |
| (options, args) = parser.parse_args(args) |
| |
| # TODO: maybe make show_branches a flag if necessary. |
| show_branches = not options.field |
| |
| if show_branches: |
| branches = RunGit(['for-each-ref', '--format=%(refname)', 'refs/heads']) |
| if branches: |
| print 'Branches associated with reviews:' |
| for branch in sorted(branches.splitlines()): |
| cl = Changelist(branchref=branch) |
| print " %10s: %s" % (cl.GetBranch(), cl.GetIssue()) |
| |
| cl = Changelist() |
| if options.field: |
| if options.field.startswith('desc'): |
| print cl.GetDescription() |
| elif options.field == 'id': |
| issueid = cl.GetIssue() |
| if issueid: |
| print issueid |
| elif options.field == 'patch': |
| patchset = cl.GetPatchset() |
| if patchset: |
| print patchset |
| elif options.field == 'url': |
| url = cl.GetIssueURL() |
| if url: |
| print url |
| else: |
| print |
| print 'Current branch:', |
| if not cl.GetIssue(): |
| print 'no issue assigned.' |
| return 0 |
| print cl.GetBranch() |
| print 'Issue number:', cl.GetIssue(), '(%s)' % cl.GetIssueURL() |
| print 'Issue description:' |
| print cl.GetDescription(pretty=True) |
| return 0 |
| |
| |
| @usage('[issue_number]') |
| def CMDissue(parser, args): |
| """Set or display the current code review issue number. |
| |
| Pass issue number 0 to clear the current issue. |
| """ |
| _, args = parser.parse_args(args) |
| |
| cl = Changelist() |
| if len(args) > 0: |
| try: |
| issue = int(args[0]) |
| except ValueError: |
| DieWithError('Pass a number to set the issue or none to list it.\n' |
| 'Maybe you want to run git cl status?') |
| cl.SetIssue(issue) |
| print 'Issue number:', cl.GetIssue(), '(%s)' % cl.GetIssueURL() |
| return 0 |
| |
| |
| def CreateDescriptionFromLog(args): |
| """Pulls out the commit log to use as a base for the CL description.""" |
| log_args = [] |
| if len(args) == 1 and not args[0].endswith('.'): |
| log_args = [args[0] + '..'] |
| elif len(args) == 1 and args[0].endswith('...'): |
| log_args = [args[0][:-1]] |
| elif len(args) == 2: |
| log_args = [args[0] + '..' + args[1]] |
| else: |
| log_args = args[:] # Hope for the best! |
| return RunGit(['log', '--pretty=format:%s\n\n%b'] + log_args) |
| |
| |
| def UserEditedLog(starting_text): |
| """Given some starting text, let the user edit it and return the result.""" |
| editor = os.getenv('EDITOR', 'vi') |
| |
| (file_handle, filename) = tempfile.mkstemp() |
| fileobj = os.fdopen(file_handle, 'w') |
| fileobj.write(starting_text) |
| fileobj.close() |
| |
| # Open up the default editor in the system to get the CL description. |
| try: |
| cmd = '%s %s' % (editor, filename) |
| if sys.platform == 'win32' and os.environ.get('TERM') == 'msys': |
| # Msysgit requires the usage of 'env' to be present. |
| cmd = 'env ' + cmd |
| # shell=True to allow the shell to handle all forms of quotes in $EDITOR. |
| try: |
| subprocess.check_call(cmd, shell=True) |
| except subprocess.CalledProcessError, e: |
| DieWithError('Editor returned %d' % e.returncode) |
| fileobj = open(filename) |
| text = fileobj.read() |
| fileobj.close() |
| finally: |
| os.remove(filename) |
| |
| if not text: |
| return |
| |
| stripcomment_re = re.compile(r'^#.*$', re.MULTILINE) |
| return stripcomment_re.sub('', text).strip() |
| |
| |
| def ConvertToInteger(inputval): |
| """Convert a string to integer, but returns either an int or None.""" |
| try: |
| return int(inputval) |
| except (TypeError, ValueError): |
| return None |
| |
| |
| def CMDpresubmit(parser, args): |
| """run presubmit tests on the current changelist""" |
| parser.add_option('--upload', action='store_true', |
| help='Run upload hook instead of the push/dcommit hook') |
| (options, args) = parser.parse_args(args) |
| |
| # Make sure index is up-to-date before running diff-index. |
| RunGit(['update-index', '--refresh', '-q'], error_ok=True) |
| if RunGit(['diff-index', 'HEAD']): |
| # TODO(maruel): Is this really necessary? |
| print 'Cannot presubmit with a dirty tree. You must commit locally first.' |
| return 1 |
| |
| cl = Changelist() |
| if args: |
| base_branch = args[0] |
| else: |
| # Default to diffing against the "upstream" branch. |
| base_branch = cl.GetUpstreamBranch() |
| |
| cl.RunHook(committing=not options.upload, upstream_branch=base_branch, |
| may_prompt=False, verbose=options.verbose, |
| author=None) |
| return 0 |
| |
| |
| @usage('[args to "git diff"]') |
| def CMDupload(parser, args): |
| """upload the current changelist to codereview""" |
| parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks', |
| help='bypass upload presubmit hook') |
| parser.add_option('-f', action='store_true', dest='force', |
| help="force yes to questions (don't prompt)") |
| parser.add_option('-m', dest='message', help='message for patch') |
| parser.add_option('-r', '--reviewers', |
| help='reviewer email addresses') |
| parser.add_option('--cc', |
| help='cc email addresses') |
| parser.add_option('--send-mail', action='store_true', |
| help='send email to reviewer immediately') |
| parser.add_option("--emulate_svn_auto_props", action="store_true", |
| dest="emulate_svn_auto_props", |
| help="Emulate Subversion's auto properties feature.") |
| parser.add_option("--desc_from_logs", action="store_true", |
| dest="from_logs", |
| help="""Squashes git commit logs into change description and |
| uses message as subject""") |
| parser.add_option('-c', '--use-commit-queue', action='store_true', |
| help='tell the commit queue to commit this patchset') |
| (options, args) = parser.parse_args(args) |
| |
| # Make sure index is up-to-date before running diff-index. |
| RunGit(['update-index', '--refresh', '-q'], error_ok=True) |
| if RunGit(['diff-index', 'HEAD']): |
| print 'Cannot upload with a dirty tree. You must commit locally first.' |
| return 1 |
| |
| cl = Changelist() |
| if args: |
| base_branch = args[0] |
| else: |
| # Default to diffing against the "upstream" branch. |
| base_branch = cl.GetUpstreamBranch() |
| args = [base_branch + "..."] |
| |
| if not options.bypass_hooks and not options.force: |
| hook_results = cl.RunHook(committing=False, upstream_branch=base_branch, |
| may_prompt=True, |
| verbose=options.verbose, |
| author=None) |
| if not options.reviewers and hook_results.reviewers: |
| options.reviewers = hook_results.reviewers |
| |
| |
| # --no-ext-diff is broken in some versions of Git, so try to work around |
| # this by overriding the environment (but there is still a problem if the |
| # git config key "diff.external" is used). |
| env = os.environ.copy() |
| if 'GIT_EXTERNAL_DIFF' in env: |
| del env['GIT_EXTERNAL_DIFF'] |
| subprocess.call(['git', 'diff', '--no-ext-diff', '--stat', '-M'] + args, |
| env=env) |
| |
| upload_args = ['--assume_yes'] # Don't ask about untracked files. |
| upload_args.extend(['--server', cl.GetRietveldServer()]) |
| if options.emulate_svn_auto_props: |
| upload_args.append('--emulate_svn_auto_props') |
| if options.send_mail: |
| if not options.reviewers: |
| DieWithError("Must specify reviewers to send email.") |
| upload_args.append('--send_mail') |
| if options.from_logs and not options.message: |
| print 'Must set message for subject line if using desc_from_logs' |
| return 1 |
| |
| change_desc = None |
| |
| if cl.GetIssue(): |
| if options.message: |
| upload_args.extend(['--message', options.message]) |
| upload_args.extend(['--issue', cl.GetIssue()]) |
| print ("This branch is associated with issue %s. " |
| "Adding patch to that issue." % cl.GetIssue()) |
| else: |
| log_desc = CreateDescriptionFromLog(args) |
| change_desc = ChangeDescription(options.message, log_desc, |
| options.reviewers) |
| if not options.from_logs: |
| change_desc.Update() |
| |
| if change_desc.IsEmpty(): |
| print "Description is empty; aborting." |
| return 1 |
| |
| upload_args.extend(['--message', change_desc.subject]) |
| upload_args.extend(['--description', change_desc.description]) |
| if change_desc.reviewers: |
| upload_args.extend(['--reviewers', change_desc.reviewers]) |
| cc = ','.join(filter(None, (cl.GetCCList(), options.cc))) |
| if cc: |
| upload_args.extend(['--cc', cc]) |
| |
| # Include the upstream repo's URL in the change -- this is useful for |
| # projects that have their source spread across multiple repos. |
| remote_url = None |
| if settings.GetIsGitSvn(): |
| # URL is dependent on the current directory. |
| data = RunGit(['svn', 'info'], cwd=settings.GetRoot()) |
| if data: |
| keys = dict(line.split(': ', 1) for line in data.splitlines() |
| if ': ' in line) |
| remote_url = keys.get('URL', None) |
| else: |
| if cl.GetRemoteUrl() and '/' in cl.GetUpstreamBranch(): |
| remote_url = (cl.GetRemoteUrl() + '@' |
| + cl.GetUpstreamBranch().split('/')[-1]) |
| if remote_url: |
| upload_args.extend(['--base_url', remote_url]) |
| |
| try: |
| issue, patchset = upload.RealMain(['upload'] + upload_args + args) |
| except KeyboardInterrupt: |
| sys.exit(1) |
| except: |
| # If we got an exception after the user typed a description for their |
| # change, back up the description before re-raising. |
| if change_desc: |
| backup_path = os.path.expanduser(DESCRIPTION_BACKUP_FILE) |
| print '\nGot exception while uploading -- saving description to %s\n' \ |
| % backup_path |
| backup_file = open(backup_path, 'w') |
| backup_file.write(change_desc.description) |
| backup_file.close() |
| raise |
| |
| if not cl.GetIssue(): |
| cl.SetIssue(issue) |
| cl.SetPatchset(patchset) |
| |
| if options.use_commit_queue: |
| cl.SetFlag('commit', '1') |
| return 0 |
| |
| |
| def SendUpstream(parser, args, cmd): |
| """Common code for CmdPush and CmdDCommit |
| |
| Squashed commit into a single. |
| Updates changelog with metadata (e.g. pointer to review). |
| Pushes/dcommits the code upstream. |
| Updates review and closes. |
| """ |
| parser.add_option('--bypass-hooks', action='store_true', dest='bypass_hooks', |
| help='bypass upload presubmit hook') |
| parser.add_option('-m', dest='message', |
| help="override review description") |
| parser.add_option('-f', action='store_true', dest='force', |
| help="force yes to questions (don't prompt)") |
| parser.add_option('-c', dest='contributor', |
| help="external contributor for patch (appended to " + |
| "description and used as author for git). Should be " + |
| "formatted as 'First Last <[email protected]>'") |
| (options, args) = parser.parse_args(args) |
| cl = Changelist() |
| |
| if not args or cmd == 'push': |
| # Default to merging against our best guess of the upstream branch. |
| args = [cl.GetUpstreamBranch()] |
| |
| if options.contributor: |
| if not re.match('^.*\s<\S+@\S+>$', options.contributor): |
| print "Please provide contibutor as 'First Last <[email protected]>'" |
| return 1 |
| |
| base_branch = args[0] |
| |
| # Make sure index is up-to-date before running diff-index. |
| RunGit(['update-index', '--refresh', '-q'], error_ok=True) |
| if RunGit(['diff-index', 'HEAD']): |
| print 'Cannot %s with a dirty tree. You must commit locally first.' % cmd |
| return 1 |
| |
| # This rev-list syntax means "show all commits not in my branch that |
| # are in base_branch". |
| upstream_commits = RunGit(['rev-list', '^' + cl.GetBranchRef(), |
| base_branch]).splitlines() |
| if upstream_commits: |
| print ('Base branch "%s" has %d commits ' |
| 'not in this branch.' % (base_branch, len(upstream_commits))) |
| print 'Run "git merge %s" before attempting to %s.' % (base_branch, cmd) |
| return 1 |
| |
| if cmd == 'dcommit': |
| # This is the revision `svn dcommit` will commit on top of. |
| svn_head = RunGit(['log', '--grep=^git-svn-id:', '-1', |
| '--pretty=format:%H']) |
| extra_commits = RunGit(['rev-list', '^' + svn_head, base_branch]) |
| if extra_commits: |
| print ('This branch has %d additional commits not upstreamed yet.' |
| % len(extra_commits.splitlines())) |
| print ('Upstream "%s" or rebase this branch on top of the upstream trunk ' |
| 'before attempting to %s.' % (base_branch, cmd)) |
| return 1 |
| |
| if not options.bypass_hooks and not options.force: |
| author = None |
| if options.contributor: |
| author = re.search(r'\<(.*)\>', options.contributor).group(1) |
| cl.RunHook(committing=True, upstream_branch=base_branch, |
| may_prompt=True, verbose=options.verbose, |
| author=author) |
| |
| if cmd == 'dcommit': |
| # Check the tree status if the tree status URL is set. |
| status = GetTreeStatus() |
| if 'closed' == status: |
| print ('The tree is closed. Please wait for it to reopen. Use ' |
| '"git cl dcommit -f" to commit on a closed tree.') |
| return 1 |
| elif 'unknown' == status: |
| print ('Unable to determine tree status. Please verify manually and ' |
| 'use "git cl dcommit -f" to commit on a closed tree.') |
| |
| description = options.message |
| if not description and cl.GetIssue(): |
| description = cl.GetDescription() |
| |
| if not description: |
| print 'No description set.' |
| print 'Visit %s/edit to set it.' % (cl.GetIssueURL()) |
| return 1 |
| |
| if cl.GetIssue(): |
| description += "\n\nReview URL: %s" % cl.GetIssueURL() |
| |
| if options.contributor: |
| description += "\nPatch from %s." % options.contributor |
| print 'Description:', repr(description) |
| |
| branches = [base_branch, cl.GetBranchRef()] |
| if not options.force: |
| subprocess.call(['git', 'diff', '--stat'] + branches) |
| ask_for_data('About to commit; enter to confirm.') |
| |
| # We want to squash all this branch's commits into one commit with the |
| # proper description. |
| # We do this by doing a "reset --soft" to the base branch (which keeps |
| # the working copy the same), then dcommitting that. |
| MERGE_BRANCH = 'git-cl-commit' |
| # Delete the merge branch if it already exists. |
| if RunGitWithCode(['show-ref', '--quiet', '--verify', |
| 'refs/heads/' + MERGE_BRANCH])[0] == 0: |
| RunGit(['branch', '-D', MERGE_BRANCH]) |
| |
| # We might be in a directory that's present in this branch but not in the |
| # trunk. Move up to the top of the tree so that git commands that expect a |
| # valid CWD won't fail after we check out the merge branch. |
| rel_base_path = RunGit(['rev-parse', '--show-cdup']).strip() |
| if rel_base_path: |
| os.chdir(rel_base_path) |
| |
| # Stuff our change into the merge branch. |
| # We wrap in a try...finally block so if anything goes wrong, |
| # we clean up the branches. |
| retcode = -1 |
| try: |
| RunGit(['checkout', '-q', '-b', MERGE_BRANCH]) |
| RunGit(['reset', '--soft', base_branch]) |
| if options.contributor: |
| RunGit(['commit', '--author', options.contributor, '-m', description]) |
| else: |
| RunGit(['commit', '-m', description]) |
| if cmd == 'push': |
| # push the merge branch. |
| remote, branch = cl.FetchUpstreamTuple() |
| retcode, output = RunGitWithCode( |
| ['push', '--porcelain', remote, 'HEAD:%s' % branch]) |
| logging.debug(output) |
| else: |
| # dcommit the merge branch. |
| retcode, output = RunGitWithCode(['svn', 'dcommit', |
| '--no-rebase', '--rmdir']) |
| finally: |
| # And then swap back to the original branch and clean up. |
| RunGit(['checkout', '-q', cl.GetBranch()]) |
| RunGit(['branch', '-D', MERGE_BRANCH]) |
| |
| if cl.GetIssue(): |
| if cmd == 'dcommit' and 'Committed r' in output: |
| revision = re.match('.*?\nCommitted r(\\d+)', output, re.DOTALL).group(1) |
| elif cmd == 'push' and retcode == 0: |
| match = (re.match(r'.*?([a-f0-9]{7})\.\.([a-f0-9]{7})$', l) |
| for l in output.splitlines(False)) |
| match = filter(None, match) |
| if len(match) != 1: |
| DieWithError("Couldn't parse ouput to extract the committed hash:\n%s" % |
| output) |
| revision = match[0].group(2) |
| else: |
| return 1 |
| viewvc_url = settings.GetViewVCUrl() |
| if viewvc_url and revision: |
| cl.description += ('\n\nCommitted: ' + viewvc_url + revision) |
| print ('Closing issue ' |
| '(you may be prompted for your codereview password)...') |
| cl.CloseIssue() |
| cl.SetIssue(0) |
| |
| if retcode == 0: |
| hook = POSTUPSTREAM_HOOK_PATTERN % cmd |
| if os.path.isfile(hook): |
| RunCommand([hook, base_branch], error_ok=True) |
| |
| return 0 |
| |
| |
| @usage('[upstream branch to apply against]') |
| def CMDdcommit(parser, args): |
| """commit the current changelist via git-svn""" |
| if not settings.GetIsGitSvn(): |
| message = """This doesn't appear to be an SVN repository. |
| If your project has a git mirror with an upstream SVN master, you probably need |
| to run 'git svn init', see your project's git mirror documentation. |
| If your project has a true writeable upstream repository, you probably want |
| to run 'git cl push' instead. |
| Choose wisely, if you get this wrong, your commit might appear to succeed but |
| will instead be silently ignored.""" |
| print(message) |
| ask_for_data('[Press enter to dcommit or ctrl-C to quit]') |
| return SendUpstream(parser, args, 'dcommit') |
| |
| |
| @usage('[upstream branch to apply against]') |
| def CMDpush(parser, args): |
| """commit the current changelist via git""" |
| if settings.GetIsGitSvn(): |
| print('This appears to be an SVN repository.') |
| print('Are you sure you didn\'t mean \'git cl dcommit\'?') |
| ask_for_data('[Press enter to push or ctrl-C to quit]') |
| return SendUpstream(parser, args, 'push') |
| |
| |
| @usage('<patch url or issue id>') |
| def CMDpatch(parser, args): |
| """patch in a code review""" |
| parser.add_option('-b', dest='newbranch', |
| help='create a new branch off trunk for the patch') |
| parser.add_option('-f', action='store_true', dest='force', |
| help='with -b, clobber any existing branch') |
| parser.add_option('--reject', action='store_true', dest='reject', |
| help='allow failed patches and spew .rej files') |
| parser.add_option('-n', '--no-commit', action='store_true', dest='nocommit', |
| help="don't commit after patch applies") |
| (options, args) = parser.parse_args(args) |
| if len(args) != 1: |
| parser.print_help() |
| return 1 |
| issue_arg = args[0] |
| |
| # TODO(maruel): Use apply_issue.py |
| |
| if re.match(r'\d+', issue_arg): |
| # Input is an issue id. Figure out the URL. |
| issue = issue_arg |
| patch_data = Changelist().GetPatchSetDiff(issue) |
| else: |
| # Assume it's a URL to the patch. Default to http. |
| issue_url = FixUrl(issue_arg) |
| match = re.match(r'.*?/issue(\d+)_\d+.diff', issue_url) |
| if not match: |
| DieWithError('Must pass an issue ID or full URL for ' |
| '\'Download raw patch set\'') |
| issue = match.group(1) |
| patch_data = urllib2.urlopen(issue_arg).read() |
| |
| if options.newbranch: |
| if options.force: |
| RunGit(['branch', '-D', options.newbranch], |
| swallow_stderr=True, error_ok=True) |
| RunGit(['checkout', '-b', options.newbranch, |
| Changelist().GetUpstreamBranch()]) |
| |
| # Switch up to the top-level directory, if necessary, in preparation for |
| # applying the patch. |
| top = RunGit(['rev-parse', '--show-cdup']).strip() |
| if top: |
| os.chdir(top) |
| |
| # Git patches have a/ at the beginning of source paths. We strip that out |
| # with a sed script rather than the -p flag to patch so we can feed either |
| # Git or svn-style patches into the same apply command. |
| # re.sub() should be used but flags=re.MULTILINE is only in python 2.7. |
| sed_proc = Popen(['sed', '-e', 's|^--- a/|--- |; s|^+++ b/|+++ |'], |
| stdin=subprocess.PIPE, stdout=subprocess.PIPE) |
| patch_data = sed_proc.communicate(patch_data)[0] |
| if sed_proc.returncode: |
| DieWithError('Git patch mungling failed.') |
| logging.info(patch_data) |
| # We use "git apply" to apply the patch instead of "patch" so that we can |
| # pick up file adds. |
| # The --index flag means: also insert into the index (so we catch adds). |
| cmd = ['git', 'apply', '--index', '-p0'] |
| if options.reject: |
| cmd.append('--reject') |
| patch_proc = Popen(cmd, stdin=subprocess.PIPE) |
| patch_proc.communicate(patch_data) |
| if patch_proc.returncode: |
| DieWithError('Failed to apply the patch') |
| |
| # If we had an issue, commit the current state and register the issue. |
| if not options.nocommit: |
| RunGit(['commit', '-m', 'patch from issue %s' % issue]) |
| cl = Changelist() |
| cl.SetIssue(issue) |
| print "Committed patch." |
| else: |
| print "Patch applied to index." |
| return 0 |
| |
| |
| def CMDrebase(parser, args): |
| """rebase current branch on top of svn repo""" |
| # Provide a wrapper for git svn rebase to help avoid accidental |
| # git svn dcommit. |
| # It's the only command that doesn't use parser at all since we just defer |
| # execution to git-svn. |
| RunGit(['svn', 'rebase'] + args, redirect_stdout=False) |
| return 0 |
| |
| |
| def GetTreeStatus(): |
| """Fetches the tree status and returns either 'open', 'closed', |
| 'unknown' or 'unset'.""" |
| url = settings.GetTreeStatusUrl(error_ok=True) |
| if url: |
| status = urllib2.urlopen(url).read().lower() |
| if status.find('closed') != -1 or status == '0': |
| return 'closed' |
| elif status.find('open') != -1 or status == '1': |
| return 'open' |
| return 'unknown' |
| return 'unset' |
| |
| |
| def GetTreeStatusReason(): |
| """Fetches the tree status from a json url and returns the message |
| with the reason for the tree to be opened or closed.""" |
| url = settings.GetTreeStatusUrl() |
| json_url = urlparse.urljoin(url, '/current?format=json') |
| connection = urllib2.urlopen(json_url) |
| status = json.loads(connection.read()) |
| connection.close() |
| return status['message'] |
| |
| |
| def CMDtree(parser, args): |
| """show the status of the tree""" |
| _, args = parser.parse_args(args) |
| status = GetTreeStatus() |
| if 'unset' == status: |
| print 'You must configure your tree status URL by running "git cl config".' |
| return 2 |
| |
| print "The tree is %s" % status |
| print |
| print GetTreeStatusReason() |
| if status != 'open': |
| return 1 |
| return 0 |
| |
| |
| def CMDupstream(parser, args): |
| """print the name of the upstream branch, if any""" |
| _, args = parser.parse_args(args) |
| if args: |
| parser.error('Unrecognized args: %s' % ' '.join(args)) |
| cl = Changelist() |
| print cl.GetUpstreamBranch() |
| return 0 |
| |
| |
| def CMDset_commit(parser, args): |
| """set the commit bit""" |
| _, args = parser.parse_args(args) |
| if args: |
| parser.error('Unrecognized args: %s' % ' '.join(args)) |
| cl = Changelist() |
| cl.SetFlag('commit', '1') |
| return 0 |
| |
| |
| def Command(name): |
| return getattr(sys.modules[__name__], 'CMD' + name, None) |
| |
| |
| def CMDhelp(parser, args): |
| """print list of commands or help for a specific command""" |
| _, args = parser.parse_args(args) |
| if len(args) == 1: |
| return main(args + ['--help']) |
| parser.print_help() |
| return 0 |
| |
| |
| def GenUsage(parser, command): |
| """Modify an OptParse object with the function's documentation.""" |
| obj = Command(command) |
| more = getattr(obj, 'usage_more', '') |
| if command == 'help': |
| command = '<command>' |
| else: |
| # OptParser.description prefer nicely non-formatted strings. |
| parser.description = re.sub('[\r\n ]{2,}', ' ', obj.__doc__) |
| parser.set_usage('usage: %%prog %s [options] %s' % (command, more)) |
| |
| |
| def main(argv): |
| """Doesn't parse the arguments here, just find the right subcommand to |
| execute.""" |
| # Do it late so all commands are listed. |
| CMDhelp.usage_more = ('\n\nCommands are:\n' + '\n'.join([ |
| ' %-10s %s' % (fn[3:], Command(fn[3:]).__doc__.split('\n')[0].strip()) |
| for fn in dir(sys.modules[__name__]) if fn.startswith('CMD')])) |
| |
| # Create the option parse and add --verbose support. |
| parser = optparse.OptionParser() |
| parser.add_option( |
| '-v', '--verbose', action='count', default=0, |
| help='Use 2 times for more debugging info') |
| old_parser_args = parser.parse_args |
| def Parse(args): |
| options, args = old_parser_args(args) |
| if options.verbose >= 2: |
| logging.basicConfig(level=logging.DEBUG) |
| elif options.verbose: |
| logging.basicConfig(level=logging.INFO) |
| else: |
| logging.basicConfig(level=logging.WARNING) |
| return options, args |
| parser.parse_args = Parse |
| |
| if argv: |
| command = Command(argv[0]) |
| if command: |
| # "fix" the usage and the description now that we know the subcommand. |
| GenUsage(parser, argv[0]) |
| try: |
| return command(parser, argv[1:]) |
| except urllib2.HTTPError, e: |
| if e.code != 500: |
| raise |
| DieWithError( |
| ('AppEngine is misbehaving and returned HTTP %d, again. Keep faith ' |
| 'and retry or visit go/isgaeup.\n%s') % (e.code, str(e))) |
| |
| # Not a known command. Default to help. |
| GenUsage(parser, 'help') |
| return CMDhelp(parser, argv) |
| |
| |
| if __name__ == '__main__': |
| fix_encoding.fix_encoding() |
| sys.exit(main(sys.argv[1:])) |
