def VirtualMachine_List(VIServer, VirtualMachineList):
"""
Listet Virtuelle Maschienen
"""
logger.info("Listing found Virtual Machines using provided information")
logger.info("Virtual Machine count is " + str(len(VirtualMachineList)))
for VirtualMachineEntry in range(len(VirtualMachineList)):
VirtualMachine = VIServer.get_vm_by_path(VirtualMachineList[VirtualMachineEntry])
logger.info("("+ str(VirtualMachineEntry+1) +"/"+ str(len(VirtualMachineList)) +") " + VirtualMachine.get_property("name"))
def revert(datastore):
#vmsphear username and password
server = VIServer()
server.connect("101.91.1.21", "root", "Vsphear_root_password")
vm1 = server.get_vm_by_path(datastore)
print "Cuurrent Status", vm1.get_status()
print "Reverting VM:", datastore
vm1.revert_to_snapshot()
print "Vm reverted"
def revert(datastore):
#vmsphear username and password
server = VIServer()
server.connect("101.91.1.21", "root", "Vsphear_root_password")
vm1 = server.get_vm_by_path(datastore)
print "Cuurrent Status",vm1.get_status()
print "Reverting VM:", datastore
vm1.revert_to_snapshot()
print "Vm reverted"
def VirtualMachine_PowerOff(VIServer, VirtualMachineList):
"""VMs Power Off Funktion
Faehrt VMs mit dem Befehl "Power Off" asyncron runter.
"""
for VirtualMachineEntry in VirtualMachineList:
VirtualMachine = VIServer.get_vm_by_path(VirtualMachineEntry)
if VirtualMachine.is_powered_on():
try:
logger.info("Sending Power-Off signal to " + VirtualMachine.get_property("name"))
VirtualMachine.power_off(sync_run=False)
except:
logger.critical("Power-Off signal failed on " + VirtualMachine.get_property("name"))
def VirtualMachine_Start(VIServer, VirtualMachineList):
"""VMs Start Funktion
Faehrt die OS auf den VMs asyncron hoch.
Wenn die VMWare Tools nich installiert sind, werden die VMs ignoriert und dieser vorfall gelogt.
"""
for VirtualMachineEntry in VirtualMachineList:
VirtualMachine = VIServer.get_vm_by_path(VirtualMachineEntry)
if VirtualMachine.is_powered_off():
try:
logger.info("Sending Power-On signal to " + VirtualMachine.get_property("name"))
VirtualMachine.power_on()
except:
logger.error(VirtualMachine.get_property("name") + " could not be turned on")
def VirtualMachine_Shutdown(VIServer, VirtualMachineList):
"""VMs Shutdown Funktion
Faehrt die OS auf den VMs asyncron runter.
Wenn die VMWare Tools nich installiert sind, werden die VMs mit dem Befehl "Power Off" heruntergefahren.
"""
for VirtualMachineEntry in VirtualMachineList:
VirtualMachine = VIServer.get_vm_by_path(VirtualMachineEntry)
if VirtualMachine.is_powered_on():
try:
logger.info("Sending Guest Shutdown signal to " + VirtualMachine.get_property("name"))
VirtualMachine.shutdown_guest()
except:
logger.error("Problem with VMWare Tools on " + VirtualMachine.get_property("name"))
logger.warn("Switching to Power-Off sequence on " + VirtualMachine.get_property("name"))
VirtualMachine.power_off(sync_run=False)
def start_vm(vcenter_fqdn):
server = VIServer()
vcenter_state = False
end_time = time.time()+600
while time.time() < end_time:
try:
server.connect(vcenter_fqdn, "login", "password")
vm = server.get_vm_by_path("[datastore1] DHCP-server/DHCP-server.vmx")
#vm.power_on()
vcenter_state = True
print vm.get_status()
return
except:
print ("Waiting for vCenter vm to boot...")
time.sleep(10)
if not vcenter_state:
print "Time out waiting for vCenter vm to boot."
kill_vpn()
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 revert_and_start():
try:
for host in get_hosts():
server = VIServer()
server.connect(host.ip, host.user, host.pwd)
for vm_path in host.vms:
try:
vm = server.get_vm_by_path(vm_path.strip())
vm.revert_to_snapshot()
if not vm.is_powered_on():
vm.power_on()
except Exception, e:
print "[ERROR] Error happened when revert and start test lab %s" % vm_path
print e
server.disconnect()
except Exception, e:
print "[ERROR] Error happened when prepare test enviroment(revert and start test labs)."
print e
def revert_and_start():
try:
for host in get_hosts():
server = VIServer()
server.connect(host.ip, host.user, host.pwd)
for vm_path in host.vms:
try:
vm = server.get_vm_by_path(vm_path.strip())
vm.revert_to_snapshot()
if not vm.is_powered_on():
vm.power_on()
except Exception, e:
print "[ERROR] Error happened when revert and start test lab %s" % vm_path
print e
server.disconnect()
except Exception, e:
print "[ERROR] Error happened when prepare test enviroment(revert and start test labs)."
print e
class vSphere:
hostname = ""
username = ""
password = ""
def __init__(self, vm_path):
self.vm_path = vm_path
def __enter__(self):
self.server = VIServer()
self.server.connect(self.hostname, self.username, self.password)
print "DBG connect"
vm = self.server.get_vm_by_path(self.vm_path)
return vm
def __exit__(self, type, value, traceback):
try:
self.server.disconnect()
print "DBG disconnect"
except VIException as e:
print "DBG problem in disconnection. Fault is: %s" % e.fault
pass
class vSphere:
hostname = ""
username = ""
password = ""
def __init__(self, vm_path):
self.vm_path = vm_path
def __enter__(self):
self.server = VIServer()
self.server.connect(self.hostname, self.username, self.password)
print "DBG connect"
vm = self.server.get_vm_by_path(self.vm_path)
return vm
def __exit__(self, type, value, traceback):
try:
self.server.disconnect()
print "DBG disconnect"
except VIException as e:
print "DBG problem in disconnection. Fault is: %s" % e.fault
pass
def get_vms():
"""
Output example:
VM_NAME SO
MYVM01 Microsoft Windows Server 2003 Standard (32-bit)
"""
server = VIServer()
vmlist = {}
for Env in vCenter.keys():
try:
server.connect(vCenter[Env]['host'], vCenter[Env]['user'],
vCenter[Env]['pass'])
except:
print "[x] Error connecting to vCernter server. "
return 1
vm_list = server.get_registered_vms()
for disk_path in vm_list:
vm = server.get_vm_by_path(disk_path)
print(
'%s %s' %
(vm.get_property('name'), vm.get_property('guest_full_name')))
class vSphere:
def __init__(self, vm_path, sdk_host, sdk_user, sdk_domain, sdk_passwd):
self.vm_path = vm_path
self.sdk_host = sdk_host
self.sdk_user = sdk_domain + "\\" + sdk_user
self.sdk_passwd = sdk_passwd
def __enter__(self):
self.server = VIServer()
self.server.connect(self.sdk_host, self.sdk_user, self.sdk_passwd)
if config.verbose:
logging.debug("connected to vSphere")
vm = self.server.get_vm_by_path(self.vm_path)
return vm
def __exit__(self, type, value, traceback):
try:
self.server.disconnect()
if config.verbose:
logging.debug("disconnected from vSphere")
except VIException as e:
logging.debug("Problem in disconnection. Fault is: %s" % e.fault)
pass
class VMWare():
def __init__(self, server, username, password):
self.server = server
self.username = username
self.password = password
self.sserver = VIServer()
self.sserver.connect(self.server, self.username, self.password)
#GETS ALL SHARED VMS
def getRegistered(self):
isConnected(self.sserver)
return self.sserver.get_registered_vms(None, None, None, None)
#SPECIFIC VM GETTER
#NOT RECOMMENDED
def getByName(self, name):
try:
isConnected(self.sserver)
return self.sserver.get_vm_by_name(name)
except:
return None
#RECOMMENDED - Get from getRegistered method
def getByPath(self, path):
try:
isConnected(self.sserver)
return self.sserver.get_vm_by_path(path)
except:
return None
#PROPERTIES AND VARIABLES
#TODO: check this works for windows!?
def getEnvVar(self, name):
try:
isConnected(self.sserver)
machine = self.sserver.get_vm_by_name(name)
return machine.get_environment_variables()
except:
return None
def getStatus(self, name):
try:
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
return machine.get_status()
except:
return None
def getInfo(self, name):
try:
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
x = machine.get_properties()
stat = machine.get_status()
ip = ""
if "ip_address" in x:
ip = x["ip_address"]
ret = {
"ip": ip,
"status": stat,
"memory": x["memory_mb"],
"guest_full_name": x["guest_full_name"]
}
print ret
#print x
return ret
except Exception as e:
print e
return None
#POWER SETTINGS
def machineOn(self, name):
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
machine.power_on()
def machineOff(self, name):
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
machine.power_off()
def reset(self, name):
isConnected(self.sserver)
machien = self.sserver.get_vm_by_path(name)
machine.reset()
#Snapshots
def getSnapshots(self, name):
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
arr = []
for snapshot in machine.get_snapshots():
name = snapshot.get_name()
desc = snapshot.get_description()
create = snapshot.get_create_time()
state = snapshot.get_state()
path = snapshot.get_path()
arr.append({
"name": name,
"desc": desc,
"create": create,
"state": state,
"path": path
#"parent": parent,
#"children": children
})
return json.dumps(arr)
def createSnapShot(self, name, snap, desc):
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
machine.create_snapshot(snap, description=desc)
return "OK"
def deleteSnapShot(self, name, snap):
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
machine.delete_snapshot_by_path(snap)
return "OK"
def revertSnapShot(self, name, snap):
isConnected(self.sserver)
machine = self.sserver.get_vm_by_path(name)
machine.revert_to_path(snap)
return "OK"
from pysphere import VIServer
server=VIServer()
server.connect(XXXXXXXX","root","********")
vms=server.get_registered_vms()
vms
def get all hostnames(System_name)
for vm in vms:
vms=server.get_registered_vms()
if System_name in vm:
vm1=server.get_vm_by_path(vm)
print vm1.get_property('hostname')
mvas-omu-app1a
smsc-sfe4
smsc-sfe3
smsc-cdrpp2
smsc-cdrpp1
smsc-sfe1
mvas-omu-db1a
smsc-sem1
mvas-omu-db1b
smsc-sem2
smsc-mre1
# create server object
server = VIServer()
# connect to server
server.connect(host, username, password)
# get registered vms
vm_list = server.get_registered_vms()
# list for storing vm dictionaries
vm_obj_list = []
# get attributes for each vm
for vm in vm_list:
# get our attributes
vm_attr = server.get_vm_by_path(vm)
vm_name = vm_attr.get_property('name')
vm_ipv4 = vm_attr.get_property('ip_address', from_cache=False)
# create our connection string
vm_cmd = connectionstring + str(vm_ipv4)
# save to dict
vm_obj = { 'cmd': vm_cmd, 'name': vm_name }
# add to list
vm_obj_list.append(vm_obj)
# close connection
server.disconnect()
#!/usr/bin/env python
from pysphere import VIServer
server = VIServer()
server.connect("192.168.1.1", '*****@*****.**', 'Password')
vmpathlist = server.get_registered_vms()
print vmpathlist
for path in vmpathlist:
vm = server.get_vm_by_path(path)
print vm.get_properties(False)
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()
# all the snaps we created in the first place.
for vmsnapobj in qs:
snapvms[vmsnapobj] = []
snapvmfails[vmsnapobj] = []
snapvmskips[vmsnapobj] = []
try:
server.connect(vmsnapobj.hostname, vmsnapobj.username,
vmsnapobj.get_password())
except:
log.warn("VMware login failed to %s", vmsnapobj.hostname)
# TODO: This should generate an alert.
continue
# There's no point to even consider VMs that are paused or powered off.
vmlist = server.get_registered_vms(status='poweredOn')
for vm in vmlist:
vmobj = server.get_vm_by_path(vm)
if doesVMDependOnDataStore(vmobj, vmsnapobj.datastore):
try:
if canSnapshotVM(vmobj):
if not doesVMSnapshotByNameExists(
vmobj, vmsnapname):
# have we already created a snapshot of the VM for this volume
# iteration? can happen if the VM uses two datasets (a and b)
# where both datasets are mapped to the same ZFS volume in FreeNAS.
vmobj.create_snapshot(
vmsnapname,
description=vmsnapdescription,
memory=False)
else:
log.debug(
"Not creating snapshot %s for VM %s because it "
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
from pysphere import VIServer
server = VIServer()
HOST = "172.17.11.74"
LOGIN = "******"
PASSWORD = "******"
server.connect(HOST, LOGIN, PASSWORD)
oc = []
oc.append(server._retrieve_properties_traversal(obj_type='VirtualMachine'))
power = []
machines = server.get_registered_vms()
for machine in server.get_registered_vms():
power.append(server.get_vm_by_path(machine).get_status())
zindex = -1
for elem in oc:
for b in elem:
s = (b)
zindex = zindex + 1
print "vmrc://" + LOGIN + ":" + PASSWORD + "@" + HOST + ":443/?moid=" + s.Obj, machines[zindex], power[zindex]
server.disconnect()
#!/usr/bin/env python
from pysphere import VIServer
server = VIServer()
server.connect("my.esx.host.example.org", "username", "secret")
vm = server.get_vm_by_path("[datastore] path/to/file.vmx")
vm.wait_for_tools()
vm.login_in_guest("Administrator", "secret")
vm.get_screenshot("vm_screenshot.png", overwrite=True)
server.disconnect()
from pysphere import VIServer
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
server = VIServer()
server.connect("192.168.15.245", "root", "1111111")
vm = server.get_vm_by_path(
"[datastore1] Coordinator-1-16/Coordinator-1-16.vmx")
vm.login_in_guest("root", "aaaaaa")
vm.send_file("E:\\server_1_16\\server_1_16\\abn_05fa.dst",
r"/mnt/abn_05fa.dst")
print vm.get_status()
guest.shutdown_guest()
elif cmd == 'reset':
guest.reset(sync_run=False)
elif cmd == 'hard':
guest.terminate_process()
else:
print 'Unrecognized Command!'
if len(sys.argv) == 1:
print '''
commandline : esxpy.py 'GuestName' 'option'
The available options are: 'REBOOT', 'ON', 'OFF', 'SHUTDOWN', 'RESET',
or 'HARD' (which terminates the process of a stuck VM).
If no option is given the status of the Guest is returned.
Currently available VM's are:
'''
for i in server.get_registered_vms():
print '\t' + i
#print server.get_registered_vms()
sys.exit(0)
guest = server.get_vm_by_path(sys.argv[1])
print "The guest's current state is: \n %s\n" % guest_status()
if sys.argv[2:]:
guest_power(sys.argv[2].lower())
def getVMdata(configFilePath, host, user, password, vmListFile):
if (host is None and user is None and password is None):
OPTION_CHAR = '='
options = {}
if os.path.exists(configFilePath):
content = open(configFilePath)
for line in content:
if OPTION_CHAR in line:
option, value = line.split(OPTION_CHAR, 1)
option = option.strip()
value = value.strip()
if value.startswith('"') and value.endswith('"'):
value = value[1:-1]
options[option] = value
HOST = options['HOST']
USER = options['USER']
PASSWORD = options['PASSWORD']
else:
print "Must supply valid ESX configuration file."
sys.exit(1)
else:
HOST = host
USER = user
PASSWORD = password
try:
server = VIServer()
server.connect(HOST, USER, PASSWORD)
if vmListFile is None:
vmlist = server.get_registered_vms()
else:
if os.path.exists(vmListFile):
fileptr = open(vmListFile)
content = fileptr.read()
vmlist = content.split(",")
metric = []
vmMetrics = {
'disk.write': 131079,
'disk.read': 131078,
'disk.usage': 131073,
'cpu.usage': 1,
'mem.usage': 65537
}
for vms in vmlist:
vms = vms.strip()
start = vms.find(']') + 2
end = vms.find('/', start)
vmName = vms[start:end]
pm = server.get_performance_manager()
vm = server.get_vm_by_path(vms)
mor = vm._mor
for key, value in vmMetrics.iteritems():
entitystats = pm.get_entity_statistic(mor, key)
for i in entitystats:
dict_result = dict(
(name, getattr(i, name)) for name in dir(i))
metric_name = vmName + '.' + dict_result[
'group'] + '.' + dict_result['counter']
group = dict_result['group']
timeTuple = dict_result['time']
ts = time.mktime(timeTuple.timetuple())
maxValue = getMaxValue(group)
if dict_result['unit'] == 'percent':
mvalue = float(dict_result['value']) / 100
else:
mvalue = dict_result['value']
metric.append({
"metric_name": metric_name,
"value": mvalue,
"unit": dict_result['unit'],
"server": vmName,
"maxValue": maxValue,
"time_stamp": ts
})
return metric
except Exception as e:
print e
sys.exit(1)
for vmsnapobj in qs:
snapvms[vmsnapobj] = []
snapvmfails[vmsnapobj] = []
snapvmskips[vmsnapobj] = []
try:
server.connect(vmsnapobj.hostname,
vmsnapobj.username,
vmsnapobj.get_password())
except:
log.warn("VMware login failed to %s", vmsnapobj.hostname)
# TODO: This should generate an alert.
continue
# There's no point to even consider VMs that are paused or powered off.
vmlist = server.get_registered_vms(status='poweredOn')
for vm in vmlist:
vmobj = server.get_vm_by_path(vm)
if doesVMDependOnDataStore(vmobj, vmsnapobj.datastore):
try:
if canSnapshotVM(vmobj):
if not doesVMSnapshotByNameExists(vmobj, vmsnapname):
# have we already created a snapshot of the VM for this volume
# iteration? can happen if the VM uses two datasets (a and b)
# where both datasets are mapped to the same ZFS volume in FreeNAS.
vmobj.create_snapshot(vmsnapname,
description=vmsnapdescription,
memory=False)
else:
log.debug("Not creating snapshot %s for VM %s because it "
"already exists", vmsnapname, vm)
else:
# TODO:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import ssl
from pysphere import VIServer
ssl._create_default_https_context = ssl._create_unverified_context
server = VIServer()
server.connect("192.168.5.30","root","12345678")
vmlist = ['[Data1] file forward 1.60/file forward 1.60.vmx','[Data1] drupa_test_nginx_1.15/drupa_test_nginx_1.15.vmx', '[Data1] druapl_test_web/druapl_test_web.vmx', '[Data1] drupal_test_web_1.17/drupal_test_web_1.17.vmx', '[Data1] drupal_test_mysql_1.18/drupal_test_mysql_1.18.vmx', '[Data1] win 2008 1.62w/win 2008 1.62w.vmx', '[Data1] win 2008 1.61w/win 2008 1.61w.vmx']
for vm_name in vmlist:
vm = server.get_vm_by_path(vm_name)
vm.power_on()
server.connect("192.168.5.31","root","12345678")
vmlist = ['[datastore1 (4)] to Nagra-5.251/to Nagra-5.251.vmx']
vm = server.get_vm_by_path('[datastore1 (4)] to Nagra-5.251/to Nagra-5.251.vmx')
vm.power_on()
server.connect("192.168.5.32","root","12345678")
vmlist = ['[datastore1 (6)] 5.143bianyi server/5.143bianyi server.vmx', '[datastore1 (6)] linuxAS5.5/linuxAS5.5.vmx', '[datastore1 (6)] linuxas5.5 --9.176/linuxas5.5 --9.176.vmx', '[datastore1 (6)] linuxAS5.5--5.169/linuxAS5.5--5.169.vmx']
for vm_name in vmlist:
vm = server.get_vm_by_path(vm_name)
vm.power_on()
server.connect("192.168.5.33","root","12345678")
vmlist = ['[datastore1 (18)] SVN ubuntu13.10-5.146/SVN ubuntu13.10-5.146.vmx]']
for vm_name in vmlist:
vm = server.get_vm_by_path(vm_name)
vm.power_on()
HOST = "virtualcenter.com"
USER = "******"
PASSWORD = "******"
DATASTORE_NAME = "datastore1" #WHERE THE DISK WILL BE CREATED AT
DISK_SIZE_IN_MB = 500
VM_PATH = "[datastore1] path/to/the/config/file.vmx"
UNIT_NUMBER = 1
from pysphere import VIServer, VITask
from pysphere.resources import VimService_services as VI
s = VIServer()
s.connect(HOST, USER, PASSWORD)
vm = s.get_vm_by_path(VM_PATH)
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dc = spec.new_deviceChange()
dc.Operation = "add"
dc.FileOperation = "create"
hd = VI.ns0.VirtualDisk_Def("hd").pyclass()
hd.Key = -100
hd.UnitNumber = UNIT_NUMBER
class Stack(SimpleStack):
state_translation = {
"POWERED ON": "STARTED",
"POWERED OFF": "STOPPED",
"SUSPENDED": "PAUSED"
}
def __init__(self, poolinfo):
self.connection = False
self.poolinfo = poolinfo
self.format_for = Formatter()
self.connect()
def libvirt_connect(self):
self.libvirt_connection = libvirt.open(
"esx://%s@%s/" %
(self.poolinfo.get("username"), self.poolinfo.get("api_server")))
def connect(self):
self.connection = VIServer()
self.connection.connect(self.poolinfo.get("api_server"),
self.poolinfo.get("username"),
self.poolinfo.get("password"))
return
def pool_info(self):
return (self.format_for.pool(0, 0, self.poolinfo.get("api_server")))
def guest_list(self):
return [{
"id": self.connection.get_vm_by_path(path).properties.name
} for path in self.connection.get_registered_vms(
cluster=self.poolinfo.get('cluster'))]
def guest_info(self, guest_id):
vm = self._vm_ref(guest_id)
return self._vm_info(vm)
def guest_shutdown(self, guest_id, force=False):
vm = self._vm_ref(guest_id)
if force:
return vm.power_off()
else:
return vm.shutdown_guest()
def guest_start(self, guest_id):
vm = self._vm_ref(guest_id)
return vm.power_on()
def guest_reboot(self, guest_id, force=False):
vm = self._vm_ref(guest_id)
if force:
return vm.reset()
else:
return vm.reboot_guest()
def guest_suspend(self, guest_id):
vm = self._vm_ref(guest_id)
return vm.suspend()
def guest_resume(self, guest_id):
return self.guest_start(guest_id)
def guest_update(self, guest_id, guestdata):
vm = self._vm_ref(guest_id)
vmware.update_vm(self.connection, vm, guestdata)
return self._vm_info(self._vm_ref(guest_id))
def guest_delete(self, guest_id):
vm = self._vm_ref(guest_id)
vmware.delete_vm(self.connection, vm)
def media_mount(self, guest_id, media_data):
vm = self._vm_ref(guest_id)
vmware.update_vm(self.connection, vm, {"iso": media_data})
def media_info(self, guest_id):
vm = self._vm_ref(guest_id)
media = vmware.get_cd(vm)
if media.connectable.connected:
return {"name": media.backing.fileName}
else:
return {"name": None}
def network_interface_list(self, guest_id):
vm = self._vm_ref(guest_id)
vifs = vmware.get_network_interfaces(vm)
return [self._network_interface_info(n) for n in vifs]
def network_interface_info(self, guest_id, network_interface_id):
vm = self._vm_ref(guest_id)
vifs = vmware.get_network_interfaces(vm)
for vif in vifs:
if vif.macAddress == network_interface_id:
return self._network_interface_info(vif)
entity_info = "%s - on Guest %s" % (network_interface_id, guest_id)
raise EntityNotFound("NetworkInterface", entity_info)
def snapshot_list(self, guest_id):
vm = self._vm_ref(guest_id)
snaps = [self._snapshot_info(s) for s in vm.get_snapshots()]
return snaps
def snapshot_create(self, guest_id, snapshot_name=None):
if not snapshot_name:
snapshot_name = str(datetime.datetime.now())
vm = self._vm_ref(guest_id)
snap = vmware.create_snapshot(self.connection, vm, snapshot_name)
return self._snapshot_info(snap)
def snapshot_info(self, guest_id, snapshot_id):
vm = self._vm_ref(guest_id)
snap = vmware.get_snapshot(vm, snapshot_id)
if snap:
return self._snapshot_info(snap)
else:
raise EntityNotFound("Snapshot", snapshot_id)
def snapshot_revert(self, guest_id, snapshot_id):
vm = self._vm_ref(guest_id)
snap = vmware.get_snapshot(vm, snapshot_id)
vmware.revert_to_snapshot(self.connection, vm, snap)
def snapshot_delete(self, guest_id, snapshot_id):
vm = self._vm_ref(guest_id)
snap = vmware.get_snapshot(vm, snapshot_id)
vmware.delete_snapshot(self.connection, vm, snap)
def tag_list(self, guest_id):
vm = self._vm_ref(guest_id)
return vmware.get_tags(vm)
def tag_create(self, guest_id, tag_name):
vm = self._vm_ref(guest_id)
tags = vmware.create_tag(tag_name, vm)
vmware.update_vm(self.connection, vm, {"tags": tags})
return tags
def tag_delete(self, guest_id, tag_name):
vm = self._vm_ref(guest_id)
tags = vmware.delete_tag(tag_name, vm)
vmware.update_vm(self.connection, vm, {"tags": tags})
return tags
def _vm_ref(self, vm_id):
regex = r'[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}'
if re.match(regex, vm_id, re.I):
return vmware.get_vm_by_uuid(self.connection, vm_id)
else:
return self.connection.get_vm_by_name(vm_id)
def _vm_info(self, vm):
vm_info = vm.get_properties()
return (self.format_for.guest(
vm.properties.config.uuid, vm_info.get('name'),
vm_info.get('num_cpu'), vm_info.get('memory_mb'),
vmware.get_disk_size(vm) / (1024 * 1024),
vmware.get_vmi_driver(vm) is not None,
vm.properties.guest.toolsStatus == "toolsOk", None,
self.state_translation[vm.get_status()], None))
def _network_interface_info(self, vif):
return (self.format_for.network_interface(vif.macAddress,
vif.unitNumber,
vif.macAddress, '', '', '',
vif.backing.network.name))
def _snapshot_info(self, snapshot):
return (self.format_for.snapshot(snapshot.get_description(),
snapshot.get_name(),
snapshot.get_state(),
snapshot.get_path(),
snapshot.get_create_time()))
guest.shutdown_guest()
elif cmd == "reset":
guest.reset(sync_run=False)
elif cmd == "hard":
guest.terminate_process()
else:
print "Unrecognized Command!"
if len(sys.argv) == 1:
print """
commandline : esxpy.py 'GuestName' 'option'
The available options are: 'REBOOT', 'ON', 'OFF', 'SHUTDOWN', 'RESET',
or 'HARD' (which terminates the process of a stuck VM).
If no option is given the status of the Guest is returned.
Currently available VM's are:
"""
for i in server.get_registered_vms():
print "\t" + i
# print server.get_registered_vms()
sys.exit(0)
guest = server.get_vm_by_path(sys.argv[1])
print "The guest's current state is: \n %s\n" % guest_status()
if sys.argv[2:]:
guest_power(sys.argv[2].lower())
snapshot_name="base"
host="vcenter.example.com"
login="******"
password="******"
pre_name="VDS"
#####################################
import datetime
import sys
from pysphere import VIServer
server = VIServer()
print "connect"
server.connect(host, login, password)
print "get vm"
vmlist = server.get_registered_vms()
for vmpath in vmlist:
vm = server.get_vm_by_path(vmpath)
name = vm.get_property('name')
if name.find(pre_name) != -1 and name.find("-"+pre_name) == -1:
print "create snapshot " + snapshot_name + " for " + vm.get_property('name') + ": " + str(datetime.datetime.now())[0:19]
vm.create_snapshot(snapshot_name, memory = True, quiesce = True, sync_run = False)
print "end " + str(datetime.datetime.now())[0:19]
server.disconnect()
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!")
'''
Created on Apr 13, 2015
@author: tim.huang
¡easy_install pysphere
or
pip install ¡VU pysphere
'''
from pysphere import VIServer
if __name__ == '__main__':
server = VIServer()
server.connect("10.90.1.16", "root", "xxxxxxx")
vms = server.get_registered_vms()
for serverpath in vms:
print serverpath
vm = server.get_vm_by_path(serverpath)
vm.get_properties()
vm.get_property("hostname")
vm = server.get_vm_by_path(vms[0])
print vm.get_property("mac_address")
print vm.get_property("ip_address")
print vm.get_property("name")
print vm.get_resource_pool_name()
#vm = server.get_vm_by_path("[datastore1] s1/s1.vmx")
vm.power_on()
vmPropPath = ""
host = ""
for prop in propset.PropSet:
if prop.Name == "name":
host = prop.Val
elif prop.Name == "guest.toolsVersion":
vmToolsVersion = prop.Val
elif prop.Name == "config.files.vmPathName":
vmPropPath = prop.Val
if not serverVMToolVersion.has_key(host):
serverVMToolVersion[host] = vmToolsVersion
for vms in vmlist:
print vms
vm = server.get_vm_by_path(vms)
vmGuestFullName = vm.get_property('guest_full_name')
if not re.search('Microsoft', vmGuestFullName, re.IGNORECASE):
vmStatus = vm.get_status()
print "VM STATUS: " + vmStatus
guestID = vm.get_property('guest_id')
print "VM GUEST ID: " + guestID
vmPath = vm.get_property('path')
print "VM PATH: " + vmPath
vmName = vm.get_property('name')
print "VM NAME: " + vmName
print "VM GUEST FULL NAME: " + vmGuestFullName
vmHostname = vm.get_property('hostname')
print "VM HOSTNAME: " + str(vmHostname)
vmCPU = vm.get_property('num_cpu')
print "VM NUMBER CPU: " + str(vmCPU)
# 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)
vm = find_vm(vmname)
if vm:
ip = find_ip(vm,ipv6)
if ip:
print '%s : %s' % (vmname,ip)
else:
class Stack(SimpleStack):
state_translation = {"POWERED ON": "STARTED", "POWERED OFF": "STOPPED", "SUSPENDED": "PAUSED"}
def __init__(self, poolinfo):
self.connection = False
self.poolinfo = poolinfo
self.format_for = Formatter()
self.connect()
def libvirt_connect(self):
self.libvirt_connection = libvirt.open(
"esx://%s@%s/" % (self.poolinfo.get("username"), self.poolinfo.get("api_server"))
)
def connect(self):
self.connection = VIServer()
self.connection.connect(
self.poolinfo.get("api_server"), self.poolinfo.get("username"), self.poolinfo.get("password")
)
return
def pool_info(self):
return self.format_for.pool(0, 0, self.poolinfo.get("api_server"))
def guest_list(self):
return [
{"id": self.connection.get_vm_by_path(path).properties.name}
for path in self.connection.get_registered_vms(cluster=self.poolinfo.get("cluster"))
]
def guest_info(self, guest_id):
vm = self._vm_ref(guest_id)
return self._vm_info(vm)
def guest_shutdown(self, guest_id, force=False):
vm = self._vm_ref(guest_id)
if force:
return vm.power_off()
else:
return vm.shutdown_guest()
def guest_start(self, guest_id):
vm = self._vm_ref(guest_id)
return vm.power_on()
def guest_reboot(self, guest_id, force=False):
vm = self._vm_ref(guest_id)
if force:
return vm.reset()
else:
return vm.reboot_guest()
def guest_suspend(self, guest_id):
vm = self._vm_ref(guest_id)
return vm.suspend()
def guest_resume(self, guest_id):
return self.guest_start(guest_id)
def guest_update(self, guest_id, guestdata):
vm = self._vm_ref(guest_id)
vmware.update_vm(self.connection, vm, guestdata)
return self._vm_info(self._vm_ref(guest_id))
def guest_delete(self, guest_id):
vm = self._vm_ref(guest_id)
vmware.delete_vm(self.connection, vm)
def media_mount(self, guest_id, media_data):
vm = self._vm_ref(guest_id)
vmware.update_vm(self.connection, vm, {"iso": media_data})
def media_info(self, guest_id):
vm = self._vm_ref(guest_id)
media = vmware.get_cd(vm)
if media.connectable.connected:
return {"name": media.backing.fileName}
else:
return {"name": None}
def network_interface_list(self, guest_id):
vm = self._vm_ref(guest_id)
vifs = vmware.get_network_interfaces(vm)
return [self._network_interface_info(n) for n in vifs]
def network_interface_info(self, guest_id, network_interface_id):
vm = self._vm_ref(guest_id)
vifs = vmware.get_network_interfaces(vm)
for vif in vifs:
if vif.macAddress == network_interface_id:
return self._network_interface_info(vif)
entity_info = "%s - on Guest %s" % (network_interface_id, guest_id)
raise EntityNotFound("NetworkInterface", entity_info)
def snapshot_list(self, guest_id):
vm = self._vm_ref(guest_id)
snaps = [self._snapshot_info(s) for s in vm.get_snapshots()]
return snaps
def snapshot_create(self, guest_id, snapshot_name=None):
if not snapshot_name:
snapshot_name = str(datetime.datetime.now())
vm = self._vm_ref(guest_id)
snap = vmware.create_snapshot(self.connection, vm, snapshot_name)
return self._snapshot_info(snap)
def snapshot_info(self, guest_id, snapshot_id):
vm = self._vm_ref(guest_id)
snap = vmware.get_snapshot(vm, snapshot_id)
if snap:
return self._snapshot_info(snap)
else:
raise EntityNotFound("Snapshot", snapshot_id)
def snapshot_revert(self, guest_id, snapshot_id):
vm = self._vm_ref(guest_id)
snap = vmware.get_snapshot(vm, snapshot_id)
vmware.revert_to_snapshot(self.connection, vm, snap)
def snapshot_delete(self, guest_id, snapshot_id):
vm = self._vm_ref(guest_id)
snap = vmware.get_snapshot(vm, snapshot_id)
vmware.delete_snapshot(self.connection, vm, snap)
def tag_list(self, guest_id):
vm = self._vm_ref(guest_id)
return vmware.get_tags(vm)
def tag_create(self, guest_id, tag_name):
vm = self._vm_ref(guest_id)
tags = vmware.create_tag(tag_name, vm)
vmware.update_vm(self.connection, vm, {"tags": tags})
return tags
def tag_delete(self, guest_id, tag_name):
vm = self._vm_ref(guest_id)
tags = vmware.delete_tag(tag_name, vm)
vmware.update_vm(self.connection, vm, {"tags": tags})
return tags
def _vm_ref(self, vm_id):
regex = r"[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}"
if re.match(regex, vm_id, re.I):
return vmware.get_vm_by_uuid(self.connection, vm_id)
else:
return self.connection.get_vm_by_name(vm_id)
def _vm_info(self, vm):
vm_info = vm.get_properties()
return self.format_for.guest(
vm.properties.config.uuid,
vm_info.get("name"),
vm_info.get("num_cpu"),
vm_info.get("memory_mb"),
vmware.get_disk_size(vm) / (1024 * 1024),
vmware.get_vmi_driver(vm) is not None,
vm.properties.guest.toolsStatus == "toolsOk",
None,
self.state_translation[vm.get_status()],
None,
)
def _network_interface_info(self, vif):
return self.format_for.network_interface(
vif.macAddress, vif.unitNumber, vif.macAddress, "", "", "", vif.backing.network.name
)
def _snapshot_info(self, snapshot):
return self.format_for.snapshot(
snapshot.get_description(),
snapshot.get_name(),
snapshot.get_state(),
snapshot.get_path(),
snapshot.get_create_time(),
)
def getVMdata(configFilePath, host, user, password, vmListFile):
if (host is None and user is None and password is None):
OPTION_CHAR = '='
options = {}
if os.path.exists(configFilePath):
content = open(configFilePath)
for line in content:
if OPTION_CHAR in line:
option, value = line.split(OPTION_CHAR, 1)
option = option.strip()
value = value.strip()
if value.startswith('"') and value.endswith('"'):
value = value[1:-1]
options[option] = value
HOST = options['HOST']
USER = options['USER']
PASSWORD = options['PASSWORD']
else:
print "Must supply valid ESX configuration file."
sys.exit(1)
else:
HOST = host
USER = user
PASSWORD = password
try:
server = VIServer()
server.connect(HOST, USER, PASSWORD)
if vmListFile is None:
vmlist = server.get_registered_vms()
else:
if os.path.exists(vmListFile):
fileptr = open(vmListFile)
content = fileptr.read()
vmlist = content.split(",")
metric = []
vmMetrics = {'disk.write': 131079, 'disk.read': 131078, 'disk.usage': 131073, 'cpu.usage': 1, 'mem.usage': 65537}
for vms in vmlist:
vms = vms.strip()
start = vms.find(']') + 2
end = vms.find('/', start)
vmName = vms[start:end]
pm = server.get_performance_manager()
vm = server.get_vm_by_path(vms)
mor = vm._mor
for key, value in vmMetrics.iteritems():
entitystats = pm.get_entity_statistic(mor, key)
for i in entitystats:
dict_result = dict((name, getattr(i, name)) for name in dir(i))
metric_name = vmName+'.'+dict_result['group']+'.'+dict_result['counter']
group = dict_result['group']
timeTuple = dict_result['time']
ts = time.mktime(timeTuple.timetuple())
maxValue = getMaxValue(group)
if dict_result['unit'] == 'percent':
mvalue = float(dict_result['value'])/100
else:
mvalue = dict_result['value']
metric.append({"metric_name": metric_name, "value": mvalue, "unit":dict_result['unit'], "server":vmName, "maxValue":maxValue,"time_stamp":ts})
return metric
except Exception as e:
print e
sys.exit(1)
class Report:
"""Class report. Generate a dictionnary with the VMs and these properties"""
def __init__(self, config):
self.login = config['user']
self.password = config['password']
self.vcenter = config['vcenter']
self.server = VIServer()
def connect(self):
"""Connect to the hypervisor"""
self.server.connect(self.vcenter, self.login, self.password)
def disconnect(self):
"""Close the connection with the hypervisor"""
if self.server:
self.server.disconnect()
def generate_report(self):
"""Generate the report of the actual connection"""
report = []
# Create the report
vms_list = self.server.get_registered_vms()
for vm_path in vms_list:
virtual_machine = self.server.get_vm_by_path(vm_path)
if str(virtual_machine.__class__) != "pysphere.vi_virtual_machine.VIVirtualMachine":
continue
if re.match(r'rhel', virtual_machine.get_property('guest_id')):
vm_infos = {
'name': virtual_machine.get_property('name'),
'ip': virtual_machine.get_property('ip_address'),
'os': virtual_machine.get_property('guest_id')
}
try:
status = virtual_machine.get_status()
except Exception, e:
print "Couldn't do it: %s" % e
vm_infos['powered'] = 'none'
report.append(vm_infos)
continue
if status == "POWERED ON":
vm_infos['powered'] = 'on'
# Get version in ssh
ssh = subprocess.Popen([
"ssh",
"-i ~/.ssh/id_rsa",
"%s" % vm_infos['name'],
"cat /etc/redhat-release"],
shell=False, stdout=subprocess.PIPE, stderr=subprocess.PIPE
)
release = ssh.stdout.readlines()
if release == []:
error = ssh.stderr.readlines()
vm_infos['release'] = "error: " + error
else:
regex = re.compile("release (\d.*).+\(\D*(\d*)\)")
r = regex.search(release[0])
release = r.groups()
if release[1].strip():
vm_infos['release'] = release[0] + "." + release[1]
else:
vm_infos['release'] = release[0]
else:
vm_infos['powered'] = 'off'
report.append(vm_infos)
return report
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
from pysphere import VIServer
server = VIServer()
HOST = "172.17.11.74"
LOGIN = "******"
PASSWORD = "******"
server.connect(HOST, LOGIN, PASSWORD)
oc = []
oc.append(server._retrieve_properties_traversal(obj_type='VirtualMachine'))
power = []
machines = server.get_registered_vms()
for machine in server.get_registered_vms():
power.append(server.get_vm_by_path(machine).get_status())
zindex = -1
for elem in oc:
for b in elem:
s = (b)
zindex = zindex + 1
print "vmrc://" + LOGIN + ":" + PASSWORD + "@" + HOST + ":443/?moid=" + s.Obj, machines[
zindex], power[zindex]
server.disconnect()
www_user = '******'
www_pass = '******'
def printlog(text):
fileToBeWriten = "/home/dimi/prog/exsi/exsi_reboot.txt"
fichierWrite = open(fileToBeWriten,'a')
fichierWrite.write(text)
fichierWrite.write('\n')
fichierWrite.close()
server = VIServer()
server.connect(exsi_ip, exsi_user, exsi_pass)
vms = server.get_registered_vms()
vm = server.get_vm_by_path(vms[0])
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
ssh.connect(www_ip, username=www_user, password=www_pass)
except:
printlog(time.asctime())
printlog('----------------------------')
printlog('ssh down, trying to reboot www vm')
vm.power_off()
vm.power_on()
printlog(vm.get_property('name',from_cache=False))
printlog(vm.get_status())
USER = "******"
PASSWORD = "******"
VMDK_FILE = "[datastore1] vm-test-name/test.vmdk"
AddDisk = 5
CAPACITY_IN_KB = AddDisk * 1024 * 1024
DESTINATION_VM = "[datastore1-data] vm-test-name/vm-test-name.vmx"
UNIT_NUMBER = 2 # this is the scsi number 0, 1, 2 - would normally be 1 for a second disk
from pysphere import VIServer, VITask
from pysphere.resources import VimService_services as VI
s = VIServer()
s.connect(HOST, USER, PASSWORD)
vm = s.get_vm_by_path(DESTINATION_VM)
print(vm)
print("capapcity = %s" % CAPACITY_IN_KB)
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
dc = spec.new_deviceChange()
dc.Operation = "add"
hd = VI.ns0.VirtualDisk_Def("hd").pyclass()
class Report:
"""Class report. Generate a dictionnary with the VMs and these properties"""
def __init__(self, config):
self.login = config['user']
self.password = config['password']
self.vcenter = config['vcenter']
self.server = VIServer()
def connect(self):
"""Connect to the hypervisor"""
self.server.connect(self.vcenter, self.login, self.password)
def disconnect(self):
"""Close the connection with the hypervisor"""
if self.server:
self.server.disconnect()
def generate_report(self):
"""Generate the report of the actual connection"""
report = []
# Create the report
vms_list = self.server.get_registered_vms()
for vm_path in vms_list:
virtual_machine = self.server.get_vm_by_path(vm_path)
if str(virtual_machine.__class__
) != "pysphere.vi_virtual_machine.VIVirtualMachine":
continue
if re.match(r'rhel', virtual_machine.get_property('guest_id')):
vm_infos = {
'name': virtual_machine.get_property('name'),
'ip': virtual_machine.get_property('ip_address'),
'os': virtual_machine.get_property('guest_id')
}
try:
status = virtual_machine.get_status()
except Exception, e:
print "Couldn't do it: %s" % e
vm_infos['powered'] = 'none'
report.append(vm_infos)
continue
if status == "POWERED ON":
vm_infos['powered'] = 'on'
# Get version in ssh
ssh = subprocess.Popen([
"ssh", "-i ~/.ssh/id_rsa",
"%s" % vm_infos['name'], "cat /etc/redhat-release"
],
shell=False,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
release = ssh.stdout.readlines()
if release == []:
error = ssh.stderr.readlines()
vm_infos['release'] = "error: " + error
else:
regex = re.compile("release (\d.*).+\(\D*(\d*)\)")
r = regex.search(release[0])
release = r.groups()
if release[1].strip():
vm_infos['release'] = release[0] + "." + release[1]
else:
vm_infos['release'] = release[0]
else:
vm_infos['powered'] = 'off'
report.append(vm_infos)
return report
#!/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()
server = VIServer()
qs = VMWarePlugin.objects.filter(filesystem=fs)
vmsnapname = str(uuid.uuid4())
vmsnapdescription = str(datetime.now()).split('.')[0] + " FreeNAS Created Snapshot"
snapvms = []
snapvmfails = []
for obj in qs:
try:
server.connect(obj.hostname, obj.username, obj.get_password())
except:
log.warn("VMware login failed to %s", obj.hostname)
continue
vmlist = server.get_registered_vms(status='poweredOn')
for vm in vmlist:
if vm.startswith("[%s]" % obj.datastore):
vm1 = server.get_vm_by_path(vm)
try:
vm1.create_snapshot(vmsnapname, description=vmsnapdescription, memory=False)
except:
log.warn("Snapshot of VM %s failed", vm1)
snapvmfails.append(vm)
snapvms.append(vm1)
if snapvmfails:
try:
with LockFile(VMWARE_FAILS) as lock:
with open(VMWARE_FAILS, 'rb') as f:
fails = pickle.load(f)
except:
fails = {}
fails[snapname] = [str(vm) for vm in snapvmfails]
# 获取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的实例 vm1 = server_obj.get_vm_by_name() # 下面就可以获取vm的具体信息 print vm1.get_status() # 返回的状态信息会更快 print vm1.get_status(basic_status=True) # 判断虚拟机状态的方法 # print vm1.is_powered_off() # print vm1.is_powered_on() # 。。。。。。。。
raise Exception("No ESX specified")
if OPER == None:
if not sys.argv[ARG] in OPERS:
raise Exception("Not a known operation <" + sys.argv[ARG] + ">")
OPER = sys.argv[ARG]
continue
APPLYTO = sys.argv[ARG:len(sys.argv)]
break
if ESX == None:
Usage("Missing ESX argument")
sys.exit(1)
if OPER == None:
Usage("Missing OPER argument")
sys.exit(1)
operate(ESX, FILTER, OPER, APPLYTO)
exit(0)
################################################################################
# Main:
exit(0)
vm = server.get_vm_by_path("[datastore] path/to/file.vmx")
#vm.power_on()
argc = len(argvs)
if (argc != 7):
print "Usage : python tst.py --vcenter=<vCenter IP> --vuser=<user> --vpass=<password> \
--name=<VM name> --var=<var> --val=<val>"
sys.exit(1)
# connect to vCenter
server = VIServer()
#server.connect(opt_vcenter, opt_vuser, opt_vpass, trace_file="debug.txt")
server.connect(opt_vcenter, opt_vuser, opt_vpass)
#path_to_vm = "[%s] %/%s.vmx" % (datastore_name, opt_name, opt_name)
path_to_vm = "[%s] %s/%s.vmx" % (DATASTORE_NAME, opt_name, opt_name)
vm = server.get_vm_by_path(path_to_vm)
#disk.locking = "FALSE"
#disk.EnableUUID = "TRUE"
#settings = { 'disk.locking': 'FALSE' }
#settings = { 'disk.EnableUUID': 'TRUE' }
settings = {opt_var: opt_val}
#print settings
vm.set_extra_config(settings)
server.disconnect()
