Shutdown VM by name on ESXI

esxi_shutdown_vm_by_name.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
##############################################################
#  Shutdown VM by name on ESXI
#
##############################################################
##############################################################
#  author: Valeriy Solovyov <weldpua2008@gmail.com>
#  version 0.1 <3.11.2015>
#       - initial
##############################################################
from pysphere import VIException
from pysphere import VIServer
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 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 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
        vm = vm_by_name(vmname, con)

        if vm:
            logger.info(
                'Successfully found %s in %s' %
                (vm.get_property('name'), vm.get_property('path')))
        else:
            logger.error(
                "Could not find %s, please verify VM's name and try again." %
                vm)
            con.disconnect()
            sys.exit(0)
        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
        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()