Google Git
Sign in
chromium / chromium / tools / depot_tools.git / 46e832a00b2936ebfdf7bbaec1a6b15538315422 / . / gclient.py
blob: 76373f084cee611ce8bedb18d0504d4bd5f457b0 [file] [log] [blame]
#!/usr/bin/python
#
# Copyright 2008 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""A wrapper script to manage a set of client modules in different SCM.
This script is intended to be used to help basic management of client
program sources residing in one or more Subversion modules, along with
other modules it depends on, also in Subversion, but possibly on
multiple respositories, making a wrapper system apparently necessary.
Files
.gclient : Current client configuration, written by 'config' command.
Format is a Python script defining 'solutions', a list whose
entries each are maps binding the strings "name" and "url"
to strings specifying the name and location of the client
module, as well as "custom_deps" to a map similar to the DEPS
file below.
.gclient_entries : A cache constructed by 'update' command. Format is a
Python script defining 'entries', a list of the names
of all modules in the client
<module>/DEPS : Python script defining var 'deps' as a map from each requisite
submodule name to a URL where it can be found (via one SCM)
Hooks
.gclient and DEPS files may optionally contain a list named "hooks" to
allow custom actions to be performed based on files that have changed in the
working copy as a result of a "sync"/"update" or "revert" operation. Hooks
can also be run based on what files have been modified in the working copy
with the "runhooks" operation. If any of these operation are run with
--force, all known hooks will run regardless of the state of the working
copy.
Each item in a "hooks" list is a dict, containing these two keys:
"pattern" The associated value is a string containing a regular
expression. When a file whose pathname matches the expression
is checked out, updated, or reverted, the hook's "action" will
run.
"action" A list describing a command to run along with its arguments, if
any. An action command will run at most one time per gclient
invocation, regardless of how many files matched the pattern.
The action is executed in the same directory as the .gclient
file. If the first item in the list is the string "python",
the current Python interpreter (sys.executable) will be used
to run the command.
Example:
hooks = [
{ "pattern": "\\.(gif|jpe?g|pr0n|png)$",
"action": ["python", "image_indexer.py", "--all"]},
]
"""
__author__ = "[email protected] (Darin Fisher)"
__version__ = "0.3.2"
import errno
import optparse
import os
import re
import stat
import subprocess
import sys
import time
import urlparse
import xml.dom.minidom
import urllib
SVN_COMMAND = "svn"
# default help text
DEFAULT_USAGE_TEXT = (
"""usage: %prog <subcommand> [options] [--] [svn options/args...]
a wrapper for managing a set of client modules in svn.
Version """ + __version__ + """
subcommands:
cleanup
config
diff
revert
status
sync
update
runhooks
revinfo
Options and extra arguments can be passed to invoked svn commands by
appending them to the command line. Note that if the first such
appended option starts with a dash (-) then the options must be
preceded by -- to distinguish them from gclient options.
For additional help on a subcommand or examples of usage, try
%prog help <subcommand>
%prog help files
""")
GENERIC_UPDATE_USAGE_TEXT = (
"""Perform a checkout/update of the modules specified by the gclient
configuration; see 'help config'. Unless --revision is specified,
then the latest revision of the root solutions is checked out, with
dependent submodule versions updated according to DEPS files.
If --revision is specified, then the given revision is used in place
of the latest, either for a single solution or for all solutions.
Unless the --force option is provided, solutions and modules whose
local revision matches the one to update (i.e., they have not changed
in the repository) are *not* modified.
This a synonym for 'gclient %(alias)s'
usage: gclient %(cmd)s [options] [--] [svn update options/args]
Valid options:
--force : force update even for unchanged modules
--revision REV : update/checkout all solutions with specified revision
--revision SOLUTION@REV : update given solution to specified revision
--deps PLATFORM(S) : sync deps for the given platform(s), or 'all'
--verbose : output additional diagnostics
Examples:
gclient %(cmd)s
update files from SVN according to current configuration,
*for modules which have changed since last update or sync*
gclient %(cmd)s --force
update files from SVN according to current configuration, for
all modules (useful for recovering files deleted from local copy)
""")
COMMAND_USAGE_TEXT = {
"cleanup":
"""Clean up all working copies, using 'svn cleanup' for each module.
Additional options and args may be passed to 'svn cleanup'.
usage: cleanup [options] [--] [svn cleanup args/options]
Valid options:
--verbose : output additional diagnostics
""",
"config": """Create a .gclient file in the current directory; this
specifies the configuration for further commands. After update/sync,
top-level DEPS files in each module are read to determine dependent
modules to operate on as well. If optional [url] parameter is
provided, then configuration is read from a specified Subversion server
URL. Otherwise, a --spec option must be provided.
usage: config [option | url] [safesync url]
Valid options:
--spec=GCLIENT_SPEC : contents of .gclient are read from string parameter.
*Note that due to Cygwin/Python brokenness, it
probably can't contain any newlines.*
Examples:
gclient config https://gclient.googlecode.com/svn/trunk/gclient
configure a new client to check out gclient.py tool sources
gclient config --spec='solutions=[{"name":"gclient","""
'"url":"https://gclient.googlecode.com/svn/trunk/gclient",'
'"custom_deps":{}}]',
"diff": """Display the differences between two revisions of modules.
(Does 'svn diff' for each checked out module and dependences.)
Additional args and options to 'svn diff' can be passed after
gclient options.
usage: diff [options] [--] [svn args/options]
Valid options:
--verbose : output additional diagnostics
Examples:
gclient diff
simple 'svn diff' for configured client and dependences
gclient diff -- -x -b
use 'svn diff -x -b' to suppress whitespace-only differences
gclient diff -- -r HEAD -x -b
diff versus the latest version of each module
""",
"revert":
"""Revert every file in every managed directory in the client view.
usage: revert
""",
"status":
"""Show the status of client and dependent modules, using 'svn diff'
for each module. Additional options and args may be passed to 'svn diff'.
usage: status [options] [--] [svn diff args/options]
Valid options:
--verbose : output additional diagnostics
""",
"sync": GENERIC_UPDATE_USAGE_TEXT % {"cmd": "sync", "alias": "update"},
"update": GENERIC_UPDATE_USAGE_TEXT % {"cmd": "update", "alias": "sync"},
"help": """Describe the usage of this program or its subcommands.
usage: help [options] [subcommand]
Valid options:
--verbose : output additional diagnostics
""",
"runhooks":
"""Runs hooks for files that have been modified in the local working copy,
according to 'svn status'.
usage: runhooks [options]
Valid options:
--force : runs all known hooks, regardless of the working
copy status
--verbose : output additional diagnostics
""",
"revinfo":
"""Outputs source path, server URL and revision information for every
dependency in all solutions (no local checkout required).
usage: revinfo [options]
""",
}
# parameterized by (solution_name, solution_url, safesync_url)
DEFAULT_CLIENT_FILE_TEXT = (
"""
# An element of this array (a \"solution\") describes a repository directory
# that will be checked out into your working copy. Each solution may
# optionally define additional dependencies (via its DEPS file) to be
# checked out alongside the solution's directory. A solution may also
# specify custom dependencies (via the \"custom_deps\" property) that
# override or augment the dependencies specified by the DEPS file.
# If a \"safesync_url\" is specified, it is assumed to reference the location of
# a text file which contains nothing but the last known good SCM revision to
# sync against. It is fetched if specified and used unless --head is passed
solutions = [
{ \"name\" : \"%s\",
\"url\" : \"%s\",
\"custom_deps\" : {
# To use the trunk of a component instead of what's in DEPS:
#\"component\": \"https://svnserver/component/trunk/\",
# To exclude a component from your working copy:
#\"data/really_large_component\": None,
},
\"safesync_url\": \"%s\"
}
]
""")
## Generic utils
def ParseXML(output):
try:
return xml.dom.minidom.parseString(output)
except xml.parsers.expat.ExpatError:
return None
def GetNamedNodeText(node, node_name):
child_nodes = node.getElementsByTagName(node_name)
if not child_nodes:
return None
assert len(child_nodes) == 1 and child_nodes[0].childNodes.length == 1
return child_nodes[0].firstChild.nodeValue
def GetNodeNamedAttributeText(node, node_name, attribute_name):
child_nodes = node.getElementsByTagName(node_name)
if not child_nodes:
return None
assert len(child_nodes) == 1
return child_nodes[0].getAttribute(attribute_name)
class Error(Exception):
"""gclient exception class."""
pass
class PrintableObject(object):
def __str__(self):
output = ''
for i in dir(self):
if i.startswith('__'):
continue
output += '%s = %s\n' % (i, str(getattr(self, i, '')))
return output
def FileRead(filename):
content = None
f = open(filename, "rU")
try:
content = f.read()
finally:
f.close()
return content
def FileWrite(filename, content):
f = open(filename, "w")
try:
f.write(content)
finally:
f.close()
def RemoveDirectory(*path):
"""Recursively removes a directory, even if it's marked read-only.
Remove the directory located at *path, if it exists.
shutil.rmtree() doesn't work on Windows if any of the files or directories
are read-only, which svn repositories and some .svn files are. We need to
be able to force the files to be writable (i.e., deletable) as we traverse
the tree.
Even with all this, Windows still sometimes fails to delete a file, citing
a permission error (maybe something to do with antivirus scans or disk
indexing). The best suggestion any of the user forums had was to wait a
bit and try again, so we do that too. It's hand-waving, but sometimes it
works. :/
On POSIX systems, things are a little bit simpler. The modes of the files
to be deleted doesn't matter, only the modes of the directories containing
them are significant. As the directory tree is traversed, each directory
has its mode set appropriately before descending into it. This should
result in the entire tree being removed, with the possible exception of
*path itself, because nothing attempts to change the mode of its parent.
Doing so would be hazardous, as it's not a directory slated for removal.
In the ordinary case, this is not a problem: for our purposes, the user
will never lack write permission on *path's parent.
"""
file_path = os.path.join(*path)
if not os.path.exists(file_path):
return
if os.path.islink(file_path) or not os.path.isdir(file_path):
raise Error("RemoveDirectory asked to remove non-directory %s" % file_path)
has_win32api = False
if sys.platform == 'win32':
has_win32api = True
# Some people don't have the APIs installed. In that case we'll do without.
try:
win32api = __import__('win32api')
win32con = __import__('win32con')
except ImportError:
has_win32api = False
else:
# On POSIX systems, we need the x-bit set on the directory to access it,
# the r-bit to see its contents, and the w-bit to remove files from it.
# The actual modes of the files within the directory is irrelevant.
os.chmod(file_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
for fn in os.listdir(file_path):
fullpath = os.path.join(file_path, fn)
# If fullpath is a symbolic link that points to a directory, isdir will
# be True, but we don't want to descend into that as a directory, we just
# want to remove the link. Check islink and treat links as ordinary files
# would be treated regardless of what they reference.
if os.path.islink(fullpath) or not os.path.isdir(fullpath):
if sys.platform == 'win32':
os.chmod(fullpath, stat.S_IWRITE)
if has_win32api:
win32api.SetFileAttributes(fullpath, win32con.FILE_ATTRIBUTE_NORMAL)
try:
os.remove(fullpath)
except OSError, e:
if e.errno != errno.EACCES or sys.platform != 'win32':
raise
print 'Failed to delete %s: trying again' % fullpath
time.sleep(0.1)
os.remove(fullpath)
else:
RemoveDirectory(fullpath)
if sys.platform == 'win32':
os.chmod(file_path, stat.S_IWRITE)
if has_win32api:
win32api.SetFileAttributes(file_path, win32con.FILE_ATTRIBUTE_NORMAL)
try:
os.rmdir(file_path)
except OSError, e:
if e.errno != errno.EACCES or sys.platform != 'win32':
raise
print 'Failed to remove %s: trying again' % file_path
time.sleep(0.1)
os.rmdir(file_path)
def SubprocessCall(command, in_directory, fail_status=None):
"""Runs command, a list, in directory in_directory.
This function wraps SubprocessCallAndCapture, but does not perform the
capturing functions. See that function for a more complete usage
description.
"""
# Call subprocess and capture nothing:
SubprocessCallAndCapture(command, in_directory, fail_status)
def SubprocessCallAndCapture(command, in_directory, fail_status=None,
pattern=None, capture_list=None):
"""Runs command, a list, in directory in_directory.
A message indicating what is being done, as well as the command's stdout,
is printed to out.
If a pattern is specified, any line in the output matching pattern will have
its first match group appended to capture_list.
If the command fails, as indicated by a nonzero exit status, gclient will
exit with an exit status of fail_status. If fail_status is None (the
default), gclient will raise an Error exception.
"""
print("\n________ running \'%s\' in \'%s\'"
% (' '.join(command), in_directory))
# *Sigh*: Windows needs shell=True, or else it won't search %PATH% for the
# executable, but shell=True makes subprocess on Linux fail when it's called
# with a list because it only tries to execute the first item in the list.
kid = subprocess.Popen(command, bufsize=0, cwd=in_directory,
shell=(sys.platform == 'win32'), stdout=subprocess.PIPE)
if pattern:
compiled_pattern = re.compile(pattern)
# Also, we need to forward stdout to prevent weird re-ordering of output.
# This has to be done on a per byte basis to make sure it is not buffered:
# normally buffering is done for each line, but if svn requests input, no
# end-of-line character is output after the prompt and it would not show up.
in_byte = kid.stdout.read(1)
in_line = ""
while in_byte:
if in_byte != "\r":
sys.stdout.write(in_byte)
in_line += in_byte
if in_byte == "\n" and pattern:
match = compiled_pattern.search(in_line[:-1])
if match:
capture_list.append(match.group(1))
in_line = ""
in_byte = kid.stdout.read(1)
rv = kid.wait()
if rv:
msg = "failed to run command: %s" % " ".join(command)
if fail_status != None:
print >>sys.stderr, msg
sys.exit(fail_status)
raise Error(msg)
def IsUsingGit(root, paths):
"""Returns True if we're using git to manage any of our checkouts.
|entries| is a list of paths to check."""
for path in paths:
if os.path.exists(os.path.join(root, path, '.git')):
return True
return False
# -----------------------------------------------------------------------------
# SVN utils:
def RunSVN(args, in_directory):
"""Runs svn, sending output to stdout.
Args:
args: A sequence of command line parameters to be passed to svn.
in_directory: The directory where svn is to be run.
Raises:
Error: An error occurred while running the svn command.
"""
c = [SVN_COMMAND]
c.extend(args)
SubprocessCall(c, in_directory)
def CaptureSVN(args, in_directory=None, print_error=True):
"""Runs svn, capturing output sent to stdout as a string.
Args:
args: A sequence of command line parameters to be passed to svn.
in_directory: The directory where svn is to be run.
Returns:
The output sent to stdout as a string.
"""
c = [SVN_COMMAND]
c.extend(args)
# *Sigh*: Windows needs shell=True, or else it won't search %PATH% for
# the svn.exe executable, but shell=True makes subprocess on Linux fail
# when it's called with a list because it only tries to execute the
# first string ("svn").
stderr = None
if not print_error:
stderr = subprocess.PIPE
return subprocess.Popen(c,
cwd=in_directory,
shell=(sys.platform == 'win32'),
stdout=subprocess.PIPE,
stderr=stderr).communicate()[0]
def RunSVNAndGetFileList(args, in_directory, file_list):
"""Runs svn checkout, update, or status, output to stdout.
The first item in args must be either "checkout", "update", or "status".
svn's stdout is parsed to collect a list of files checked out or updated.
These files are appended to file_list. svn's stdout is also printed to
sys.stdout as in RunSVN.
Args:
args: A sequence of command line parameters to be passed to svn.
in_directory: The directory where svn is to be run.
Raises:
Error: An error occurred while running the svn command.
"""
command = [SVN_COMMAND]
command.extend(args)
# svn update and svn checkout use the same pattern: the first three columns
# are for file status, property status, and lock status. This is followed
# by two spaces, and then the path to the file.
update_pattern = '^... (.*)$'
# The first three columns of svn status are the same as for svn update and
# svn checkout. The next three columns indicate addition-with-history,
# switch, and remote lock status. This is followed by one space, and then
# the path to the file.
status_pattern = '^...... (.*)$'
# args[0] must be a supported command. This will blow up if it's something
# else, which is good. Note that the patterns are only effective when
# these commands are used in their ordinary forms, the patterns are invalid
# for "svn status --show-updates", for example.
pattern = {
'checkout': update_pattern,
'status': status_pattern,
'update': update_pattern,
}[args[0]]
SubprocessCallAndCapture(command,
in_directory,
pattern=pattern,
capture_list=file_list)
def CaptureSVNInfo(relpath, in_directory=None, print_error=True):
"""Returns a dictionary from the svn info output for the given file.
Args:
relpath: The directory where the working copy resides relative to
the directory given by in_directory.
in_directory: The directory where svn is to be run.
"""
output = CaptureSVN(["info", "--xml", relpath], in_directory, print_error)
dom = ParseXML(output)
result = {}
if dom:
def C(item, f):
if item is not None: return f(item)
# /info/entry/
# url
# reposityory/(root|uuid)
# wc-info/(schedule|depth)
# commit/(author|date)
# str() the results because they may be returned as Unicode, which
# interferes with the higher layers matching up things in the deps
# dictionary.
# TODO(maruel): Fix at higher level instead (!)
result['Repository Root'] = C(GetNamedNodeText(dom, 'root'), str)
result['URL'] = C(GetNamedNodeText(dom, 'url'), str)
result['UUID'] = C(GetNamedNodeText(dom, 'uuid'), str)
result['Revision'] = C(GetNodeNamedAttributeText(dom, 'entry', 'revision'),
int)
result['Node Kind'] = C(GetNodeNamedAttributeText(dom, 'entry', 'kind'),
str)
result['Schedule'] = C(GetNamedNodeText(dom, 'schedule'), str)
result['Path'] = C(GetNodeNamedAttributeText(dom, 'entry', 'path'), str)
result['Copied From URL'] = C(GetNamedNodeText(dom, 'copy-from-url'), str)
result['Copied From Rev'] = C(GetNamedNodeText(dom, 'copy-from-rev'), str)
return result
def CaptureSVNHeadRevision(url):
"""Get the head revision of a SVN repository.
Returns:
Int head revision
"""
info = CaptureSVN(["info", "--xml", url], os.getcwd())
dom = xml.dom.minidom.parseString(info)
return int(dom.getElementsByTagName('entry')[0].getAttribute('revision'))
def CaptureSVNStatus(files):
"""Returns the svn 1.5 svn status emulated output.
@files can be a string (one file) or a list of files.
Returns an array of (status, file) tuples."""
command = ["status", "--xml"]
if not files:
pass
elif isinstance(files, basestring):
command.append(files)
else:
command.extend(files)
status_letter = {
None: ' ',
'': ' ',
'added': 'A',
'conflicted': 'C',
'deleted': 'D',
'external': 'X',
'ignored': 'I',
'incomplete': '!',
'merged': 'G',
'missing': '!',
'modified': 'M',
'none': ' ',
'normal': ' ',
'obstructed': '~',
'replaced': 'R',
'unversioned': '?',
}
dom = ParseXML(CaptureSVN(command))
results = []
if dom:
# /status/target/entry/(wc-status|commit|author|date)
for target in dom.getElementsByTagName('target'):
base_path = target.getAttribute('path')
for entry in target.getElementsByTagName('entry'):
file = entry.getAttribute('path')
wc_status = entry.getElementsByTagName('wc-status')
assert len(wc_status) == 1
# Emulate svn 1.5 status ouput...
statuses = [' ' for i in range(7)]
# Col 0
xml_item_status = wc_status[0].getAttribute('item')
if xml_item_status in status_letter:
statuses[0] = status_letter[xml_item_status]
else:
raise Exception('Unknown item status "%s"; please implement me!' %
xml_item_status)
# Col 1
xml_props_status = wc_status[0].getAttribute('props')
if xml_props_status == 'modified':
statuses[1] = 'M'
elif xml_props_status == 'conflicted':
statuses[1] = 'C'
elif (not xml_props_status or xml_props_status == 'none' or
xml_props_status == 'normal'):
pass
else:
raise Exception('Unknown props status "%s"; please implement me!' %
xml_props_status)
# Col 2
if wc_status[0].getAttribute('wc-locked') == 'true':
statuses[2] = 'L'
# Col 3
if wc_status[0].getAttribute('copied') == 'true':
statuses[3] = '+'
item = (''.join(statuses), file)
results.append(item)
return results
### SCM abstraction layer
class SCMWrapper(object):
"""Add necessary glue between all the supported SCM.
This is the abstraction layer to bind to different SCM. Since currently only
subversion is supported, a lot of subersionism remains. This can be sorted out
once another SCM is supported."""
def __init__(self, url=None, root_dir=None, relpath=None,
scm_name='svn'):
# TODO(maruel): Deduce the SCM from the url.
self.scm_name = scm_name
self.url = url
self._root_dir = root_dir
if self._root_dir:
self._root_dir = self._root_dir.replace('/', os.sep)
self.relpath = relpath
if self.relpath:
self.relpath = self.relpath.replace('/', os.sep)
def FullUrlForRelativeUrl(self, url):
# Find the forth '/' and strip from there. A bit hackish.
return '/'.join(self.url.split('/')[:4]) + url
def RunCommand(self, command, options, args, file_list=None):
# file_list will have all files that are modified appended to it.
if file_list == None:
file_list = []
commands = {
'cleanup': self.cleanup,
'update': self.update,
'revert': self.revert,
'status': self.status,
'diff': self.diff,
'runhooks': self.status,
}
if not command in commands:
raise Error('Unknown command %s' % command)
return commands[command](options, args, file_list)
def cleanup(self, options, args, file_list):
"""Cleanup working copy."""
command = ['cleanup']
command.extend(args)
RunSVN(command, os.path.join(self._root_dir, self.relpath))
def diff(self, options, args, file_list):
# NOTE: This function does not currently modify file_list.
command = ['diff']
command.extend(args)
RunSVN(command, os.path.join(self._root_dir, self.relpath))
def update(self, options, args, file_list):
"""Runs SCM to update or transparently checkout the working copy.
All updated files will be appended to file_list.
Raises:
Error: if can't get URL for relative path.
"""
# Only update if git is not controlling the directory.
checkout_path = os.path.join(self._root_dir, self.relpath)
git_path = os.path.join(self._root_dir, self.relpath, '.git')
if os.path.exists(git_path):
print("________ found .git directory; skipping %s" % self.relpath)
return
if args:
raise Error("Unsupported argument(s): %s" % ",".join(args))
url = self.url
components = url.split("@")
revision = None
forced_revision = False
if options.revision:
# Override the revision number.
url = '%s@%s' % (components[0], str(options.revision))
revision = int(options.revision)
forced_revision = True
elif len(components) == 2:
revision = int(components[1])
forced_revision = True
rev_str = ""
if revision:
rev_str = ' at %d' % revision
if not os.path.exists(checkout_path):
# We need to checkout.
command = ['checkout', url, checkout_path]
if revision:
command.extend(['--revision', str(revision)])
RunSVNAndGetFileList(command, self._root_dir, file_list)
return
# Get the existing scm url and the revision number of the current checkout.
from_info = CaptureSVNInfo(os.path.join(checkout_path, '.'), '.')
if not from_info:
raise Error("Can't update/checkout %r if an unversioned directory is "
"present. Delete the directory and try again." %
checkout_path)
if options.manually_grab_svn_rev:
# Retrieve the current HEAD version because svn is slow at null updates.
if not revision:
from_info_live = CaptureSVNInfo(from_info['URL'], '.')
revision = int(from_info_live['Revision'])
rev_str = ' at %d' % revision
if from_info['URL'] != components[0]:
to_info = CaptureSVNInfo(url, '.')
can_switch = ((from_info['Repository Root'] != to_info['Repository Root'])
and (from_info['UUID'] == to_info['UUID']))
if can_switch:
print("\n_____ relocating %s to a new checkout" % self.relpath)
# We have different roots, so check if we can switch --relocate.
# Subversion only permits this if the repository UUIDs match.
# Perform the switch --relocate, then rewrite the from_url
# to reflect where we "are now." (This is the same way that
# Subversion itself handles the metadata when switch --relocate
# is used.) This makes the checks below for whether we
# can update to a revision or have to switch to a different
# branch work as expected.
# TODO(maruel): TEST ME !
command = ["switch", "--relocate",
from_info['Repository Root'],
to_info['Repository Root'],
self.relpath]
RunSVN(command, self._root_dir)
from_info['URL'] = from_info['URL'].replace(
from_info['Repository Root'],
to_info['Repository Root'])
else:
if CaptureSVNStatus(checkout_path):
raise Error("Can't switch the checkout to %s; UUID don't match and "
"there is local changes in %s. Delete the directory and "
"try again." % (url, checkout_path))
# Ok delete it.
print("\n_____ switching %s to a new checkout" % self.relpath)
RemoveDirectory(checkout_path)
# We need to checkout.
command = ['checkout', url, checkout_path]
if revision:
command.extend(['--revision', str(revision)])
RunSVNAndGetFileList(command, self._root_dir, file_list)
return
# If the provided url has a revision number that matches the revision
# number of the existing directory, then we don't need to bother updating.
if not options.force and from_info['Revision'] == revision:
if options.verbose or not forced_revision:
print("\n_____ %s%s" % (self.relpath, rev_str))
return
command = ["update", checkout_path]
if revision:
command.extend(['--revision', str(revision)])
RunSVNAndGetFileList(command, self._root_dir, file_list)
def revert(self, options, args, file_list):
"""Reverts local modifications. Subversion specific.
All reverted files will be appended to file_list, even if Subversion
doesn't know about them.
"""
path = os.path.join(self._root_dir, self.relpath)
if not os.path.isdir(path):
# svn revert won't work if the directory doesn't exist. It needs to
# checkout instead.
print("\n_____ %s is missing, synching instead" % self.relpath)
# Don't reuse the args.
return self.update(options, [], file_list)
files = CaptureSVNStatus(path)
# Batch the command.
files_to_revert = []
for file in files:
file_path = os.path.join(path, file[1])
print(file_path)
# Unversioned file or unexpected unversioned file.
if file[0][0] in ('?', '~'):
# Remove extraneous file. Also remove unexpected unversioned
# directories. svn won't touch them but we want to delete these.
file_list.append(file_path)
try:
os.remove(file_path)
except EnvironmentError:
RemoveDirectory(file_path)
if file[0][0] != '?':
# For any other status, svn revert will work.
file_list.append(file_path)
files_to_revert.append(file[1])
# Revert them all at once.
if files_to_revert:
accumulated_paths = []
accumulated_length = 0
command = ['revert']
for p in files_to_revert:
# Some shell have issues with command lines too long.
if accumulated_length and accumulated_length + len(p) > 3072:
RunSVN(command + accumulated_paths,
os.path.join(self._root_dir, self.relpath))
accumulated_paths = []
accumulated_length = 0
else:
accumulated_paths.append(p)
accumulated_length += len(p)
if accumulated_paths:
RunSVN(command + accumulated_paths,
os.path.join(self._root_dir, self.relpath))
def status(self, options, args, file_list):
"""Display status information."""
path = os.path.join(self._root_dir, self.relpath)
command = ['status']
command.extend(args)
if not os.path.isdir(path):
# svn status won't work if the directory doesn't exist.
print("\n________ couldn't run \'%s\' in \'%s\':\nThe directory "
"does not exist."
% (' '.join(command), path))
# There's no file list to retrieve.
else:
RunSVNAndGetFileList(command, path, file_list)
## GClient implementation.
class GClient(object):
"""Object that represent a gclient checkout."""
supported_commands = [
'cleanup', 'diff', 'revert', 'status', 'update', 'runhooks'
]
def __init__(self, root_dir, options):
self._root_dir = root_dir
self._options = options
self._config_content = None
self._config_dict = {}
self._deps_hooks = []
def SetConfig(self, content):
self._config_dict = {}
self._config_content = content
try:
exec(content, self._config_dict)
except SyntaxError, e:
try:
# Try to construct a human readable error message
error_message = [
'There is a syntax error in your configuration file.',
'Line #%s, character %s:' % (e.lineno, e.offset),
'"%s"' % re.sub(r'[\r\n]*$', '', e.text) ]
except:
# Something went wrong, re-raise the original exception
raise e
else:
# Raise a new exception with the human readable message:
raise Error('\n'.join(error_message))
def SaveConfig(self):
FileWrite(os.path.join(self._root_dir, self._options.config_filename),
self._config_content)
def _LoadConfig(self):
client_source = FileRead(os.path.join(self._root_dir,
self._options.config_filename))
self.SetConfig(client_source)
def ConfigContent(self):
return self._config_content
def GetVar(self, key, default=None):
return self._config_dict.get(key, default)
@staticmethod
def LoadCurrentConfig(options, from_dir=None):
"""Searches for and loads a .gclient file relative to the current working
dir.
Returns:
A dict representing the contents of the .gclient file or an empty dict if
the .gclient file doesn't exist.
"""
if not from_dir:
from_dir = os.curdir
path = os.path.realpath(from_dir)
while not os.path.exists(os.path.join(path, options.config_filename)):
next = os.path.split(path)
if not next[1]:
return None
path = next[0]
client = GClient(path, options)
client._LoadConfig()
return client
def SetDefaultConfig(self, solution_name, solution_url, safesync_url):
self.SetConfig(DEFAULT_CLIENT_FILE_TEXT % (
solution_name, solution_url, safesync_url
))
def _SaveEntries(self, entries):
"""Creates a .gclient_entries file to record the list of unique checkouts.
The .gclient_entries file lives in the same directory as .gclient.
Args:
entries: A sequence of solution names.
"""
text = "entries = [\n"
for entry in entries:
text += " \"%s\",\n" % entry
text += "]\n"
FileWrite(os.path.join(self._root_dir, self._options.entries_filename),
text)
def _ReadEntries(self):
"""Read the .gclient_entries file for the given client.
Args:
client: The client for which the entries file should be read.
Returns:
A sequence of solution names, which will be empty if there is the
entries file hasn't been created yet.
"""
scope = {}
filename = os.path.join(self._root_dir, self._options.entries_filename)
if not os.path.exists(filename):
return []
exec(FileRead(filename), scope)
return scope["entries"]
class FromImpl:
"""Used to implement the From syntax."""
def __init__(self, module_name):
self.module_name = module_name
def __str__(self):
return 'From("%s")' % self.module_name
class _VarImpl:
def __init__(self, custom_vars, local_scope):
self._custom_vars = custom_vars
self._local_scope = local_scope
def Lookup(self, var_name):
"""Implements the Var syntax."""
if var_name in self._custom_vars:
return self._custom_vars[var_name]
elif var_name in self._local_scope.get("vars", {}):
return self._local_scope["vars"][var_name]
raise Error("Var is not defined: %s" % var_name)
def _ParseSolutionDeps(self, solution_name, solution_deps_content,
custom_vars):
"""Parses the DEPS file for the specified solution.
Args:
solution_name: The name of the solution to query.
solution_deps_content: Content of the DEPS file for the solution
custom_vars: A dict of vars to override any vars defined in the DEPS file.
Returns:
A dict mapping module names (as relative paths) to URLs or an empty
dict if the solution does not have a DEPS file.
"""
# Skip empty
if not solution_deps_content:
return {}
# Eval the content
local_scope = {}
var = self._VarImpl(custom_vars, local_scope)
global_scope = {"From": self.FromImpl, "Var": var.Lookup, "deps_os": {}}
exec(solution_deps_content, global_scope, local_scope)
deps = local_scope.get("deps", {})
# load os specific dependencies if defined. these dependencies may
# override or extend the values defined by the 'deps' member.
if "deps_os" in local_scope:
deps_os_choices = {
"win32": "win",
"win": "win",
"cygwin": "win",
"darwin": "mac",
"mac": "mac",
"unix": "unix",
"linux": "unix",
"linux2": "unix",
}
if self._options.deps_os is not None:
deps_to_include = self._options.deps_os.split(",")
if "all" in deps_to_include:
deps_to_include = deps_os_choices.values()
else:
deps_to_include = [deps_os_choices.get(self._options.platform, "unix")]
deps_to_include = set(deps_to_include)
for deps_os_key in deps_to_include:
os_deps = local_scope["deps_os"].get(deps_os_key, {})
if len(deps_to_include) > 1:
# Ignore any overrides when including deps for more than one
# platform, so we collect the broadest set of dependencies available.
# We may end up with the wrong revision of something for our
# platform, but this is the best we can do.
deps.update([x for x in os_deps.items() if not x[0] in deps])
else:
deps.update(os_deps)
if 'hooks' in local_scope:
self._deps_hooks.extend(local_scope['hooks'])
# If use_relative_paths is set in the DEPS file, regenerate
# the dictionary using paths relative to the directory containing
# the DEPS file.
if local_scope.get('use_relative_paths'):
rel_deps = {}
for d, url in deps.items():
# normpath is required to allow DEPS to use .. in their
# dependency local path.
rel_deps[os.path.normpath(os.path.join(solution_name, d))] = url
return rel_deps
else:
return deps
def _ParseAllDeps(self, solution_urls, solution_deps_content):
"""Parse the complete list of dependencies for the client.
Args:
solution_urls: A dict mapping module names (as relative paths) to URLs
corresponding to the solutions specified by the client. This parameter
is passed as an optimization.
solution_deps_content: A dict mapping module names to the content
of their DEPS files
Returns:
A dict mapping module names (as relative paths) to URLs corresponding
to the entire set of dependencies to checkout for the given client.
Raises:
Error: If a dependency conflicts with another dependency or of a solution.
"""
deps = {}
for solution in self.GetVar("solutions"):
custom_vars = solution.get("custom_vars", {})
solution_deps = self._ParseSolutionDeps(
solution["name"],
solution_deps_content[solution["name"]],
custom_vars)
# If a line is in custom_deps, but not in the solution, we want to append
# this line to the solution.
if "custom_deps" in solution:
for d in solution["custom_deps"]:
if d not in solution_deps:
solution_deps[d] = solution["custom_deps"][d]
for d in solution_deps:
if "custom_deps" in solution and d in solution["custom_deps"]:
# Dependency is overriden.
url = solution["custom_deps"][d]
if url is None:
continue
else:
url = solution_deps[d]
# if we have a From reference dependent on another solution, then
# just skip the From reference. When we pull deps for the solution,
# we will take care of this dependency.
#
# If multiple solutions all have the same From reference, then we
# should only add one to our list of dependencies.
if type(url) != str:
if url.module_name in solution_urls:
# Already parsed.
continue
if d in deps and type(deps[d]) != str:
if url.module_name == deps[d].module_name:
continue
else:
parsed_url = urlparse.urlparse(url)
scheme = parsed_url[0]
if not scheme:
# A relative url. Fetch the real base.
path = parsed_url[2]
if path[0] != "/":
raise Error(
"relative DEPS entry \"%s\" must begin with a slash" % d)
# Create a scm just to query the full url.
scm = SCMWrapper(solution["url"], self._root_dir, None)
url = scm.FullUrlForRelativeUrl(url)
if d in deps and deps[d] != url:
raise Error(
"Solutions have conflicting versions of dependency \"%s\"" % d)
if d in solution_urls and solution_urls[d] != url:
raise Error(
"Dependency \"%s\" conflicts with specified solution" % d)
# Grab the dependency.
deps[d] = url
return deps
def _RunHookAction(self, hook_dict):
"""Runs the action from a single hook.
"""
command = hook_dict['action'][:]
if command[0] == 'python':
# If the hook specified "python" as the first item, the action is a
# Python script. Run it by starting a new copy of the same
# interpreter.
command[0] = sys.executable
# Use a discrete exit status code of 2 to indicate that a hook action
# failed. Users of this script may wish to treat hook action failures
# differently from VC failures.
SubprocessCall(command, self._root_dir, fail_status=2)
def _RunHooks(self, command, file_list, is_using_git):
"""Evaluates all hooks, running actions as needed.
"""
# Hooks only run for these command types.
if not command in ('update', 'revert', 'runhooks'):
return
# Get any hooks from the .gclient file.
hooks = self.GetVar("hooks", [])
# Add any hooks found in DEPS files.
hooks.extend(self._deps_hooks)
# If "--force" was specified, run all hooks regardless of what files have
# changed. If the user is using git, then we don't know what files have
# changed so we always run all hooks.
if self._options.force or is_using_git:
for hook_dict in hooks:
self._RunHookAction(hook_dict)
return
# Run hooks on the basis of whether the files from the gclient operation
# match each hook's pattern.
for hook_dict in hooks:
pattern = re.compile(hook_dict['pattern'])
for file in file_list:
if not pattern.search(file):
continue
self._RunHookAction(hook_dict)
# The hook's action only runs once. Don't bother looking for any
# more matches.
break
def RunOnDeps(self, command, args):
"""Runs a command on each dependency in a client and its dependencies.
The module's dependencies are specified in its top-level DEPS files.
Args:
command: The command to use (e.g., 'status' or 'diff')
args: list of str - extra arguments to add to the command line.
Raises:
Error: If the client has conflicting entries.
"""
if not command in self.supported_commands:
raise Error("'%s' is an unsupported command" % command)
# Check for revision overrides.
revision_overrides = {}
for revision in self._options.revisions:
if revision.find("@") == -1:
raise Error(
"Specify the full dependency when specifying a revision number.")
revision_elem = revision.split("@")
# Disallow conflicting revs
if revision_overrides.has_key(revision_elem[0]) and \
revision_overrides[revision_elem[0]] != revision_elem[1]:
raise Error(
"Conflicting revision numbers specified.")
revision_overrides[revision_elem[0]] = revision_elem[1]
solutions = self.GetVar("solutions")
if not solutions:
raise Error("No solution specified")
# When running runhooks --force, there's no need to consult the SCM.
# All known hooks are expected to run unconditionally regardless of working
# copy state, so skip the SCM status check.
run_scm = not (command == 'runhooks' and self._options.force)
entries = {}
entries_deps_content = {}
file_list = []
# Run on the base solutions first.
for solution in solutions:
name = solution["name"]
if name in entries:
raise Error("solution %s specified more than once" % name)
url = solution["url"]
entries[name] = url
if run_scm:
self._options.revision = revision_overrides.get(name)
scm = SCMWrapper(url, self._root_dir, name)
scm.RunCommand(command, self._options, args, file_list)
self._options.revision = None
try:
deps_content = FileRead(os.path.join(self._root_dir, name,
self._options.deps_file))
except IOError, e:
if e.errno != errno.ENOENT:
raise
deps_content = ""
entries_deps_content[name] = deps_content
# Process the dependencies next (sort alphanumerically to ensure that
# containing directories get populated first and for readability)
deps = self._ParseAllDeps(entries, entries_deps_content)
deps_to_process = deps.keys()
deps_to_process.sort()
# First pass for direct dependencies.
for d in deps_to_process:
if type(deps[d]) == str:
url = deps[d]
entries[d] = url
if run_scm:
self._options.revision = revision_overrides.get(d)
scm = SCMWrapper(url, self._root_dir, d)
scm.RunCommand(command, self._options, args, file_list)
self._options.revision = None
# Second pass for inherited deps (via the From keyword)
for d in deps_to_process:
if type(deps[d]) != str:
sub_deps = self._ParseSolutionDeps(
deps[d].module_name,
FileRead(os.path.join(self._root_dir,
deps[d].module_name,
self._options.deps_file)),
{})
url = sub_deps[d]
entries[d] = url
if run_scm:
self._options.revision = revision_overrides.get(d)
scm = SCMWrapper(url, self._root_dir, d)
scm.RunCommand(command, self._options, args, file_list)
self._options.revision = None
is_using_git = IsUsingGit(self._root_dir, entries.keys())
self._RunHooks(command, file_list, is_using_git)
if command == 'update':
# notify the user if there is an orphaned entry in their working copy.
# TODO(darin): we should delete this directory manually if it doesn't
# have any changes in it.
prev_entries = self._ReadEntries()
for entry in prev_entries:
e_dir = os.path.join(self._root_dir, entry)
if entry not in entries and os.path.exists(e_dir):
if CaptureSVNStatus(e_dir):
# There are modified files in this entry
entries[entry] = None # Keep warning until removed.
print("\nWARNING: \"%s\" is no longer part of this client. "
"It is recommended that you manually remove it.\n") % entry
else:
# Delete the entry
print("\n________ deleting \'%s\' " +
"in \'%s\'") % (entry, self._root_dir)
RemoveDirectory(e_dir)
# record the current list of entries for next time
self._SaveEntries(entries)
def PrintRevInfo(self):
"""Output revision info mapping for the client and its dependencies. This
allows the capture of a overall "revision" for the source tree that can
be used to reproduce the same tree in the future. The actual output
contains enough information (source paths, svn server urls and revisions)
that it can be used either to generate external svn commands (without
gclient) or as input to gclient's --rev option (with some massaging of
the data).
NOTE: Unlike RunOnDeps this does not require a local checkout and is run
on the Pulse master. It MUST NOT execute hooks.
Raises:
Error: If the client has conflicting entries.
"""
# Check for revision overrides.
revision_overrides = {}
for revision in self._options.revisions:
if revision.find("@") < 0:
raise Error(
"Specify the full dependency when specifying a revision number.")
revision_elem = revision.split("@")
# Disallow conflicting revs
if revision_overrides.has_key(revision_elem[0]) and \
revision_overrides[revision_elem[0]] != revision_elem[1]:
raise Error(
"Conflicting revision numbers specified.")
revision_overrides[revision_elem[0]] = revision_elem[1]
solutions = self.GetVar("solutions")
if not solutions:
raise Error("No solution specified")
entries = {}
entries_deps_content = {}
# Inner helper to generate base url and rev tuple (including honoring
# |revision_overrides|)
def GetURLAndRev(name, original_url):
if original_url.find("@") < 0:
if revision_overrides.has_key(name):
return (original_url, int(revision_overrides[name]))
else:
# TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
return (original_url, CaptureSVNHeadRevision(original_url))
else:
url_components = original_url.split("@")
if revision_overrides.has_key(name):
return (url_components[0], int(revision_overrides[name]))
else:
return (url_components[0], int(url_components[1]))
# Run on the base solutions first.
for solution in solutions:
name = solution["name"]
if name in entries:
raise Error("solution %s specified more than once" % name)
(url, rev) = GetURLAndRev(name, solution["url"])
entries[name] = "%s@%d" % (url, rev)
# TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
entries_deps_content[name] = CaptureSVN(
["cat",
"%s/%s@%d" % (url,
self._options.deps_file,
rev)],
os.getcwd())
# Process the dependencies next (sort alphanumerically to ensure that
# containing directories get populated first and for readability)
deps = self._ParseAllDeps(entries, entries_deps_content)
deps_to_process = deps.keys()
deps_to_process.sort()
# First pass for direct dependencies.
for d in deps_to_process:
if type(deps[d]) == str:
(url, rev) = GetURLAndRev(d, deps[d])
entries[d] = "%s@%d" % (url, rev)
# Second pass for inherited deps (via the From keyword)
for d in deps_to_process:
if type(deps[d]) != str:
deps_parent_url = entries[deps[d].module_name]
if deps_parent_url.find("@") < 0:
raise Error("From %s missing revisioned url" % deps[d].module_name)
deps_parent_url_components = deps_parent_url.split("@")
# TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
deps_parent_content = CaptureSVN(
["cat",
"%s/%s@%s" % (deps_parent_url_components[0],
self._options.deps_file,
deps_parent_url_components[1])],
os.getcwd())
sub_deps = self._ParseSolutionDeps(
deps[d].module_name,
FileRead(os.path.join(self._root_dir,
deps[d].module_name,
self._options.deps_file)),
{})
(url, rev) = GetURLAndRev(d, sub_deps[d])
entries[d] = "%s@%d" % (url, rev)
print(";".join(["%s,%s" % (x, entries[x]) for x in sorted(entries.keys())]))
## gclient commands.
def DoCleanup(options, args):
"""Handle the cleanup subcommand.
Raises:
Error: if client isn't configured properly.
"""
client = GClient.LoadCurrentConfig(options)
if not client:
raise Error("client not configured; see 'gclient config'")
if options.verbose:
# Print out the .gclient file. This is longer than if we just printed the
# client dict, but more legible, and it might contain helpful comments.
print(client.ConfigContent())
options.verbose = True
return client.RunOnDeps('cleanup', args)
def DoConfig(options, args):
"""Handle the config subcommand.
Args:
options: If options.spec set, a string providing contents of config file.
args: The command line args. If spec is not set,
then args[0] is a string URL to get for config file.
Raises:
Error: on usage error
"""
if len(args) < 1 and not options.spec:
raise Error("required argument missing; see 'gclient help config'")
if os.path.exists(options.config_filename):
raise Error("%s file already exists in the current directory" %
options.config_filename)
client = GClient('.', options)
if options.spec:
client.SetConfig(options.spec)
else:
# TODO(darin): it would be nice to be able to specify an alternate relpath
# for the given URL.
base_url = args[0].rstrip('/')
name = base_url.split("/")[-1]
safesync_url = ""
if len(args) > 1:
safesync_url = args[1]
client.SetDefaultConfig(name, base_url, safesync_url)
client.SaveConfig()
def DoHelp(options, args):
"""Handle the help subcommand giving help for another subcommand.
Raises:
Error: if the command is unknown.
"""
if len(args) == 1 and args[0] in COMMAND_USAGE_TEXT:
print(COMMAND_USAGE_TEXT[args[0]])
else:
raise Error("unknown subcommand '%s'; see 'gclient help'" % args[0])
def DoStatus(options, args):
"""Handle the status subcommand.
Raises:
Error: if client isn't configured properly.
"""
client = GClient.LoadCurrentConfig(options)
if not client:
raise Error("client not configured; see 'gclient config'")
if options.verbose:
# Print out the .gclient file. This is longer than if we just printed the
# client dict, but more legible, and it might contain helpful comments.
print(client.ConfigContent())
options.verbose = True
return client.RunOnDeps('status', args)
def DoUpdate(options, args):
"""Handle the update and sync subcommands.
Raises:
Error: if client isn't configured properly.
"""
client = GClient.LoadCurrentConfig(options)
if not client:
raise Error("client not configured; see 'gclient config'")
if not options.head:
solutions = client.GetVar('solutions')
if solutions:
for s in solutions:
if s.get('safesync_url', ''):
# rip through revisions and make sure we're not over-riding
# something that was explicitly passed
has_key = False
for r in options.revisions:
if r.split('@')[0] == s['name']:
has_key = True
break
if not has_key:
handle = urllib.urlopen(s['safesync_url'])
rev = handle.read().strip()
handle.close()
if len(rev):
options.revisions.append(s['name']+'@'+rev)
if options.verbose:
# Print out the .gclient file. This is longer than if we just printed the
# client dict, but more legible, and it might contain helpful comments.
print(client.ConfigContent())
return client.RunOnDeps('update', args)
def DoDiff(options, args):
"""Handle the diff subcommand.
Raises:
Error: if client isn't configured properly.
"""
client = GClient.LoadCurrentConfig(options)
if not client:
raise Error("client not configured; see 'gclient config'")
if options.verbose:
# Print out the .gclient file. This is longer than if we just printed the
# client dict, but more legible, and it might contain helpful comments.
print(client.ConfigContent())
options.verbose = True
return client.RunOnDeps('diff', args)
def DoRevert(options, args):
"""Handle the revert subcommand.
Raises:
Error: if client isn't configured properly.
"""
client = GClient.LoadCurrentConfig(options)
if not client:
raise Error("client not configured; see 'gclient config'")
return client.RunOnDeps('revert', args)
def DoRunHooks(options, args):
"""Handle the runhooks subcommand.
Raises:
Error: if client isn't configured properly.
"""
client = GClient.LoadCurrentConfig(options)
if not client:
raise Error("client not configured; see 'gclient config'")
if options.verbose:
# Print out the .gclient file. This is longer than if we just printed the
# client dict, but more legible, and it might contain helpful comments.
print(client.ConfigContent())
return client.RunOnDeps('runhooks', args)
def DoRevInfo(options, args):
"""Handle the revinfo subcommand.
Raises:
Error: if client isn't configured properly.
"""
client = GClient.LoadCurrentConfig(options)
if not client:
raise Error("client not configured; see 'gclient config'")
client.PrintRevInfo()
gclient_command_map = {
"cleanup": DoCleanup,
"config": DoConfig,
"diff": DoDiff,
"help": DoHelp,
"status": DoStatus,
"sync": DoUpdate,
"update": DoUpdate,
"revert": DoRevert,
"runhooks": DoRunHooks,
"revinfo" : DoRevInfo,
}
def DispatchCommand(command, options, args, command_map=None):
"""Dispatches the appropriate subcommand based on command line arguments."""
if command_map is None:
command_map = gclient_command_map
if command in command_map:
return command_map[command](options, args)
else:
raise Error("unknown subcommand '%s'; see 'gclient help'" % command)
def Main(argv):
"""Parse command line arguments and dispatch command."""
option_parser = optparse.OptionParser(usage=DEFAULT_USAGE_TEXT,
version=__version__)
option_parser.disable_interspersed_args()
option_parser.add_option("", "--force", action="store_true", default=False,
help=("(update/sync only) force update even "
"for modules which haven't changed"))
option_parser.add_option("", "--revision", action="append", dest="revisions",
metavar="REV", default=[],
help=("(update/sync only) sync to a specific "
"revision, can be used multiple times for "
"each solution, e.g. --revision=src@123, "
"--revision=internal@32"))
option_parser.add_option("", "--deps", default=None, dest="deps_os",
metavar="OS_LIST",
help=("(update/sync only) sync deps for the "
"specified (comma-separated) platform(s); "
"'all' will sync all platforms"))
option_parser.add_option("", "--spec", default=None,
help=("(config only) create a gclient file "
"containing the provided string"))
option_parser.add_option("", "--verbose", action="store_true", default=False,
help="produce additional output for diagnostics")
option_parser.add_option("", "--manually_grab_svn_rev", action="store_true",
default=False,
help="Skip svn up whenever possible by requesting "
"actual HEAD revision from the repository")
option_parser.add_option("", "--head", action="store_true", default=False,
help=("skips any safesync_urls specified in "
"configured solutions"))
if len(argv) < 2:
# Users don't need to be told to use the 'help' command.
option_parser.print_help()
return 1
# Add manual support for --version as first argument.
if argv[1] == '--version':
option_parser.print_version()
return 0
# Add manual support for --help as first argument.
if argv[1] == '--help':
argv[1] = 'help'
command = argv[1]
options, args = option_parser.parse_args(argv[2:])
if len(argv) < 3 and command == "help":
option_parser.print_help()
return 0
# Files used for configuration and state saving.
options.config_filename = os.environ.get("GCLIENT_FILE", ".gclient")
options.entries_filename = ".gclient_entries"
options.deps_file = "DEPS"
options.platform = sys.platform
return DispatchCommand(command, options, args)
if "__main__" == __name__:
try:
result = Main(sys.argv)
except Error, e:
print >> sys.stderr, "Error: %s" % str(e)
result = 1
sys.exit(result)
# vim: ts=2:sw=2:tw=80:et: