Merge lp:~jimbaker/juju-jitsu/provider-info into lp:juju-jitsu

[Jim Baker]

Adds provider-info subcommand, which collects together all available provider info (machine list, provider state), then dumps YAML. Sample output:

$ jitsu provider-info
machines:
- dns_name: localhost
    instance_id: local
    private_dns_name: localhost
    state: running
provider-state:
    zookeeper-address: 192.168.122.1:45239
    zookeeper-instances:
    - local

This also fixes a bug in how jitsu dispatches to subcommands; it should not use the result of parse_known_args for the dispatch, but instead do this directly from the original args, so that's sys.argv[2:]

[Mark Mims (mark-mims)]

lgtm

review: Approve

=== modified file 'bin/jitsu.in'
--- bin/jitsu.in	2012-07-05 17:30:37 +0000
+++ bin/jitsu.in	2012-07-17 01:14:22 +0000
@@ -52,23 +52,24 @@
 for cmd, details in sorted(cmds.iteritems()):
     add_command_help(subparser, subcommand_home, cmd, details)
 
-(args, cmd_args) = parser.parse_known_args()
-
+args, cmd_args = parser.parse_known_args()
 run_cmd = args.subcommand
 
 if args.subcommand == 'help':
     run_cmd = args.help_subcommand
     cmd_args = ['--help']
+else:
+    cmd_args = sys.argv[2:]
 
 def is_executable(path):
     return isfile(path) and os.access(path, os.X_OK)
 
 user_path = expanduser(join(user_subcommands, run_cmd))
-if is_executable( user_path ):
-    os.execv(user_path, [user_path]+cmd_args)
+if is_executable(user_path):
+    os.execv(user_path, [user_path] + cmd_args)
 
 subcommand_path = join(subcommand_home, run_cmd)
-if is_executable( subcommand_path ):
-    os.execv(subcommand_path, [subcommand_path]+cmd_args)
+if is_executable(subcommand_path):
+    os.execv(subcommand_path, [subcommand_path] + cmd_args)
 
-os.execvp('juju', ['juju',run_cmd]+cmd_args)
+os.execvp('juju', ['juju', run_cmd] + cmd_args)
 
=== added file 'sub-commands/provider-info'
--- sub-commands/provider-info	1970-01-01 00:00:00 +0000
+++ sub-commands/provider-info	2012-07-17 01:14:22 +0000
@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+
+import logging
+import sys
+import traceback
+
+from twisted.internet import reactor
+from twisted.internet.defer import inlineCallbacks
+
+from aiki.cli import make_arg_parser, setup_logging
+from juju.environment.config import EnvironmentsConfig
+from juju.errors import EnvironmentNotFound
+from juju.lib.format import YAMLFormat
+
+
+log = logging.getLogger("provider-info")
+
+
+def main():
+    parser = make_parser()
+    options = parser.parse_args()
+    setup_logging(options)
+    run_command(get_info, options)
+
+
+def make_parser(root_parser=None):
+    main_parser = make_arg_parser(
+        root_parser, "provider-info",
+        description="Gets the available provider info for specified environment")
+    return main_parser
+
+
+def get_provider(options):
+    env_config = EnvironmentsConfig()
+    env_config.load()
+    if options.environment is None:
+        environment = env_config.get_default()
+    else:
+        environment = env_config.get(options.environment)
+    if environment is None:
+        raise EnvironmentNotFound(
+            "Environment %r not configured in environments.yaml" % options.environment)
+    return environment.get_machine_provider()
+
+
+def run_command(command, options):
+    try:
+        provider = get_provider(options)
+    except Exception, e:
+        print >> sys.stderr, e
+        sys.exit(1)
+
+    exit_code = [0]
+    reactor.callWhenRunning(run_command_in_reactor, command, exit_code, provider, options)
+    reactor.run()
+    sys.exit(exit_code[0])
+
+
+@inlineCallbacks
+def run_command_in_reactor(command, exit_code, provider, options):
+    try:
+        yield command(exit_code, provider, options)
+    except Exception, e:
+        exit_code[0] = 1
+        if options.verbose:
+            traceback.print_exc()  # Writes to stderr
+        else:
+            print >> sys.stderr, e
+    finally:
+        reactor.stop()
+
+
+@inlineCallbacks
+def get_info(result, provider, options):
+    info = {
+        "machines": [], 
+        "provider-state": (yield provider.load_state())}
+    machines = yield provider.get_machines()
+    for machine in machines:
+	info["machines"].append(dict(
+                dns_name=machine.dns_name, private_dns_name=machine.private_dns_name,
+		instance_id=machine.instance_id,  state=machine.state))
+    print YAMLFormat().format(info)
+
+
+if __name__ == '__main__':
+    main()