vptool

#! /usr/bin/python

import argparse
import os
import sys
import time
import tempfile
import traceback
from printer import show
import subprocess
from vm import VM

# Import sensitive settings
import locals
import util
import inspect
import backend as backends

def inspect_obj(obj, value=False):
    for name, data in inspect.getmembers(obj):
        if value:
            print '%s :' % name, repr(data)
        else:
            print '%s' % name

class OperationError(Exception):
    foo = ''


class App:

    def __init__(self, args):
        self.verbose = args.v
        self.connected = False
        self.args = args

    def connect(self):
        BackendClass = getattr(backends, locals.BACKEND)
        if self.connected:
            if self.verbose:
                show('Already connected to %s lab: %s' %
                    (locals.BACKEND, locals.DEFAULT_LOCATION))
            return
        if self.verbose:
            show('Estabilishing connection to %s lab: %s' %
                (locals.BACKEND, locals.DEFAULT_LOCATION))
        self.backend = BackendClass(url=locals.URL,
                               kerberos=locals.KERBEROS,
                               username=locals.USERNAME,
                               password=locals.PASSWORD,
                               cluster_name=locals.CLUSTER_NAME,
                               ca_file=locals.CA_FILE,
                               verbose=self.verbose)
        self.connected = True

    def template_list(self):
        tmpl_list = self.backend.api.templates.list()
        return [t.get_name() for t in tmpl_list]

    def disconnect(self):
        return
        if self.connected:
            if self.verbose:
                show('Disconnecting')
            self.backend.api.disconnect()
        self.connected = False

    def list(self):
        if self.verbose:
            show('Getting vms')
        vms = self.backend.api.vms.list()
        vms.sort(key=lambda vm: vm.get_name())
        state= ""
        for vm in vms:
            name = vm.get_name()
            ip = ''
            fqdn = ''
            gi = vm.get_guest_info()
            if gi:
                ips = gi.get_ips()
                if ips:
                    ip = ips.get_ip()[0].get_address()
                fqdn = gi.fqdn
            state = self.backend.get_vm_state(name, vm)
            print("{: >20} {: >20} {: >20} {: >20} ".format(
                name, ip, state, fqdn))

        return

    def info(self):
        if not any((self.args.ip, self.args.host)):
            self.args.ip = True
            self.args.host = True
        if self.args.ip:
            ips = self.backend.get_ips(self.args.name)
            print(" ".join(ips))

        if self.args.host:
            hostname = self.backend.get_hostname(self.args.name)
            print(hostname)

    def create(self):
        template = self.args.template
        names = self.args.name

        for name in names:
            if not name.startswith(locals.USER):
                raise OperationError(
                    "%s: incorrect vm prefix. Must start with: %s" %
                        (name, locals.USER)
                )


        if not template:
            template = locals.TEMPLATE_NAME

        for name in names:
            if self.args.remove:
                self.backend.remove_vm(name)
            self.backend.create_vm(name, template=template)
            if self.args.start:
                self.backend.start(name, wait=False)
        return

    def console(self):
        virtual_viewer_params = self.backend.console(self.args.name)
        with tempfile.NamedTemporaryFile() as vvcfg:
            vvcfg.write('[virt-viewer]\n')
            for key, value in virtual_viewer_params.items():
                vvcfg.write('%s=%s\n' % (key, value))
            vvcfg.flush()
            subprocess.call(['/usr/bin/remote-viewer', vvcfg.name])

    def remove(self):
        for name in self.args.name:
            self.backend.remove_vm(name)

    def reboot(self):
        self.backend.reboot(self.args.name)

    def stop(self):
        self.backend.stop(self.args.name)

    def shutdown(self):
        self.backend.shutdown(self.args.name)

    def start(self):
        wants_console = getattr(self.args, 'wants_open_console', False)
        self.backend.start(self.args.name,
                           # if the user wants console ASAP do not wait until
                           # the VM is up
                           wait=not wants_console)
        if wants_console:
            while True:
                try:
                    self.console()
                except RuntimeError as ex:
                    show('Cannot open vm console, retrying: %s' % ex)
                    time.sleep(1)  # sleep a bit
                else:
                    break


    def templates(self):
        tmpl_list = self.template_list()
        for template in tmpl_list:
            print template
        return

    def run(self):
        lab = locals.DEFAULT_LOCATION
        if self.args.lab:
            lab = self.args.lab
        locals.set_locale(lab)
        self.connect()
        if self.args.action == 'list':
            self.list()
        elif self.args.action == 'info':
            self.info()
        elif self.args.action == 'create':
            self.create()
        elif self.args.action == 'console':
            self.console()
        elif self.args.action == 'remove':
            self.remove()
        elif self.args.action == 'reboot':
            self.reboot()
        elif self.args.action == 'stop':
            self.stop()
        elif self.args.action == 'shutdown':
            self.shutdown()
        elif self.args.action == 'start':
            self.start()
        elif self.args.action == 'templates':
            self.templates()
        self.disconnect()
        return

def parse_args():
    # create the top-level parser
    parser = argparse.ArgumentParser(prog='vptool', description=
        'Tool for managing vms in a lab')
    parser.add_argument('-v', '--verbose', dest='v', action='count', default=0,
                        help='verbose output')
    parser.add_argument('-l', '--lab', dest="lab", help='lab to use')

    subparsers = parser.add_subparsers(help='sub-command help', dest='action')

    # "list" command
    parser_a = subparsers.add_parser('list', help='list vms')
    parser_a.add_argument('--all', action='store_true', help='list all vms')

    # "info" command
    parser_b = subparsers.add_parser('info', help='get vm info')
    parser_b.add_argument('name', help='vm name')
    parser_b.add_argument('-i', '--ip', dest='ip',  action='store_true',
                          help='get only IP address')
    parser_b.add_argument('-H', '--host', dest='host',  action='store_true',
                          help='get only hostname')

    # "create" command
    parser_b = subparsers.add_parser('create', help='create new vm')
    parser_b.add_argument('name', help='vm name', nargs='+')
    parser_b.add_argument('-t', '--template', dest='template', help='template name')
    parser_b.add_argument('-s', '--start', dest='start',
                          action='store_true', help='start VM',
                          default=False)
    parser_b.add_argument('-d', '--remove', dest='remove',
                          action='store_true', help='remove VM before creation',
                          default=False)
    # "console" command
    parser_b = subparsers.add_parser('console', help='connect to vm console')
    parser_b.add_argument('name', help='vm name')

    # "remove" command
    parser_b = subparsers.add_parser('remove', help='remove vm')
    parser_b.add_argument('name', help='vm name', nargs='+')

    # "reboot" command
    parser_b = subparsers.add_parser('reboot', help='reboot vm')
    parser_b.add_argument('name', help='vm name')

    # "stop" command
    parser_b = subparsers.add_parser('stop', help='stop vm')
    parser_b.add_argument('name', help='vm name')

    # "shutdown" command
    parser_b = subparsers.add_parser('shutdown', help='shutdown vm')
    parser_b.add_argument('name', help='vm name')

    # "start" command
    parser_b = subparsers.add_parser('start', help='start vm')
    parser_b.add_argument('name', help='vm name')
    parser_b.add_argument('-c', '--console', dest='wants_open_console',
                          action='store_true', help='open vm console ASAP',
                          default=False)

    # "templates" command
    parser_b = subparsers.add_parser('templates', help='list templates')

    args = parser.parse_args()
    return args

if __name__ == '__main__':
    args = parse_args()
    try:
        app = App(args)
        app.run()
    except OperationError as e:
        print(e)
        app.disconnect()
        sys.exit(1)
    except Exception as e:
        print '***The command above has FAILED***'
        traceback.print_exc()
        sys.exit(1)