From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:38619) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1b4jkg-0006El-S8 for qemu-devel@nongnu.org; Mon, 23 May 2016 02:54:12 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1b4jkb-00088t-7v for qemu-devel@nongnu.org; Mon, 23 May 2016 02:54:09 -0400 Received: from mx1.redhat.com ([209.132.183.28]:48253) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1b4jka-00088m-VH for qemu-devel@nongnu.org; Mon, 23 May 2016 02:54:05 -0400 From: Fam Zheng Date: Mon, 23 May 2016 14:54:13 +0800 Message-Id: <1463986466-764-2-git-send-email-famz@redhat.com> In-Reply-To: <1463986466-764-1-git-send-email-famz@redhat.com> References: <1463986466-764-1-git-send-email-famz@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Subject: [Qemu-devel] [PATCH v5 01/14] tests: Add utilities for docker testing List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: =?UTF-8?q?Alex=20Benn=C3=A9e?= docker.py is added with a number of useful subcommands to manager docker images and instances for QEMU docker testing. Subcommands are: run: A wrapper of "docker run" (or "sudo -n docker run" if necessary), which takes care of killing and removing the running container at SIGINT. clean: Tear down all the containers including inactive ones that are started by docker_run. build: Compare an image from given dockerfile and rebuild it if they're different. Reviewed-by: Alex Benn=C3=A9e Signed-off-by: Fam Zheng --- tests/docker/docker.py | 191 +++++++++++++++++++++++++++++++++++++++++++= ++++++ 1 file changed, 191 insertions(+) create mode 100755 tests/docker/docker.py diff --git a/tests/docker/docker.py b/tests/docker/docker.py new file mode 100755 index 0000000..fe73de7 --- /dev/null +++ b/tests/docker/docker.py @@ -0,0 +1,191 @@ +#!/usr/bin/env python2 +# +# Docker controlling module +# +# Copyright (c) 2016 Red Hat Inc. +# +# Authors: +# Fam Zheng +# +# This work is licensed under the terms of the GNU GPL, version 2 +# or (at your option) any later version. See the COPYING file in +# the top-level directory. + +import os +import sys +import subprocess +import json +import hashlib +import atexit +import uuid +import argparse +import tempfile + +def _text_checksum(text): + """Calculate a digest string unique to the text content""" + return hashlib.sha1(text).hexdigest() + +def _guess_docker_command(): + """ Guess a working docker command or raise exception if not found""= " + commands =3D [["docker"], ["sudo", "-n", "docker"]] + for cmd in commands: + if subprocess.call(cmd + ["images"], + stdout=3Dsubprocess.PIPE, + stderr=3Dsubprocess.PIPE) =3D=3D 0: + return cmd + commands_txt =3D "\n".join([" " + " ".join(x) for x in commands]) + raise Exception("Cannot find working docker command. Tried:\n%s" % \ + commands_txt) + +class Docker(object): + """ Running Docker commands """ + def __init__(self): + self._command =3D _guess_docker_command() + self._instances =3D [] + atexit.register(self._kill_instances) + + def _do(self, cmd, quiet=3DTrue, **kwargs): + if quiet: + kwargs["stdout"] =3D subprocess.PIPE + return subprocess.call(self._command + cmd, **kwargs) + + def _do_kill_instances(self, only_known, only_active=3DTrue): + cmd =3D ["ps", "-q"] + if not only_active: + cmd.append("-a") + for i in self._output(cmd).split(): + resp =3D self._output(["inspect", i]) + labels =3D json.loads(resp)[0]["Config"]["Labels"] + active =3D json.loads(resp)[0]["State"]["Running"] + if not labels: + continue + instance_uuid =3D labels.get("com.qemu.instance.uuid", None) + if not instance_uuid: + continue + if only_known and instance_uuid not in self._instances: + continue + print "Terminating", i + if active: + self._do(["kill", i]) + self._do(["rm", i]) + + def clean(self): + self._do_kill_instances(False, False) + return 0 + + def _kill_instances(self): + return self._do_kill_instances(True) + + def _output(self, cmd, **kwargs): + return subprocess.check_output(self._command + cmd, + stderr=3Dsubprocess.STDOUT, + **kwargs) + + def get_image_dockerfile_checksum(self, tag): + resp =3D self._output(["inspect", tag]) + labels =3D json.loads(resp)[0]["Config"].get("Labels", {}) + return labels.get("com.qemu.dockerfile-checksum", "") + + def build_image(self, tag, dockerfile, df_path, quiet=3DTrue, argv=3D= None): + if argv =3D=3D None: + argv =3D [] + tmp =3D dockerfile + "\n" + \ + "LABEL com.qemu.dockerfile-checksum=3D%s" % \ + _text_checksum(dockerfile) + dirname =3D os.path.dirname(df_path) + tmp_df =3D tempfile.NamedTemporaryFile(dir=3Ddirname) + tmp_df.write(tmp) + tmp_df.flush() + self._do(["build", "-t", tag, "-f", tmp_df.name] + argv + \ + [dirname], + quiet=3Dquiet) + + def image_matches_dockerfile(self, tag, dockerfile): + try: + checksum =3D self.get_image_dockerfile_checksum(tag) + except Exception: + return False + return checksum =3D=3D _text_checksum(dockerfile) + + def run(self, cmd, keep, quiet): + label =3D uuid.uuid1().hex + if not keep: + self._instances.append(label) + ret =3D self._do(["run", "--label", + "com.qemu.instance.uuid=3D" + label] + cmd, + quiet=3Dquiet) + if not keep: + self._instances.remove(label) + return ret + +class SubCommand(object): + """A SubCommand template base class""" + name =3D None # Subcommand name + def shared_args(self, parser): + parser.add_argument("--quiet", action=3D"store_true", + help=3D"Run quietly unless an error occured"= ) + + def args(self, parser): + """Setup argument parser""" + pass + def run(self, args, argv): + """Run command. + args: parsed argument by argument parser. + argv: remaining arguments from sys.argv. + """ + pass + +class RunCommand(SubCommand): + """Invoke docker run and take care of cleaning up""" + name =3D "run" + def args(self, parser): + parser.add_argument("--keep", action=3D"store_true", + help=3D"Don't remove image when command comp= letes") + def run(self, args, argv): + return Docker().run(argv, args.keep, quiet=3Dargs.quiet) + +class BuildCommand(SubCommand): + """ Build docker image out of a dockerfile. Arguments: """ + name =3D "build" + def args(self, parser): + parser.add_argument("tag", + help=3D"Image Tag") + parser.add_argument("dockerfile", + help=3D"Dockerfile name") + + def run(self, args, argv): + dockerfile =3D open(args.dockerfile, "rb").read() + tag =3D args.tag + + dkr =3D Docker() + if dkr.image_matches_dockerfile(tag, dockerfile): + if not args.quiet: + print "Image is up to date." + return 0 + + dkr.build_image(tag, dockerfile, args.dockerfile, + quiet=3Dargs.quiet, argv=3Dargv) + return 0 + +class CleanCommand(SubCommand): + """Clean up docker instances""" + name =3D "clean" + def run(self, args, argv): + Docker().clean() + return 0 + +def main(): + parser =3D argparse.ArgumentParser(description=3D"A Docker helper", + usage=3D"%s ..." % os.path.basename(sys.argv[0]= )) + subparsers =3D parser.add_subparsers(title=3D"subcommands", help=3DN= one) + for cls in SubCommand.__subclasses__(): + cmd =3D cls() + subp =3D subparsers.add_parser(cmd.name, help=3Dcmd.__doc__) + cmd.shared_args(subp) + cmd.args(subp) + subp.set_defaults(cmdobj=3Dcmd) + args, argv =3D parser.parse_known_args() + return args.cmdobj.run(args, argv) + +if __name__ =3D=3D "__main__": + sys.exit(main()) --=20 2.8.2