2 # Copyright 2014 The Chromium Authors. All rights reserved.
3 # Use of this source code is governed by a BSD-style license that can be
4 # found in the LICENSE file.
6 """A utility script for downloading versioned Syzygy binaries."""
24 _LOGGER = logging.getLogger(os.path.basename(__file__))
26 # The URL where official builds are archived.
27 _SYZYGY_ARCHIVE_URL = ('http://syzygy-archive.commondatastorage.googleapis.com/'
28 'builds/official/%(revision)s')
30 # A JSON file containing the state of the download directory. If this file and
31 # directory state do not agree, then the binaries will be downloaded and
35 # This matches an integer (an SVN revision number) or a SHA1 value (a GIT hash).
36 # The archive exclusively uses lowercase GIT hashes.
37 _REVISION_RE = re.compile('^(?:\d+|[a-f0-9]{40})$')
39 # This matches an MD5 hash.
40 _MD5_RE = re.compile('^[a-f0-9]{32}$')
42 # List of reources to be downloaded and installed. These are tuples with the
44 # (basename, logging name, relative installation path, extraction filter)
46 ('benchmark.zip', 'benchmark', '', None),
47 ('binaries.zip', 'binaries', 'exe', None),
48 ('symbols.zip', 'symbols', 'exe',
49 lambda x: x.filename.endswith('.dll.pdb'))]
52 def _Shell(*cmd, **kw):
53 """Runs |cmd|, returns the results from Popen(cmd).communicate()."""
54 _LOGGER.debug('Executing %s.', cmd)
55 prog = subprocess.Popen(cmd, shell=True, **kw)
57 stdout, stderr = prog.communicate()
58 if prog.returncode != 0:
59 raise RuntimeError('Command "%s" returned %d.' % (cmd, prog.returncode))
60 return (stdout, stderr)
63 def _LoadState(output_dir):
64 """Loads the contents of the state file for a given |output_dir|, returning
65 None if it doesn't exist.
67 path = os.path.join(output_dir, _STATE)
68 if not os.path.exists(path):
69 _LOGGER.debug('No state file found.')
71 with open(path, 'rb') as f:
72 _LOGGER.debug('Reading state file: %s', path)
76 _LOGGER.debug('Invalid state file.')
80 def _SaveState(output_dir, state, dry_run=False):
81 """Saves the |state| dictionary to the given |output_dir| as a JSON file."""
82 path = os.path.join(output_dir, _STATE)
83 _LOGGER.debug('Writing state file: %s', path)
86 with open(path, 'wb') as f:
87 f.write(json.dumps(state, sort_keys=True, indent=2))
91 """Returns the MD5 hash of the file at |path|, which must exist."""
92 return hashlib.md5(open(path, 'rb').read()).hexdigest()
95 def _StateIsValid(state):
96 """Returns true if the given state structure is valid."""
97 if not isinstance(state, dict):
98 _LOGGER.debug('State must be a dict.')
100 r = state.get('revision', None)
101 if not isinstance(r, basestring) or not _REVISION_RE.match(r):
102 _LOGGER.debug('State contains an invalid revision.')
104 c = state.get('contents', None)
105 if not isinstance(c, dict):
106 _LOGGER.debug('State must contain a contents dict.')
108 for (relpath, md5) in c.iteritems():
109 if not isinstance(relpath, basestring) or len(relpath) == 0:
110 _LOGGER.debug('State contents dict contains an invalid path.')
112 if not isinstance(md5, basestring) or not _MD5_RE.match(md5):
113 _LOGGER.debug('State contents dict contains an invalid MD5 digest.')
118 def _BuildActualState(stored, revision, output_dir):
119 """Builds the actual state using the provided |stored| state as a template.
120 Only examines files listed in the stored state, causing the script to ignore
121 files that have been added to the directories locally. |stored| must be a
122 valid state dictionary.
125 state = { 'revision': revision, 'contents': contents }
126 for relpath, md5 in stored['contents'].iteritems():
127 abspath = os.path.abspath(os.path.join(output_dir, relpath))
128 if os.path.isfile(abspath):
130 contents[relpath] = m
135 def _StatesAreConsistent(stored, actual):
136 """Validates whether two state dictionaries are consistent. Both must be valid
137 state dictionaries. Additional entries in |actual| are ignored.
139 if stored['revision'] != actual['revision']:
140 _LOGGER.debug('Mismatched revision number.')
142 cont_stored = stored['contents']
143 cont_actual = actual['contents']
144 for relpath, md5 in cont_stored.iteritems():
145 if relpath not in cont_actual:
146 _LOGGER.debug('Missing content: %s', relpath)
148 if md5 != cont_actual[relpath]:
149 _LOGGER.debug('Modified content: %s', relpath)
154 def _GetCurrentState(revision, output_dir):
155 """Loads the current state and checks to see if it is consistent. Returns
156 a tuple (state, bool). The returned state will always be valid, even if an
157 invalid state is present on disk.
159 stored = _LoadState(output_dir)
160 if not _StateIsValid(stored):
161 _LOGGER.debug('State is invalid.')
162 # Return a valid but empty state.
163 return ({'revision': '0', 'contents': {}}, False)
164 actual = _BuildActualState(stored, revision, output_dir)
165 # If the script has been modified consider the state invalid.
166 path = os.path.join(output_dir, _STATE)
167 if os.path.getmtime(__file__) > os.path.getmtime(path):
168 return (stored, False)
169 # Otherwise, explicitly validate the state.
170 if not _StatesAreConsistent(stored, actual):
171 return (stored, False)
172 return (stored, True)
175 def _DirIsEmpty(path):
176 """Returns true if the given directory is empty, false otherwise."""
177 for root, dirs, files in os.walk(path):
178 return not dirs and not files
181 def _RmTreeHandleReadOnly(func, path, exc):
182 """An error handling function for use with shutil.rmtree. This will
183 detect failures to remove read-only files, and will change their properties
184 prior to removing them. This is necessary on Windows as os.remove will return
185 an access error for read-only files, and git repos contain read-only
189 if func in (os.rmdir, os.remove) and excvalue.errno == errno.EACCES:
190 _LOGGER.debug('Removing read-only path: %s', path)
191 os.chmod(path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
198 """A wrapper of shutil.rmtree that handles read-only files."""
199 shutil.rmtree(path, ignore_errors=False, onerror=_RmTreeHandleReadOnly)
202 def _CleanState(output_dir, state, dry_run=False):
203 """Cleans up files/directories in |output_dir| that are referenced by
204 the given |state|. Raises an error if there are local changes. Returns a
205 dictionary of files that were deleted.
207 _LOGGER.debug('Deleting files from previous installation.')
210 # Generate a list of files to delete, relative to |output_dir|.
211 contents = state['contents']
212 files = sorted(contents.keys())
214 # Try to delete the files. Keep track of directories to delete as well.
216 for relpath in files:
217 fullpath = os.path.join(output_dir, relpath)
218 fulldir = os.path.dirname(fullpath)
220 if os.path.exists(fullpath):
221 # If somehow the file has become a directory complain about it.
222 if os.path.isdir(fullpath):
223 raise Exception('Directory exists where file expected: %s' % fullpath)
225 # Double check that the file doesn't have local changes. If it does
226 # then refuse to delete it.
227 if relpath in contents:
228 stored_md5 = contents[relpath]
229 actual_md5 = _Md5(fullpath)
230 if actual_md5 != stored_md5:
231 raise Exception('File has local changes: %s' % fullpath)
233 # The file is unchanged so it can safely be deleted.
234 _LOGGER.debug('Deleting file "%s".', fullpath)
235 deleted[relpath] = True
239 # Sort directories from longest name to shortest. This lets us remove empty
240 # directories from the most nested paths first.
241 dirs = sorted(dirs.keys(), key=lambda x: len(x), reverse=True)
243 if os.path.exists(p) and _DirIsEmpty(p):
244 _LOGGER.debug('Deleting empty directory "%s".', p)
252 """Downloads the given URL and returns the contents as a string."""
253 response = urllib2.urlopen(url)
254 if response.code != 200:
255 raise RuntimeError('Failed to download "%s".' % url)
256 return response.read()
259 def _InstallBinaries(options, deleted={}):
260 """Installs Syzygy binaries. This assumes that the output directory has
261 already been cleaned, as it will refuse to overwrite existing files."""
263 state = { 'revision': options.revision, 'contents': contents }
264 archive_url = _SYZYGY_ARCHIVE_URL % { 'revision': options.revision }
265 for (base, name, subdir, filt) in _RESOURCES:
266 # Create the output directory if it doesn't exist.
267 fulldir = os.path.join(options.output_dir, subdir)
268 if os.path.isfile(fulldir):
269 raise Exception('File exists where a directory needs to be created: %s' %
271 if not os.path.exists(fulldir):
272 _LOGGER.debug('Creating directory: %s', fulldir)
273 if not options.dry_run:
276 # Download the archive.
277 url = archive_url + '/' + base
278 _LOGGER.debug('Retrieving %s archive at "%s".', name, url)
279 data = _Download(url)
281 _LOGGER.debug('Unzipping %s archive.', name)
282 archive = zipfile.ZipFile(cStringIO.StringIO(data))
283 for entry in archive.infolist():
284 if not filt or filt(entry):
285 fullpath = os.path.normpath(os.path.join(fulldir, entry.filename))
286 relpath = os.path.relpath(fullpath, options.output_dir)
287 if os.path.exists(fullpath):
288 # If in a dry-run take into account the fact that the file *would*
290 if options.dry_run and relpath in deleted:
293 raise Exception('Path already exists: %s' % fullpath)
295 # Extract the file and update the state dictionary.
296 _LOGGER.debug('Extracting "%s".', fullpath)
297 if not options.dry_run:
298 archive.extract(entry.filename, fulldir)
300 contents[relpath] = md5
301 if sys.platform == 'cygwin':
302 os.chmod(fullpath, os.stat(fullpath).st_mode | stat.S_IXUSR)
307 def _ParseCommandLine():
308 """Parses the command-line and returns an options structure."""
309 option_parser = optparse.OptionParser()
310 option_parser.add_option('--dry-run', action='store_true', default=False,
311 help='If true then will simply list actions that would be performed.')
312 option_parser.add_option('--force', action='store_true', default=False,
313 help='Force an installation even if the binaries are up to date.')
314 option_parser.add_option('--output-dir', type='string',
315 help='The path where the binaries will be replaced. Existing binaries '
316 'will only be overwritten if not up to date.')
317 option_parser.add_option('--overwrite', action='store_true', default=False,
318 help='If specified then the installation will happily delete and rewrite '
319 'the entire output directory, blasting any local changes.')
320 option_parser.add_option('--revision', type='string',
321 help='The SVN revision or GIT hash associated with the required version.')
322 option_parser.add_option('--revision-file', type='string',
323 help='A text file containing an SVN revision or GIT hash.')
324 option_parser.add_option('--verbose', dest='log_level', action='store_const',
325 default=logging.INFO, const=logging.DEBUG,
326 help='Enables verbose logging.')
327 option_parser.add_option('--quiet', dest='log_level', action='store_const',
328 default=logging.INFO, const=logging.ERROR,
329 help='Disables all output except for errors.')
330 options, args = option_parser.parse_args()
332 option_parser.error('Unexpected arguments: %s' % args)
333 if not options.output_dir:
334 option_parser.error('Must specify --output-dir.')
335 if not options.revision and not options.revision_file:
336 option_parser.error('Must specify one of --revision or --revision-file.')
337 if options.revision and options.revision_file:
338 option_parser.error('Must not specify both --revision and --revision-file.')
341 logging.basicConfig(level=options.log_level)
343 # If a revision file has been specified then read it.
344 if options.revision_file:
345 options.revision = open(options.revision_file, 'rb').read().strip()
346 _LOGGER.debug('Parsed revision "%s" from file "%s".',
347 options.revision, options.revision_file)
349 # Ensure that the specified SVN revision or GIT hash is valid.
350 if not _REVISION_RE.match(options.revision):
351 option_parser.error('Must specify a valid SVN or GIT revision.')
353 # This just makes output prettier to read.
354 options.output_dir = os.path.normpath(options.output_dir)
359 def _RemoveOrphanedFiles(options):
360 """This is run on non-Windows systems to remove orphaned files that may have
361 been downloaded by a previous version of this script.
363 # Reconfigure logging to output info messages. This will allow inspection of
364 # cleanup status on non-Windows buildbots.
365 _LOGGER.setLevel(logging.INFO)
367 output_dir = os.path.abspath(options.output_dir)
369 # We only want to clean up the folder in 'src/third_party/syzygy', and we
370 # expect to be called with that as an output directory. This is an attempt to
371 # not start deleting random things if the script is run from an alternate
372 # location, or not called from the gclient hooks.
373 expected_syzygy_dir = os.path.abspath(os.path.join(
374 os.path.dirname(__file__), '..', 'third_party', 'syzygy'))
375 expected_output_dir = os.path.join(expected_syzygy_dir, 'binaries')
376 if expected_output_dir != output_dir:
377 _LOGGER.info('Unexpected output directory, skipping cleanup.')
380 if not os.path.isdir(expected_syzygy_dir):
381 _LOGGER.info('Output directory does not exist, skipping cleanup.')
384 def OnError(function, path, excinfo):
385 """Logs error encountered by shutil.rmtree."""
386 _LOGGER.error('Error when running %s(%s)', function, path, exc_info=excinfo)
388 _LOGGER.info('Removing orphaned files from %s', expected_syzygy_dir)
389 if not options.dry_run:
390 shutil.rmtree(expected_syzygy_dir, True, OnError)
394 options = _ParseCommandLine()
397 _LOGGER.debug('Performing a dry-run.')
399 # We only care about Windows platforms, as the Syzygy binaries aren't used
400 # elsewhere. However, there was a short period of time where this script
401 # wasn't gated on OS types, and those OSes downloaded and installed binaries.
402 # This will cleanup orphaned files on those operating systems.
403 if sys.platform not in ('win32', 'cygwin'):
404 return _RemoveOrphanedFiles(options)
406 # Load the current installation state, and validate it against the
407 # requested installation.
408 state, is_consistent = _GetCurrentState(options.revision, options.output_dir)
410 # Decide whether or not an install is necessary.
412 _LOGGER.debug('Forcing reinstall of binaries.')
414 # Avoid doing any work if the contents of the directory are consistent.
415 _LOGGER.debug('State unchanged, no reinstall necessary.')
418 # Under normal logging this is the only only message that will be reported.
419 _LOGGER.info('Installing revision %s Syzygy binaries.',
420 options.revision[0:12])
422 # Clean up the old state to begin with.
424 if options.overwrite:
425 if os.path.exists(options.output_dir):
426 # If overwrite was specified then take a heavy-handed approach.
427 _LOGGER.debug('Deleting entire installation directory.')
428 if not options.dry_run:
429 _RmTree(options.output_dir)
431 # Otherwise only delete things that the previous installation put in place,
432 # and take care to preserve any local changes.
433 deleted = _CleanState(options.output_dir, state, options.dry_run)
435 # Install the new binaries. In a dry-run this will actually download the
436 # archives, but it won't write anything to disk.
437 state = _InstallBinaries(options, deleted)
439 # Build and save the state for the directory.
440 _SaveState(options.output_dir, state, options.dry_run)
443 if __name__ == '__main__':