Builds Docker image. Does not yet build .debs.

baiji

@@ -2,6 +2,7 @@
 
 import debian.deb822
 import subprocess
+import textwrap
 import argparse
 import tempfile
 import tarfile
@@ -41,11 +42,11 @@ class tempdir(object):
 # Debian version of that has a wildly different API than the version
 # on GitHub.
 
-class DockerError(Exception):
-    "Docker returned failure."
-
 class Docker(subprocess.Popen):
 
+    class DockerError(Exception):
+        "Docker returned failure."
+
     def __init__(self, *args, **kwargs):
         super(Docker, self).__init__(("docker",) + args, **kwargs)
 
@@ -55,7 +56,7 @@ class Docker(subprocess.Popen):
     def __exit__(self, *oops):
         status = self.wait()
         if status and all(o is None for o in oops):
-            raise DockerError()
+            raise self.DockerError()
 
 # Filter which acts like fakeroot for tarfile.TarFile.add() 
 
@@ -87,11 +88,11 @@ def create_base(args):
             docker.stdin.close()
 
     with Docker("build", "-t", args.tag, "-", stdin = subprocess.PIPE) as docker:
-        docker.communicate('''\
+        docker.communicate(textwrap.dedent('''\
             FROM {args.tag}
             RUN sed -i '/mount -t proc /d; /mount -t sysfs /d' /debootstrap/functions && /debootstrap/debootstrap --second-stage
-            RUN apt-get update && apt-get install -y --no-install-recommends build-essential fakeroot git
-        '''.format(args = args))
+            RUN apt-get update && apt-get install -y --no-install-recommends build-essential fakeroot git apt-utils
+        '''.format(args = args)))
 
 
 @cmd(arg("--tag",  default = "baiji:jessie", help = "tag of base docker image to update"),
@@ -102,15 +103,15 @@ def update_base(args):
     """
 
     with Docker("build", "-t", args.tag, "-", stdin = subprocess.PIPE) as docker:
-       docker.communicate('''\
+       docker.communicate(textwrap.dedent('''\
            FROM {args.tag}
            RUN apt-get update && apt-get upgrade -y --with-new-pkgs --no-install-recommends && apt-get autoremove && apt-get clean
-       '''.format(args = args))
+       '''.format(args = args)))
 
 
 @cmd(arg("--tag",           default = "baiji:jessie",                           help = "tag of base docker image to use"),
      arg("--dsc",           required = True,  type = argparse.FileType("r"),    help = ".dsc file to build"),
-     arg("--local-package", nargs = "+",                                        help = "local packages to make available to build"),
+     arg("--local-package", default = [],     nargs = "+",                      help = "local packages to make available to build"),
 )
 def build(args):
     """
@@ -122,23 +123,47 @@ def build(args):
     """
 
     dsc = debian.deb822.Dsc(args.dsc)
-    files = [os.path.join(os.path.dirname(args.dsc.name), f["name"]) for f in dsc["Files"]]
+
     dummy = debian.deb822.Deb822()
-    dummy_name = dsc["Source"] + "-build-depends"
+    dummy_name = "baiji-depends-" + dsc["Source"]
     dummy_fn = "{}_{}_all.deb".format(dummy_name, dsc["Version"])
     dummy["Depends"] = dsc["Build-Depends"]
     dummy["Package"] = dummy_name
     for tag in ("Version", "Maintainer", "Homepage"):
         dummy[tag] = dsc[tag]
 
+    source_files = [os.path.join(os.path.dirname(args.dsc.name), f["name"]) for f in dsc["Files"]]
+
+    build_image = "baiji/build/{}:{}".format(dsc["Source"], dsc["Version"])
+
     with tempdir() as dn:
         equivs = subprocess.Popen(("equivs-build", "/dev/stdin"), stdin = subprocess.PIPE, stdout = subprocess.PIPE, cwd = dn)
         equivs.communicate(str(dummy))
         if equivs.wait():
             sys.exit("Couldn't generate dummy dependency package")
 
-        # Do something useful with generated file here
-        subprocess.check_call(("dpkg", "-c", os.path.join(dn, dummy_fn)))
+        dockerfile_fn = os.path.join(dn, "Dockerfile")
+        with open(dockerfile_fn, "w") as f:
+            f.write(textwrap.dedent('''\
+                FROM {args.tag}
+                COPY micro-apt /micro-apt/
+                RUN  cd /micro-apt && apt-ftparchive packages . > Packages
+                RUN echo 'deb [trusted=yes] file:///micro-apt ./' > /etc/apt/sources.list.d/micro-apt.list
+                RUN apt-get update && apt-get install -y --no-install-recommends {dummy_name} && apt-get clean
+                '''.format(args = args, dummy_name = dummy_name)))
+
+        with open(dockerfile_fn) as f:
+            sys.stderr.write("# Dockerfile:\n" + f.read() + "\n")
+
+        with Docker("build", "-t", build_image, "-", stdin = subprocess.PIPE) as docker:
+            tar = tarfile.open(mode = "w|", fileobj = docker.stdin)
+            tar.add(dockerfile_fn, "Dockerfile", filter = fakeroot_filter)
+            for pkg in [os.path.join(dn, dummy_fn)] + args.local_package:
+                tar.add(pkg, os.path.join("micro-apt", os.path.basename(pkg)), filter = fakeroot_filter)
+            tar.close()
+            docker.stdin.close()
+
+    # Continue here with actual build once we have environment set up
 
 
 # Parse arguments and dispatch to one of the commands above.