Update ADD handling in Dockerfiles and test bundle creation

blimp/tools/create-bundle.py

 #!/usr/bin/env python
 # Copyright 2015 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.
 
 '''Bundles the Blimp target and its runtime dependencies into a tarball.
 
    The created bundle can be passed as input to docker build.  E.g.
    docker build - < ../../out-linux/Debug/blimp_engine_deps.tar.gz
 '''
 
 
 import argparse
 import os
 import subprocess
 import sys
 
-def ReadDependencies(manifest):
+def ReadDependencies(manifest, relative_path):
   """Read the manifest and return the list of dependencies.

[maniscalco, 2016/07/18 16:01:05]

Docs of this function need to be updated now that it does more than just read
and return the list.  The doc string should explain that it prefixes each
returned item with relative_path (and normalizes the prefixed path?).

[Jess, 2016/07/19 21:36:08]

Done.

   :raises IOError: if the manifest could not be read.
   """
-  deps = []
+  dependency_list = []
   with open(manifest) as f:
     for line in f.readlines():
       # Strip comments.
-      dep = line.partition('#')[0].strip()
+      dependency = line.partition('#')[0].strip()
       # Ignore empty strings.
-      if dep:
-        deps.append(dep)
-  return deps
+      if dependency:
+        if relative_path != '':
+          dependency = os.path.normpath(os.path.join(relative_path, dependency))
+        dependency_list.append(dependency)
+  return dependency_list
 
 def main():
   parser = argparse.ArgumentParser(description=__doc__)
   parser.add_argument('--build-dir',
                       help=('build output directory (e.g. out/Debug)'),
                       required=True,
                       metavar='DIR')
   parser.add_argument('--filelist',
                       help=('optional space separated list of files (e.g. '
                             'Dockerfile and startup script) to add to the '
                             'bundle'),
                       required=False,
                       metavar='FILE',
                       nargs='*')
   parser.add_argument('--manifest',
                       help=('file listing the set of files to include in '
                             'the bundle'),
                       required=True)
   parser.add_argument('--output',
                       help=('name and path of bundle to create'),
                       required=True,
                       metavar='FILE')
+  parser.add_argument('--root-dir',

[maniscalco, 2016/07/18 16:01:05]

Let's say the manifest (really the runtime deps file) contains:

foo/bar/baz
./buzz
../../datafile

If I call this program with build-dir=/build and don't specify --root-dir, the
tar will contain:

foo/bar/baz
./buzz
../../datafile

right?

Now if I were to pass apple/banana as --root-dir, I'd get:

apple/banana/foo/bar/baz
apple/banana/buzz
datafile

right?



I'm not sure the help text for this arg fully conveys its purpose.  It might be
more obvious if you gave it a more descriptive name.  For example:

--with-tar-contents-relative-to
--with-tar-contents-rooted-in


As for the help text, how about something like:

'optional path prefix to use inside the resulting tar file.' ?

[Jess, 2016/07/19 21:36:08]

Updated. PTAL. Agree this value's meaning is not the simplest concept to convey.

+                      help=('optional docker rootdir to use to reference '
+                            'dependencies; defaults to build-dir'),
+                      required=False,
+                      metavar='DIR')
   args = parser.parse_args()
 
-  deps = ReadDependencies(args.manifest)
+  dependencies_path = args.build_dir
+  if args.root_dir:
+    dependencies_path = args.root_dir
+  relative_path = os.path.relpath(args.build_dir, dependencies_path)
+
+  dependency_list = ReadDependencies(args.manifest, relative_path)
 
   try:
     env = os.environ.copy()
     # Use fastest possible mode when gzipping.
     env["GZIP"] = "-1"
     subprocess_args = [
         "tar",
         "-zcf", args.output,
         # Ensure tarball content group permissions are appropriately set for
         # use as part of a "docker build". That is group readable with
         # executable files also being group executable.
         "--mode=g+rX",
-        "-C", args.build_dir] + deps
+        "-C", dependencies_path] + dependency_list
     for f in args.filelist:
       dirname, basename = os.path.split(f)
       subprocess_args.extend(["-C", dirname, basename])
     subprocess.check_output(
         subprocess_args,
         # Redirect stderr to stdout, so that its output is captured.
         stderr=subprocess.STDOUT,
         env=env)
   except subprocess.CalledProcessError as e:
     print >> sys.stderr, "Failed to create tarball:"
     print >> sys.stderr, e.output
     sys.exit(1)
 
 if __name__ == "__main__":
   main()