path: root/ansible/start-prov-boot.py

#!/usr/bin/python -tt
#written by skvidal@fedoraproject.org
# (c) 2012, Red Hat, Inc
# GPLv2+

import sys
import socket
from socket import gaierror
import ansible
import ansible.runner
import ansible.playbook
import time
from ansible import callbacks
from pprint import pprint
import optparse

def get_ans_results(results, hostname):
    if hostname in results['dark']:
        return results['dark'][hostname]
    if hostname in results['contacted']:
        return results['contacted'][hostname]
    
    return {}

def confirm():
    ans = raw_input()
    if ans.lower() == 'yes':
        return True
    return False
    
def check_for_ans_error(results, hostname, err_codes=[], success_codes=[0], 
                             return_on_error=['stdout', 'stderr']):
    # returns True or False + dict
    # dict includes 'msg'
    # may include 'rc', 'stderr', 'stdout' and any other
    # requested result codes
    err_results = {}
    
    if 'dark' in results and hostname in results['dark']:
        err_results['msg'] = "Error: Could not contact/connect to %s." % hostname
        return (True, err_results)
    
    error = False

    if err_codes or success_codes:
        if hostname in results['contacted']:
            if 'rc' in results['contacted'][hostname]:
                rc = int(results['contacted'][hostname]['rc'])
                err_results['rc'] = rc
                # check for err codes first
                if rc in err_codes:
                    error = True
                    err_results['msg'] = 'rc %s matched err_codes' % rc
                elif rc not in success_codes:
                    error = True
                    err_results['msg'] = 'rc %s not in success_codes' % rc
            elif 'failed' in results['contacted'][hostname] and results['contacted'][hostname]['failed']:
                error = True
                err_results['msg'] = 'results included failed as true'
                 
        if error:
            for item in return_on_error:
                if item in results['contacted'][hostname]:
                    err_results[item] = results['contacted'][hostname][item]
                    
    return error, err_results

def vm_is_defined(conn, vm, vmhost):
    # get list of vms
    conn.module_name = 'virt'
    conn.module_args = 'command=list_vms'
    results = get_ans_results(conn.run(), vmhost)
    # if vm is in in there
    if vm in results.get('list_vms', []):
        return True
    return False
    

def vm_is_alive(conn, vm, vmhost):
    if not vm_is_defined(conn, vm, vmhost):
        return False
    conn.module_name = 'virt'
    conn.module_args = 'command=status guest=%s' % vm
    results = get_ans_results(conn.run(), vmhost)
    if results.get('status', None)  == 'running':
        return True

    return False

def wait_for_host(hn, timeout=300):
    # watch for that host ssh to come up
    conn = ansible.runner.Runner(host_list=[hn], pattern=hn)
    is_up = False
    start = time.time()
    while not is_up:
        if time.time() - start >= timeout:
            raise Exception, "Hit Timeout waiting for %s to boot" % hn
        conn.module_name='ping'
        res = get_ans_results(conn.run(), hn)
        if res.get('ping'):
            is_up=True
        else:
            time.sleep(2)
        



def parse_args(args):
    parser = optparse.OptionParser('\nnewbuilder [options] buildvm buildvmhost]')
    parser.add_option('-s', default='50G', dest='lvm_size',
                    help='size of lv for vm: %default')
    parser.add_option('-m', default='4096', dest='memsize',
                    help='size of memory for vm: %default')
    parser.add_option('-n', default='4', dest='numcpus',
                    help='num of vcpus for vm: %default')
    parser.add_option('-k', default='http://myhost.org/ks/my_ks.cfg', dest='ks',
                    help='url to kickstart to use for install: %default')
    parser.add_option('-r', default='http://myhost.org/repo/6-x86_64/', dest='repo',
                    help='url of repo to use for install: %default')
    parser.add_option('--nm', default='255.255.255.0', dest='netmask',
                    help='netmask to use for kickstart: %default')
    parser.add_option('--gw', default='10.1.1.1', dest='gw',
                    help='gw to use for kickstart: %default')
    parser.add_option('--dns', default='10.1.1.2', dest='dns',
                    help='dns server to use for kickstart: %default')
    parser.add_option('--vg', default='/dev/vg_host01', dest='vg',
                    help='path to volumegroup to use on vmhost for vm disk: %default')
    parser.add_option('--postinst-play', default='playbooks/postinstall.yml', dest='postinst_play',
                    help='relative path to postinstall playbook to execute on vm: %default')
    parser.add_option('--reboot-play', default='playbooks/reboot.yml', dest='reboot_play',
                    help='relative path to reboot playbook to execute on vm: %default')
    parser.add_option('-y', '--yes', default=False, dest='yes', action="store_true",
                    help='Do not confirm any of the destructive actions - just do them')

    opts, args = parser.parse_args(args)

    if len(args) != 2:
        print 'usage:\n   newbuilder [options] buildvm buildvmhost\n\n'
        sys.exit(1)


    return opts, args



def main():

    opts, args = parse_args(sys.argv[1:])
    # args
    vm = args[0]
    vmhost = args[1]


    try:
        ip = socket.gethostbyname(vm)
    except gaierror,e:
        print 'Could not find ip for %s' % vm
        return 1

    if vm.find('.') == -1:
        print '%s was not a fqdn, cmon!' % vm
        return 1
           
    s_vm = vm.split('.')[0]

    # FIXME check out the vmhost to make sure it is a vmhost
    # error out if it is not
    vmhost_conn = ansible.runner.Runner(host_list=[vmhost], pattern=vmhost)
        
    print 'Checking for %s' % vm

    if vm_is_defined(vmhost_conn, vm, vmhost):
        if vm_is_alive(vmhost_conn, vm, vmhost):
            if not opts.yes:
                print "%s is running. Okay to Destroy? ('yes' to confirm): " % vm,
                if not confirm():
                    print 'Exiting on user input'
                    return 1
                
            # destroy it
            vmhost_conn.module_args = "command=destroy guest=%s" % vm
            err, err_res = check_for_ans_error(vmhost_conn.run(), vmhost)
            if err:
                print 'Error destroying %s on %s' % (vm, vmhost)
                print err_res
                return 1
                
        # undefine it
        if not opts.yes:
            print "%s is defined. Okay to Undefine? ('yes' to confirm): " % vm,
            if not confirm():
                print 'Exiting on user input'
                return 1
        
        vmhost_conn.module_args = "command=undefine guest=%s" % vm
        err, err_res = check_for_ans_error(vmhost_conn.run(), vmhost)
        if err:
            print 'Error undefining %s on %s' % (vm, vmhost)
            print err_res
            return 1

    # check for the lv being allocated already
    lv_check = '/sbin/lvs %s/%s --noheadings' % (opts.vg, s_vm)
    vmhost_conn.module_name='command'
    vmhost_conn.module_args=lv_check
    results = get_ans_results(vmhost_conn.run(), vmhost)
    if 'rc' not in results:
        print 'Could not talk to vmhost about disks'
        return 1

    if results['rc'] == 0:
        print 'Removing old disk: %s/%s' % (opts.vg, s_vm)
        # lvremove its disk
        lvrm='/sbin/lvremove -f %s/%s' % (opts.vg, s_vm)
        vmhost_conn.module_name='command'   
        vmhost_conn.module_args=lvrm
        results = get_ans_results(vmhost_conn.run(), vmhost)
        if results.get('rc', None) != 0:
            print "Could not remove lv for old vm %s" % vm
            print results
            return 1


     
    # lvcreate it 
    print 'Creating %s LV at %s/%s' % (opts.lvm_size, opts.vg, s_vm)
    lvcreate = '/sbin/lvcreate -L %s -n %s %s' % (opts.lvm_size, s_vm, opts.vg)
    vmhost_conn.module_name='command'
    vmhost_conn.module_args=lvcreate
    results = get_ans_results(vmhost_conn.run(), vmhost)
    if results.get('rc', None) != 0:
        print "Could not create lv for new vm %s"
        print results
        return 1
       


    ks_start = time.time()
    # do the virt-install 
    inst_cmd = """/usr/bin/virt-install -n %s -r %s \
     --disk %s/%s --vcpus=%s  -l %s -x "ksdevice=eth0 ks=%s ip=%s netmask=%s gateway=%s dns=%s console=tty0 console=ttyS0" \
     --network=bridge=br0 --network=bridge=br1 --vnc --noautoconsole""" % (vm, opts.memsize, opts.vg, 
                             s_vm, opts.numcpus, opts.repo, opts.ks, ip, opts.netmask, opts.gw, opts.dns)
    print 'running on %s' % vmhost
    print '%r' % inst_cmd
    vmhost_conn.module_name='command'
    vmhost_conn.module_args=inst_cmd
    err, err_res = check_for_ans_error(vmhost_conn.run(), vmhost)
    if err:
        print 'Error starting install of %s on %s' % (vm, vmhost)
        print err_res
        return 1

    # watch vmhost for vm to not be running 
    print 'Waiting for kickstart to complete.',
    time.sleep(1)
    while vm_is_alive(vmhost_conn, vm, vmhost):
        time.sleep(10)
        print '.',

    print 'Kicked!'   

    print 'Finished, kicking the vm: took %d seconds' % (time.time() - ks_start)

    # set vm autostart
    vmhost_conn.module_name='virt'
    vmhost_conn.module_args='command=start guest=%s' % vm
    err, err_res = check_for_ans_error(vmhost_conn.run(), vmhost)
    if err:
        print 'Error setting start of %s on %s' % (vm, vmhost)
        print err_res
        return 1   


    # start vm
    vmhost_conn.module_args='command=autostart guest=%s' % vm
    err, err_res = check_for_ans_error(vmhost_conn.run(), vmhost)
    if err:
        print 'Error setting autostart of %s on %s' % (vm, vmhost)
        print err_res
        print 'continuing'


    print 'Waiting for host to boot'
    try:
        wait_for_host(vm)
    except Exception, e:
        print e
        return 1
        
    print 'Booted'

    pl_start = time.time()
    # once up  run the postinstall playbook on the 
    for thisplay in (opts.postinst_play, opts.reboot_play):
        stats = callbacks.AggregateStats()
        playbook_cb = callbacks.PlaybookCallbacks(verbose=False)
        runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=False)
        play = ansible.playbook.PlayBook(host_list=[vm], stats=stats, playbook=thisplay, 
                 callbacks=playbook_cb, runner_callbacks=runner_cb)
        play.run()

        pprint(play.stats.summarize(vm))

    print 'Playbooks finished time was: %d' % (time.time()-pl_start)
    print 'Waiting for it to come back up'
    try:
        wait_for_host(vm)
    except Exception, e:
        print e
        return 1

    print '%s is now ready for use' % vm
    return 0




if __name__ == "__main__":
    sys.exit(main())