Remove a VM by name from ESXI

esxi_remove_vm_by_name.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
##############################################################
#  Remove VM by name on ESXI
#
##############################################################
##############################################################
#  author: Valeriy Solovyov <weldpua2008@gmail.com>
#  version 0.1 <3.11.2015>
#       - initial
##############################################################
from pysphere.resources import VimService_services as VI
from pysphere import VIException
from pysphere import VIServer
from pysphere.vi_task import VITask
import logging
import sys
import argparse
import base64
import getpass
import time


def vm_by_name(name, con):
    """Find vm by name
    :param name:
    :param con:
    :return:
    """
    try:
        vm = con.get_vm_by_name(name)
        logging.debug('Found VM %s' % vm.properties.name)
        return vm
    except VIException:
        return None


def get_vm_by_name_started_with(name, con):
    """get all vm that start with 'name'"""
    vms = []
    vmlist = []
    if len(name) < 5:
        print "get_vm_by_name_started_with: name less then 4 symbols"
        return vmlist
    try:
        vmlist = con.get_registered_vms()
    except Exception as error:
        print error
        sys.exit(126)
    for vm_path in vmlist:
        try:
            vm = con.get_vm_by_path(vm_path)
            vm_name = vm.properties.name
            if vm_name.startswith(name):
                vms.append(vm)
        except Exception as error:
            print "Got an error %s" % error
    return vms

def to_esx(server, username, password):
    con = VIServer()
    try:
        logging.debug('Trying to connect with provided credentials')
        con.connect(server, username, password)
        logging.info('Connected to server %s' % server)
        logging.debug('Server type: %s' % con.get_server_type())
        logging.debug('API version: %s' % con.get_api_version())
    except VIException as ins:
        logging.error(ins)
        logging.debug('Loggin error. Program will exit now.')
        sys.exit()
    return con


def remove_vm(vm, con):
    #Invoke Destroy_Task
    request = VI.Destroy_TaskRequestMsg()
    _this = request.new__this(vm._mor)
    _this.set_attribute_type(vm._mor.get_attribute_type())
    request.set_element__this(_this)
    ret = con._proxy.Destroy_Task(request)._returnval
    task = VITask(ret, con)
    #Wait for the task to finish
    status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
    if status == task.STATE_SUCCESS:
        print "VM successfully unregistered and deleted from datastore"
    elif status == task.STATE_ERROR:
        print "Error removing vm:", task.get_error_message()

def get_args(): # pragma: no cover
    # Creating the argument parser
    parser = argparse.ArgumentParser(
        description="Getting info of VM.")
    parser.add_argument(
        '-s',
        '--server',
        nargs=1,
        required=True,
        help='The vCenter or ESXi server to connect to',
        dest='server',
        type=str)
    parser.add_argument(
        '-u',
        '--user',
        nargs=1,
        required=True,
        help='The username with which to connect to the server',
        dest='username',
        type=str)
    parser.add_argument(
        '-p',
        '--password',
        nargs=1,
        required=False,
        help='The password in plain text with which to connect to the host. If not specified, the user is prompted at runtime for a password.',
        dest='password',
        type=str)
    parser.add_argument(
        '-pe',
        '--password-encrypted',
        nargs=1,
        required=False,
        help='The password encrypted using Base64 with which to connect to the host. ',
        dest='passwordEncrypted',
        type=str)
    parser.add_argument(
        '-m',
        '--vm',
        nargs=1,
        required=True,
        help='The virtual machine (VM)',
        dest='vmname',
        type=str)
    parser.add_argument(
        '-v',
        '--verbose',
        required=False,
        help='Enable verbose output',
        dest='verbose',
        action='store_true')
    parser.add_argument(
        '-d',
        '--debug',
        required=False,
        help='Enable debug output',
        dest='debug',
        action='store_true')
    parser.add_argument(
        '-l',
        '--log-file',
        nargs=1,
        required=False,
        help='File to log to (default = stdout)',
        dest='logfile',
        type=str)

    parser.add_argument(
        '-V',
        '--version',
        action='version',
        version="%(prog)s (version 0.1)")

    # subparsers = parser.add_subparsers(help='commands')
    args = parser.parse_args()
    return args


def run(): # pragma: no cover
    # Notification settings
    args = get_args()
    # argsdict = vars(args)
    server = args.server[0]
    username = args.username[0]
    vmname = args.vmname[0]
    verbose = args.verbose
    debug = args.debug
    log_file = None
    password = None

    if args.password:
        password = args.password[0]
    if args.logfile:
        log_file = args.logfile[0]

    # Logging settings
    if debug:
        log_level = logging.DEBUG
    elif verbose:
        log_level = logging.INFO
    else:
        log_level = logging.WARNING

    #Initializing logger
    if log_file:
        logging.basicConfig(
            filename=log_file,
            format='%(asctime)s %(levelname)s %(message)s',
            level=log_level)
    else:
        logging.basicConfig(

            format='%(asctime)s %(levelname)s %(message)s',
            level=log_level)

    logger = logging.getLogger(__name__)
    logger.debug('logger initialized')
    try:
        logger.debug('Using encrypted password. Decrypting now.')
        if args.passwordEncrypted:
            password = base64.b64decode(args.passwordEncrypted[0])
    except Exception as error:
        logger.error(error)
        logger.debug(
            'Password error. Either this is not an encrypted passowrd or is not well formated.')
        sys.exit()

    # Asking Users password for server
    if password is None:
        logger.debug(
            'No command line password received, requesting plain text password from user.')
        password = getpass.getpass(
            prompt='Enter password for vCenter %s for user %s: ' %
            (server, username))
    # Connecting to server
    logger.info('Connecting to server %s with username %s' % (server, username))
    con = to_esx(
        server=server,
        username=username,
        password=password)
    try:
            # Getting VM object
        vms = get_vm_by_name_started_with(vmname, con)
        for vm in vms:
            # if vm:
            #     logger.info(
            #         'Successfully found %s in %s' %
            #         (vm.get_property('name'), vm.get_property('path')))
            vmname = vm.properties.name
            if not vm.is_powered_off():
                try:
                    vm.power_off()
                    try:
                        while not vm.is_powered_off():
                            time.sleep(1)
                    except Exception as error:
                        print "!!!!!!!!!!!!Catched ERROR %s " % error

                except Exception as error:
                    logger.error(error)
                    con.disconnect()
                    sys.exit(127)
                print "VM '%s' is shutted down " % vmname
            remove_vm(vm, con)
        con.disconnect()
    except VIException as inst:
        logger.error(inst)
        logger.error('An unexpceted error ocurred. Program will be terminated.')
        sys.exit(127)

if __name__ == '__main__':  # pragma: no cover
    run()