def esxi_version(self):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
servertype, version = server_obj.get_server_type(),server_obj.get_api_version()
server_obj.disconnect()
return servertype, version
except Exception as e:
print e
def test_vmware_version_vcenter(self):
""" Is the Vmware version at 5.1?"""
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
api = server.get_api_version()
self.assertEqual('5.1', api)
server.disconnect()
def conexion_viserver(self):
self.logger.debug(self)
esxi = VIServer()
esxi.connect(self.creds['ip'], self.creds['user'],
self.creds['pw'], trace_file=self.config.logpysphere)
self.logger.debug("Conectado a %s %s", esxi.get_server_type(),
esxi.get_api_version())
return esxi
def test_vmware_version_vcenter(self):
""" Is the Vmware version at 5.1?"""
server = VIServer()
server.connect(CREDS.get('Vcenter', 'server'),
CREDS.get('Vcenter', 'user'),
CREDS.get('Vcenter', 'pass'))
api = server.get_api_version()
self.assertEqual('5.1', api)
server.disconnect()
def setupConnection(host, user, password):
server = VIServer()
try:
server.connect(host, user, password)
print "Host: " + host
print "Version: " + server.get_server_type() + " " + server.get_api_version() + "\n"
return server
except Exception, err:
print "Cannot connect to host: "+host+" error message: " +err.message
sys.exit(2)
def setupConnection(host, user, password):
server = VIServer()
try:
server.connect(host, user, password)
print "Host: " + host
print "Version: " + server.get_server_type(
) + " " + server.get_api_version() + "\n"
return server
except Exception, err:
print "Cannot connect to host: " + host + " error message: " + err.message
sys.exit(2)
def setupConnection(host, user, password):
server = VIServer()
try:
server.connect(host, user, password)
print "[+] Host: " + host + " Version: " + server.get_server_type(
) + " " + server.get_api_version() + "\n"
closeConnection(server)
return True
except Exception, err:
print "[-] Cannot connect to host: " + host + " error message: " + err.message
return None
class ESXiHostClass:
def __init__(self, host, user, passwd):
self._connection = VIServer()
logger.info("%s:connecting to '%s' as '%s'", __name__, host, user)
try:
ssl._create_default_https_context = ssl._create_unverified_context
self._connection.connect(host, user, passwd)
logger.debug("%s:host reports '%s V.%s'", __name__,
self._connection.get_server_type(), self._connection.get_api_version())
self.host_config, n, n, n = self._get_host_config()
except Exception, err:
logger.critical("%s:%s", __name__, err)
quit(2)
def vConnect(VIHost, VIUser, VIPassword):
"""Verbindungs Funktion zum Server
Baut eine Verbindung mit VCS Server auf und speichert die Verbindungsinformationen in der VISerever variable des Typs "VIServer".
"""
logger.info("Connecting to vSphere: " + VIHost)
VirtualServerInstance = VIServer()
VirtualServerInstance.connect(VIHost, VIUser, VIPassword)
if VirtualServerInstance:
logger.info("Connected to vSphere: " + VIHost)
logger.info(VirtualServerInstance.get_api_type() + " API " + VirtualServerInstance.get_api_version())
return VirtualServerInstance
else:
logger.error("Connection to the vSphere failed.")
sys.exit(2)
def esxi_version(self):
m = Info_log(time.strftime('%Y-%m-%d', time.localtime(time.time())))
log = m.log()
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
servertype, version = server_obj.get_server_type(
), server_obj.get_api_version()
server_obj.disconnect()
return servertype, version, self.flag
except Exception as e:
server_obj.disconnect()
log.info(e)
class VMRUNNer:
def __init__(self, hostname, username, password):
self.server = VIServer()
self.server.connect(hostname, username, password)
def get_vm(self, vm_path_name):
self.vm = self.server.get_vm_by_path(vm_path_name)
return self.vm
def list_vms(self):
vmlist = self.server.get_registered_vms()
for vm in vmlist:
print vm
return vmlist
def get_vmserver_version(self):
type = self.server.get_server_type()
version = self.server.get_api_version()
print 'Server Type: ' + type
print 'Server API Version: ' + version
class VMRUNNer:
def __init__(self, hostname, username, password):
self.server = VIServer()
self.server.connect(hostname, username, password)
def get_vm(self, vm_path_name):
self.vm = self.server.get_vm_by_path(vm_path_name)
return self.vm
def list_vms(self):
vmlist = self.server.get_registered_vms()
for vm in vmlist:
print vm
return vmlist
def get_vmserver_version(self):
type = self.server.get_server_type()
version = self.server.get_api_version()
print 'Server Type: ' + type
print 'Server API Version: ' + version
def setupConnection(host, user, password, release):
global Found
global Fails
try:
server = VIServer()
server.connect(host, user, password)
print "[+] Password Found: " + password
print "[+] Host: " + host + " Version: " + server.get_server_type(
) + " " + server.get_api_version() + "\n"
closeConnection(server)
Found = True
except Exception, err:
if 'read_nonblocking' in str(err):
Fails += 1
time.sleep(5)
connect(host, user, password, False)
elif 'synchronize with original prompt' in str(err):
time.sleep(1)
connect(host, user, password, False)
def main():
if len(sys.argv) <> 3:
print ("Usage:")
print (sys.argv[0], "<username> <password")
username = sys.argv[1]
password = sys.argv[2]
vcenter = "ecnshmw1001.sh.cn.ao.ericsson.se"
server = VIServer()
server.connect( vcenter, username, password )
print ("Login .....")
type = server.get_api_type()
version = server.get_api_version()
print ("You are now connecting with {0} with API version {1}".format(type, version))
select(server)
server.disconnect()
'No command line password received, requesting password from user')
password = getpass.getpass(
prompt='Enter password for vCenter %s for user %s: ' %
(servervctr, username))
# Connecting to server
logger.info('Connecting to server %s with username %s' %
(servervctr, username))
server = VIServer()
try:
logger.debug('Trying to connect with provided credentials')
server.connect(servervctr, username, password)
logger.info('Connected to server %s' % servervctr)
logger.debug('Server type: %s' % server.get_server_type())
logger.debug('API version: %s' % server.get_api_version())
except VIException as ins:
logger.error(ins)
logger.debug('Loggin error. Program will exit now.')
sys.exit()
if dcname is None:
logger.error('No datacenter name. Progam will exit now.')
sys.exit()
# Setting up properties
logger.debug('Getting properties to query')
properties = create_vm_props()
logger.debug('First set of properties: %s' % properties)
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
Args:
hostname: The hostname of the system.
username: The username to connect with.
password: The password to connect with.
Returns: A :py:class:`VMWareSystem` object.
"""
_api = None
_stats_available = {
'num_vm': lambda self: len(self.list_vm()),
'num_host': lambda self: len(self.list_host()),
'num_cluster': lambda self: len(self.list_cluster()),
'num_template': lambda self: len(self.list_template()),
'num_datastore': lambda self: len(self.list_datastore()),
}
def __init__(self, hostname, username, password, **kwargs):
self.hostname = hostname
self.username = username
self.password = password
self.api = VIServer()
@property
def api(self):
# wrap calls to the API with a keepalive check, reconnect if needed
try:
keepalive = self._api.keep_session_alive()
if not keepalive:
logger.debug('The connection to %s "%s" timed out' %
(type(self).__name__, self.hostname))
except VIException as ex:
if ex.fault == "Not Connected":
# set this to trigger a connection below
keepalive = None
else:
raise
if not keepalive:
self._connect()
return self._api
@api.setter
def api(self, api):
# Allow for changing the api object via public setter
self._api = api
def _connect(self):
# Since self.api calls _connect, connect via self._api to prevent implosion
logger.debug('Connecting to %s "%s"' % (type(self).__name__, self.hostname))
self._api.connect(self.hostname, self.username, self.password)
def _get_vm(self, vm_name=None):
""" Returns a vm from the VI object.
Args:
vm_name: The name of the VM.
Returns: a pysphere object.
"""
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def does_vm_exist(self, name):
""" Checks if a vm exists or not.
Args:
name: The name of the requested vm.
Returns: A boolean, ``True`` if the vm exists, ``False`` if not.
"""
try:
self._get_vm(name)
return True
except Exception:
return False
def _get_resource_pool(self, resource_pool_name=None):
""" Returns a resource pool MOR for a specified name.
Args:
resource_pool_name: The name of the resource pool.
Returns: The MOR of the resource pool.
"""
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def get_ip_address(self, vm_name):
""" Returns the first IP address for the selected VM.
Args:
vm_name: The name of the vm to obtain the IP for.
Returns: A string containing the first found IP that isn't the loopback device.
"""
vm = self._get_vm(vm_name)
try:
net_info, tc = wait_for(vm.get_property, ['net', False],
fail_condition=None, delay=5, num_sec=600,
message="get_ip_address from vsphere")
except TimedOutError:
net_info = None
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def _get_list_vms(self, get_template=False):
""" Obtains a list of all VMs on the system.
Optional flag to obtain template names too.
Args:
get_template: A boolean describing if it should return template names also.
Returns: A list of VMs.
"""
template_or_vm_list = []
props = self.api._retrieve_properties_traversal(property_names=['name', 'config.template'],
from_node=None,
obj_type=MORTypes.VirtualMachine)
for prop in props:
vm = None
template = None
for elem in prop.PropSet:
if elem.Name == "name":
vm = elem.Val
elif elem.Name == "config.template":
template = elem.Val
if vm is None or template is None:
continue
if template == bool(get_template):
template_or_vm_list.append(vm)
return template_or_vm_list
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError('This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self):
return self._get_list_vms()
def list_template(self):
return self._get_list_vms(get_template=True)
def list_flavor(self):
raise NotImplementedError('This function is not supported on this platform.')
def list_host(self):
return self.api.get_hosts()
def list_datastore(self):
return self.api.get_datastores()
def list_cluster(self):
return self.api.get_clusters()
def info(self):
return '%s %s' % (self.api.get_server_type(), self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self):
raise NotImplementedError('clone_vm not implemented.')
def deploy_template(self, template, *args, **kwargs):
if 'resourcepool' not in kwargs:
kwargs['resourcepool'] = None
vm = self._get_vm(template)
if vm:
vm.clone(kwargs['vm_name'], sync_run=True,
resourcepool=self._get_resource_pool(kwargs['resourcepool']))
return kwargs['vm_name']
else:
raise Exception('Could not clone %s' % template)
def remove_host_from_cluster(self, hostname):
req = VI.DisconnectHost_TaskRequestMsg()
mor = (key for key, value in self.api.get_hosts().items() if value == hostname).next()
sys = VIMor(mor, 'HostSystem')
_this = req.new__this(sys)
_this.set_attribute_type(sys.get_attribute_type())
req.set_element__this(_this)
task_mor = self.api._proxy.DisconnectHost_Task(req)._returnval
t = VITask(task_mor, self.api)
wait_for(lambda: 'success' in t.get_state())
self._destroy_host(hostname)
def _destroy_host(self, hostname):
req = VI.Destroy_TaskRequestMsg()
mor = (key for key, value in self.api.get_hosts().items() if value == hostname).next()
sys = VIMor(mor, 'HostSystem')
_this = req.new__this(sys)
_this.set_attribute_type(sys.get_attribute_type())
req.set_element__this(_this)
task_mor = self.api._proxy.Destroy_Task(req)._returnval
t = VITask(task_mor, self.api)
wait_for(lambda: 'success' in t.get_state())
for s in envs:
try:
print(" Env: %s, vSphere Server: %s" %(s.upper(), urls[s]['suffix']))
except Exception, e:
continue
try:
server = VIServer()
server.connect(r"%s" %urls[s]['suffix'], urls[s]['user'], urls[s]['pswrd'])
except Exception, e:
print(Fore.RED + Style.BRIGHT + " %s" %str(e))
print
try:
print(Fore.GREEN + Style.BRIGHT + " Server Type: %s" %server.get_server_type())
print(Fore.GREEN + Style.BRIGHT + " API Version: %s" %server.get_api_version())
except Exception, e:
print(Fore.RED + Style.BRIGHT + " %s" %str(e))
print
try:
lstvms = server.get_registered_vms()
except Exception, e:
print(Fore.RED + Style.BRIGHT + " %s" %str(e))
print
for k in lnxrls:
hstlst = []
for v in lstvms:
hstnme = v.split()[1].split('/')[0].lower()
if hstnme.startswith(lnxrls[k]['role']):
Install:
pip install pysphere
"""
from pysphere import VIServer
server = VIServer()
server.connect("serverip","adminuser","pass")
#Get server characteristics
print server.get_server_type()
print server.get_api_version()
print server.get_clusters()
print server._get_resource_pools
#Get all the hosts
print server.get_hosts()
#Get VM`s in Prod resource pool which are in poweredon state
vmachines = server.get_registered_vms()
vmachines = server.get_registered_vms(resource_pool='Prod', status='poweredOn')
#Get virtual machine status
vm1 = server.get_vm_by_name('rhel5.3_prod')
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
"""
_stats_available = {
'num_vm': lambda self: len(self.list_vm()),
'num_host': lambda self: len(self.list_host()),
'num_cluster': lambda self: len(self.list_cluster()),
'num_template': lambda self: len(self.list_template()),
'num_datastore': lambda self: len(self.list_datastore()),
}
def __init__(self, hostname, username, password, **kwargs):
self.api = VIServer()
self.api.connect(hostname, username, password)
def _get_vm(self, vm_name=None):
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def does_vm_exist(self, name):
try:
self._get_vm(name)
return True
except Exception:
return False
def _get_resource_pool(self, resource_pool_name=None):
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def get_ip_address(self, vm_name):
vm = self._get_vm(vm_name)
maxwait = 600
net_info = None
waitcount = 0
while net_info is None:
if waitcount > maxwait:
break
net_info = vm.get_property('net', False)
waitcount += 5
time.sleep(5)
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def _get_list_vms(self, get_template=False):
template_or_vm_list = []
props = self.api._retrieve_properties_traversal(
property_names=['name', 'config.template'],
from_node=None,
obj_type=MORTypes.VirtualMachine)
for prop in props:
vm = None
template = None
for elem in prop.PropSet:
if elem.Name == "name":
vm = elem.Val
elif elem.Name == "config.template":
template = elem.Val
if vm is None or template is None:
continue
if template == bool(get_template):
template_or_vm_list.append(vm)
return template_or_vm_list
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError(
'This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self):
return self._get_list_vms()
def list_template(self):
return self._get_list_vms(get_template=True)
def list_flavor(self):
raise NotImplementedError(
'This function is not supported on this platform.')
def list_host(self):
return self.api.get_hosts()
def list_datastore(self):
return self.api.get_datastores()
def list_cluster(self):
return self.api.get_clusters()
def info(self):
return '%s %s' % (self.api.get_server_type(),
self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' %
vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self):
raise NotImplementedError('clone_vm not implemented.')
def deploy_template(self, template, *args, **kwargs):
if 'resourcepool' not in kwargs:
kwargs['resourcepool'] = None
vm = self._get_vm(template)
if vm:
vm.clone(kwargs['vm_name'],
sync_run=True,
resourcepool=self._get_resource_pool(
kwargs['resourcepool']))
return kwargs['vm_name']
else:
raise Exception('Could not clone %s' % template)
logger.debug(
'No command line password received, requesting 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 = VIServer()
try:
logger.debug('Trying to connect with provided credentials')
con.connect(server, username, password)
logger.info('Connected to server %s' % server)
logger.debug('Server type: %s' % con.get_server_type())
logger.debug('API version: %s' % con.get_api_version())
except VIException as ins:
logger.error(ins)
logger.debug('Loggin error. Program will exit now.')
sys.exit()
# Setting up vars
datacenters = None
clusters = None
hosts = None
datastores = None
vms = None
try:
# Getting datacenters
logger.debug('Getting datastores')
def getserver_type_api():
"""Display's the server type(vCenter or ESX) and also the VMWare API version"""
s = VIServer()
print 'Server Type: ', s.get_server_type()
print 'API Version: ', s.get_api_version()
server = args.server[0]
template = args.template[0]
username = args.username[0]
verbose = args.verbose
maxwait = args.maxwait[0]
# Asking Users password for server
password = getpass.getpass(prompt="Enter password for vCenter %s for user %s: " % (server, username))
# Connecting to server
print_verbose("Connecting to server %s with username %s" % (server, username))
con = VIServer()
con.connect(server, username, password)
print_verbose("Connected to server %s" % server)
print_verbose("Server type: %s" % con.get_server_type())
print_verbose("API version: %s" % con.get_api_version())
# Verify the template exists
print_verbose("Finding template %s" % template)
template_vm = find_vm(template)
if template_vm is None:
print "ERROR: %s not found" % template
sys.exit(1)
print_verbose("Template %s found" % template)
# Verify the target Resource Pool exists
resource_pool_mor = None
if resource_pool is not None:
print_verbose("Finding resource pool %s" % resource_pool)
resource_pool_mor = find_resource_pool(resource_pool)
if resource_pool_mor is None:
except Exception, e:
continue
try:
server = VIServer()
server.connect(r"%s" % urls[s]['suffix'], urls[s]['user'],
urls[s]['pswrd'])
except Exception, e:
print(Fore.RED + Style.BRIGHT + " %s" % str(e))
print
try:
print(Fore.GREEN + Style.BRIGHT +
" Server Type: %s" % server.get_server_type())
print(Fore.GREEN + Style.BRIGHT +
" API Version: %s" % server.get_api_version())
except Exception, e:
print(Fore.RED + Style.BRIGHT + " %s" % str(e))
print
try:
lstvms = server.get_registered_vms()
except Exception, e:
print(Fore.RED + Style.BRIGHT + " %s" % str(e))
print
for k in lnxrls:
hstlst = []
for v in lstvms:
hstnme = v.split()[1].split('/')[0].lower()
if hstnme.startswith(lnxrls[k]['role']):
Install:
pip install pysphere
"""
from pysphere import VIServer
server = VIServer()
server.connect("serverip", "adminuser", "pass")
#Get server characteristics
print server.get_server_type()
print server.get_api_version()
print server.get_clusters()
print server._get_resource_pools
#Get all the hosts
print server.get_hosts()
#Get VM`s in Prod resource pool which are in poweredon state
vmachines = server.get_registered_vms()
vmachines = server.get_registered_vms(resource_pool='Prod', status='poweredOn')
#Get virtual machine status
vm1 = server.get_vm_by_name('rhel5.3_prod')
cur = db.cursor()
property_names = ['name', 'guest.toolsVersion', 'config.files.vmPathName']
serverVMToolVersion = {}
count = 0
clusters = {'10.127.209.21': 1, '10.95.209.21': 2, '10.64.211.139': 3}
for ip in clusters:
print ip
server = VIServer()
server.connect(ip, "nys\dnovicoff", "pitIfu12345")
serverType = server.get_server_type()
print serverType
serverAPI = server.get_api_version()
print serverAPI
vmlist = server.get_registered_vms()
properties = server._retrieve_properties_traversal(
property_names=property_names, obj_type="VirtualMachine")
for propset in properties:
vmToolsVersion = ""
vmPropPath = ""
host = ""
for prop in propset.PropSet:
if prop.Name == "name":
host = prop.Val
elif prop.Name == "guest.toolsVersion":
vmToolsVersion = prop.Val
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))
logger.debug(password)
# Connecting to server
logger.info('Connecting to server %s with username %s' % (server,username))
con = VIServer()
try:
logger.debug('Trying to connect with provided credentials')
con.connect(server,username,password)
logger.info('Connected to server %s' % server)
logger.debug('Server type: %s' % con.get_server_type())
logger.debug('API version: %s' % con.get_api_version())
except VIException as ins:
logger.error(ins)
logger.debug('Loggin error. Program will exit now.')
sys.exit()
try:
# Getting VM object
vm = find_vm(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()
class EsxiController(object):
def __init__(self, servername=None, password=None, username='******'):
# Initialize viserver
self.vi_server = VIServer()
# Specify excluding VMs' preffix
self.p = re.compile('xx|yy', re.I)
self.class_name = self.__class__.__name__
self.servername = servername
self.username = username
self.password = password
self.vmlist = []
self.vmstatusdict = {}
self.inUse_vmstatusdict = {}
self.vmfullnamelist = {}
self.inUse_vmfullnamelist = {}
self.vmdict = {}
self.inUseDict = {}
def connect(self):
logging.debug('connecting to %s' % self.servername)
try:
self.vi_server.connect(self.servername,
self.username,
self.password,
trace_file='/tmp/esxi_debug.txt')
except BaseException as e:
logging.debug('Can not connect to %s: %s' % (self.servername, e))
# sys.exit(1)
else:
if self.vi_server.is_connected():
logging.debug('connected to %s successfully' % self.servername)
logging.debug('Currently server version is: %s %s' %
(self.vi_server.get_server_type(),
self.vi_server.get_api_version()))
def disconnect(self):
self.vi_server.disconnect()
logging.debug('To disconnect from server %s\n' % self.servername)
def get_vmlist(self):
self.vmlist = self.vi_server.get_registered_vms()
return self.vmlist
def get_vmstatus(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmstatus = vm.get_status()
vmname = vminfo['name']
self.vmstatusdict[vmname] = vmstatus
return self.vmstatusdict
def get_inuse_vmstatus(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmstatus = vm.get_status()
vmname = vminfo['name']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.inUse_vmstatusdict[vmname] = vmstatus
return self.inUse_vmstatusdict
def get_vmnamelist(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmfullnameinfo = vminfo['guest_full_name']
self.vmfullnamelist[vmname] = vmfullnameinfo
return self.vmfullnamelist
def get_inuse_vmnamelist(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmfullnameinfo = vminfo['guest_full_name']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.inUse_vmfullnamelist[vmname] = vmfullnameinfo
return self.inUse_vmfullnamelist
def get_inuse_vmdict(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.vmdict[vmname] = vmpath
return self.vmdict
def power_off_all(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
if not vm.is_powered_off():
logging.debug('%s is powered on, now doing power off' % vmPath)
vm.power_off()
def power_on_all(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
if not vm.is_powered_on():
logging.debug('%s is powered off, now doing power on' % vmPath)
vm.power_on()
def power_on_in_use(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None and not vm.is_powered_on():
logging.debug('%s is powered off, now doing power on' % vmname)
vm.power_on()
def power_off_in_use(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None and not vm.is_powered_off():
logging.debug('%s is powered on, now doing power off' % vmname)
vm.power_off()
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
"""
def __init__(self, hostname, username, password, **kwargs):
self.api = VIServer()
self.api.connect(hostname, username, password)
def _get_vm(self, vm_name=None):
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def _get_resource_pool(self, resource_pool_name=None):
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def _find_ip(self, vm):
maxwait = 600
net_info = None
waitcount = 0
while net_info is None:
if waitcount > maxwait:
break
net_info = vm.get_property('net', False)
waitcount += 5
time.sleep(5)
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError('This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self, **kwargs):
vm_list = self.api.get_registered_vms(**kwargs)
# The vms come back in an unhelpful format, so run them through a regex
# Example vm name: '[datastore] vmname/vmname.vmx'
def vm_name_generator():
for vm in vm_list:
match = re.match(r'\[.*\] (.*)/\1\..*', vm)
if match:
yield match.group(1)
# Unroll the VM name generator, and sort it to be more user-friendly
return sorted(list(vm_name_generator()))
def info(self):
return '%s %s' % (self.api.get_server_type(), self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self, source_name, vm_name, resourcepool=None):
vm = self._get_vm(source_name)
if vm:
clone = vm.clone(vm_name, sync_run=True,
resourcepool=self._get_resource_pool(resourcepool))
return self._find_ip(clone)
else:
raise Exception('Could not clone %s' % source_name)
#!/usr/bin/python
import os
from pysphere import VIServer
server = VIServer()
server.connect("172.16.1.215", "root", "password", trace_file="debug.txt")
print "Server Type : "+server.get_server_type()
print "Server API version : "+server.get_api_version()
vmlist = server.get_registered_vms()
print "List of registered VM's :", vmlist
vm1 = server.get_vm_by_path(vmlist[0])
print "Current status", vm1.get_status(basic_status=True)
print "Is the VM powering ON? :", vm1.is_powering_on()
print "Is the VM powering OFF? :", vm1.is_powering_off()
properties = vm1.get_properties()
#print properties
print "Guest ID of the VM :", vm1.get_property('guest_id')
if vm1.get_status(basic_status=True) !="POWERED ON":
print "Powering on the VM :", vm1.power_on()
else:
print "VM is already POWERED ON"
print "Current status", vm1.get_status(basic_status=True)
server.disconnect()
from pysphere import VIServer host_ip = "200.200.173.45" username = "******" passwd = "admin123." server_obj = VIServer() server_obj.connect(host=host_ip,user=username,password=passwd) # 可以连接esxi主机，也可以连接vcenter # 获取连接的对象类型 print server_obj.get_server_type() # 获取esxi的版本信息 print server_obj.get_api_version() # 获取vcenter下的虚拟机的列表，可以带很多的参数，具体看方法的帮助 vm_list = server_obj.get_registered_vms() # 关闭连接 server_obj.disconnect() # 获取虚拟机的状态信息 # 通过路径获取vm的实例 vm1 = server_obj.get_vm_by_path() # 通过名称获取vm的实例
def main(options):
global host_vms
LOGGER.debug("Options: {0}".format(options))
LOGGER.debug("Args: {0}".format(args))
#check for senseful inputs
if not options.vcServer or not options.satServer:
LOGGER.error("You need to specify at least Satellite and vCenter hostnames!")
exit(1)
#get Satellite and vCenter credentials
if options.dryrun: LOGGER.info("I'm only doing a simulation, I promise!")
(satUsername, satPassword) = get_credentials("Satellite", options.satAuthfile)
(vcUsername, vcPassword) = get_credentials("Virtualization", options.vcAuthfile)
#connect to vCenter
myVC = VIServer()
myVC.connect(options.vcServer, vcUsername, vcPassword)
#connect to Satellite
satellite_url = "http://{0}/rpc/api".format(options.satServer)
mySat = xmlrpclib.Server(satellite_url, verbose=options.debug)
key = mySat.auth.login(satUsername, satPassword)
check_if_api_is_supported(mySat)
#print information about host
LOGGER.info("Connected to " + options.vcServer + " (" + myVC.get_server_type() + "), version " + myVC.get_api_version() + ".")
#get list of all ESXi hosts by datacenter
LOGGER.info("Searching for ESXi hosts by datacenter...")
esxiHosts = myVC.get_hosts()
datacenters = myVC.get_datacenters()
for dc in datacenters:
tempHosts = myVC.get_hosts(from_mor=dc).values()
hosts_by_dc[datacenters.get(dc)] = (tempHosts)
LOGGER.debug("Hosts by DC: " + str(hosts_by_dc))
#get list of all ESXi hosts by cluster
LOGGER.info("Searching for ESXi hosts by cluster...")
clusters = myVC.get_clusters()
for cluster in clusters:
tempHosts = myVC.get_hosts(from_mor=cluster).values()
hosts_by_cluster[clusters.get(cluster)] = (tempHosts)
LOGGER.debug("Hosts by cluster: " + str(hosts_by_cluster))
#get list of all VMs by ESXi host
for dc in datacenters:
for host in hosts_by_dc[datacenters.get(dc)]:
LOGGER.debug("Found ESXi host '" + host + "'")
host_vms[host]=[]
LOGGER.debug("Added hosts to dict: " + str(host_vms))
#get list of all Linux VMs managed by Satellite
satlist = mySat.system.listSystems(key)
target_vms=[]
LOGGER.info("Digging through list of systems managed by Satellite...")
for system in satlist:
LOGGER.debug("Found system '" + system["name"] + "'")
#get custom keys
thisKeys = mySat.system.getCustomValues(key, system["id"])
#add virt_vmname if given
if "SYSTEM_VIRT_VMNAME" in thisKeys and thisKeys["SYSTEM_VIRT_VMNAME"] != "":
target_vms.append(thisKeys["SYSTEM_VIRT_VMNAME"])
else: target_vms.append(system)
LOGGER.debug("VM names: " + str(target_vms))
#get list of all VMs and assign to host dicts
LOGGER.info("Getting list of all VMs and assign them to host arrays - grab some coffee.")
vmlist = myVC.get_registered_vms()
counter=0
hit=0
for vm in vmlist:
#get VM and its properties
thisVM = myVC.get_vm_by_path(vm)
#only add if in target_vms
if thisVM.properties.name in target_vms:
LOGGER.debug("Found VM managed by Satellite: '" + thisVM.properties.name + "'")
host_vms[thisVM.properties.runtime.host.name].append(thisVM.properties.name)
else: LOGGER.debug("'" + thisVM.properties.name + "' dropped as it is not managed by Satellite")
LOGGER.debug("Current array for host '" + thisVM.properties.runtime.host.name + "': " + str(host_vms[thisVM.properties.runtime.host.name]))
#show progress
if hit == 9:
LOGGER.info("Checked " + str(counter+1) + " of " + str(len(vmlist)) + " VMs so far...")
hit=0
else: hit=(hit+1)
counter=(counter+1)
LOGGER.debug("Added VMs to host dicts: " + str(host_vms))
#get list of all Linux VMs managed by Satellite
satlist = mySat.system.listSystems(key)
LOGGER.info("Updating relevant system custom info keys...")
for system in satlist:
LOGGER.debug("Found system '" + system["name"] + "'")
#get custom keys
thisKeys = mySat.system.getCustomValues(key, system["id"])
#update key if exists
if "SYSTEM_VIRT_HOST" in thisKeys and thisKeys["SYSTEM_VIRT_HOST"] != "":
#get ESXi host running VM
if "SYSTEM_VIRT_VMNAME" in thisKeys and thisKeys["SYSTEM_VIRT_VMNAME"] != "":
this_ESXi = get_ESXi_host_by_vm(thisKeys["SYSTEM_VIRT_VMNAME"])
else: this_ESXi = get_ESXi_host_by_vm(system["name"])
#get cluster if applicable
this_cluster = get_cluster_by_ESXi_host(this_ESXi)
#update custom key
if this_cluster != "":
#cluster
this_value = "vpx://" + options.vcServer + "/" + get_datacenter_by_ESXi_host(this_ESXi) + "/" + this_cluster + "/" + this_ESXi
else:
#no cluster
this_value = "vpx://" + options.vcServer + "/" + get_datacenter_by_ESXi_host(this_ESXi) + "/" + this_ESXi
if options.vcVerify == False: this_value = this_value + "?no_verify=1"
if options.dryrun:
if this_ESXi != "": LOGGER.info("I'd like to set SYSTEM_VIRT_HOST='" + this_value + "' for system '" + system["name"] + "' (ID " + str(system["id"]) + ")")
else: LOGGER.error("No valid virt host entry for system '" + system["name"] + "' (ID " + str(system["id"]) + ") found!")
else:
#update customkey if not null
if this_ESXi != "":
if mySat.system.setCustomValues(key, system["id"], {"SYSTEM_VIRT_HOST": this_value}):
LOGGER.info("Updated virtual host entry for system '" + system["name"] + "' (ID " + str(system["id"]) + ").")
else: LOGGER.error("No valid virt host entry for system '" + system["name"] + "' (ID " + str(system["id"]) + ") found!")
'verbose': False # optional, defaults to False
}
vmindex = {}
server = VIServer()
default_context = ssl._create_default_https_context
try:
ssl._create_default_https_context = ssl._create_unverified_context
server.connect(esxurl, esxiserver['username'], esxiserver['password'])
finally:
##DO NOT DO the following line or else you'll get "ssl.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed" error
##ssl._create_default_https_context = default_context
print "vserver: AFTER CONNECTION - [{}] [{}]".format(server.get_server_type(), server.get_api_version())
def initargs():
""" initialize variables with command-line arguments """
parser = argparse.ArgumentParser(description='input -f [file]')
parser.add_argument('-s', '--shutdown', \
help='Shutdown ESX host', \
action='store_true')
parser.add_argument('-o', '--on', \
help='Start Machines')
arg = parser.parse_args()
return arg
def poweronvm(vmpath):
# Asking Users password for server
if password is None:
logger.debug('No command line password received, requesting password from user')
password = getpass.getpass(prompt='Enter password for vCenter %s for user %s: ' % (servervctr,username))
# Connecting to server
logger.info('Connecting to server %s with username %s' % (servervctr,username))
server = VIServer()
try:
logger.debug('Trying to connect with provided credentials')
server.connect(servervctr,username,password)
logger.info('Connected to server %s' % servervctr)
logger.debug('Server type: %s' % server.get_server_type())
logger.debug('API version: %s' % server.get_api_version())
except VIException as ins:
logger.error(ins)
logger.debug('Loggin error. Program will exit now.')
sys.exit()
if dcname is None:
logger.error('No datacenter name. Progam will exit now.')
sys.exit()
# Setting up properties
logger.debug('Getting properties to query')
properties = create_vm_props()
logger.debug('First set of properties: %s' %properties)
def setupConnection(host, user, password, release):
global Found
global Fails
try:
server = VIServer()
server.connect(host, user, password)
print "[+] Password Found: " +password
print "[+] Host: " + host + " Version: " + server.get_server_type() + " " + server.get_api_version() + "\n"
closeConnection(server)
Found = True
except Exception, err:
if 'read_nonblocking' in str(err):
Fails += 1
time.sleep(5)
connect(host, user, password, False)
elif 'synchronize with original prompt' in str(err):
time.sleep(1)
connect(host, user, password, False)
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))
logger.debug(password)
# Connecting to server
logger.info("Connecting to server %s with username %s" % (server, username))
con = VIServer()
try:
logger.debug("Trying to connect with provided credentials")
con.connect(server, username, password)
logger.info("Connected to server %s" % server)
logger.debug("Server type: %s" % con.get_server_type())
logger.debug("API version: %s" % con.get_api_version())
except VIException as ins:
logger.error(ins)
logger.debug("Loggin error. Program will exit now.")
sys.exit()
try:
# Getting VM object
vm = find_vm(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()
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
"""
_stats_available = {
'num_vm': lambda self: len(self.list_vm()),
'num_host': lambda self: len(self.list_host()),
'num_cluster': lambda self: len(self.list_cluster()),
'num_template': lambda self: len(self.list_template()),
'num_datastore': lambda self: len(self.list_datastore()),
}
def __init__(self, hostname, username, password, **kwargs):
self.api = VIServer()
self.api.connect(hostname, username, password)
def _get_vm(self, vm_name=None):
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def does_vm_exist(self, name):
try:
self._get_vm(name)
return True
except Exception:
return False
def _get_resource_pool(self, resource_pool_name=None):
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def get_ip_address(self, vm_name):
vm = self._get_vm(vm_name)
maxwait = 600
net_info = None
waitcount = 0
while net_info is None:
if waitcount > maxwait:
break
net_info = vm.get_property('net', False)
waitcount += 5
time.sleep(5)
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def _get_list_vms(self, get_template=False):
template_or_vm_list = []
props = self.api._retrieve_properties_traversal(property_names=['name', 'config.template'],
from_node=None,
obj_type=MORTypes.VirtualMachine)
for prop in props:
vm = None
template = None
for elem in prop.PropSet:
if elem.Name == "name":
vm = elem.Val
elif elem.Name == "config.template":
template = elem.Val
if vm is None or template is None:
continue
if template == bool(get_template):
template_or_vm_list.append(vm)
return template_or_vm_list
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError('This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self):
return self._get_list_vms()
def list_template(self):
return self._get_list_vms(get_template=True)
def list_flavor(self):
raise NotImplementedError('This function is not supported on this platform.')
def list_host(self):
return self.api.get_hosts()
def list_datastore(self):
return self.api.get_datastores()
def list_cluster(self):
return self.api.get_clusters()
def info(self):
return '%s %s' % (self.api.get_server_type(), self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' % vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self):
raise NotImplementedError('clone_vm not implemented.')
def deploy_template(self, template, *args, **kwargs):
if 'resourcepool' not in kwargs:
kwargs['resourcepool'] = None
vm = self._get_vm(template)
if vm:
vm.clone(kwargs['vm_name'], sync_run=True,
resourcepool=self._get_resource_pool(kwargs['resourcepool']))
return kwargs['vm_name']
else:
raise Exception('Could not clone %s' % template)
class VMWareSystem(MgmtSystemAPIBase):
"""Client to Vsphere API
This class piggy backs off pysphere.
Benefits of pysphere:
- Don't need intimate knowledge w/ vsphere api itself.
Detriments of pysphere:
- Response often are not detailed enough.
"""
def __init__(self, hostname, username, password, **kwargs):
self.api = VIServer()
self.api.connect(hostname, username, password)
def _get_vm(self, vm_name=None):
if vm_name is None:
raise Exception('Could not find a VM named %s.' % vm_name)
else:
try:
vm = self.api.get_vm_by_name(vm_name)
return vm
except VIException as ex:
raise Exception(ex)
def _get_resource_pool(self, resource_pool_name=None):
rps = self.api.get_resource_pools()
for mor, path in rps.iteritems():
if re.match('.*%s' % resource_pool_name, path):
return mor
# Just pick the first
return rps.keys()[0]
def _find_ip(self, vm):
maxwait = 600
net_info = None
waitcount = 0
while net_info is None:
if waitcount > maxwait:
break
net_info = vm.get_property('net', False)
waitcount += 5
time.sleep(5)
if net_info:
ipv4_re = r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
for ip in net_info[0]['ip_addresses']:
if re.match(ipv4_re, ip) and ip != '127.0.0.1':
return ip
return None
def start_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
return True
else:
vm.power_on()
ack = vm.get_status()
if ack == 'POWERED ON':
return True
return False
def stop_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
return True
else:
vm.power_off()
ack = vm.get_status()
if ack == 'POWERED OFF':
return True
return False
def delete_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_on():
self.stop_vm(vm_name)
# When pysphere moves up to 0.1.8, we can just do:
# vm.destroy()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
rtn = self.api._proxy.Destroy_Task(request)._returnval
task = VITask(rtn, self.api)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
return True
else:
return False
def create_vm(self, vm_name):
raise NotImplementedError(
'This function has not yet been implemented.')
def restart_vm(self, vm_name):
if not self.stop_vm(vm_name):
return False
else:
return self.start_vm(vm_name)
def list_vm(self, **kwargs):
vm_list = self.api.get_registered_vms(**kwargs)
# The vms come back in an unhelpful format, so run them through a regex
# Example vm name: '[datastore] vmname/vmname.vmx'
def vm_name_generator():
for vm in vm_list:
match = re.match(r'\[.*\] (.*)/\1\..*', vm)
if match:
yield match.group(1)
# Unroll the VM name generator, and sort it to be more user-friendly
return sorted(list(vm_name_generator()))
def info(self):
return '%s %s' % (self.api.get_server_type(),
self.api.get_api_version())
def disconnect(self):
self.api.disconnect()
def vm_status(self, vm_name):
state = self._get_vm(vm_name).get_status()
print "vm " + vm_name + " status is " + state
return state
def is_vm_running(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED ON" == state
def is_vm_stopped(self, vm_name):
state = self.vm_status(vm_name)
return "POWERED OFF" == state
def is_vm_suspended(self, vm_name):
state = self.vm_status(vm_name)
return "SUSPENDED" == state
def suspend_vm(self, vm_name):
vm = self._get_vm(vm_name)
if vm.is_powered_off():
raise Exception('Could not suspend %s because it\'s not running.' %
vm_name)
else:
vm.suspend()
return self.is_vm_suspended(vm_name)
def clone_vm(self, source_name, vm_name, resourcepool=None):
vm = self._get_vm(source_name)
if vm:
clone = vm.clone(
vm_name,
sync_run=True,
resourcepool=self._get_resource_pool(resourcepool))
return self._find_ip(clone)
else:
raise Exception('Could not clone %s' % source_name)
vmname = args.vmname[0]
server = args.server[0]
username = args.username[0]
verbose = args.verbose
password = args.password[0]
# Asking Users password for server
#password=getpass.getpass(prompt='Enter password for vCenter %s for user %s: ' % (server,username))
# Connecting to server
print_verbose('Connecting to server %s with username %s' % (server,username))
con = VIServer()
con.connect(server,username,password)
print_verbose('Connected to server %s' % server)
print_verbose('Server type: %s' % con.get_server_type())
print_verbose('API version: %s' % con.get_api_version())
if allvms:
vms = con.get_registered_vms(None, None, None, 'poweredOn', None)
for vmpath in vms:
print_verbose('================================================================================')
vm = con.get_vm_by_path(vmpath)
vmname = vm.get_property('name')
ip = find_ip(vm,ipv6)
if ip:
print '%s : %s' % (vmname,ip)
else:
print 'ERROR: IP for VM %s not found' % vmname
else:
print_verbose('================================================================================')
print_verbose('Trying to find IP for VM %s' % vmname)
def setupConnection(host, user, password):
server = VIServer()
try:
server.connect(host, user, password)
print "[+] Host: " + host + " Version: " + server.get_server_type() + " " + server.get_api_version() + "\n"
closeConnection(server)
return True
except Exception, err:
print "[-] Cannot connect to host: "+host+" error message: " +err.message
return None
