Merge lp:~jimbaker/juju-jitsu/unit-test into lp:juju-jitsu

[Jim Baker]

Adds jitsu test subcommand

Adds new subcommand, jitsu test, that runs unit tests in a charm's tests/ directory.

$ jitsu test --logdir=/tmp/test-results-42 mediawiki # --logdir LOGDIR must be specified

Executing this command then results in extensive logging (we may want to consider trimming this down); the key piece for each unit test is something like the following:

PASS: Verify top page is available for mediawiki/0
PASS: Verify top page is available for mediawiki/1
INFO: Completed test ./100_deploy.test
INFO: Passed test results for ./100_deploy.test in /tmp/test-results-42/100_deploy, skips=0

jitsu test ensures that the specified charm (mediawiki in this example) is deployed from the local repository, specifically the directory from which this test is being run. Otherwise any referenced but not qualified charms are deployed from the charm store.

Unit test ouput is captured in the specified LOGDIR. Note that unit tests can capture additional files by using JITSU_LOGDIR, which is passed as an environment variable to each unit test; it's LOGDIR/UNIT_TEST_NAME:

/tmp/test-results-42/100_deploy$ tree
.
├── 0
│   └── var
│   └── log
│   └── juju
│   ├── machine-agent.log
│   └── provision-agent.log
├── 1
│   └── var
│   ├── lib
│   │   └── juju
│   │   └── units
│   │   └── mediawiki-0
│   │   └── charm.log
│   └── log
│   └── juju
│   └── machine-agent.log
...
├── passed
└── wget.log

Other useful options include:

--no-bootstrap - so as to reuse an existing set of machines; note that jitsu test will not destroy services, so this would need to be automated outside jitsu test.

--isolate=ENVIRONMENT - creates an isolated environment using a unique name (jitsu-test-$(uuid)), including corresponding LOGDIR/.juju/environments.yaml. Note that no cleanup of security groups; this could be automated in testing through euca2ools.

https://codereview.appspot.com/6821104/

[Jim Baker (jimbaker)]

Reviewers: mp+133807_code.launchpad.net,

Message:
Please take a look.

Description:
Adds jitsu test subcommand

Adds new subcommand, jitsu test, that runs unit tests in a charm's
tests/ directory.

$ jitsu test --logdir=/tmp/test-results-42 mediawiki # --logdir LOGDIR
must be specified

Executing this command then results in extensive logging (we may want to
consider trimming this down); the key piece for each unit test is
something like the following:

PASS: Verify top page is available for mediawiki/0
PASS: Verify top page is available for mediawiki/1
INFO: Completed test ./100_deploy.test
INFO: Passed test results for ./100_deploy.test in
/tmp/test-results-42/100_deploy, skips=0

jitsu test ensures that the specified charm (mediawiki in this example)
is deployed from the local repository, specifically the directory from
which this test is being run. Otherwise any referenced but not qualified
charms are deployed from the charm store.

Unit test ouput is captured in the specified LOGDIR. Note that unit
tests can capture additional files by using JITSU_LOGDIR, which is
passed as an environment variable to each unit test; it's
LOGDIR/UNIT_TEST_NAME:

/tmp/test-results-42/100_deploy$ tree
.
├── 0
│   └── var
│   └── log
│   └── juju
│   ├── machine-agent.log
│   └── provision-agent.log
├── 1
│   └── var
│   ├── lib
│   │   └── juju
│   │   └── units
│   │   └── mediawiki-0
│   │   └── charm.log
│   └── log
│   └── juju
│   └── machine-agent.log
...
├── passed
└── wget.log

Other useful options include:

--no-bootstrap - so as to reuse an existing set of machines; note that
jitsu test will not destroy services, so this would need to be automated
outside jitsu test.

--isolate=ENVIRONMENT - creates an isolated environment using a unique
name (jitsu-test-$(uuid)), including corresponding
LOGDIR/.juju/environments.yaml. Note that no cleanup of security groups;
this could be automated in testing through euca2ools.

https://code.launchpad.net/~jimbaker/juju-jitsu/unit-test/+merge/133807

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/6821104/

Affected files:
   A [revision details]
   M sub-commands/Makefile.am
   M sub-commands/aiki/cli.py
   A sub-commands/files/juju
   A sub-commands/test
   D sub-commands/topodump

[Jim Baker (jimbaker)]

I also pushed up lp:~jimbaker/+junk/mediawiki-test-strawman, which shows how to write a unit test, to take advantage of JITSU_LOGDIR. Otherwise lib/test-helpers.sh will generate a temporary dir, but jitsu test won't know about this and therefore cannot capture.

Next up: propose the unit test as an update to the mediawiki charm!

[Benji York (benji)]

Thanks for this subcommand, Jim. Nicola and I have been using it to write some tests (see a first cut at lp:~juju-gui/charms/precise/juju-gui/trunk). A few remarks follow.

The charm directory name has to be the same as the charm name itself, which makes testing different branches difficult. Is revisiting that requirement possible?

It seems to us that the exit code from each one of the *.test files should be propagated and reported by the test subcommand (e.g., if any test returns a non-zero then Jitsu should return non-zero).

Bootstrapping from within the command either causes errors or times out: one needs to bootstrap in advance and use the --no-bootstrap option.

When accessing machines for log retrieval, rsync asks for a password for ubuntu@localhost. We can not figure out what that password should be.

We would appreciate any information you can give us about the above. Thanks.

[Kapil Thangavelu (hazmat)]

On Wed, Nov 14, 2012 at 1:10 PM, Benji York <email address hidden>wrote:

> Thanks for this subcommand, Jim. Nicola and I have been using it to write
> some tests (see a first cut at lp:~juju-gui/charms/precise/juju-gui/trunk).
> A few remarks follow.
>
> The charm directory name has to be the same as the charm name itself,
> which makes testing different branches difficult. Is revisiting that
> requirement possible?
>

This is a core requirement to guard against errant charm authorship. Its
not a jitsu check per se, but a juju core one. Its unlikely to be revisited
imo, but #juju-dev would be the appropriate place to confirm that.

>
> It seems to us that the exit code from each one of the *.test files should
> be propagated and reported by the test subcommand (e.g., if any test
> returns a non-zero then Jitsu should return non-zero).
>
> Bootstrapping from within the command either causes errors or times out:
> one needs to bootstrap in advance and use the --no-bootstrap option.
>
> When accessing machines for log retrieval, rsync asks for a password for
> ubuntu@localhost. We can not figure out what that password should be.
>

try setting up the key of your environment file as an authorized key for a
user ubuntu.

i assume based on the address that this is being tested with the local
provider, which is a bit of an oddball compared to other providers as the
default user isn't 'ubuntu' but whatever the user account is. ideally the
test runner could distinguish this based on provider type and use the local
provider user account. that would still need manual addition of the ssh key
to authorized keys as the local machine is not cloud-init initialized.
alternatively in the case of the local provider the testrunner eschews
machine log collection in favor of just unit log collection which should
still work as per other providers.

 hth,
Kapil

[Benji York (benji)]

> On Wed, Nov 14, 2012 at 1:10 PM, Benji York <email address hidden>wrote:
>
> > Thanks for this subcommand, Jim. Nicola and I have been using it to write
> > some tests (see a first cut at lp:~juju-gui/charms/precise/juju-gui/trunk).
> > A few remarks follow.
> >
> > The charm directory name has to be the same as the charm name itself,
> > which makes testing different branches difficult. Is revisiting that
> > requirement possible?
> >
>
> This is a core requirement to guard against errant charm authorship. Its
> not a jitsu check per se, but a juju core one. Its unlikely to be revisited
> imo, but #juju-dev would be the appropriate place to confirm that.

I can see how that would be important when handling submitted charms.
Our use case is a little different though, we want to run functional
tests of a charm in development. It seems a bit heavy-handed to force
all charm authors to name their development directory after the charm.

>
> > When accessing machines for log retrieval, rsync asks for a password for
> > ubuntu@localhost. We can not figure out what that password should be.
> >
>
> try setting up the key of your environment file as an authorized key for a
> user ubuntu.

I don't quite follow, but the next time I look at this I'll investigate
further.

> i assume based on the address that this is being tested with the local
> provider, which is a bit of an oddball compared to other providers as the
> default user isn't 'ubuntu' but whatever the user account is.

Right.

> alternatively in the case of the local provider the testrunner eschews
> machine log collection in favor of just unit log collection which should
> still work as per other providers.

It would be nice to have access to all the logs, but any way to avoid
the unanswerable password prompts in the middle of test runs would be an
improvement.

>
> hth,
> Kapil

Many thanks.

[Jim Baker (jimbaker)]

> On Wed, Nov 14, 2012 at 1:10 PM, Benji York <email address hidden>wrote:
>
> > Thanks for this subcommand, Jim. Nicola and I have been using it to write
> > some tests (see a first cut at lp:~juju-gui/charms/precise/juju-gui/trunk).
> > A few remarks follow.
> >
> > The charm directory name has to be the same as the charm name itself,
> > which makes testing different branches difficult. Is revisiting that
> > requirement possible?
> >
>
> This is a core requirement to guard against errant charm authorship. Its
> not a jitsu check per se, but a juju core one. Its unlikely to be revisited
> imo, but #juju-dev would be the appropriate place to confirm that.

Correct, the test in jitsu test is only an extra check to avoid unnecessary test runs. I don't see this changing anytime soon, and if it does in juju, we can readily change jitsu test.

> > It seems to us that the exit code from each one of the *.test files should
> > be propagated and reported by the test subcommand (e.g., if any test
> > returns a non-zero then Jitsu should return non-zero).

I will add that in a future release, it sounds like a great feature.

> >
> > Bootstrapping from within the command either causes errors or times out:
> > one needs to bootstrap in advance and use the --no-bootstrap option.
> >
> > When accessing machines for log retrieval, rsync asks for a password for
> > ubuntu@localhost. We can not figure out what that password should be.
> >
>
> try setting up the key of your environment file as an authorized key for a
> user ubuntu.
>
> i assume based on the address that this is being tested with the local
> provider, which is a bit of an oddball compared to other providers as the
> default user isn't 'ubuntu' but whatever the user account is. ideally the
> test runner could distinguish this based on provider type and use the local
> provider user account. that would still need manual addition of the ssh key
> to authorized keys as the local machine is not cloud-init initialized.
> alternatively in the case of the local provider the testrunner eschews
> machine log collection in favor of just unit log collection which should
> still work as per other providers.

Based on discussion about this in #juju, I will do some additional work on the lxc provider support in the next release.

[Mark Mims (mark-mims)]

charm_dir name is a #juju-dev issue.

Please clean up / consolidate log extraction in a future release.

Thanks!

review: Approve

=== modified file 'sub-commands/Makefile.am'
--- sub-commands/Makefile.am	2012-08-09 16:40:53 +0000
+++ sub-commands/Makefile.am	2012-11-10 21:15:24 +0000
@@ -10,10 +10,11 @@
     export \
     import \
     open-port \
-		provider-info \
+    provider-info \
     run-as-hook \
     search \
     setup-environment \
+    test \
     upgrade-charm \
     watch \
     wrap-juju
@@ -31,6 +32,7 @@
     run-as-hook \
     search \
     setup-environment \
+    test \
     upgrade-charm \
     watch \
     wrap-juju

=== modified file 'sub-commands/aiki/cli.py'
--- sub-commands/aiki/cli.py	2012-08-08 21:22:19 +0000
+++ sub-commands/aiki/cli.py	2012-11-10 21:15:24 +0000
@@ -34,7 +34,10 @@
             kwargs["help"] = kwargs["description"]  # Fallback
         parser = root_parser.add_parser(subcommand, **kwargs)
     parser.add_argument(
-        "-e", "--environment", default=None, help="Environment to act upon (otherwise uses default)", metavar="ENVIRONMENT")
+        "-e", "--environment", 
+        default=os.environ.get("JUJU_ENV"),
+        help="Environment to act upon (otherwise uses default)",
+        metavar="ENVIRONMENT")
     parser.add_argument(
         "--loglevel", default=None, choices=LOG_LEVELS, help="Log level",
         metavar="CRITICAL|ERROR|WARNING|INFO|DEBUG")
@@ -146,6 +149,8 @@
        of the script.
     """
     filename = os.path.join(details["home"], cmd)
+    if not (os.path.isfile(filename) and os.access(filename, os.X_OK)):
+        return
     attempt_python_parse = subcommand_home == details["home"]
     with open(filename) as f:
         lines = f.readlines()

=== added directory 'sub-commands/files'
=== added file 'sub-commands/files/juju'
--- sub-commands/files/juju	1970-01-01 00:00:00 +0000
+++ sub-commands/files/juju	2012-11-10 21:15:24 +0000
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+# A juju delegator that rewrites juju deploy|upgrade-charm ... charm [service] to use the desired respository
+
+# Only matches the charm if it equals the environment variable
+# $DELEGATE_CHARM and it is not qualified with cs: or local:
+# specifiers. If so, it rewrites the arg list to include --repository
+# $DELEGATE_REPOSITORY.
+#
+# Then call the real juju with the arg list.
+#
+# Requires that $PATH have the directory of the delegator as the first item in the search path.
+
+
+import os
+import sys
+
+from juju.control import setup_parser, SUBCOMMANDS
+
+
+def is_passthru(options):
+    # Only worry about juju deploy and upgrade-charm subcommands
+    if options.parser.prog not in ("juju deploy", "juju upgrade-charm"):
+        return True
+
+    if options.charm != os.environ.get("DELEGATE_CHARM"):
+        return True
+
+    # Charm name cannot be qualified with cs: or local:
+    if len(options.charm.split(":")) > 1:
+        return True
+
+    # Repository cannot be specified; this could be set by
+    # JUJU_REPOSITORY, so just iterate through the raw args
+    for arg in sys.argv[1:]:
+        if arg.startswith("--repository"):
+            return True
+
+    return False
+
+
+def main():
+    # Use juju itself to parse the command line options, to keep it simple;
+    # will need to be changed when moving to golang version
+    original_args = sys.argv[:]
+    parser = setup_parser(
+        subcommands=SUBCOMMANDS,
+        prog="juju",
+        description="juju cloud orchestration admin")
+    options, extra = parser.parse_known_args()  # don't need to worry about more complex parse setups like juju ssh
+
+    # Create a new env with PATH that looks up the real juju; use the
+    # convention that we pop the first item in the search path to
+    # restore PATH
+    new_env = dict(os.environ)  # make a copy
+    new_env["PATH"] = ":".join(new_env["PATH"].split(":")[1:])  # pop the first dir off the path
+
+    # Then exec in the real juju, with args modified as necessary
+    if is_passthru(options):
+        print "juju", " ".join(original_args)
+        os.execvpe("juju", original_args, new_env)
+    else:
+        if options.service_name:
+            args = original_args[0:-2]
+        else:
+            args = original_args[0:-1]
+        args.extend(["--repository", os.environ.get("DELEGATE_REPOSITORY")])
+        args.append("local:" + options.charm)
+        if options.service_name:
+            args.append(options.service_name)
+        print "juju", " ".join(args)
+        os.execvpe("juju", args, new_env)
+
+if __name__ == "__main__":
+    main()

=== added file 'sub-commands/test'
--- sub-commands/test	1970-01-01 00:00:00 +0000
+++ sub-commands/test	2012-11-10 21:15:24 +0000
@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+
+# TODO snapshot logs at any time in the test
+
+import argparse
+import glob
+import logging
+import os.path
+import subprocess
+import sys
+import textwrap
+import uuid
+
+import yaml
+
+from aiki.cli import make_arg_parser, setup_logging
+from juju.lib.format import YAMLFormat
+
+
+log = logging.getLogger("jitsu.test")
+
+
+class Tester(object):
+
+    def __init__(self, options):
+        self.options = options
+        
+        # Create a search path that includes files/juju as the first
+        # item when searching for juju; this will enable delegating it
+        # so that juju deploy|upgrade-charm use the local repository
+        # for the tested charm
+        delegated_juju = [os.path.realpath(os.path.normpath(os.path.join(__file__, "..", "files")))]
+        delegated_juju.extend(os.environ["PATH"].split(":"))
+        self.delegated_path = ":".join(delegated_juju)
+        if self.options.isolate:
+            self.options.bootstrap = True  # implied by --isolate
+
+    def install_required_test_packages(self):
+        if os.path.exists("tests/test.yaml"):
+            with open("tests/test.yaml") as f:
+                config = yaml.safe_load(f)
+            packages = config.get("packages")
+            if packages:
+                # Check if the test packages are already installed. If
+                # not, install them. We use this check to avoid an
+                # unnecessary requirement to sudo.
+                if subprocess.call(["dpkg", "-s"].extend(packages)):
+                    subprocess.check_call(["sudo", "apt-get", "--yes", "install"].extend(packages), env=self.env)
+
+    def run_tests(self):
+        if not glob.glob("tests/*.test"):
+            log.info("Nothing to do: charm %s has no tests defined", self.options.charm)
+            return
+
+        if os.path.split(os.getcwd())[1] != self.options.charm:
+            log.error("Not in the directory of the charm being tested: %s", self.options.charm)
+            sys.exit(1)
+
+        self.install_required_test_packages()
+        os.chdir("tests")
+        unit_tests = sorted(glob.glob("*.test"))
+        for unit_test in unit_tests:
+            log.info("Running unit test: %s", unit_test)
+            runner = TestRunner(self, unit_test)
+            try:
+                runner.setup()
+                runner.run_unit_test()
+            except Exception:
+                log.exception("Unit test failure")
+            finally:
+                runner.teardown()
+            log.info("Completed unit test: %s", unit_test)
+
+
+class TestRunner(object):
+
+    def __init__(self, tester, unit_test):
+        self.tester = tester
+        self.unit_test = unit_test
+        unit_test_name = os.path.splitext(self.unit_test)[0]
+        self.test_logdir = os.path.join(self.tester.options.logdir, unit_test_name)
+        if not os.path.exists(self.test_logdir):
+            os.makedirs(self.test_logdir)  # maybe just do this in scope of an exception, to prevent races (but most unlikely)
+        self.env = dict(os.environ)
+        self.env["JITSU_LOGDIR"] = self.test_logdir
+        self.env["JITSU_UNIT_TEST"] = unit_test_name
+        self.env["PATH"] = self.tester.delegated_path
+        self.env["DELEGATE_CHARM"] = self.tester.options.charm
+        self.env["DELEGATE_REPOSITORY"] = os.path.realpath(os.path.normpath(os.path.join(os.getcwd(), "../../..")))
+        self.bootstrapped = False
+
+    def setup(self):
+        if self.tester.options.isolate:
+            self.env["HOME"] = self.tester.options.logdir
+            self.juju_env = "jitsu-test-" + str(uuid.uuid1())
+            with open(os.path.expanduser("~/.juju/environments.yaml")) as f:
+                env_config = yaml.safe_load(f.read())
+            try:
+                cloned = dict(env_config["environments"][self.tester.options.isolate])
+            except KeyError:
+                log.error("Isolated environment %s is not defined in ~/.juju/environments.yaml", self.tester.options.isolate)
+                sys.exit(1)
+                
+            if "authorized-keys" not in cloned:
+                log.error("Isolated environment %s must define authorized-keys", self.tester.options.isolate)
+                sys.exit(1)
+            cloned.update({"control-bucket": self.juju_env})
+            test_config = {
+                "default": self.juju_env,
+                "environments": {
+                    self.juju_env: cloned
+                    }}
+            juju_env_dir = os.path.join(self.tester.options.logdir, ".juju")
+            try:
+                os.makedirs(juju_env_dir)
+            except OSError:
+                pass  # ignore existing directory
+            with open(os.path.join(juju_env_dir, "environments.yaml"), "w") as f:
+                f.write(YAMLFormat().format(test_config))
+        else:
+            self.juju_env = self.tester.options.environment
+        if self.juju_env:
+            self.env["JUJU_ENV"] = self.juju_env
+
+        if self.tester.options.bootstrap:
+            log.info("Bootstrapping %s", self.juju_env or "default environment")
+            output = subprocess.check_output(
+                ["juju", "bootstrap"], env=self.env, stderr=subprocess.STDOUT)
+            if "juju environment previously bootstrapped" in output:
+                log.error("Environment previously bootstraped (use --no-bootstrap or different environment)")
+                sys.exit(1)
+            self.bootstrapped = True
+            sys.stderr.write(output)  # After capture, simply redirect back to stderr
+
+    def teardown(self):
+        log.info("Tearing down unit test: %s", self.unit_test)
+        if self.tester.options.bootstrap and self.bootstrapped:
+            log.info("Destroying environment")
+            subprocess.check_call("echo y | juju destroy-environment", shell=True, env=self.env)
+
+    def run_unit_test(self):
+        try:
+            cmd = ["timeout", "--kill-after", "2m", self.tester.options.timeout, os.path.join(".", self.unit_test)]
+            output =  subprocess.check_output(cmd, env=self.env)
+            log.info("Unit test %s: %s", " ".join(cmd), output)
+        except subprocess.CalledProcessError, e:
+            log.warn("Error running unit test %s: %s %s", self.unit_test, e.returncode, e.output)
+        except Exception, e:
+            log.error("Error running unit test %s: %s", self.unit_test, e)
+        try:
+            self.archive_logs()
+        except Exception, e:
+            log.error("Error archiving logs for %s: %s", self.unit_test, e)
+
+    def archive_logs(self):
+        status = yaml.safe_load(subprocess.check_output(["juju", "status"]))
+        for machine, info in status["machines"].iteritems():
+            self.gather_logs(machine, info["dns-name"])
+
+    def gather_logs(self, machine, host):
+        host_dir = os.path.abspath(os.path.join(self.test_logdir, str(machine)))
+        if not os.path.exists(host_dir):
+            os.makedirs(host_dir)
+        log.info("Gathering logs for %s:%s in %s", machine, host, host_dir)
+        self.retrieve_path(host, host_dir, "/var/log/juju")
+        if machine != 0:
+            self.retrieve_path(host, host_dir, "/var/lib/juju/units/*/charm.log")
+
+    def retrieve_path(self, host, local_path, remote_path):
+        args = ["rsync", "--archive", "--compress", "--relative", "--verbose",
+                "-e", "ssh",
+                "ubuntu@{host}:{remote_path}".format(host=host, remote_path=remote_path),
+                local_path]
+        try:
+            subprocess.check_call(args)
+        except Exception, e:
+            log.warn("Error retrieving log %s from %s: %s", remote_path, host, e)
+
+
+def main():
+    parser = make_parser()
+    options = parser.parse_args()
+    setup_logging(options)
+    tester = Tester(options)
+    if options.archive_only:
+        runner = TestRunner(tester, "archive-only")
+        runner.archive_logs()
+    else:
+        tester.run_tests()
+
+
+def make_parser(root_parser=None):
+    main_parser = make_arg_parser(
+        root_parser, "test",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="runs charm unit tests",
+        epilog=textwrap.dedent("""\
+Charms are resolved against the charm store if not otherwise
+qualified, *except for the charm being tested*.
+
+SSH host keys are problematic for testing with juju at this
+time. Currently this cannot be mitigated by using per-environment
+ssh_config.
+
+Add the following in ~/.ssh/config
+
+Host *.amazonaws.com  # set for the specific cloud provider
+    StrictHostKeyChecking no
+    UserKnownHostsFile /dev/null
+
+Remember: such setup is a potential security hole, and it should not
+be used for any production systems. However, for testing purposes,
+especially for unit testing, this configuration should be reasonable.
+
+TODO: isolated environments should have support for env cleanup,
+such as security group removal.
+"""))
+
+    main_parser.add_argument("--archive-only", action="store_true", help="Archive all Juju logs")
+    main_parser.add_argument("--logdir", required=True, help="Write test logs and snapshots to this directory")
+    main_parser.add_argument("--timeout", default="15m", help="Timeout per unit test. Examples: 10m or 900s.")
+    main_parser.add_argument("--no-bootstrap", dest="bootstrap", default=True, action="store_false",
+                             help="Do not bootstrap env before each test, then destroy")
+    main_parser.add_argument("--isolate", metavar="ENVIRONMENT",
+                             help="Runs in an isolated, unique environment cloned from ENVIRONMENT in ~/.juju/environments.yaml")
+    main_parser.add_argument("charm", metavar="CHARM", help="Test for this charm")
+    return main_parser
+
+
+if __name__ == '__main__':
+    main()

=== removed file 'sub-commands/topodump'
--- sub-commands/topodump	2012-06-21 23:17:57 +0000
+++ sub-commands/topodump	1970-01-01 00:00:00 +0000
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-#
-# topodump - dumps the zookeeper topology
-
-from twisted.internet.defer import inlineCallbacks
-from aiki.cli import make_arg_parser, setup_logging, run_command
-from juju.state.base import StateBase
-
-
-def main():
-    parser = make_arg_parser()
-    options = parser.parse_args()
-    setup_logging(options)
-    print "options", options
-    run_command(topodump, options)
-
-
-@inlineCallbacks
-def topodump(result, client, options):
-    Dumper = TopoDump(client)
-    yield Dumper.dump()
-
-
-class TopoDump(StateBase):
-
-    @inlineCallbacks
-    def dump(self):
-        topology = yield self._read_topology()
-        print topology.dump()
-
-
-if __name__ == '__main__':
-    main()