Home | History | Annotate | Download | only in tools 
      1 #!/usr/bin/env python
      2 # Copyright (c) 2012 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.
      5 
      6 """Generates .msi from a .zip archive or an unpacked directory.
      7 
      8 The structure of the input archive or directory should look like this:
      9 
     10   +- archive.zip
     11      +- archive
     12         +- parameters.json
     13 
     14 The name of the archive and the top level directory in the archive must match.
     15 When an unpacked directory is used as the input "archive.zip/archive" should
     16 be passed via the command line.
     17 
     18 'parameters.json' specifies the parameters to be passed to candle/light and
     19 must have the following structure:
     20 
     21   {
     22     "defines": { "name": "value" },
     23     "extensions": [ "WixFirewallExtension.dll" ],
     24     "switches": [ '-nologo' ],
     25     "source": "chromoting.wxs",
     26     "bind_path": "files",
     27     "sign": [ ... ],
     28     "candle": { ... },
     29     "light": { ... }
     30   }
     31 
     32 "source" specifies the name of the input .wxs relative to
     33     "archive.zip/archive".
     34 "bind_path" specifies the path where to look for binary files referenced by
     35     .wxs relative to "archive.zip/archive".
     36 
     37 This script is used for both building Chromoting Host installation during
     38 Chromuim build and for signing Chromoting Host installation later. There are two
     39 copies of this script because of that:
     40 
     41   - one in Chromium tree at src/remoting/tools/zip2msi.py.
     42   - another one next to the signing scripts.
     43 
     44 The copies of the script can be out of sync so make sure that a newer version is
     45 compatible with the older ones when updating the script.
     46 """
     47 
     48 import copy
     49 import json
     50 from optparse import OptionParser
     51 import os
     52 import re
     53 import subprocess
     54 import sys
     55 import zipfile
     56 
     57 
     58 def UnpackZip(target, source):
     59   """Unpacks |source| archive to |target| directory."""
     60   target = os.path.normpath(target)
     61   archive = zipfile.ZipFile(source, 'r')
     62   for f in archive.namelist():
     63     target_file = os.path.normpath(os.path.join(target, f))
     64     # Sanity check to make sure .zip uses relative paths.
     65     if os.path.commonprefix([target_file, target]) != target:
     66       print "Failed to unpack '%s': '%s' is not under '%s'" % (
     67           source, target_file, target)
     68       return 1
     69 
     70     # Create intermediate directories.
     71     target_dir = os.path.dirname(target_file)
     72     if not os.path.exists(target_dir):
     73       os.makedirs(target_dir)
     74 
     75     archive.extract(f, target)
     76   return 0
     77 
     78 
     79 def Merge(left, right):
     80   """Merges two values.
     81 
     82   Raises:
     83     TypeError: |left| and |right| cannot be merged.
     84 
     85   Returns:
     86     - if both |left| and |right| are dictionaries, they are merged recursively.
     87     - if both |left| and |right| are lists, the result is a list containing
     88         elements from both lists.
     89     - if both |left| and |right| are simple value, |right| is returned.
     90     - |TypeError| exception is raised if a dictionary or a list are merged with
     91         a non-dictionary or non-list correspondingly.
     92   """
     93   if isinstance(left, dict):
     94     if isinstance(right, dict):
     95       retval = copy.copy(left)
     96       for key, value in right.iteritems():
     97         if key in retval:
     98           retval[key] = Merge(retval[key], value)
     99         else:
    100           retval[key] = value
    101       return retval
    102     else:
    103       raise TypeError('Error: merging a dictionary and non-dictionary value')
    104   elif isinstance(left, list):
    105     if isinstance(right, list):
    106       return left + right
    107     else:
    108       raise TypeError('Error: merging a list and non-list value')
    109   else:
    110     if isinstance(right, dict):
    111       raise TypeError('Error: merging a dictionary and non-dictionary value')
    112     elif isinstance(right, list):
    113       raise TypeError('Error: merging a dictionary and non-dictionary value')
    114     else:
    115       return right
    116 
    117 quote_matcher_regex = re.compile(r'\s|"')
    118 quote_replacer_regex = re.compile(r'(\\*)"')
    119 
    120 
    121 def QuoteArgument(arg):
    122   """Escapes a Windows command-line argument.
    123 
    124   So that the Win32 CommandLineToArgv function will turn the escaped result back
    125   into the original string.
    126   See http://msdn.microsoft.com/en-us/library/17w5ykft.aspx
    127   ("Parsing C++ Command-Line Arguments") to understand why we have to do
    128   this.
    129 
    130   Args:
    131       arg: the string to be escaped.
    132   Returns:
    133       the escaped string.
    134   """
    135 
    136   def _Replace(match):
    137     # For a literal quote, CommandLineToArgv requires an odd number of
    138     # backslashes preceding it, and it produces half as many literal backslashes
    139     # (rounded down). So we need to produce 2n+1 backslashes.
    140     return 2 * match.group(1) + '\\"'
    141 
    142   if re.search(quote_matcher_regex, arg):
    143     # Escape all quotes so that they are interpreted literally.
    144     arg = quote_replacer_regex.sub(_Replace, arg)
    145     # Now add unescaped quotes so that any whitespace is interpreted literally.
    146     return '"' + arg + '"'
    147   else:
    148     return arg
    149 
    150 
    151 def GenerateCommandLine(tool, source, dest, parameters):
    152   """Generates the command line for |tool|."""
    153   # Merge/apply tool-specific parameters
    154   params = copy.copy(parameters)
    155   if tool in parameters:
    156     params = Merge(params, params[tool])
    157 
    158   wix_path = os.path.normpath(params.get('wix_path', ''))
    159   switches = [os.path.join(wix_path, tool), '-nologo']
    160 
    161   # Append the list of defines and extensions to the command line switches.
    162   for name, value in params.get('defines', {}).iteritems():
    163     switches.append('-d%s=%s' % (name, value))
    164 
    165   for ext in params.get('extensions', []):
    166     switches += ('-ext', os.path.join(wix_path, ext))
    167 
    168   # Append raw switches
    169   switches += params.get('switches', [])
    170 
    171   # Append the input and output files
    172   switches += ('-out', dest, source)
    173 
    174   # Generate the actual command line
    175   #return ' '.join(map(QuoteArgument, switches))
    176   return switches
    177 
    178 
    179 def Run(args):
    180   """Runs a command interpreting the passed |args| as a command line."""
    181   command = ' '.join(map(QuoteArgument, args))
    182   popen = subprocess.Popen(
    183       command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    184   out, _ = popen.communicate()
    185   if popen.returncode:
    186     print command
    187     for line in out.splitlines():
    188       print line
    189     print '%s returned %d' % (args[0], popen.returncode)
    190   return popen.returncode
    191 
    192 
    193 def GenerateMsi(target, source, parameters):
    194   """Generates .msi from the installation files prepared by Chromium build."""
    195   parameters['basename'] = os.path.splitext(os.path.basename(source))[0]
    196 
    197   # The script can handle both forms of input a directory with unpacked files or
    198   # a ZIP archive with the same files. In the latter case the archive should be
    199   # unpacked to the intermediate directory.
    200   source_dir = None
    201   if os.path.isdir(source):
    202     # Just use unpacked files from the supplied directory.
    203     source_dir = source
    204   else:
    205     # Unpack .zip
    206     rc = UnpackZip(parameters['intermediate_dir'], source)
    207     if rc != 0:
    208       return rc
    209     source_dir = '%(intermediate_dir)s\\%(basename)s' % parameters
    210 
    211   # Read parameters from 'parameters.json'.
    212   f = open(os.path.join(source_dir, 'parameters.json'))
    213   parameters = Merge(json.load(f), parameters)
    214   f.close()
    215 
    216   if 'source' not in parameters:
    217     print 'The source .wxs is not specified'
    218     return 1
    219 
    220   if 'bind_path' not in parameters:
    221     print 'The binding path is not specified'
    222     return 1
    223 
    224   wxs = os.path.join(source_dir, parameters['source'])
    225 
    226   #  Add the binding path to the light-specific parameters.
    227   bind_path = os.path.join(source_dir, parameters['bind_path'])
    228   parameters = Merge(parameters, {'light': {'switches': ['-b', bind_path]}})
    229 
    230   target_arch = parameters['target_arch']
    231   if target_arch == 'ia32':
    232     arch_param = 'x86'
    233   elif target_arch == 'x64':
    234     arch_param = 'x64'
    235   else:
    236     print 'Invalid target_arch parameter value'
    237     return 1
    238 
    239   # Add the architecture to candle-specific parameters.
    240   parameters = Merge(
    241       parameters, {'candle': {'switches': ['-arch', arch_param]}})
    242 
    243   # Run candle and light to generate the installation.
    244   wixobj = '%(intermediate_dir)s\\%(basename)s.wixobj' % parameters
    245   args = GenerateCommandLine('candle', wxs, wixobj, parameters)
    246   rc = Run(args)
    247   if rc:
    248     return rc
    249 
    250   args = GenerateCommandLine('light', wixobj, target, parameters)
    251   rc = Run(args)
    252   if rc:
    253     return rc
    254 
    255   return 0
    256 
    257 
    258 def main():
    259   usage = 'Usage: zip2msi [options] <input.zip> <output.msi>'
    260   parser = OptionParser(usage=usage)
    261   parser.add_option('--intermediate_dir', dest='intermediate_dir', default='.')
    262   parser.add_option('--wix_path', dest='wix_path', default='.')
    263   parser.add_option('--target_arch', dest='target_arch', default='x86')
    264   options, args = parser.parse_args()
    265   if len(args) != 2:
    266     parser.error('two positional arguments expected')
    267 
    268   return GenerateMsi(args[1], args[0], dict(options.__dict__))
    269 
    270 if __name__ == '__main__':
    271   sys.exit(main())
    272 
    273