Exemple #1
0
 def __init__(self, host='127.0.0.1', port=None, user='******', debug=False):
     self.conn = 'fake'
     self.host = host
     templates = [os.path.basename(t) for t in list(TEMPLATES.values()) if t is not None and (t.endswith('qcow2') or
                                                                                              t.endswith('img'))]
     rheltemplates = ['rhel-guest-image-7.2-20160302.0.x86_64.qcow2', 'rhel-guest-image-7.3-35.x86_64.qcow2',
                      'rhel-server-7.4-x86_64-kvm.qcow2']
     self.templates = templates + rheltemplates
     return
Exemple #2
0
def cli():
    global config
    parser = argparse.ArgumentParser(
        description=
        'Libvirt/VirtualBox wrapper on steroids. Check out https://github.com/karmab/kcli!'
    )
    parser.add_argument('-C', '--client')
    parser.add_argument('-d', '--debug', action='store_true')
    parser.add_argument('--version', action='version', version=__version__)

    subparsers = parser.add_subparsers(metavar='')

    bootstrap_info = 'Generate basic config file'
    bootstrap_parser = subparsers.add_parser('bootstrap',
                                             help=bootstrap_info,
                                             description=bootstrap_info)
    bootstrap_parser.add_argument('-n',
                                  '--name',
                                  help='Name to use',
                                  metavar='CLIENT')
    bootstrap_parser.add_argument('-H',
                                  '--host',
                                  help='Host to use',
                                  metavar='HOST')
    bootstrap_parser.add_argument('-p',
                                  '--port',
                                  help='Port to use',
                                  metavar='PORT')
    bootstrap_parser.add_argument('-u',
                                  '--user',
                                  help='User to use',
                                  default='root',
                                  metavar='USER')
    bootstrap_parser.add_argument('-P',
                                  '--protocol',
                                  help='Protocol to use',
                                  default='ssh',
                                  metavar='PROTOCOL')
    bootstrap_parser.add_argument('-U',
                                  '--url',
                                  help='URL to use',
                                  metavar='URL')
    bootstrap_parser.add_argument('--pool', help='Pool to use', metavar='POOL')
    bootstrap_parser.add_argument('--poolpath',
                                  help='Pool Path to use',
                                  metavar='POOLPATH')
    bootstrap_parser.set_defaults(func=bootstrap)

    clone_info = 'Clone existing vm'
    clone_parser = subparsers.add_parser('clone',
                                         description=clone_info,
                                         help=clone_info)
    clone_parser.add_argument('-b', '--base', help='Base VM', metavar='BASE')
    clone_parser.add_argument('-f',
                              '--full',
                              action='store_true',
                              help='Full Clone')
    clone_parser.add_argument('-s',
                              '--start',
                              action='store_true',
                              help='Start cloned VM')
    clone_parser.add_argument('name', metavar='VMNAME')
    clone_parser.set_defaults(func=clone)

    console_info = 'Vnc/Spice/Serial/Container console'
    console_parser = subparsers.add_parser('console',
                                           description=console_info,
                                           help=console_info)
    console_parser.add_argument('-s', '--serial', action='store_true')
    console_parser.add_argument('--container', action='store_true')
    console_parser.add_argument('name', metavar='VMNAME')
    console_parser.set_defaults(func=console)

    container_info = 'Create container'
    container_parser = subparsers.add_parser('container',
                                             description=container_info,
                                             help=container_info)
    container_parser.add_argument('-p',
                                  '--profile',
                                  help='Profile to use',
                                  metavar='PROFILE')
    container_parser.add_argument('name', metavar='NAME', nargs='?')
    container_parser.set_defaults(func=container)

    delete_info = 'Delete vm/container'
    delete_parser = subparsers.add_parser('delete',
                                          description=delete_info,
                                          help=delete_info)
    delete_parser.add_argument('-y',
                               '--yes',
                               action='store_true',
                               help='Dont ask for confirmation')
    delete_parser.add_argument('--container', action='store_true')
    delete_parser.add_argument('--snapshots',
                               action='store_true',
                               help='Remove snapshots if needed')
    delete_parser.add_argument('names', metavar='VMNAMES', nargs='+')
    delete_parser.set_defaults(func=delete)

    disk_info = 'Add/Delete disk of vm'
    disk_parser = subparsers.add_parser('disk',
                                        description=disk_info,
                                        help=disk_info)
    disk_parser.add_argument('-d', '--delete', action='store_true')
    disk_parser.add_argument('-s',
                             '--size',
                             help='Size of the disk to add, in GB',
                             metavar='SIZE')
    disk_parser.add_argument('-n',
                             '--diskname',
                             help='Name or Path of the disk, when deleting',
                             metavar='DISKNAME')
    disk_parser.add_argument('-t',
                             '--template',
                             help='Name or Path of a Template, when adding',
                             metavar='TEMPLATE')
    disk_parser.add_argument('-p',
                             '--pool',
                             default='default',
                             help='Pool',
                             metavar='POOL')
    disk_parser.add_argument('name')
    disk_parser.set_defaults(func=disk)

    download_info = 'Download template'
    download_parser = subparsers.add_parser('download',
                                            description=download_info,
                                            help=download_info)
    download_parser.add_argument(
        '-c',
        '--cmd',
        help='Extra command to launch after downloading',
        metavar='CMD')
    download_parser.add_argument('-p',
                                 '--pool',
                                 default='default',
                                 help='Pool to use',
                                 metavar='POOL')
    download_parser.add_argument('template',
                                 choices=sorted(TEMPLATES.keys()),
                                 help='Template/Image to download')
    download_parser.set_defaults(func=download)

    host_info = 'List and Handle host'
    host_parser = subparsers.add_parser('host',
                                        description=host_info,
                                        help=host_info)
    host_parser.add_argument('-d',
                             '--disable',
                             help='Disable indicated client',
                             metavar='CLIENT')
    host_parser.add_argument('-e',
                             '--enable',
                             help='Enable indicated client',
                             metavar='CLIENT')
    host_parser.add_argument('-s',
                             '--switch',
                             help='Switch To indicated client',
                             metavar='CLIENT')
    host_parser.set_defaults(func=host)

    info_info = 'Info vms'
    info_parser = subparsers.add_parser('info',
                                        description=info_info,
                                        help=info_info)
    info_parser.add_argument('-o',
                             '--output',
                             choices=['plain', 'yaml'],
                             help='Format of the output')
    info_parser.add_argument('names', help='VMNAMES', nargs='+')
    info_parser.set_defaults(func=info)

    list_info = 'List hosts, profiles, templates, isos,...'
    list_parser = subparsers.add_parser('list',
                                        description=list_info,
                                        help=list_info)
    list_parser.add_argument('-H', '--hosts', action='store_true')
    list_parser.add_argument('-p', '--profiles', action='store_true')
    list_parser.add_argument('-t', '--templates', action='store_true')
    list_parser.add_argument('-i', '--isos', action='store_true')
    list_parser.add_argument('-d', '--disks', action='store_true')
    list_parser.add_argument('-P', '--pools', action='store_true')
    list_parser.add_argument('-n', '--networks', action='store_true')
    list_parser.add_argument('--containers', action='store_true')
    list_parser.add_argument('--images', action='store_true')
    list_parser.add_argument('--short', action='store_true')
    list_parser.add_argument('--plans', action='store_true')
    list_parser.add_argument('-f', '--filters', choices=('up', 'down'))
    list_parser.set_defaults(func=list)

    network_info = 'Create/Delete Network'
    network_parser = subparsers.add_parser('network',
                                           description=network_info,
                                           help=network_info)
    network_parser.add_argument('-d', '--delete', action='store_true')
    network_parser.add_argument('-i',
                                '--isolated',
                                action='store_true',
                                help='Isolated Network')
    network_parser.add_argument('-c',
                                '--cidr',
                                help='Cidr of the net',
                                metavar='CIDR')
    network_parser.add_argument('--nodhcp',
                                action='store_true',
                                help='Disable dhcp on the net')
    network_parser.add_argument('--domain',
                                help='DNS domain. Defaults to network name')
    network_parser.add_argument('-p',
                                '--pxe',
                                help='Ip of a Pxe Server',
                                metavar='PXE')
    network_parser.add_argument('name', metavar='NETWORK')
    network_parser.set_defaults(func=network)

    nic_info = 'Add/Delete nic of vm'
    nic_parser = subparsers.add_parser('nic',
                                       description=nic_info,
                                       help=nic_info)
    nic_parser.add_argument('-d', '--delete', action='store_true')
    nic_parser.add_argument('-i',
                            '--interface',
                            help='Name of the interface, when deleting',
                            metavar='INTERFACE')
    nic_parser.add_argument('-n',
                            '--network',
                            help='Network',
                            metavar='NETWORK')
    nic_parser.add_argument('name', metavar='VMNAME')
    nic_parser.set_defaults(func=nic)

    plan_info = 'Create/Delete/Stop/Start vms from plan file'
    plan_parser = subparsers.add_parser('plan',
                                        description=plan_info,
                                        help=plan_info)
    plan_parser.add_argument('-A',
                             '--ansible',
                             help='Generate ansible inventory',
                             action='store_true')
    plan_parser.add_argument('-d', '--delete', action='store_true')
    plan_parser.add_argument(
        '-g',
        '--get',
        help='Download specific plan(s). Use --path for specific directory',
        metavar='URL')
    plan_parser.add_argument(
        '-p',
        '--path',
        default='plans',
        help='Path where to download plans. Defaults to plan',
        metavar='PATH')
    plan_parser.add_argument('-a',
                             '--autostart',
                             action='store_true',
                             help='Set all vms from plan to autostart')
    plan_parser.add_argument('-c',
                             '--container',
                             action='store_true',
                             help='Handle container')
    plan_parser.add_argument('-n',
                             '--noautostart',
                             action='store_true',
                             help='Prevent all vms from plan to autostart')
    plan_parser.add_argument('-f', '--inputfile', help='Input file')
    plan_parser.add_argument('-s',
                             '--start',
                             action='store_true',
                             help='start all vms from plan')
    plan_parser.add_argument('-w', '--stop', action='store_true')
    plan_parser.add_argument('--scale',
                             help='Scale plan using provided parameters')
    plan_parser.add_argument('-t', '--topologyfile', help='Topology file')
    plan_parser.add_argument('-u',
                             '--use',
                             nargs='?',
                             const='kvirt',
                             help='Plan to set as current. Defaults to kvirt',
                             metavar='USE')
    plan_parser.add_argument('-y',
                             '--yes',
                             action='store_true',
                             help='Dont ask for confirmation')
    plan_parser.add_argument('--delay',
                             default=0,
                             help="Delay between each vm's creation",
                             metavar='DELAY')
    plan_parser.add_argument('plan', metavar='PLAN', nargs='?')
    plan_parser.set_defaults(func=plan)

    pool_info = 'Create/Delete pool'
    pool_parser = subparsers.add_parser('pool',
                                        description=pool_info,
                                        help=pool_info)
    pool_parser.add_argument('-d', '--delete', action='store_true')
    pool_parser.add_argument('-f', '--full', action='store_true')
    pool_parser.add_argument('-t',
                             '--pooltype',
                             help='Type of the pool',
                             choices=('dir', 'logical'),
                             default='dir')
    pool_parser.add_argument('-p',
                             '--path',
                             help='Path of the pool',
                             metavar='PATH')
    pool_parser.add_argument('pool')
    pool_parser.set_defaults(func=pool)

    report_info = 'Report Info about Host'
    report_parser = subparsers.add_parser('report',
                                          description=report_info,
                                          help=report_info)
    report_parser.set_defaults(func=report)

    scp_info = 'Scp into vm'
    scp_parser = subparsers.add_parser('scp',
                                       description=scp_info,
                                       help=scp_info)
    scp_parser.add_argument('-r',
                            '--recursive',
                            help='Recursive',
                            action='store_true')
    scp_parser.add_argument('source', nargs=1)
    scp_parser.add_argument('destination', nargs=1)
    scp_parser.set_defaults(func=scp)

    snapshot_info = 'Create/Delete/Revert snapshot'
    snapshot_parser = subparsers.add_parser('snapshot',
                                            description=snapshot_info,
                                            help=snapshot_info)
    snapshot_parser.add_argument('-n',
                                 '--name',
                                 help='Use vm name for creation/revert/delete',
                                 required=True,
                                 metavar='VMNAME')
    snapshot_parser.add_argument('-r',
                                 '--revert',
                                 help='Revert to indicated snapshot',
                                 action='store_true')
    snapshot_parser.add_argument('-d',
                                 '--delete',
                                 help='Delete indicated snapshot',
                                 action='store_true')
    snapshot_parser.add_argument('-l',
                                 '--listing',
                                 help='List snapshots',
                                 action='store_true')
    snapshot_parser.add_argument('snapshot', nargs='?')
    snapshot_parser.set_defaults(func=snapshot)

    ssh_info = 'Ssh into vm'
    ssh_parser = subparsers.add_parser('ssh',
                                       description=ssh_info,
                                       help=ssh_info)
    ssh_parser.add_argument('-L', help='Local Forwarding', metavar='LOCAL')
    ssh_parser.add_argument('-R', help='Remote Forwarding', metavar='REMOTE')
    ssh_parser.add_argument('name', metavar='VMNAME', nargs='+')
    ssh_parser.set_defaults(func=ssh)

    start_info = 'Start vms/containers'
    start_parser = subparsers.add_parser('start',
                                         description=start_info,
                                         help=start_info)
    start_parser.add_argument('-c', '--container', action='store_true')
    start_parser.add_argument('names', metavar='VMNAMES', nargs='+')
    start_parser.set_defaults(func=start)

    stop_info = 'Stop vms/containers'
    stop_parser = subparsers.add_parser('stop',
                                        description=stop_info,
                                        help=stop_info)
    stop_parser.add_argument('-c', '--container', action='store_true')
    stop_parser.add_argument('names', metavar='VMNAMES', nargs='+')
    stop_parser.set_defaults(func=stop)

    switch_info = 'Switch host'
    switch_parser = subparsers.add_parser('switch',
                                          description=switch_info,
                                          help=switch_info)
    switch_parser.add_argument('host', help='HOST')
    switch_parser.set_defaults(func=switch)

    update_info = 'Update ip, memory or numcpus'
    update_parser = subparsers.add_parser('update',
                                          description=update_info,
                                          help=update_info)
    update_parser.add_argument('-1', '--ip1', help='Ip to set', metavar='IP1')
    update_parser.add_argument('--network',
                               '--net',
                               help='Network to update',
                               metavar='NETWORK')
    update_parser.add_argument('-m',
                               '--memory',
                               help='Memory to set',
                               metavar='MEMORY')
    update_parser.add_argument('-c',
                               '--numcpus',
                               help='Number of cpus to set',
                               metavar='NUMCPUS')
    update_parser.add_argument('-p',
                               '--plan',
                               help='Plan Name to set',
                               metavar='PLAN')
    update_parser.add_argument('-a',
                               '--autostart',
                               action='store_true',
                               help='Set VM to autostart')
    update_parser.add_argument('-n',
                               '--noautostart',
                               action='store_true',
                               help='Prevent VM from autostart')
    update_parser.add_argument('--dns',
                               action='store_true',
                               help='Update Dns entry for the vm')
    update_parser.add_argument('--host',
                               action='store_true',
                               help='Update Host entry for the vm')
    update_parser.add_argument('-d',
                               '--domain',
                               help='Domain',
                               metavar='DOMAIN')
    update_parser.add_argument('-t',
                               '--template',
                               help='Template to set',
                               metavar='TEMPLATE')
    update_parser.add_argument('--cloudinit',
                               action='store_true',
                               help='Remove Cloudinit Information from vm')
    update_parser.add_argument('name', metavar='VMNAME')
    update_parser.set_defaults(func=update)

    vm_info = 'Create vm'
    vm_parser = subparsers.add_parser('vm', description=vm_info, help=vm_info)
    vm_parser.add_argument('-p',
                           '--profile',
                           help='Profile to use',
                           metavar='PROFILE')
    vm_parser.add_argument(
        '-1',
        '--ip1',
        help=
        'Optional Ip to assign to eth0. Netmask and gateway will be retrieved from profile',
        metavar='IP1')
    vm_parser.add_argument(
        '-2',
        '--ip2',
        help=
        'Optional Ip to assign to eth1. Netmask and gateway will be retrieved from profile',
        metavar='IP2')
    vm_parser.add_argument(
        '-3',
        '--ip3',
        help=
        'Optional Ip to assign to eth2. Netmask and gateway will be retrieved from profile',
        metavar='IP3')
    vm_parser.add_argument(
        '-4',
        '--ip4',
        help=
        'Optional Ip to assign to eth3. Netmask and gateway will be retrieved from profile',
        metavar='IP4')
    vm_parser.add_argument('name', metavar='VMNAME', nargs='?')
    vm_parser.set_defaults(func=vm)
    args = parser.parse_args()
    if args.func.func_name != 'bootstrap':
        config = Kconfig(client=args.client, debug=args.debug)
        if args.client != 'all' and not config.enabled:
            common.pprint("Disabled hypervisor.Leaving...", color='red')
            os._exit(1)
        args.func(args)
        if args.client != 'all':
            config.k.close()
    else:
        args.func(args)