vmware-events.py

#!/usr/bin/env python
from pyVim import connect
from pyVmomi import vim
from pyVmomi import vmodl
from threading import Thread
import tasks
import argparse
import atexit
import logging
import requests
import sys
import time

"""
Per minute table: (Churn_number = 1)
Sleep Time  Resets  Power On  Power Off  Create  Destroy
12s         5       2.5       2.5        2.5     2.5
6s          10      5         5          5       5
1s          60      30        30         30      30

* 6s above appears to be too much and causes miq_queue backup

Per minute table: (Churn_number = 2)
Sleep Time  Resets  Power On  Power Off  Create  Destroy
12s         10      5         5          5       5
6s          20      10        10         10      10
1s          120     60        60         60      60
"""

# Not good, but turn off that warning message
requests.packages.urllib3.disable_warnings()


def create_vms(si, datacenter, churn_number, sleep_time, logger):
    idx = 0
    vm_folder = datacenter.vmFolder
    hosts = datacenter.hostFolder.childEntity
    rp = hosts[0].resourcePool
    while True:
        task = None
        logger.info("Create IDX: {}".format(idx))
        if (idx + churn_number) >= 10000:
            idx = 0
        for i in range(idx, idx + churn_number):
            vm_name = 'b-churn{}'.format(str(i).zfill(4))
            datastore_path = '[GlobalDS_0] ' + vm_name
            vmx_file = vim.vm.FileInfo(logDirectory=None, snapshotDirectory=None, suspendDirectory=None,
            vmPathName=datastore_path)
            vm_uuid = '12345678-abcd-1234-cdef-1234567{}'.format(str(i).zfill(4))
            logger.info('Creating VM: uuid:{} : {}'.format(vm_uuid, vm_name))
            vm_create_config = vim.vm.ConfigSpec(name=vm_name, memoryMB=1024, numCPUs=1, files=vmx_file,
                    guestId='Linux', version='vmx-07', uuid=vm_uuid)
            task = vm_folder.CreateVM_Task(config=vm_create_config, pool=rp)
        time.sleep(sleep_time)
        tasks.wait_for_tasks(si, [task])
        for i in range(idx, idx + churn_number):
            vm_uuid = '12345678-abcd-1234-cdef-1234567{}'.format(str(i).zfill(4))
            logger.info('Destroying VM: uuid:{} : {}'.format(vm_uuid, vm_name))
            vm = None
            while(vm is None):
                vm = si.content.searchIndex.FindByUuid(None, vm_uuid, True, False)
            task = vm.Destroy_Task()
        idx = idx + churn_number
        time.sleep(sleep_time)


def power_vms(vms, churn_number, sleep_time, logger):
    idx = 0
    powered_on = False
    while True:
        logger.info("Power IDX: {}".format(idx))
        if (idx + churn_number) >= len(vms):
            idx = 0
        for i in range(idx, idx + churn_number):
            logger.info("Powering On: vms[{}] : {}".format(i, vms[i].config.name))
            vms[i].PowerOn()
        time.sleep(sleep_time)
        for i in range(idx, idx + churn_number):
            logger.info("Powering Off: vms[{}] : {}".format(i, vms[i].config.name))
            vms[i].PowerOff()
        idx = idx + churn_number
        time.sleep(sleep_time)


def reset_vms(vms, churn_number, sleep_time, logger):
    idx = 0
    while True:
       logger.info("Reset IDX: {}".format(idx))
       if (idx + churn_number) >= len(vms):
           idx = 0
       for i in range(idx, idx + churn_number):
           logger.info("Resetting: vms[{}] : {}".format(i, vms[i].config.name))
           vms[i].ResetVM_Task()
       idx = idx + churn_number
       time.sleep(sleep_time)


def main():
    parser = argparse.ArgumentParser(description='Program used to Clone/Power/Reset VMs on a'
            ' VMware simulator environment.')
    # Environment args:
    parser.add_argument('ip_address', help='VCSIM IP Address')
    parser.add_argument('-p', '--port', dest='port', default=443, type=int,
            help='VCSIM Port, defaults to 443')
    parser.add_argument('-u', '--user', dest='user', default='Administrator@vsphere.local',
            help='VCSIM Username, defaults to Administrator@vsphere.local')
    parser.add_argument('-pwd', dest='password', default='vmware', help='VCSIM Password, defaults'
            ' to vmware')

    # Generate Action args:
    parser.add_argument('-s', '--sleep', dest='sleep_time', default='6', type=int,
            help='Approximate sleep_time between actions on the VCSIM.  A 6 second sleep_time '
            'results in 10 resets per minute, 5 Power On, 5 Power Off that could be increased by '
            'churn. Defaults to 6 seconds.')
    parser.add_argument('-c', '--churn', dest='churn_number', default='1', type=int,
            help='Number of VMs to perform actions against then wait the sleep_time and repeat. '
            'Defaults to 1.')
    args = parser.parse_args()

    # Setup the logger...
    logger = logging.getLogger('vcsim-events')
    logger.setLevel(logging.INFO)
    ch = logging.StreamHandler()
    ch.setLevel(logging.INFO)
    format = logging.Formatter('%(asctime)s : %(levelname)s : %(message)s')
    ch.setFormatter(format)
    logger.addHandler(ch)

    logger.info('--------------------------------------------------------------------------------')
    logger.info('VCSIM IP Address: {}'.format(args.ip_address))
    logger.info('VCSIM Port: {}'.format(args.port))
    logger.info('VCSIM Username: {}'.format(args.user))
    logger.info('VCSIM Password: {}'.format(args.password))
    logger.info('--------------------------------------------------------------------------------')
    logger.info('Sleep Time: {}'.format(args.sleep_time))
    logger.info('Churn: {}'.format(args.churn_number))
    logger.info('--------------------------------------------------------------------------------')

    si = None
    try:
        si = connect.SmartConnect(host=args.ip_address, user=args.user, pwd=args.password,
                port=args.port)
        atexit.register(connect.Disconnect, si)

    except vmodl.MethodFault as error:
        logger.error("Caught vmodl fault : {}".format(error.msg))
        return -1

    content = si.RetrieveContent()
    datacenter = content.rootFolder.childEntity[0]
    vm_folder = datacenter.vmFolder
    vmList = vm_folder.childEntity

    r_vms = []
    p_vms = []
    for vm in vmList:
        if vm.runtime.powerState == "poweredOn":
            r_vms.append(vm)
        elif vm.runtime.powerState == "poweredOff":
            p_vms.append(vm)
    logger.info("VMs for Reset: {}".format(len(r_vms)))
    logger.info("VMs for Power On/Off: {}".format(len(p_vms)))

    c_thread = Thread(target=create_vms, args=(si, datacenter, args.churn_number, args.sleep_time, logger))
    r_thread = Thread(target=reset_vms, args=(r_vms, args.churn_number, args.sleep_time, logger))
    p_thread = Thread(target=power_vms, args=(p_vms, args.churn_number, args.sleep_time, logger))
    c_thread.setDaemon(True)
    r_thread.setDaemon(True)
    p_thread.setDaemon(True)
    c_thread.start()
    r_thread.start()
    p_thread.start()


    while True:
       time.sleep(args.sleep_time + 1)
       logger.info("Running...")
       #if reset_proc.is_alive():
       #    logger.info("Reset Process still alive.")
       #if power_proc.is_alive():
       #    logger.info("Power Process still alive.")


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