def main():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
template = opts.template
cd_iso_location = opts.iso
datastorename = opts.datastore # if None, will use the first datastore available
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
# Clone the VM.
try:
template_vm = s.get_vm_by_name(template)
except Exception as e:
print "Failed to locate the template."
print "Exception:", str(e)
sys.exit(1)
vm = template_vm.clone(vmname, power_on=False)
cdrom = None
for dev in vm.properties.config.hardware.device:
if dev._type == "VirtualCdrom":
cdrom = dev._obj
break
change_cdrom_type(cdrom, "ISO", "[%s] %s" % (datastorename, cd_iso_location))
apply_changes(vm, s, cdrom)
# Here you should power your VM (refer to the pysphere documentation)
# So it boots from the specified ISO location
try:
new_vm = s.get_vm_by_name(opts.name)
connect_vm_cdroms(new_vm, s)
try:
new_vm.power_on()
except Exception as e:
print "Failed to power-on the new VM using:", opts.name
print "Exception:", str(e)
except Exception as e:
print "Failed to locate the new VM using:", opts.name
print "Exception:", str(e)
# disconnect from the server
s.disconnect()
def main(argv):
try:
opts, args = getopt.getopt(
argv, "i:u:p:n:h",
["iphost=", "vuser="******"vpass="******"vmname=", "help"])
except getopt.GetoptError:
print 'test.py -i <vhost> -u <name> -p <vpass> -n <vmname>'
sys.exit(4)
for opt, arg in opts:
if opt == '-h':
print 'test.py -i <vhost> -u <vname> -p <vpass> -n <vmname>'
sys.exit()
elif opt in ("-i", "--vhost"):
iphost = arg
elif opt in ("-u", "--vname"):
vuser = arg
elif opt in ("-p", "--vpass"):
vpass = arg
elif opt in ("-n", "--vmname"):
vmname = arg
ssl._create_default_https_context = ssl._create_unverified_context
server = VIServer()
server.connect(iphost, vuser, vpass)
vm1 = server.get_vm_by_name(vmname)
print vm1.get_properties().get('ip_address')
def del_datas(self, vm_name, guster_user, guster_pwd, del_dir):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
# print(e)
return 0
print(vm.get_tools_status())
if vm.get_tools_status() == 'RUNNING': #判断tools状态
print(f'{vm_name} tools is RUNING--------------------')
try:
vm.login_in_guest(guster_user, guster_pwd)
vm.delete_directory(del_dir, recursive=True) # 清空数据盘
except Exception as e:
# print(e)
pass
finally:
print(f'{vm_name} 数据盘清空完毕！！！！！')
else:
print(f'{vm_name} tools is not RUNING--------------------')
def vmaction(self, vm_name, vm_hz):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print e
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
return 0
if vm.is_powered_off() == False:
try:
vm.reset()
# print (type(int(vm_hz)))
for i in range(1, int(vm_hz)):
print u'虚拟机%s 正在重置中。。。。，请等待注册\n' % (vm_name)
time.sleep(1)
print u'重置完成'
server_obj.disconnect()
return 1
except Exception as e:
print e
if vm.is_powered_off() == True:
try:
vm.power_on()
print u'虚拟机%s 正在开机中。。。。' % (vm_name)
server_obj.disconnect()
except Exception as e:
return 2
def vm_status(self, vm_name):
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()
except Exception as e:
server_obj.disconnect()
log.info(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
if vm.is_powered_off() == False:
server_obj.disconnect()
return 1
if vm.is_powered_off() == True:
server_obj.disconnect()
return 2
except Exception as e:
server_obj.disconnect()
return 3
def vm_status(self, vm_name):
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()
except Exception as e:
server_obj.disconnect()
print e
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
if vm.is_powered_off() == False:
server_obj.disconnect()
return 1
if vm.is_powered_off() == True:
server_obj.disconnect()
return 2
except Exception as e:
server_obj.disconnect()
return 3
def main():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
try:
vm = s.get_vm_by_name(opts.name)
vm.shutdown_guest()
count = 1
wait_for = 60
try:
while count < wait_for and vm.is_powered_off() == False:
count += 1
time.sleep(1)
print "Elapsed %s seconds ..." % str(count)
except Exception as e:
if count >= wait_for:
print "Failed to shutdown the VM (%s) even after %s seconds." % (vmname, str(wait_for))
print "Please login to the EXSi server and fix the issue. Exception: %s" % str(e)
sys.exit(1)
check_count(count, wait_for)
except Exception as e:
print "Failed to locate and shutdown the new VM using:", opts.name
print "VM could not be deleted."
print "Exception:", str(e)
# Invoke Destroy_Task
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = s._proxy.Destroy_Task(request)._returnval
# Wait for the task to finish
task = VITask(ret, s)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
print "VM successfully deleted from disk"
elif status == task.STATE_ERROR:
print "Error removing vm:", task.get_error_message()
# disconnect from the server
s.disconnect()
def vm_stop(server, username, password, vmID):
s_server=str(server)
s_username=str(username)
s_password=str(password)
s_vm=str(vmID)
server = VIServer()
server.connect(s_server, s_username, s_password)
vm1 = server.get_vm_by_name(s_vm)
vm1.suspend()
return
def del_datas(self, vm_name, guster_user, guster_pwd, del_dir):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
# print(e)
return 0
print(vm.get_tools_status())
if vm.get_tools_status() == 'RUNNING': #判断tools状态
print(f'{vm_name} tools is RUNING--------------------')
try:
vm.login_in_guest(guster_user, guster_pwd)
# vm.delete_directory(del_dir, recursive=True) # 清空数据盘
path_list = vm.list_files(del_dir)
new_list = []
#排除目录或文件
not_list = [
'.', '..', '$RECYCLE.BIN', 'pagefile.sys', 'pvsvm', 'size',
'System Volume Information', 'vdiskdif.vhdx', 'desktop.ini'
]
for list_ctent in path_list:
if list_ctent['path'] not in not_list:
new_list.append(list_ctent)
if len(new_list) > 0:
for filter_list in new_list:
print(filter_list)
if filter_list['type'] == 'file':
try:
vm.delete_file(del_dir + filter_list['path'])
except Exception as e:
print(e)
if filter_list['type'] == 'directory':
try:
vm.delete_directory(del_dir +
filter_list['path'],
recursive=True)
except Exception as e:
print(e)
except Exception as e:
print(e)
finally:
print(f'{vm_name} 数据盘清空完毕！！！！！')
else:
print(f'{vm_name} tools is not RUNING--------------------')
def main():
"""Sets up the module parameters, validates them and perform the change"""
module = AnsibleModule(
argument_spec=dict(
vcenter_hostname=dict(required=True),
username=dict(required=True),
password=dict(required=True),
guest=dict(required=True),
resource_pool=dict(required=True),
cluster=dict(required=True),
sync=dict(required=False, type='bool', default=True)
),
supports_check_mode=True
)
server = VIServer()
server.connect(
module.params['vcenter_hostname'],
module.params['username'],
module.params['password'])
virtualmachine = server.get_vm_by_name(module.params['guest'])
old_name = virtualmachine.get_resource_pool_name()
new_name = module.params['resource_pool']
# find the clusters ManagedObjectReference
cluster = None
clusters = server.get_clusters()
for mor, name in clusters.iteritems():
if name == module.params['cluster']:
cluster = mor
break
if cluster is None:
module.fail_json(msg='Cluster %s not found on server %s' %
(module.params['cluster'], module.params['vcenter_hostname']))
# find the new resource pools Managed Object Reference and migrate the VM
rps = server.get_resource_pools(from_mor=cluster)
for mor, path in rps.iteritems():
if re.match('.*%s$' % new_name, path):
if not re.match('.*%s$' % old_name, path):
if not module.check_mode:
virtualmachine.migrate(
resource_pool=mor,
host=virtualmachine.get_property('hostname'),
sync_run=module.params['sync'])
module.exit_json(changed=True, changes=module.params)
module.exit_json(changed=False, changes=module.params)
module.fail_json(msg='Resource pool %s not found' %
module.params['resource_pool'])
def vm_state(server, username, password, vmID):
s_server=str(server)
s_username=str(username)
s_password=str(password)
s_vm=str(vmID)
server = VIServer()
server.connect(s_server, s_username, s_password)
vm1 = server.get_vm_by_name(s_vm)
if vm1.is_suspended() or vm1.is_powered_off():
return "OFF"
elif vm1.is_powered_on():
return "ON"
else:
return "UNK"
def set_ip_via_vsphere(vm_name, fqdn):
#Connect to vSphere
server = VIServer()
server.connect(settings.VSPHERE_HOSTNAME, settings.VSPHERE_USERNAME, settings.VSPHERE_PASSWORD)
#Connect to the new vm. Call the object vm1
vm1 = server.get_vm_by_name(vm_name)
vm1.login_in_guest(settings.VSPHERE_TEMPLATE_USERNAME, settings.VSPHERE_TEMPLATE_PASSWORD)
#login and set the IP and restart networking to get it on the air
vm1.send_file(settings.TEMP_LOCATION_CONFIG_NETWORK.format(fqdn=fqdn), '/etc/sysconfig/network', overwrite=True)
vm1.send_file(settings.TEMP_LOCATION_CONFIG_ETH0.format(fqdn=fqdn), '/etc/sysconfig/network-scripts/ifcfg-eth0', overwrite=True)
vm1.start_process("/sbin/service", args=["network", "restart"])
vm1.start_process("/bin/hostname", args=[fqdn])
#disconnect from vSphere
server.disconnect()
def vm_migrate():
"""Migrate the VMs based on the list given"""
user, passwd, vcenter = get_user_info()
host, servers, servercount = get_serverlist()
s = VIServer()
s.connect(vcenter, user, passwd)
getserver_type_api()
esxhost_input = raw_input('Enter target ESX Host: ')
esxhost = s.get_hosts().items()
for k,v in esxhost:
if v == esxhost_input:
for host in servers:
host = host.strip()
vm = s.get_vm_by_name(host)
vm.migrate(host=k)
time.sleep(10)
s.disconnect()
def set_vm_datastore(host_ip, host_name, host_password, vm_name, reservation):
#DebugInfo.objects.create(text_info=host_ip+host_name+host_password+vm_name+reservation)
server = VIServer()
server.connect(host_ip, host_name, host_password)
vm_mor = server.get_vm_by_name(vm_name)
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm_mor._mor)
_this.set_attribute_type(vm_mor._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
disk_size = get_disk_size(vm_mor)
new_hdd = reservation
device_config_specs = []
if new_hdd * 1024 * 1024 > disk_size:
disk = get_disks(vm_mor)[-1]
hdd_in_GB = new_hdd * 1024 * 1024
new_disk_size = hdd_in_GB - disk_size + disk.capacityInKB
device_config_spec = spec.new_deviceChange()
device_config_spec.set_element_operation('edit')
disk._obj.set_element_capacityInKB(new_disk_size)
device_config_spec.set_element_device(disk._obj)
device_config_specs.append(device_config_spec)
if len(device_config_specs) != 0:
spec.set_element_deviceChange(device_config_specs)
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
ret_flag = False
if status == task.STATE_SUCCESS:
#ret = "VM <" + vm_name + "> successfully reconfigured"
ret_flag = True
elif status == task.STATE_ERROR:
#ret = "Error reconfiguring vm <" + vm_name + ">: %s" % task.get_error_message()
ret_flag = False
return ret_flag
def vmaction(self, vm_name, vm_hz):
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)
except Exception as e:
server_obj.disconnect()
log.info(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
server_obj.disconnect()
return 0
if vm.is_powered_off() == False:
try:
vm.reset()
# logger.info (type(int(vm_hz)))
for i in range(1, int(vm_hz)):
log.info('虚拟机%s 正在重置中。。。。，请等待注册\n' % (vm_name))
time.sleep(1)
log.info('重置完成')
server_obj.disconnect()
return 1
except Exception as e:
server_obj.disconnect()
log.info(e)
if vm.is_powered_off() == True:
try:
vm.power_on()
log.info('虚拟机%s 正在开机中。。。。' % (vm_name))
server_obj.disconnect()
except Exception as e:
server_obj.disconnect()
return 2
def vmaction(self, vm_name):
server_obj = VIServer()
try:
server_obj.connect(self.host_ip, self.user, self.password)
except Exception as e:
print(e)
# 通过名称获取vm的实例
try:
vm = server_obj.get_vm_by_name(vm_name)
except Exception as e:
print(e)
return 0
if vm.is_powered_off() == False:
try:
vm.reset()
# vm.power_off()
# print (type(int(vm_hz)))
# for i in range(1, int(vm_hz)):
# print (f'虚拟机{vm_name} 正在重置中。。。。，请等待注册\n' )
# time.sleep(1)
# print ('重置完成')
server_obj.disconnect()
return 1
except Exception as e:
print(e)
if vm.is_powered_off() == True:
try:
# vm.power_on()
# print (f'虚拟机{vm_name} 正在开机中。。。。')
server_obj.disconnect()
except Exception as e:
return 2
def main():
vcenter = ""
esx_username = ""
esx_password = ""
ldap_password = ""
# Read config file in...
vcf = ".vcenters"
try:
file = open(vcf, "r")
read = file.read()
except IOError:
print "ERROR --> Config file '%s' does not exist! Please create it as described below." % vcf
print "--> echo 'vc1 = \"<VCENTER1>\"' > %s" % vcf
print "--> echo 'vc2 = \"<VCENTER2>\"' >> %s" % vcf
print ""
vserver.disconnect()
exit(1)
i = 1
vc = {}
for line in read.splitlines():
if "vc%s = " % i in line:
vc["vc" + str(i)] = line.split('=', 1)[1]
i += 1
if "domain = " in line:
domain = line.split('=', 1)[1].lstrip().translate(None, '"')
vc1 = vc.get("vc1").lstrip().translate(None, '"')
vc2 = vc.get("vc2").lstrip().translate(None, '"')
if domain == None:
print "ERROR --> Domain is blank, add to settings in config..."
print "--> echo 'domain = \"<DOMAIN>\"' >> %s" % vcf
vserver.disconnect()
exit(1)
options, args = usage_and_opts(vc1, vc2)
def connect_vsphere():
default_context = ssl._create_default_https_context
ssl._create_default_https_context = ssl._create_unverified_context
vserver.connect(vcenter, esx_username, esx_password)
if options.username:
esx_username = options.username
print "--> CruzID: " + esx_username
else:
print ""
print " Identity "
print "======================================"
if esx_username == "":
if py3:
esx_username = input("--> Please input your CruzID: ")
else:
esx_username = raw_input("--> Please input your CruzID: ")
else:
print "--> CruzID: " + esx_username
if esx_password == "":
esx_password = getpass.getpass("--> Please input your AD password: "******"--> vCenter: " + vcenter
else:
print ""
print " vCenter "
print "================================"
print "(1) %s" % vc1
print "(2) %s" % vc2
if vcenter == "":
if py3:
esx_c = input("--> Which vCenter: ")
else:
esx_c = raw_input("--> Which vCenter: ")
if esx_c == "1" or esx_c == vc1:
vcenter = vc1
elif esx_c == "2" or esx_c == vc2:
vcenter = vc2
else:
print "ERROR --> Please select a vCenter from list..."
exit(1)
else:
print "--> vCenter: " + vcenter
vserver = VIServer()
connect_vsphere()
hostname = select_host(vserver, options)
vm = vserver.get_vm_by_name(hostname)
ifc, curvlan = get_current_vlan(vserver, vm, hostname)
curhost = vm.properties.runtime.host.name
print ""
print " Settings of VM '%s' " % hostname
print "======================================="
print "Current VLAN: %s" % curvlan
print "Current HOST: %s" % curhost
print ""
destvlan = print_available_vlans(vserver, curhost, hostname, options)
print ""
print "NOTE --> Host will continue to use DHCP on new network if no static IP defined..."
if py3:
ans = input("--> Do you wish to set a static IP for VM '%s'? (Y/N): " %
hostname)
else:
ans = raw_input(
"--> Do you wish to set a static IP for VM '%s'? (Y/N): " %
hostname)
print ""
if ans == "Y" or ans == "y":
set_host_static_ip(vserver, ifc, hostname, esx_username, options)
else:
restart_host_network(hostname, esx_username, ldap_password)
change_dvs_net(vserver, vm, hostname, destvlan, curvlan)
if platform.system() != "Darwin":
call([
"/local/adm/infoblox-scripts/remove_dcnet_dns_from_hostmaster.sh",
hostname
])
vserver.disconnect()
#!/usr/bin/python
"""
Author: Pryz
Description: Get current status and properties of a VM with pysphere
"""
from pysphere import VIServer
# Connect to the vcenter
LOGIN = "******"
PWD = "password"
VCENTER = "vcenter.labo.fr"
SERVER = VIServer()
SERVER.connect(VCENTER, LOGIN, PWD)
VMNAME = "vm1.labo.fr"
VM = SERVER.get_vm_by_name(VMNAME)
print VM.get_status()
print VM.get_property("ip_address")
print VM.get_properties()
# Close connection
SERVER.disconnect()
argvs = sys.argv
argc = len(argvs)
if (argc != 6):
print "Usage : python tst.py --vcenter=<vCenter IP> --vuser=<user> --vpass=<password> \
--name=<VM name> --net=<vlan label>"
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)
# specify the name of a VM
vm = server.get_vm_by_name("%s" % opt_name)
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()
dev_change = spec.new_deviceChange()
dev_change.set_element_operation("add")
# We use a VMXNET3 controller here. Introspect into
# VI.ns0 for all available controller names.
nic_ctlr = VI.ns0.VirtualVmxnet3_Def("nic_ctlr").pyclass()
def create_vm():
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
# datacentername = "ha-datacenter"
datacentername = opts.datacenter
hostname = opts.hostname
annotation = "My Product Product Virtual Machine"
memorysize = opts.ram
cpucount = opts.cpus
# cd_iso_location =
# "iso/My_Product_2013_02_26_05_15_00.iso"
# # located in the ESX datastore
cd_iso_location = opts.iso
guestosid = "centos64Guest"
# find your os in
# http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html
disksize = (1024 ** 2) * 100 # In Kb: 1024 ** 2 (power) = 1GB; 1GB * 100 = 100GB.
# OPTIONAL PARAMETERS
datastorename = opts.datastore # if None, will use the first datastore available
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
# GET INITIAL PROPERTIES AND OBJECTS
# get datacenter
dcmor = s._get_datacenters()[datacentername]
dcprops = VIProperty(s, dcmor)
# get host folder
hfmor = dcprops.hostFolder._obj
# get computer resources
crmors = s._retrieve_properties_traversal(property_names=['name',
'host'], from_node=hfmor, obj_type='ComputeResource')
# get host
for hosts in s.get_hosts().items():
try:
if hosts.index(hostname) == 1:
hostmor = hosts[0]
except:
pass
# get computer resource of this host
crmor = None
for cr in crmors:
if crmor:
break
for p in cr.PropSet:
# print 'p.Name:', p.Name
if p.Name == "host":
for h in p.Val.get_element_ManagedObjectReference():
if h == hostmor:
crmor = cr.Obj
break
if crmor:
break
crprops = VIProperty(s, crmor)
# get resource pool
rpmor = crprops.resourcePool._obj
# get vmFolder
vmfmor = dcprops.vmFolder._obj
# CREATE VM CONFIGURATION
# get config target
request = VI.QueryConfigTargetRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_target = s._proxy.QueryConfigTarget(request)._returnval
# get default devices
request = VI.QueryConfigOptionRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_option = s._proxy.QueryConfigOption(request)._returnval
defaul_devs = config_option.DefaultDevice
# get network name
# would be assigned to the last known working network interface.
# in this case, it would be VM Network 2.
network_name = None
for n in config_target.Network:
if n.Network.Accessible:
network_name = n.Network.Name
# can hard-code it as 'VM Network'
# get datastore
# Just verifies that the datastorename mentioned at the top matches with the
# available list of datastores.
ds = None
for d in config_target.Datastore:
if d.Datastore.Accessible and (datastorename and d.Datastore.Name
== datastorename) or (not datastorename):
ds = d.Datastore.Datastore
datastorename = d.Datastore.Name
break
if not ds:
raise Exception("couldn't find datastore")
volume_name = "[%s]" % datastorename
# add parameters to the create vm task
create_vm_request = VI.CreateVM_TaskRequestMsg()
config = create_vm_request.new_config()
vmfiles = config.new_files()
vmfiles.set_element_vmPathName(volume_name)
config.set_element_files(vmfiles)
config.set_element_name(vmname)
config.set_element_annotation(annotation)
config.set_element_memoryMB(memorysize)
config.set_element_numCPUs(cpucount)
config.set_element_guestId(guestosid)
devices = []
# add a scsi controller
disk_ctrl_key = 1
scsi_ctrl_spec = config.new_deviceChange()
scsi_ctrl_spec.set_element_operation('add')
scsi_ctrl = VI.ns0.VirtualLsiLogicController_Def("scsi_ctrl").pyclass()
scsi_ctrl.set_element_busNumber(0)
scsi_ctrl.set_element_key(disk_ctrl_key)
scsi_ctrl.set_element_sharedBus("noSharing")
scsi_ctrl_spec.set_element_device(scsi_ctrl)
devices.append(scsi_ctrl_spec)
# find ide controller
ide_ctlr = None
for dev in defaul_devs:
if dev.typecode.type[1] == "VirtualIDEController":
ide_ctlr = dev
# add a cdrom based on a physical device
if ide_ctlr:
cd_spec = config.new_deviceChange()
cd_spec.set_element_operation('add')
cd_ctrl = VI.ns0.VirtualCdrom_Def("cd_ctrl").pyclass()
cd_device_backing = VI.ns0.VirtualCdromIsoBackingInfo_Def("cd_device_backing").pyclass()
ds_ref = cd_device_backing.new_datastore(ds)
ds_ref.set_attribute_type(ds.get_attribute_type())
cd_device_backing.set_element_datastore(ds_ref)
cd_device_backing.set_element_fileName("%s %s" % (volume_name,
cd_iso_location))
cd_ctrl.set_element_backing(cd_device_backing)
cd_ctrl.set_element_key(20)
cd_ctrl.set_element_controllerKey(ide_ctlr.get_element_key())
cd_ctrl.set_element_unitNumber(0)
cd_spec.set_element_device(cd_ctrl)
devices.append(cd_spec)
# create a new disk - file based - for the vm
disk_spec = config.new_deviceChange()
disk_spec.set_element_fileOperation("create")
disk_spec.set_element_operation("add")
disk_ctlr = VI.ns0.VirtualDisk_Def("disk_ctlr").pyclass()
disk_backing = VI.ns0.VirtualDiskFlatVer2BackingInfo_Def("disk_backing").pyclass()
disk_backing.set_element_fileName(volume_name)
disk_backing.set_element_diskMode("persistent")
disk_backing.ThinProvisioned = True
disk_ctlr.set_element_key(0)
disk_ctlr.set_element_controllerKey(disk_ctrl_key)
disk_ctlr.set_element_unitNumber(0)
disk_ctlr.set_element_backing(disk_backing)
disk_ctlr.set_element_capacityInKB(disksize)
disk_spec.set_element_device(disk_ctlr)
devices.append(disk_spec)
# add a NIC. the network Name must be set as the device name to create the NIC.
nic_spec = config.new_deviceChange()
if network_name:
nic_spec.set_element_operation("add")
nic_ctlr = VI.ns0.VirtualPCNet32_Def("nic_ctlr").pyclass()
nic_backing = VI.ns0.VirtualEthernetCardNetworkBackingInfo_Def("nic_backing").pyclass()
nic_backing.set_element_deviceName(network_name)
nic_ctlr.set_element_addressType("generated")
nic_ctlr.set_element_backing(nic_backing)
nic_ctlr.set_element_key(4)
nic_spec.set_element_device(nic_ctlr)
devices.append(nic_spec)
config.set_element_deviceChange(devices)
create_vm_request.set_element_config(config)
folder_mor = create_vm_request.new__this(vmfmor)
folder_mor.set_attribute_type(vmfmor.get_attribute_type())
create_vm_request.set_element__this(folder_mor)
rp_mor = create_vm_request.new_pool(rpmor)
rp_mor.set_attribute_type(rpmor.get_attribute_type())
create_vm_request.set_element_pool(rp_mor)
host_mor = create_vm_request.new_host(hostmor)
host_mor.set_attribute_type(hostmor.get_attribute_type())
create_vm_request.set_element_host(host_mor)
# CREATE THE VM
taskmor = s._proxy.CreateVM_Task(create_vm_request)._returnval
task = VITask(taskmor, s)
task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if task.get_state() == task.STATE_ERROR:
raise Exception("Error creating vm: %s" %
task.get_error_message())
# Here you should power your VM (refer to the pysphere documentation)
# So it boots from the specified ISO location
try:
new_vm = s.get_vm_by_name(opts.name)
connect_vm_cdroms(new_vm, s)
try:
new_vm.power_on()
except Exception as e:
print "Failed to power-on the new VM using:", opts.name
print "Exception:", str(e)
except Exception as e:
print "Failed to locate the new VM using:", opts.name
print "Exception:", str(e)
# disconnect from the server
s.disconnect()
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')
print vm1.get_status()
#Also you can ask the following:
print vm1.is_powering_off()
print vm1.is_powered_off()
print vm1.is_powering_on()
print vm1.is_powered_on()
print vm1.is_suspending()
print vm1.is_suspended()
print vm1.is_resetting()
print vm1.is_blocked_on_msg()
print vm1.is_reverting()
#For power options:
from pysphere import VIServer, VITask, VIProperty
from pysphere.resources import VimService_services as VI
from pprint import pprint
HOST = "my esxi server"
USER = "******"
PASSWORD = "******"
DATASTORE = "datastore1" #WHERE THE DISK WILL BE CREATED AT
VM_NAME = "vm-test-name"
folder = "vm-test-name"
server = VIServer()
server.connect(HOST, USER, PASSWORD)
#th = server.get_task_history_collector(entity='all', recursion='all')
vm = server.get_vm_by_name(VM_NAME)
th = server.get_task_history_collector(entity=vm._mor, recursion='all')
#get the most recent tasks
tasks = th.get_latest_tasks()
for t in tasks:
try:
print t.get_info().name, t.get_state()
except:
#some tasks may be old enough to be removed
#so you won't be able to get its info
pass
#!/usr/bin/python
from pysphere import VIServer
server = VIServer()
server.connect("172.16.1.10", "Administrator", "pass*&^")
vm = server.get_vm_by_name("Windows")
vm.login_in_guest("Administrator", "pass*&^")
vm.send_file("/var/www/html/scripts/misc/winautoip.bat",
r"C:\Users\Administrator\Desktop\winautoip.bat",
overwrite=True)
vm.start_process("C:\Users\Administrator\Desktop\winautoip.bat",
args=["172.16.1.20", "172.16.1.254", "255.255.255.0"])
server.disconnect()
import sys, ssl
from pprint import pprint
from pysphere import VIServer
server = VIServer()
VCENTER_IP = "10.9.34.204"
VCENTER_USER = "******"
VCENTER_PASS = "******"
#ova_name="VCFC-2.2.0-jenkins-3108"
ova_name = sys.argv[1]
server.connect(VCENTER_IP, VCENTER_USER, VCENTER_PASS)
vm = server.get_vm_by_name(ova_name)
net_info = vm.get_property('net', False)
vcfc_ip = [
x['ip_addresses'][0] for x in net_info if x['network'] == 'VM Network'
][0]
pprint(vcfc_ip)
class basicOps:
server=None
def connect(self):
configuration=Config()
server = configuration._config_value("general", "server")
if server is None:
raise ValueError("server must be supplied on command line"+"or in configuration file.")
username = configuration._config_value("general", "username")
if username is None:
raise ValueError("username must be supplied on command line"
" or in configuration file.")
password = configuration._config_value("general", "password")
if password is None:
raise ValueError("password must be supplied on command line"
" or in configuration file.")
self.server=VIServer()
self.server.connect(server,username,password)
def startVm(self,vmname):
vm=self.server.get_vm_by_name(vmname)
status=vm.get_status()
if status=="POWERED OFF":
task=vm.power_on(run_sync=False)
return task
def stopVm(self, vmname):
vm=self.server.get_vm_by_name(vmname)
status=vm.get_status()
if status=="POWERED ON":
task=vm.power_off(run_sync=False)
return task
def stopGuest(self,vmname):
vm=self.server.get_vm_by_name(vmname)
task=vm.shutdown_guest(run_sync=False)
return task
def rebootGuest(self,vmname):
vm=self.server.get_vm_by_name(vmname)
task=vm.reboot_guest(run_sync=False)
return task
def getDataCenters(self):
return self.server.get_datacenters()
def clone(self,templateName,cloneName="Template Clone"):
vm=self.server.get_vm_by_name(templateName)
resourcePool=self.getResourcePool()
print resourcePool
task=vm.clone(cloneName,resourcepool=resourcePool,sync_run=False)
try:
status=task.get_state()
print(status)
print "Creating machine from template:Job Status:" + status
if status!="error":
while (status!="success" or status !="error"):
status=task.get_state()
if status=="success":
break;
print "Creating machine from template: Job Status:" + status
#vm_new=self.server.get_vm_by_name(cloneName)
#return vm_new
except:
print("Error Occured:")
def getResourcePool(self):
configuration=Config()
datacenter = configuration._config_value("vmware", "datacenter")
if datacenter is None:
raise ValueError("server must be supplied"+"in configuration file.")
cluster = configuration._config_value("vmware", "cluster")
if cluster is None:
raise ValueError("cluster name must be supplied in configuration file.")
resourcePool = configuration._config_value("vmware", "resourcePool")
if resourcePool is None:
raise ValueError("Resource Pool name must be supplied in configuration file")
clusters=self.server.get_clusters()
#print clusters
keycluster=self.find_key(clusters,cluster)
# print(keycluster)
resource_pools=self.server.get_resource_pools(keycluster)
# print(resource_pools)
resourcePool=self.find_key(resource_pools,resourcePool,True)
# print (resourcePool)
return resourcePool
# resource_pools=self.server.get_resource_pools()
def find_key(self,dic, val, partial=False):
retval=None
if partial==False:
retval=[k for k, v in dic.iteritems() if v == val][0]
else:
retval =[k for k, v in dic.iteritems() if (v.find(val)>0)][0]
return retval
def find_value(self,dic, key):
return dic[key]
argc = len(argvs)
if ( argc != 7):
print "Usage : python clone_VMs_from_template_VM.py --vcenter=<vCenter IP> --user=<user> --password=<password>--prefix=<string> --number=<int> --template=<template VM name>"
sys.exit(1)
# connect to vCenter
server = VIServer()
server.connect(opt_vcenter,opt_user,opt_password,trace_file="debug.txt")
resource_pools = server.get_resource_pools()
#print resource_pools
first_resource_pool = resource_pools.keys()[0]
#print first_resource_pool
# specify the full path of a template VM
template_vm = server.get_vm_by_name("%s" % opt_template)
i = 1
while i <= opt_number:
new_vm = "%s-%s" % ( opt_prefix,i )
clonedVM = template_vm.clone(new_vm,resourcepool=first_resource_pool)
print "VM name : %s : status %s" % (clonedVM.get_property("name") , clonedVM.get_status())
i += 1
server.disconnect()
i += 1
server.disconnect()
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)
from pysphere import VIServer
server = VIServer()
server.connect("vcenter_server", "user", "password")
vm = server.get_vm_by_name("vm_name")
if vm.is_powered_off():
vm.power_on()
print "{} is powering on, please wait...".format(vm.get_property("name"))
else:
print "{} is online with an IP address of {}".format(vm.get_property("name"), vm.get_property("ip_address"))
class Creator:
# todo; add comment
"""
"""
def __init__(self, manager_address, manager_user, manager_password):
"""
:param manager_address:
:param manager_user:
:param manager_password:
"""
self.esx_server = VIServer()
self.esx_address = manager_address
self.esx_user = manager_user
self.esx_password = manager_password
def __del__(self):
self._disconnect_from_esx()
# todo; add comment
def _connect_to_esx(self):
"""
:raise:
"""
if not self.esx_server.is_connected():
try:
self.esx_server.connect(self.esx_address, self.esx_user, self.esx_password)
except Exception as inst:
raise CreatorException(str(inst))
def _disconnect_from_esx(self):
# todo; add comment
"""
"""
if self.esx_server.is_connected():
self.esx_server.disconnect()
def create_resource_pool(
self,
name,
parent_rp="/",
esx_hostname=None,
cpu_resources=("normal", 4000, 0, True, -1),
memory_resources=("normal", 163840, 0, True, -1),
):
"""
Creates a resource pool on esx server
name - name for new resource pool
parent_pr - parent resource pool
esx_hostname - host name of esx server when resource pool will be created
cpu_resources and memory_resources: tuple
0:share level - 'low' 'normal' 'high' 'custom'
1:share value - 'custom' share value, int
2:reservation - reserved CPU/Memory, int
3:expandable reservation - bool
4:limit - -1 - unlimited, another value - limit value, int
:raise: CreatorException
"""
self._connect_to_esx()
if parent_rp == "/":
parent_rpmor = None
try:
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == "/Resources"]
except IndexError:
raise CreatorException("Couldn't find parent resource pool")
if len(rp_mor_temp) == 0:
raise CreatorException("Couldn't find parent resource pool")
if esx_hostname:
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
if prop.parent.name == esx_hostname:
parent_rpmor = rp
break
if not parent_rpmor:
raise CreatorException("Couldn't find host")
else:
parent_rpmor = rp_mor_temp[0]
else:
parent_rp = "/Resources" + parent_rp
parent_rpmor = None
try:
parent_rp_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == parent_rp]
except IndexError:
raise CreatorException("Couldn't find parent a resource pool")
if len(parent_rp_temp) == 0:
raise CreatorException("Couldn't find parent a resource pool")
##222
if len(parent_rp_temp) == 1:
parent_rpmor = parent_rp_temp[0]
elif esx_hostname:
for rp in parent_rp_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
parent_rpmor = rp
break
else:
raise CreatorException("ESX Hostname must be specified")
req = VI.CreateResourcePoolRequestMsg()
_this = req.new__this(parent_rpmor)
_this.set_attribute_type(parent_rpmor.get_attribute_type())
req.set_element__this(_this)
req.Name = name
spec = req.new_spec()
cpu_allocation = spec.new_cpuAllocation()
memory_allocation = spec.new_memoryAllocation()
# cpu allocation settings
shares = cpu_allocation.new_shares()
shares.Level = cpu_resources[0]
shares.Shares = cpu_resources[1]
cpu_allocation.Shares = shares
cpu_allocation.Reservation = cpu_resources[2]
cpu_allocation.ExpandableReservation = cpu_resources[3]
cpu_allocation.Limit = cpu_resources[4]
spec.CpuAllocation = cpu_allocation
# memory allocation settings
shares = memory_allocation.new_shares()
shares.Level = memory_resources[0]
shares.Shares = memory_resources[1]
memory_allocation.Shares = shares
memory_allocation.Reservation = memory_resources[2]
memory_allocation.ExpandableReservation = memory_resources[3]
memory_allocation.Limit = memory_resources[4]
spec.MemoryAllocation = memory_allocation
req.Spec = spec
try:
self.esx_server._proxy.CreateResourcePool(req)
except Exception as inst:
self._disconnect_from_esx()
inst = str(inst)
if "already exist" in inst:
raise ExistenceException("Couldn't create resource pool '%s', because it already exist" % name)
else:
raise CreatorException("Couldn't create the resource pool with name '%s'" % name)
def destroy_resource_pool(self, name, esx_hostname=None):
"""
Destroy named resource pool; vm included in this pool will be thrown
on upper resource pool
:param esx_hostname: host name of esx server, which contains resource pool
:param name: name of resource pool
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
if name[0] != "/":
rp_name = "/Resources/" + name
else:
rp_name = "/Resources" + name
try:
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == rp_name]
except IndexError:
raise ExistenceException("Couldn't find resource pool '%s'" % name)
rpmor = ""
if esx_hostname:
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
rpmor = rp
break
elif len(rp_mor_temp) == 1:
rpmor = rp_mor_temp[0]
else:
raise CreatorException("ESX Hostname must be specified")
req = VI.Destroy_TaskRequestMsg()
_this = req.new__this(rpmor)
_this.set_attribute_type(rpmor.get_attribute_type())
req.set_element__this(_this)
try:
self.esx_server._proxy.Destroy_Task(req)
# self._disconnect_from_esx()
except Exception:
self._disconnect_from_esx()
raise
def destroy_resource_pool_with_vms(self, name, esx_hostname=None):
"""
Destroy named resource pool; vm included in this pool also will be destroyed
:param name: name of resource pool
:param esx_hostname: host name of esx server, which contains resource pool
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
if not name:
raise CreatorException("Couldn't specify resource pool name")
if name[0] != "/":
rp_name = "/Resources/" + name
else:
rp_name = "/Resources" + name
try:
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == rp_name]
except IndexError:
raise CreatorException("Couldn't find resource pool '%s'" % name)
rpmor = ""
if esx_hostname:
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
rpmor = rp
break
elif len(rp_mor_temp) == 1:
rpmor = rp_mor_temp[0]
else:
raise ExistenceException("Couldn't find resource pool '%s'" % name)
prop = VIProperty(self.esx_server, rpmor)
vms = [str(k.name) for k in prop.vm]
for k in vms:
self.destroy_vm(k)
self.destroy_resource_pool(rp_name[10:], esx_hostname)
# self._disconnect_from_esx()
def destroy_vm(self, vmname):
"""
Destroys virtual machine by name
:param vmname: virtual machine name
:raise: ExistenceException, CreatorException
"""
self._connect_to_esx()
try:
vm = self.esx_server.get_vm_by_name(vmname)
except Exception as error:
self._disconnect_from_esx()
raise ExistenceException("Couldn't find VM '%s' - %s" % (vmname, error.message))
try:
if vm.is_powered_on() or vm.is_powering_off() or vm.is_reverting():
vm.power_off()
request = VI.Destroy_TaskRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
ret = self.esx_server._proxy.Destroy_Task(request)._returnval
# Wait for the task to finish
task = VITask(ret, self.esx_server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status != task.STATE_SUCCESS:
raise CreatorException("Couldn't destroy vm - " + task.get_error_message())
except Exception:
self._disconnect_from_esx()
raise CreatorException("Couldn't destroy the virtual machine %s" % vmname)
def create_vm_old(
self,
vmname,
esx_hostname=None,
iso=None,
datacenter=None,
resource_pool="/",
networks=None,
datastore=None,
description=None,
guestosid="debian4Guest",
memorysize=512,
cpucount=1,
disk_space=1048576,
):
"""
Creates virtual machine
:param vmname: name of virtual machine
:param esx_hostname: host's name, when vm will be created; if not specified
and ESX contains more than 1 hosts - raise CreatorException
:param iso: path to .ISO image; must be stored in the same datastore
as the virtual machine is created
:param datacenter: name of datacenter, which contain hosts and datastores
:param resource_pool: name of resource pool, when VM will be created
(e.g. win-servers/win2003)
if resource_pool_path is not defined, VM will created in root of inventory
:param networks: list of existing port groups. NIC are based on this list
:param datastore: name of datastore, which will be contain VM files; if not
specified, VM will be placed in first datastore, which is avaliable
for chosen host
:param description: description for VM
:param guestosid: ID for guest OS; full list
http://www.vmware.com/support/developer/vc-sdk/visdk41pubs/ApiReference/vim.vm.GuestOsDescriptor.GuestOsIdentifier.html
:param memorysize: size of RAM, which will be avaliable on VM, in Mb
:param cpucount: count of CPU, which will be avaliable on VM
:param create_hard_drive: if True, new .vmdk disk will be created and added to VM
:param disk_space: hard drive's maximal size, in Kb
"""
params = {}
if vmname:
params["vm_name"] = vmname
else:
raise AttributeError("Couldn't specify a virtual machine name")
if iso:
params["iso"] = iso
if datacenter:
params["datacenter_name"] = datacenter
if datastore:
params["datastore_name"] = datastore
if resource_pool:
params["resource_pool_name"] = resource_pool
if not networks:
networks = []
if networks:
params["networks"] = networks
if not description:
params["description"] = "Description of %s" % vmname
else:
params["description"] = description
params["esx_hostname"] = esx_hostname
params["guestosid"] = guestosid
params["memory_size"] = memorysize
params["cpu_count"] = cpucount
params["disk_size"] = disk_space
try:
self.create_vm(params)
except ExistenceException as error:
raise
except CreatorException as error:
raise
except Exception as error:
raise
def create_vm(self, vm_options):
"""
Creates a virtual machine on ESXi server
:param vm_options: dict, which contain parameters for VM
'vm_name'
'iso'
'datacenter_name'
'datastore_name'
'resource_pool_name'
'networks'
'description'
'esx_hostname'
'hard_drive'
'guestosid'
'memory_size'
'cpu_count'
'disk_size'
See create_vm_old for details
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
# VM NAME
vm_name = None
try:
vm_name = str(vm_options["vm_name"])
vm_temp = self.esx_server.get_vm_by_name(vm_name)
if vm_temp:
raise ExistenceException('VM "%s" already exists' % vm_name)
except KeyError:
raise CreatorException("Must specify VM name")
except pysphere.VIException as inst:
if "[Object Not Found]" in str(inst):
pass
# HOSTNAME
hosts = self.esx_server.get_hosts()
try:
esx_hostname = vm_options["esx_hostname"]
if not esx_hostname:
raise KeyError
elif not (esx_hostname in hosts.values()):
raise CreatorException("Couldn't find host '%s'" % esx_hostname)
except KeyError:
if len(hosts.values()) > 1:
raise CreatorException("More than 1 host - must specify ESX Hostname")
elif not hosts.values():
raise CreatorException("Couldn't find available host")
esx_hostname = hosts[0]
# MOR and PROPERTIES
hostmor = [k for k, v in hosts.items() if v == esx_hostname][0]
hostprop = VIProperty(self.esx_server, hostmor)
# DATACENTER - FIX EXCEPTION
# todo: fix self.esx_server.get_datacenters().values()
dcs = self.esx_server.get_datacenters()
dc_values = dcs.values()
try:
dc_name = vm_options["datacenter_name"]
if not dc_name in dc_values:
raise CreatorException("Couldn't find datacenter '%s'" + dc_name)
except KeyError:
if len(dc_values) > 1:
raise CreatorException("More than 1 datacenter - must specify ESX Hostname")
elif not dc_values:
raise CreatorException("Couldn't find available datacenter")
dc_name = dc_values[0]
# MOR and PROPERTIES
dcmor = [k for k, v in dcs.items() if v == dc_name][0]
dcprops = VIProperty(self.esx_server, dcmor)
# DATASTORE
dcs = hostprop.datastore
try:
ds_name = vm_options["datastore_name"]
ds_list = []
for ds in dcs:
ds_list.append(ds.name)
if not ds_name in ds_list:
raise CreatorException("Couldn't find datastore or datastore is not available")
except KeyError:
if len(dcs) > 1:
raise CreatorException("More than 1 datastore on ESX - must specify datastore name")
elif not dcs:
raise CreatorException("Couldn't find available datastore")
ds_name = dcs[0].name
# RESOURCE POOL
resource_pool_name = ""
try:
resource_pool_name = vm_options["resource_pool_name"]
if resource_pool_name == "/":
pass
elif resource_pool_name[0] != "/":
resource_pool_name = "/{0}".format(resource_pool_name)
except KeyError:
resource_pool_name = "/"
finally:
rpmor = self._fetch_resource_pool(resource_pool_name, esx_hostname)
if not rpmor:
raise CreatorException("Couldn't find resource pool '%s'" % resource_pool_name)
# NETWORKS
try:
networks = list(vm_options["networks"])
except Exception:
networks = []
try:
iso = vm_options["iso"]
if iso == False:
iso = None
else:
# todo: hide magic
iso = iso[iso.find(ds_name) + len(ds_name) + 1 :]
except KeyError:
iso = None
# Description
try:
description = vm_options["description"]
except KeyError:
description = "Description for VM %s" % vm_name
try:
guestosid = vm_options["guestosid"]
except KeyError:
guestosid = "otherGuest"
try:
memory_size = int(vm_options["memory_size"])
if memory_size <= 0:
raise CreatorException("Disk size must be greater than 0")
except Exception:
memory_size = DEFAULT_MEMORY_SIZE # MB
try:
cpu_count = int(vm_options["cpu_count"])
except Exception:
cpu_count = DEFAULT_CPU_COUNT
try:
disk_size = int(vm_options["disk_size"])
if disk_size < 0:
raise CreatorException("Disk size must be greater than 0")
except Exception:
disk_size = DEFAULT_DISK_SIZE # KB
crprops = self._fetch_computer_resource(dcprops, hostmor)
vmfmor = dcprops.vmFolder._obj
# CREATE VM CONFIGURATION
# get config target
request = VI.QueryConfigTargetRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_target = self.esx_server._proxy.QueryConfigTarget(request)._returnval
# get default devices
request = VI.QueryConfigOptionRequestMsg()
_this = request.new__this(crprops.environmentBrowser._obj)
_this.set_attribute_type(crprops.environmentBrowser._obj.get_attribute_type())
request.set_element__this(_this)
h = request.new_host(hostmor)
h.set_attribute_type(hostmor.get_attribute_type())
request.set_element_host(h)
config_option = self.esx_server._proxy.QueryConfigOption(request)._returnval
defaul_devs = config_option.DefaultDevice
# get network name
avaliable_networks = 0
for net in networks:
for n in config_target.Network:
if n.Network.Accessible and n.Network.Name == net:
avaliable_networks += 1
break
if len(networks) != avaliable_networks:
msg = ""
for n in config_target.Network:
msg = "%s %s" % (msg, str(n.Network.Name))
raise CreatorException("Couldn't find all networks; founded: %s" % msg)
# raise ExistenceException("Couldn't find network")
# get datastore
ds = None
for d in config_target.Datastore:
if d.Datastore.Accessible and d.Datastore.Name == ds_name:
ds = d.Datastore.Datastore
ds_name = d.Datastore.Name
break
if not ds:
raise CreatorException("Datastore is not available")
volume_name = "[%s]" % ds_name
# add parameters to the create vm task
create_vm_request = VI.CreateVM_TaskRequestMsg()
config = create_vm_request.new_config()
vmfiles = config.new_files()
vmfiles.set_element_vmPathName(volume_name)
config.set_element_files(vmfiles)
config.set_element_name(vm_name)
config.set_element_annotation(description)
config.set_element_memoryMB(memory_size)
config.set_element_numCPUs(cpu_count)
config.set_element_guestId(guestosid)
devices = []
# add a scsi controller
disk_ctrl_key = 1
scsi_ctrl_spec = config.new_deviceChange()
scsi_ctrl_spec.set_element_operation("add")
scsi_ctrl = VI.ns0.VirtualLsiLogicController_Def("scsi_ctrl").pyclass()
scsi_ctrl.set_element_busNumber(0)
scsi_ctrl.set_element_key(disk_ctrl_key)
scsi_ctrl.set_element_sharedBus("noSharing")
scsi_ctrl_spec.set_element_device(scsi_ctrl)
devices.append(scsi_ctrl_spec)
# find ide controller
if iso:
ide_ctlr = None
for dev in defaul_devs:
if dev.typecode.type[1] == "VirtualIDEController":
ide_ctlr = dev
# add a cdrom based on a physical device
if ide_ctlr:
cd_spec = config.new_deviceChange()
cd_spec.set_element_operation("add")
cd_ctrl = VI.ns0.VirtualCdrom_Def("cd_ctrl").pyclass()
cd_device_backing = VI.ns0.VirtualCdromIsoBackingInfo_Def("cd_device_backing").pyclass()
ds_ref = cd_device_backing.new_datastore(ds)
ds_ref.set_attribute_type(ds.get_attribute_type())
cd_device_backing.set_element_datastore(ds_ref)
cd_device_backing.set_element_fileName("%s %s" % (volume_name, iso))
cd_ctrl.set_element_backing(cd_device_backing)
cd_ctrl.set_element_key(20)
cd_ctrl.set_element_controllerKey(ide_ctlr.get_element_key())
cd_ctrl.set_element_unitNumber(0)
cd_spec.set_element_device(cd_ctrl)
devices.append(cd_spec)
# create a new disk - file based - for the vm
if disk_size != 0:
disk_spec = config.new_deviceChange()
disk_spec.set_element_fileOperation("create")
disk_spec.set_element_operation("add")
disk_ctlr = VI.ns0.VirtualDisk_Def("disk_ctlr").pyclass()
disk_backing = VI.ns0.VirtualDiskFlatVer2BackingInfo_Def("disk_backing").pyclass()
disk_backing.set_element_fileName(volume_name)
disk_backing.set_element_diskMode("persistent")
disk_ctlr.set_element_key(0)
disk_ctlr.set_element_controllerKey(disk_ctrl_key)
disk_ctlr.set_element_unitNumber(0)
disk_ctlr.set_element_backing(disk_backing)
disk_ctlr.set_element_capacityInKB(disk_size)
disk_spec.set_element_device(disk_ctlr)
devices.append(disk_spec)
# add a NIC. the network Name must be set as the device name to create the NIC.
for network_name in networks:
nic_spec = config.new_deviceChange()
nic_spec.set_element_operation("add")
nic_ctlr = VI.ns0.VirtualPCNet32_Def("nic_ctlr").pyclass()
nic_backing = VI.ns0.VirtualEthernetCardNetworkBackingInfo_Def("nic_backing").pyclass()
nic_backing.set_element_deviceName(network_name)
nic_ctlr.set_element_addressType("generated")
nic_ctlr.set_element_backing(nic_backing)
nic_ctlr.set_element_key(4)
nic_spec.set_element_device(nic_ctlr)
devices.append(nic_spec)
config.set_element_deviceChange(devices)
create_vm_request.set_element_config(config)
folder_mor = create_vm_request.new__this(vmfmor)
folder_mor.set_attribute_type(vmfmor.get_attribute_type())
create_vm_request.set_element__this(folder_mor)
rp_mor = create_vm_request.new_pool(rpmor)
rp_mor.set_attribute_type(rpmor.get_attribute_type())
create_vm_request.set_element_pool(rp_mor)
host_mor = create_vm_request.new_host(hostmor)
host_mor.set_attribute_type(hostmor.get_attribute_type())
create_vm_request.set_element_host(host_mor)
# CREATE THE VM - add option "wait"
taskmor = self.esx_server._proxy.CreateVM_Task(create_vm_request)._returnval
task = VITask(taskmor, self.esx_server)
task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if task.get_state() == task.STATE_ERROR:
self._disconnect_from_esx()
raise CreatorException("Error creating vm: %s" % task.get_error_message())
def create_virtual_switch(self, name, num_ports, esx_hostname=None):
"""
Creates a new standard virtual switch on esx
:param name: name for new virtual switch
:param num_ports: numbers of emulated ports
:param esx_hostname: host name of esx server when virtual switch will be created
:raise: CreatorException, ExistenceException
"""
num_ports = int(num_ports)
self._connect_to_esx()
hosts = None
try:
hosts = self.esx_server.get_hosts()
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except IndexError:
raise CreatorException("Couldn't find host")
if not host_system:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
network_system = prop.configManager.networkSystem._obj
for vs in prop.configManager.networkSystem.networkInfo.vswitch:
if vs.name == name:
self._disconnect_from_esx()
raise ExistenceException("Switch '%s' already exist" % name)
request = VI.AddVirtualSwitchRequestMsg()
_this = request.new__this(network_system)
_this.set_attribute_type(network_system.get_attribute_type())
request.set_element__this(_this)
request.set_element_vswitchName(name)
spec = request.new_spec()
spec.set_element_numPorts(num_ports)
request.set_element_spec(spec)
try:
self.esx_server._proxy.AddVirtualSwitch(request)
except Exception:
raise CreatorException("Couldn't create Switch")
# self._disconnect_from_esx()
def destroy_virtual_switch(self, name, esx_hostname=None):
"""
Destroys a named standard virtual switch on esx
:param name: virtual switch's name
:param esx_hostname: host name of esx server when virtual switch placed
:raise: CreatorException, ExistenceException
"""
self._connect_to_esx()
hosts = self.esx_server.get_hosts()
try:
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except Exception:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
network_system = prop.configManager.networkSystem._obj
exist = False
for vs in prop.configManager.networkSystem.networkInfo.vswitch:
if vs.name == name:
exist = True
break
if exist:
request = VI.RemoveVirtualSwitchRequestMsg()
_this = request.new__this(network_system)
_this.set_attribute_type(network_system.get_attribute_type())
request.set_element__this(_this)
request.set_element_vswitchName(name)
try:
self.esx_server._proxy.RemoveVirtualSwitch(request)
except Exception:
raise CreatorException("Couldn't remove virtual switch '%s'" % name)
else:
raise ExistenceException("Couldn't find virtual switch '%s'" % name)
# self._disconnect_from_esx()
def add_port_group(self, switch_name, vlan_name, esx_hostname=None, vlan_id=4095, promiscuous=False):
"""
Add new network to exist switch
:param switch_name: vlan_name of switch which will be reconfigured
:param vlan_name: vlan_name of VLAN
:param esx_hostname: ESX hostname
:param vlan_id: id for VLAN
:param promiscuous: promiscuous mode enable/disable (True/False)
:raise: ExistenceException, CreatorException
"""
self._connect_to_esx()
vlan_id = int(vlan_id)
hosts = self.esx_server.get_hosts()
try:
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except Exception:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
network_system = prop.configManager.networkSystem._obj
request = VI.AddPortGroupRequestMsg()
_this = request.new__this(network_system)
_this.set_attribute_type(network_system.get_attribute_type())
request.set_element__this(_this)
portgrp = request.new_portgrp()
portgrp.set_element_name(vlan_name)
portgrp.set_element_vlanId(vlan_id)
portgrp.set_element_vswitchName(switch_name)
policy = portgrp.new_policy()
security = policy.new_security()
security.set_element_allowPromiscuous(promiscuous)
policy.set_element_security(security)
portgrp.set_element_policy(policy)
request.set_element_portgrp(portgrp)
try:
self.esx_server._proxy.AddPortGroup(request)
except Exception as inst:
message = str(inst)
if "already exist" in message:
raise ExistenceException(
"Couldn't create network '%s:%s' on switch '%s', because it already exists" % vlan_name,
vlan_id,
switch_name,
)
else:
raise CreatorException(
"Couldn't create network '%s:%s' on switch '%s'" % vlan_name, vlan_id, switch_name
)
# self._disconnect_from_esx()
def is_connected(self):
"""
Checks ESX manager connection
:rtype : bool
:return: connection status
"""
return self.esx_server.is_connected()
def vm_power_on(self, vmname):
"""
Turns power on for the virtual machine
:param vmname: virtual machine name
:raise: ExistenceException, AttributeError, Exception
"""
if not vmname:
raise AttributeError("Couldn't specify the virtual machine name")
if not self._is_vm_exist(vmname):
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
self._connect_to_esx()
vm = self.esx_server.get_vm_by_name(vmname)
if not vm.is_powered_on() and not vm.is_powering_on():
vm.power_on()
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
def vm_power_off(self, vmname):
"""
Turns power off for the virtual machine
:param vmname: virtual machine name
:raise: ExistenceException, AttributeError, Exception
"""
if not vmname:
raise AttributeError("Couldn't specify the virtual machine name")
if not self._is_vm_exist(vmname):
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
self._connect_to_esx()
vm = self.esx_server.get_vm_by_name(vmname)
if not vm.is_powered_off() and not vm.is_powering_off():
vm.power_off()
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
def vm_reset(self, vmname):
"""
Resets a virtual machine.
If the virtual machine is powered off, then turns the power on for this virtual machine
:param vmname: virtual machine name
:raise: AttributeError, ExistenceException, Exception
"""
if not vmname:
raise AttributeError("Couldn't specify the virtual machine name")
if not self._is_vm_exist(vmname):
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
self._connect_to_esx()
vm = self.esx_server.get_vm_by_name(vmname)
if not vm.is_powered_off():
vm.reset()
else:
vm.power_on()
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
def get_vm_path(self, vmname):
"""
Gets a virtual machine path on ESX server
:param vmname: virtual machine name
:return: virtual machine path
:raise: CreatorException
"""
self._connect_to_esx()
try:
vm = self.esx_server.get_vm_by_name(vmname)
except Exception:
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
try:
return vm.get_property("path")
except Exception as error:
self._disconnect_from_esx()
raise CreatorException(error)
pass
# todo: REVIEW ME
def get_vm_obj(self, vmname):
"""
Gets a virtual machine object on ESX server
:param vmname: virtual machine name
:return: VIVirtualMachine instance
:raise: CreatorException
"""
self._connect_to_esx()
try:
return self.esx_server.get_vm_by_name(vmname)
except Exception:
raise ExistenceException("Couldn't find the virtual machine '%s'" % vmname)
finally:
self._disconnect_from_esx()
def add_existence_vmdk(self, vm_name, path):
"""
Add existence hard drive (.vmdk) to the virtual machine
:param vm_name: virtual machine name
:param path: hard drive path
:param space: space for hard drive
:raise: ExistenceException, CreatorException
"""
self._connect_to_esx()
try:
vm = self.esx_server.get_vm_by_name(vm_name)
except Exception:
raise ExistenceException("Couldn't find the virtual machine %s" % vm_name)
unit_number = -1
for disk in vm._disks:
unit_number = max(unit_number, disk["device"]["unitNumber"])
unit_number += 1
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()
hd.Key = -100
hd.UnitNumber = unit_number
hd.CapacityInKB = 0
hd.ControllerKey = 1000
backing = VI.ns0.VirtualDiskFlatVer2BackingInfo_Def("backing").pyclass()
backing.FileName = path
backing.DiskMode = "persistent"
backing.ThinProvisioned = False
hd.Backing = backing
connectable = hd.new_connectable()
connectable.StartConnected = True
connectable.AllowGuestControl = False
connectable.Connected = True
hd.Connectable = connectable
dc.Device = hd
spec.DeviceChange = [dc]
request.Spec = spec
task = self.esx_server._proxy.ReconfigVM_Task(request)._returnval
vi_task = VITask(task, self.esx_server)
# Wait for task to finis
status = vi_task.wait_for_state([vi_task.STATE_SUCCESS, vi_task.STATE_ERROR])
if status == vi_task.STATE_ERROR:
self._disconnect_from_esx()
raise CreatorException("ERROR CONFIGURING VM:%s" % vi_task.get_error_message())
# todo: add comment
def _get_portgroup_name(self, name, esx_hostname=None):
"""
Get exist network from ESX
:param name: network name
:param esx_hostname: ESX host name
:return: :raise:
"""
self._connect_to_esx()
hosts = self.esx_server.get_hosts()
try:
if esx_hostname:
host_system = [k for k, v in hosts.items() if v == esx_hostname][0]
else:
host_system = hosts.keys()[0]
except IndexError:
raise CreatorException("Couldn't find host")
if not host_system:
raise CreatorException("Couldn't find host")
prop = VIProperty(self.esx_server, host_system)
for pg in prop.configManager.networkSystem.networkInfo.portgroup:
if pg.spec.name.lower() == name.lower():
real_name = pg.spec.name
# self._disconnect_from_esx()
return real_name
# self._disconnect_from_esx()
return None
# todo: add comment
def _is_vm_exist(self, name):
"""
:param name:
:return:
"""
self._connect_to_esx()
exist = False
try:
self.esx_server.get_vm_by_name(name)
exist = True
except:
pass
# self._disconnect_from_esx()
return exist
# todo: add comment
def _fetch_resource_pool(self, rp_name, esx_hostname):
"""
:param rp_name:
:param esx_hostname:
:return:
"""
rpmor = None
if rp_name == "/":
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == "/Resources"]
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
if prop.parent.name == esx_hostname:
rpmor = rp
break
else:
resource_pool = "/Resources" + rp_name
rp_mor_temp = [k for k, v in self.esx_server.get_resource_pools().items() if v == resource_pool]
for rp in rp_mor_temp:
prop = VIProperty(self.esx_server, rp)
while prop.parent.name != "host":
prop = prop.parent
if prop.name == esx_hostname:
rpmor = rp
break
if rp:
break
return rpmor
# todo: add comment
def _fetch_computer_resource(self, datacenter_props, host):
"""
:param datacenter_props:
:param host:
:return:
"""
host_folder = datacenter_props.hostFolder._obj
# get computer resources
computer_resources = self.esx_server._retrieve_properties_traversal(
property_names=["name", "host"], from_node=host_folder, obj_type="ComputeResource"
)
# get computer resource of this host
crmor = None
for cr in computer_resources:
if crmor:
break
for p in cr.PropSet:
if p.Name == "host":
for h in p.Val.get_element_ManagedObjectReference():
if h == host:
crmor = cr.Obj
break
if crmor:
break
return VIProperty(self.esx_server, crmor)
import sys
sys.path.append("./pysphere")
from pysphere import VIServer
from pysphere.resources.vi_exception import VIException, VIApiException, \
FaultTypes
import sys
if len(sys.argv) != 6:
sys.exit("error = please check arguments")
serverName = sys.argv[1]
login = sys.argv[2]
passwd = sys.argv[3]
vm_name = sys.argv[4]
snap_name = sys.argv[5]
server = VIServer()
server.connect(serverName, login, passwd)
myVm = server.get_vm_by_name(vm_name)
try:
deleteTask = myVm.delete_named_snapshot(snap_name)
server.disconnect()
except (VIException), err:
print "DeleteResult = " + err.message
sys.exit(1)
if deleteTask is None:
print "DeleteResult = success"
else:
print "DeleteResult = failure"
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())
from pysphere import VIServer, VITask
from pysphere.resources import VimService_services as VI
server = VIServer()
server.connect("172.16.1.239", "Administrator", "pass*&^")
memory_mb = 512
vm_obj = server.get_vm_by_name("DEV_VM.clone")
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm_obj._mor)
_this.set_attribute_type(vm_obj._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
#set the new RAM size
spec.set_element_memoryMB(memory_mb)
#set the no of CPU and socket
spec.set_element_numCPUs(2)
#spec.set_element_numCoresPerSocket(2)
request.set_element_spec(spec)
ret = server._proxy.ReconfigVM_Task(request)._returnval
#Wait for the task to finish
task = VITask(ret, server)
status = task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if status == task.STATE_SUCCESS:
print "VM successfully reconfigured"
options.username
except NameError:
options.username = raw_input("Enter the usename to use: ")
try:
options.password
except NameError:
options.password = getpass()
try:
options.template
except NameError:
options.template = raw_input("Enter the template to use: ")
server = VIServer()
server.connect(options.vcenter,options.username,options.password)
vm = server.get_vm_by_name(options.template)
task = vm.power_on(sync_run=False)
try:
status = task.wait_for_state(['running', 'error'], timeout=10)
if status == 'error':
print "Error powering on:", task.get_error_message()
else:
print "Successfully powered on"
except:
print "10 second timeout reached waiting for power to finish"
server.disconnect
class ESXi_Server:
server_ip = ''
user_name = ''
password = ''
connect_flag = False
server = None
# vm_list = []
# Use the given args to connect the esxi server you want
# @ip[string]: ESXi server's IP address
# @name[string]: the username used to login the ESXi server
# @pwd[string]: the password used to login the ESXi server
def connect_server(self, ip, name, pwd):
self.server_ip = ip
self.user_name = name
self.password = pwd
self.server = VIServer()
self.server.connect(self.server_ip, self.user_name, self.password)
self.connect_flag = self.server.is_connected()
if self.connect_flag:
return True
return False
# To get all the definition registered vms from the connected server
# @param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED
# According to the param, returns a list of VM Paths. You might also filter by datacenter,
# cluster, or resource pool by providing their name or MORs.
# if cluster is set, datacenter is ignored, and if resource pool is set
# both, datacenter and cluster are ignored.
def get_registered_vms(self, param, status=None, datacenter=None, cluster=None,
resource_pool=None):
if param not in ['ALL', 'POWERED ON', 'POWERED OFF', 'SUSPENDED']:
LOG.debug("Get VMs error: param can only be set as ALL, POWERED ON,\
POWERED OFF, or SUSPENDED.")
return None
if not self.connect_flag:
LOG.info("Get VMs error: Server not connected.")
return None
if param == 'ALL':
return self.server.get_registered_vms(datacenter, cluster, resource_pool)
elif param == 'POWERED ON':
return self.server.get_registered_vms(
datacenter,
cluster,
resource_pool,
status='poweredOn')
elif param == 'POWERED OFF':
return self.server.get_registered_vms(
datacenter,
cluster,
resource_pool,
status='poweredOff')
elif param == 'SUSPENDED':
return self.server.get_registered_vms(
datacenter,
cluster,
resource_pool,
status='suspended')
else:
return None
# Disconnect to the Server
def disconnect(self):
if self.connect_flag:
self.server = self.server.disconnect()
self.connect_flag = False
# To keep session alive
def keep_session_alive(self):
return self.server.keep_session_alive()
# To get the server type
def get_server_type(self):
return self.server.get_server_type()
# To get performance manager
def get_performance_manager(self):
return self.server.get_performance_manager()
# To get the all the server's hosts
def get_all_hosts(self):
"""
Returns a dictionary of the existing hosts keys are their names
and values their ManagedObjectReference object.
"""
return self.server.get_hosts()
# To get all datastores
def get_all_datastores(self):
"""
Returns a dictionary of the existing datastores. Keys are
ManagedObjectReference and values datastore names.
"""
return self.server.get_datastores()
# To get all clusters
def get_all_clusters(self):
"""
Returns a dictionary of the existing clusters. Keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_clusters()
# To get all datacenters
def get_all_datacenters(self):
"""
Returns a dictionary of the existing datacenters. keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_datacenters()
# To get all resource pools
def get_all_resource_pools(self):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
"""
return self.server.get_resource_pools()
# To get hosts by name
def get_hosts_by_name(self, from_mor):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
@from_mor: if given, retrieves the hosts contained within the specified
managed entity.
"""
try:
hosts_dic = self.server.get_hosts(from_mor)
except:
LOG.error("Get hosts error!")
return None
return hosts_dic
def run_vm_by_name(self, name):
"""
Run vm by name.
"""
try:
vm = self.server.get_vm_by_name(name)
status = vm.get_status()
if status == 'POWERED ON':
pass
elif status == 'POWERED OFF':
try:
vm.power_on()
except:
LOG.error("Run vm error!")
pass
else:
pass
except:
LOG.error("Get vm status error when runing vm!")
pass
def stop_vm_by_name(self, name):
"""
Run vm by name.
"""
try:
vm = self.server.get_vm_by_name(name)
status = vm.get_status()
if status == 'POWERED OFF':
pass
elif status == 'POWERED ON':
try:
vm.power_off()
except:
LOG.error("Stop vm error!")
pass
else:
pass
except:
LOG.error("Get vm status error when stopping vm!")
pass
def get_vm_status_by_name(self, name):
"""
Get vm status by nam
"""
try:
vm = self.server.get_vm_by_name(name)
status = vm.get_status()
LOG.info("Get VM status is %s" % status)
return status
except:
LOG.info("Get VM status error!")
return None
import sys
from pysphere import VIServer, VITask
from pysphere.resources import VimService_services as VI
server = VIServer()
server.connect("172.16.1.239", "Administrator", "pass*&^")
memory_mb = 2048
hd_sizes_kb = {'Hard disk 1': 40000000} #1 GB
vm_obj = server.get_vm_by_name("Windows server")
hd_to_modify = []
for dev in vm_obj.properties.config.hardware.device:
if dev._type == "VirtualDisk" and dev.deviceInfo.label in hd_sizes_kb:
dev_obj = dev._obj
dev_obj.set_element_capacityInKB(hd_sizes_kb[dev.deviceInfo.label])
hd_to_modify.append(dev_obj)
request = VI.ReconfigVM_TaskRequestMsg()
_this = request.new__this(vm_obj._mor)
_this.set_attribute_type(vm_obj._mor.get_attribute_type())
request.set_element__this(_this)
spec = request.new_spec()
#set the new RAM size
spec.set_element_memoryMB(memory_mb)
#Change the HDs sizes
dev_changes = []
for hd in hd_to_modify:
#!/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(IP,user,password)
vmlist = server.get_registered_vms()
vmpathlist = server.get_registered_vms(status='poweredOn')
vm = server.get_vm_by_name("web_public")
vm.get_status()
vm.power_on()
server.connect(IP,user,password)
9.196 9.40
get_clusters
get_datacenters
get_datastores
get_resource_pools
#!/usr/bin/env python
from pysphere import VIServer
server = VIServer()
server.set_ssl_no_verify()
server.connect("my.esx.host.example.org", "username", "secret")
vm = server.get_vm_by_name("MyGuestVMName", datacenter="MyCluster")
vm.wait_for_tools(timeout=30)
print "VMware tool status: {0}".format(vm.get_tools_status())
if not vm.get_tools_status() == "RUNNING":
print "VMware tool status: {0}".format(vm.get_tools_status())
raise Exception("VMWare tools is not running")
vm.login_in_guest("GuestAccount", "GuestPassword")
try:
vm.start_process("C:\\Windows\\System32\\cmd.exe",
args=["/K timeout /t 50"],
sync_run=True,
timeout=10)
except Exception as e:
print e
server.disconnect()
if(not vm in vm_d):
if(is_replica):
ERROR(ErrorCode.E_MISSING_REPLICA,appid," (%s)" % vm)
else:
ERROR(ErrorCode.E_MISSING_VM,appid," (%s)" % vm)
continue
m = re.match('(\S+-\S+-\S+-\S+-(AMP|MGMT))',appid)
clstrid = m.group(1)
if(clstrid_d[clstrid] != host_d[vm_d[vm]]):
ERROR(ErrorCode.E_WRONG_CLUSTER,appid,"| Actual %s" % clstrname_d[host_d[vm_d[vm]]])
vmo = None
try:
vmo = vc.get_vm_by_name(vm)
osstr = vmo.get_property('guest_full_name')
except:
raise Exception("Failed to get VM object %s (%s)",appid,vm)
if(is_replica and (not re.match('.+-(M|LS)$',appid))):
if(vmo.is_powered_off()):
logger.info ("VERIFIED %s (%s/%s)",appid,vm,osstr)
else:
logger.error ("Replica VM is running %s (%s)",appid,vm)
else:
if(vmo.is_powered_on()):
logger.info ("VERIFIED %s (%s/%s)",appid,vm,osstr)
else:
logger.error ("VM not running %s (%s)",appid,vm)
options.vcenter = raw_input("Enter the vCenter to connect to: ")
try:
options.username
except NameError:
options.username = raw_input("Enter the usename to use: ")
try:
options.password
except NameError:
options.password = getpass()
try:
options.vm_path
except NameError:
options.vm_path = raw_input("Enter the Template/VM to convert: ")
# Make the vcenter connection
server = VIServer()
server.connect(options.vcenter, options.username, options.password)
vm = server.get_vm_by_name(options.vm_path)
request = VI.MarkAsTemplateRequestMsg()
_this = request.new__this(vm._mor)
_this.set_attribute_type(vm._mor.get_attribute_type())
request.set_element__this(_this)
server._proxy.MarkAsTemplate(request)
server.disconnect()
HOST = "my esxi server"
USER = "******"
PASSWORD = "******"
DATASTORE_NAME = "datastore1" #WHERE THE DISK WILL BE CREATED AT
DISK_SIZE_IN_MB = 500
VM_PATH = "[datastore1-data] vm-test-name/vm-test-name.vmx"
VM_NAME = "vm-test-name"
DISK_NAME = "50gData.vmdk"
UNIT_NUMBER = 1
s = VIServer()
s.connect(HOST, USER, PASSWORD)
#vm = s.get_vm_by_path(VM_PATH)
vm = s.get_vm_by_name(VM_NAME)
disks = [
d for d in vm.properties.config.hardware.device
if d._type == 'VirtualDisk' and d.backing._type in [
'VirtualDiskFlatVer1BackingInfo', 'VirtualDiskFlatVer2BackingInfo',
'VirtualDiskRawDiskMappingVer1BackingInfo',
'VirtualDiskSparseVer1BackingInfo', 'VirtualDiskSparseVer2BackingInfo'
]
]
print "Number of disks = %s" % len(disks)
UNIT_NUMBER = len(disks)
request = VI.ReconfigVM_TaskRequestMsg()
help='Do not remove devices from property')
parser.add_argument('-f',
'--files',
action='store_true',
help='Do not remove files from property')
parser.add_argument('vm_name', help='The name of the VM')
args = parser.parse_args()
kwargs = {}
if args.trace:
kwargs['trace_file'] = args.trace.name
# connect to vCenter
server = VIServer()
server.connect(args.vcenter, args.vuser, args.vpass, **kwargs)
# specify the name of a VM
vm = server.get_vm_by_name(args.vm_name)
data = vm.get_properties()
if not args.devices: del data['devices']
if not args.files: del data['files']
pprint.pprint(data)
server.disconnect()
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)
def main():
global vCenter, user, password, problem_keys
(options, args) = parse_args()
vCenter = options.vsphere
user = options.user
password = getpass.getpass("Please provide the password for "+user+":")
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
svr = VIServer()
for host in options.hostname:
print colors.yellow+"Starting fix for "+host+colors.endc
if options.pretend is True:
print colors.green+"This system will not be harmed during the course of this script."
print "Meaning: it will "+colors.red+"NOT"+colors.green+" be shutdown, changed, reloaded and powered on again."+colors.endc
print ""
print "Searching vCenter membership"
vmobj = None
for e in options.vsphere:
svr.connect(e,options.user,password)
try:
vm = svr.get_vm_by_name(host)
vCenterHost = e
break
except:
vm = None
if vm is None:
print colors.red+"'"+host+"' could not be found on any of the vCenter servers. Aborting."+colors.endc
continue
else:
print colors.green+"Found: "+vCenterHost+colors.endc
print "Determining ESX host"
try:
temp = vm.properties
esxhost = temp.runtime.host.name
except:
print colors.red+"Could not determine the physical host for '"+host+"'. Aborting."+colors.endc
continue
print colors.green+"Found:", esxhost, colors.endc
print "Determining local path to vmx file"
try:
vmxpath = vm.get_property("path").replace("[","/vmfs/volumes/").replace("] ","/")
except:
print colors.red+"Could not determine the vmx file path for '"+host+"'. Aborting."+colors.endc
continue
print colors.green+"Found:", vmxpath, colors.endc
print "Retrieving vmx file"
try:
ssh.connect(esxhost, username="******")
except:
print colors.red+"Could not connect to "+esxhost+" over ssh. Aborting."+colors.endc
continue
stdin, stdout, stderr = ssh.exec_command("cat "+vmxpath)
out = stdout.read()
print colors.green+"Done"+colors.endc
print "Looking for problem keys"
severity = 0
for key in problem_keys:
if key in out:
print colors.yellow+"Found: "+key+colors.endc
severity = severity +1
print colors.green+"Done"+colors.endc
if severity == 0:
print colors.yellow+"None of the offending keys have been found"+colors.endc
if options.force == False:
print colors.red+"Aborting"+colors.endc
continue
if options.pretend is not True:
print "Powering off the vm"
try:
if vm.get_status(basic_status=True) == 'POWERED ON':
vm.shutdown_guest()
count = 0
ret = ''
while ret != "POWERED OFF":
sleep(1)
ret = vm.get_status(basic_status=True)
count = count +1
if count > 300:
print "The system did not gracefully shutdown. Please fix. Aborting all."
exit(1)
elif vm.get_status(basic_status=True) == 'POWERED OFF':
print "The system is either already shutdown, or there are no vmware tools installed."
raw_input("Press ENTER to continue or CTRL+C to abort")
except:
print colors.red+"Something went wrong powering off "+host+". Aborting."+colors.endc
break
else:
print "Pretending to power off the vm"
print colors.green+"Done."+colors.endc
if options.pretend is not True:
print "Modifying vmx file."
cmd = "cp "+vmxpath+ " "+vmxpath+".hwfix;"
cmd = cmd + "sed -i -e '/^virtualHW.scheduledUpgrade.when\\b/d' -e '/^virtualHW.scheduledUpgrade.state\\b/d' -e '/^tools.upgrade.policy\\b/d' "+vmxpath
try:
ssh.connect(esxhost, username="******")
stdin, stdout, stderr = ssh.exec_command(cmd)
except:
print colors.red+"Could not connect to "+esxhost+" over ssh. Aborting."+colors.endc
break
else:
print "Pretending to modify the vmx file."
print colors.green+"Done."+colors.endc
if options.pretend is not True:
print "Reloading the vm's config file."
vm.reload()
else:
print "Pretending to reloading the vm's config file."
print colors.green+"Done."+colors.endc
if options.pretend is not True:
print "Starting the vm."
try:
sleep(5)
vm.power_on()
except:
print colors.red+"Something went wrong powering on "+host+". Aborting."+colors.endc
continue
else:
print "Pretending to start the vm."
print colors.green+"Done"+colors.endc
print ""
print colors.green+host+" is fixed."+colors.endc
if options.pretend is True:
print colors.green+"But not really..."+colors.endc
print ""
#!/usr/bin/python
'''
Author: Pryz
Description: Get current status and properties of a VM with pysphere
'''
from pysphere import VIServer
# Connect to the vcenter
LOGIN = "******"
PWD = "password"
VCENTER = "vcenter.labo.fr"
SERVER = VIServer()
SERVER.connect(VCENTER, LOGIN, PWD)
VMNAME = "vm1.labo.fr"
VM = SERVER.get_vm_by_name(VMNAME)
print VM.get_status()
print VM.get_property('ip_address')
print VM.get_properties()
# Close connection
SERVER.disconnect()
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(),
)
class VCenterManagement:
server_ip = ''
user_name = ''
password = ''
connect_flag = False
server = None
#vm_list = []
#def __init__(self):
#Use the given args to connect the esxi server you want
#@ip[string]: ESXi server's IP address
#@name[string]: the username used to login the ESXi server
#@pwd[string]: the password used to login the ESXi server
def connect_server(self, ip, name, pwd):
self.server_ip = ip
self.user_name = name
self.password = pwd
self.server = VIServer()
self.server.connect(self.server_ip, self.user_name, self.password)
self.connect_flag = self.server.is_connected()
if self.connect_flag:
return True
return False
#To get all the definition registered vms from the connected server
#@param[string]: can be set as ALL, POWER_ON, POWER_OFF, SUSPENDED
#According to the param, returns a list of VM Paths. You might also filter by datacenter,
#cluster, or resource pool by providing their name or MORs.
#if cluster is set, datacenter is ignored, and if resource pool is set
#both, datacenter and cluster are ignored.
def get_registered_vms(self,
param,
status=None,
datacenter=None,
cluster=None,
resource_pool=None):
if param not in ['ALL', 'POWER_ON', 'POWER_OFF', 'SUSPENDED']:
print "Get VMs error: param can only be set as ALL, POWER_ON, POWER_OFF, or SUSPENDED."
return None
if self.connect_flag == False:
print "Get VMs error: Server not connected."
return None
if param == 'ALL':
return self.server.get_registered_vms(datacenter, cluster,
resource_pool)
elif param == 'POWER_ON':
return self.server.get_registered_vms(datacenter,
cluster,
resource_pool,
status='poweredOn')
elif param == 'POWER_OFF':
return self.server.get_registered_vms(datacenter,
cluster,
resource_pool,
status='poweredOff')
elif param == 'SUSPENDED':
return self.server.get_registered_vms(datacenter,
cluster,
resource_pool,
status='suspended')
else:
return None
#Disconnect to the Server
def disconnect(self):
if self.connect_flag == True:
self.server = self.server.disconnect()
self.connect_flag == False
#To keep session alive
def keep_session_alive(self):
assert self.server.keep_session_alive()
#To get the server type
def get_server_type(self):
return self.server.get_server_type()
#To get performance manager
def get_performance_manager(self):
return self.server.get_performance_manager()
#To get the all the server's hosts
def get_all_hosts(self):
"""
Returns a dictionary of the existing hosts keys are their names
and values their ManagedObjectReference object.
"""
return self.server.get_hosts()
#To get all datastores
def get_all_datastores(self):
"""
Returns a dictionary of the existing datastores. Keys are
ManagedObjectReference and values datastore names.
"""
return self.server.get_datastores()
#To get all clusters
def get_all_clusters(self):
"""
Returns a dictionary of the existing clusters. Keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_clusters()
#To get all datacenters
def get_all_datacenters(self):
"""
Returns a dictionary of the existing datacenters. keys are their
ManagedObjectReference objects and values their names.
"""
return self.server.get_datacenters()
#To get all resource pools
def get_all_resource_pools(self):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
"""
return self.server.get_resource_pools()
#To get hosts by name
def get_hosts_by_name(self, from_mor):
"""
Returns a dictionary of the existing ResourcePools. keys are their
ManagedObjectReference objects and values their full path names.
@from_mor: if given, retrieves the hosts contained within the specified
managed entity.
"""
try:
hosts_dic = self.server.get_hosts(from_mor)
except:
print "Get hosts error!"
return None
return hosts_dic
def get_vm_by_name(self, vm_name):
try:
vm = self.server.get_vm_by_name(vm_name)
except:
print "Get vm error!"
return None
return vm
def power_on_vm(self, vm_name):
try:
vm = self.get_vm_by_name(vm_name)
if (vm.is_powered_off()):
vm.power_on()
print "vm " + vm_name + " power on success."
else:
print "vm " + vm_name + "is already power on"
return False
except:
print "Power on vm " + vm_name + "error"
return False
return True
def power_off_vm(self, vm_name):
try:
vm = self.get_vm_by_name(vm_name)
if (vm.is_powered_on()):
vm.power_off()
print "vm " + vm_name + " power off success."
else:
print "vm " + vm_name + "is already power off"
return False
except:
print "Power off vm " + vm_name + " error"
return False
return True
def main():
setup_logger()
log(level="info",
msg="===================================================")
log(level="info", msg="detect_installation_completion logger initialized.")
opts = options()
# CONNECTION PARAMTERS
server = opts.esx_host
user = opts.user
password = opts.passwd
# REQUIRED PARAMETERS
vmname = opts.name
# CONNECT TO THE SERVER
s = VIServer()
s.connect(server, user, password)
log(level="info", msg="Attempting to locate the guest VM: %s" % vmname)
count = 1
wait_for = 10
while count < wait_for:
count += 1
try:
guest_vm = s.get_vm_by_name(opts.name)
if guest_vm:
break
except Exception as e:
if count >= wait_for:
log(level="error", msg="Failed to locate the new VM (%s) even after %s seconds." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
time.sleep(1)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
check_count(count, wait_for)
log(level="info", msg="Located VM: %s" % vmname)
log(level="info", msg="Waiting for the OS installation to complete...")
log(level="info", msg="Will wait for about 60 minutes (at max) ...")
wait_for = 3600 # 1 hour.
log(level="info",
msg="Note: There will be no output as the process would be blocked in waiting state until the Guest OS responds.")
log(level="info",
msg="Will automatically timeout after an hour (at max) ...")
try:
guest_vm.wait_for_tools(timeout=wait_for)
except Exception as e:
if count >= wait_for:
log(level="error", msg="Failed to get OS installation status in the new VM (%s) even after %s seconds." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
log(level="info", msg="Received response from the Guest OS.")
log(level="info",
msg="Attempting to login in the Guest to check the status of the OS instalaltion (timeout 5 minutes) ...")
count = 1
wait_for = 300 # 5 minutes
while count < wait_for:
try:
guest_vm.login_in_guest(opts.username, opts.password)
break
except Exception as e:
if count >= wait_for:
log(level="error", msg="Failed to login to the Guest (%s) even after %s seconds." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
count += 1
time.sleep(1)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
check_count(count, wait_for)
log(level="info", msg="Successfully logged into guest.")
log(level="info",
msg="Checking the progress of the OS installation (will timeout after 30 minutes (at max)) ...")
log(level="info", msg="OS installation is still in progress.")
log(level="info",
msg="Waiting for it to complete (will timeout after 60 minutes (at max)) ...")
count = 1
wait_for = 3600 # 60 minutes
filename = "/etc/INSTALLATION_COMPLETED"
while count < wait_for:
try:
flag_file = guest_vm.list_files(filename)
if flag_file[0]['path'] == filename:
log(level="info",
msg="OS installation has completed. Successfully.")
break
except Exception as e:
if count >= wait_for:
log(level="error", msg="OS installation is still in progress in %s even after %s seconds. This is not expected." %
(vmname, str(wait_for)))
log(level="info", msg="Please login to the EXSi server and fix the issue. Exception: %s" %
str(e))
sys.exit(1)
count += 180
time.sleep(180)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
check_count(count, wait_for)
if opts.fetch_ip is True:
vm_ip = guest_vm.get_property(
'net', from_cache=False)[0]['ip_addresses'][0]
log(level="info", msg="IP address of the deployed VM: %s" % str(vm_ip))
ip_file_path = settings.DEPLOYED_VM_IP_SAVE_FOLDER + "/%s.txt" % vmname
try:
with open(ip_file_path, 'w') as f:
f.write(vm_ip)
log(level="info", msg="Saved the IP of the deployed machine in: %s" %
ip_file_path)
f.close()
except:
log(level="error", msg="Failed to save the IP information in %s. Please try again." %
ip_file_path)
else: # if opts.fetch_ip == False
try:
network_fix = guest_vm.list_files('/etc/init.d/vm_network_fix')
log(level="info", msg="Network fix already exists. Nothing needs to be done.")
except:
try:
# Network fix does not exist.
log(level="info", msg="Network fix does not exist. Uploading vm_network_fix.")
guest_vm.send_file('vm_network_fix', '/etc/init.d/vm_network_fix', overwrite=True)
log(level="info", msg="Upload of vm_network_fix successful. Changing permissions.")
guest_vm.start_process('/bin/chmod', args=[
'755', 'vm_network_fix'], cwd='/etc/init.d')
time.sleep(1)
log(level="info", msg="Changing permissions successful. Adding the daemon to start-up sequence.")
guest_vm.start_process('/sbin/chkconfig', args=[
'--add', 'vm_network_fix'], cwd='/etc/init.d')
time.sleep(1)
log(level="info", msg="Updating start-up sequence successful. Starting the daemon.")
guest_vm.start_process('/sbin/service', args=[
'vm_network_fix', 'start'], cwd='/etc/init.d')
time.sleep(1)
log(level="info", msg="Daemon process started successfully.")
except Exception as e:
log(level="error", msg="Failed to upload vm_network_fix and start the daemon. Exception: " + str(e))
log(level="info",
msg="Waiting for 60 seconds so that all services start successfully.")
count = 1
wait_for = 60
while count < wait_for:
count += 2
time.sleep(2)
log(level="info", msg="Elapsed %s seconds ..." % str(count))
log(level="info", msg="All services should be up and running now ...")
log(level="info",
msg="Issuing a graceful shutdown request to the Guest.")
try:
guest_vm.start_process('/sbin/shutdown', args=[
'-h', 'now'], cwd='/root')
time.sleep(1)
count = 1
wait_for = 900 # 30 minutes.
log(level="info", msg="Waiting for the Guest to power-off ...")
while guest_vm.is_powered_off() is False:
time.sleep(1)
count += 1
log(level="info", msg="Elapsed %s seconds ..." % str(count))
if count >= wait_for:
log(level="warning",
msg="Its been 30 minutes and yet the system did not poweroff. This not expected.")
log(level="warning",
msg="OVFTool may hard-poweroff the VM while attempting to create an OVA of it.")
break
if count < wait_for:
log(level="info", msg="%s powered off successfully." % vmname)
except Exception as e:
log(level="error",
msg="Could not issue a graceful shutdown request to the guest.")
log(level="warning",
msg="OVFTool may hard-poweroff the VM while attempting to create an OVA of it.")
log(level="error", msg="Exception: %s" % str(e))
# Disconnect CDROM device from the VM.
try:
disconnect_vm_cdroms(guest_vm, s)
log(level="info", msg="Disconnected Virtual CDROM from %s successfully." %
vmname)
except:
log(level="error", msg="Exception while attempting to disconnect the virtual CD rom of %s." %
vmname)
log(level="error", msg="Exception: %s" % str(e))
# disconnect from the server
s.disconnect()
sys.exit(0)
import sys
sys.path.append("./pysphere")
from pysphere import VIServer
import sys
if len(sys.argv) != 5:
sys.exit("error = please check arguments")
serverName = sys.argv[1]
login = sys.argv[2]
passwd = sys.argv[3]
vm_name = sys.argv[4]
server = VIServer()
server.connect(serverName, login, passwd)
myVm = server.get_vm_by_name(vm_name)
snapList = myVm.get_snapshots()
server.disconnect()
for snap in snapList:
print "Name =", snap.get_name()
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')
print vm1.get_status()
#Also you can ask the following:
print vm1.is_powering_off()
print vm1.is_powered_off()
print vm1.is_powering_on()
print vm1.is_powered_on()
print vm1.is_suspending()
print vm1.is_suspended()
print vm1.is_resetting()
print vm1.is_blocked_on_msg()
print vm1.is_reverting()
#For power options:
# Add a CD-ROM device to the VM.
add_cdrom("iso", cd_iso_location)
add_nic("vmxnet3", network_name, "dvs")
#add_nic("vmxnet3", "VM Network", "standard")
config.set_element_deviceChange(devices)
create_vm_request.set_element_config(config)
folder_mor = create_vm_request.new__this(vmfmor)
folder_mor.set_attribute_type(vmfmor.get_attribute_type())
create_vm_request.set_element__this(folder_mor)
rp_mor = create_vm_request.new_pool(rpmor)
rp_mor.set_attribute_type(rpmor.get_attribute_type())
create_vm_request.set_element_pool(rp_mor)
host_mor = create_vm_request.new_host(hostmor)
host_mor.set_attribute_type(hostmor.get_attribute_type())
create_vm_request.set_element_host(host_mor)
# CREATE THE VM
taskmor = s._proxy.CreateVM_Task(create_vm_request)._returnval
task = VITask(taskmor, s)
task.wait_for_state([task.STATE_SUCCESS, task.STATE_ERROR])
if task.get_state() == task.STATE_ERROR:
raise Exception("Error creating vm: %s" % task.get_error_message())
# If there is any extra config options specified, set them here.
if extra_config:
vm = s.get_vm_by_name(vmname)
vm.set_extra_config(extra_config)
s.disconnect()
#!/usr/bin/env python
from pysphere import VIServer
server = VIServer()
server.set_ssl_no_verify()
server.connect("my.esx.host.example.org", "username", "secret")
vm = server.get_vm_by_name("MyGuestVMName", datacenter="MyCluster")
vm.wait_for_tools(timeout=30)
print "VMware tool status: {0}".format(vm.get_tools_status())
if not vm.get_tools_status() == "RUNNING":
print "VMware tool status: {0}".format(vm.get_tools_status())
raise Exception("VMWare tools is not running")
vm.login_in_guest("GuestAccount", "GuestPassword")
vm.send_file("Local_file_path", "Remote_file_path", overwrite=True)
server.disconnect()
import sys from pysphere import VIServer server = VIServer() server.connect(sys.argv[1], sys.argv[2], sys.argv[3]) vm = server.get_vm_by_name(sys.argv[4]) vm.revert_to_snapshot() print "VM prepared."
if template != "":
if verbose:
print ""
print " Clone "
print "============="
def get_status(clonedVM):
st = clonedVM.get_status()
print "----> VM: '%s', Status: %s" % (clonedVM.get_property("name"),
st)
return st
first_resource_pool = get_resource_pools(vserver)
print "--> Cloning template '%s' as VM '%s' in vCenter (%s)" % (
template, hostname, vcenter)
template_vm = vserver.get_vm_by_name(template)
clonedVM = template_vm.clone(hostname,
resourcepool=first_resource_pool,
power_on='False')
sleep(5)
st = get_status(clonedVM)
while st == "Running":
st = get_status(clonedVM)
if st == "Success":
break
elif st != "Running":
print "ERROR --> Something went amiss with clone... status '%s'!" % st
exit(1)
sleep(5)
if verbose:
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)
try:
from pysphere import VIServer
def descon(vc):
if server.is_connected() == True:
print "Disconnecting from " + str(vc)
server.disconnect()
else:
print "cannot to vc " + i
except ImportError:
print "try to install pysphere module"
sys.exit(1)
vcenters = [ ]
for i in vcenters:
try:
try:
server = VIServer()
server.connect(i, "SDA\user01", "password")
if server.is_connected() == True:
vm = server.get_vm_by_name(name.upper())
if vm is not None:
print "Found " + name.upper() + " on " + i
#descon(i)
# break
except:
descon(i)
pass
except:
pass
def main():
####### MAIN #######
t0 = time.clock()
if len(sys.argv) == 3:
vm1Guest = sys.argv[1]
vm1DataCenter = sys.argv[2]
else:
print "Usage: ./script guestName dataCenter \n\n dataCenter is ABC, DEF or FGH \n\n"
exit()
print " -->> Begin"
server = VIServer()
server.connect(server1, userLDAP, passLDAP)
print "VMGuest : %s" % vm1Guest
print "Datacenter : %s" % vm1DataCenter
vm1 = server.get_vm_by_name(vm1Guest, vm1DataCenter)
vm1Path = vm1.get_property('path', from_cache=False)
vm1Path = vm1Path.split(' ', 1);
vm1DataStore = vm1Path[0].strip('[]')
vm1FolderTmp = vm1Path[1].split('/')
vm1Folder = vm1FolderTmp[0].strip()
print "VMDataStore: %s" % vm1DataStore
print "VMFolder : %s" % vm1Folder
print "VMStatus : %s" % vm1.get_status(basic_status=True)
if vm1.is_powered_on():
print "%s is powered ON" % vm1Guest
vm1.power_off()
t1 = time.clock()
while vm1.is_powering_off():
print "waiting power of..."
t = time.clock() - t1
print "%f seconds", t
print "%s is NOW powered OFF" % vm1Guest
if vm1.is_powered_off() and vm1DataStore is not None and vm1Folder is not None:
server.disconnect()
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
print "Connecting to %s" % splitOrigemHost
ssh.connect(splitOrigemHost, username=userLDAP, password=passLDAP, timeout=5)
vm1Path = '/vmfs/volumes/%s/%s/' % (vm1DataStore, vm1Folder)
print "Copying files from %s to %s" % (vm1Path, splitDestPath)
stdin, stdout, stderr = ssh.exec_command('scp -p -r root@%s:"\'%s\'" %s && echo "Scp Done!" && chmod -R 755 %s/"%s"/ ' % (vmOrigemHost, vm1Path, splitDestPath, splitDestPath, vm1Folder) )
for i in stdout.readlines():
print i.strip()
for i in stderr.readlines():
print i.strip()
print "We got something on stderr, aborting script. Probably errors on SCP."
exit()
stdin1, stdout1, stderr1 = ssh.exec_command('ls -1sSh %s"%s"/' % (splitDestPath, vm1Folder) )
for i in stdout1.readlines():
print i.strip()
stdin2, stdout2, stderr2 = ssh.exec_command('ls -1 %s"%s"/' % (splitDestPath, vm1Folder) )
filesArray = []
for i in stdout2.readlines():
filesArray.append(i.strip())
ssh.close()
print "Everything DONE for first copy phase, now get files on other side"
print "Connecting to %s" % splitDestHost
ssh.connect(splitDestHost, username=userLDAP, password=passLDAP, timeout=5)
for i in filesArray:
print "\nDownloading at %s, from %s. File: %s" % (splitDestHost, splitOrigemHostFr, i)
stdin, stdout, stderr = ssh.exec_command('aria2c --conditional-get=true --max-concurrent-downloads=16 --max-connection-per-server=16 --split=16 --continue=true --connect-timeout=300 --max-tries=5 --dir="%s%s/" \'http://%s/%s/%s\' && echo "Download OK!"' % (splitDestPath, vm1Folder, splitOrigemHostFr, vm1Folder, i) )
for j in stdout.readlines():
print "ARIA2C log: %s" % j.strip()
for j in stderr.readlines():
print "ARIA2C stderr log: %s" % j.strip()
print "Download at %s was OK!" % splitDestHost
if vmDestDataStore is not None and vm1Folder is not None:
vm1Path = '/vmfs/volumes/%s/' % (vmDestDataStore)
print "Sending files from %s:%s%s/, to %s:%s" % (splitDestHost, splitDestPath, vm1Folder, vmDestHost, vm1Path)
stdin, stdout, stderr = ssh.exec_command('scp -p -r \'%s%s/\' root@%s:"%s" && echo "Scp Done!" ' % (splitDestPath, vm1Folder, vmDestHost, vm1Path) )
for i in stderr.readlines():
print i.strip()
print "Registering guest on VMWare"
vm1Path = '/vmfs/volumes/%s/%s/' % (vmDestDataStore, vm1Folder)
stdin, stdout, stderr = ssh.exec_command('ssh root@%s ls -1 "\'%s\'"*.vmx' % (vmDestHost, vm1Path) )
vmxArray = []
for i in stdout.readlines():
vmxArray.append(i.strip())
#default guests name are guest01-abc, guest02-def, guest01-fgh , so "name-datacenter"
#just replace datacenter string
r = vm1Guest.find('-abc')
if r == -1:
regName = '%s-def' % vm1Guest
else:
regName = vm1Guest.replace('-abc', '-def')
if vmRPool:
print "Using predefined vmRPool: %s" % vmRPool
print "Registering path %s, name %s, pool %s" % (vmxArray[0], regName, vmRPool)
r = registerVM(ssh, vmDestHost, vmxArray[0], regName, vmRPool)
else:
print "Using automatic vmRPool automatic discover"
print "Registering path %s, name %s" % (vmxArray[0], regName)
r = registerVM(ssh, vmDestHost, vmxArray[0], regName, None)
if r == 0:
print "Guest is registered!"
else:
print "Error registering Guest."
ssh.close()
print "\nRunning cleanup of folder %s, path %s on %s and %s" % (vm1Folder, splitDestPath, splitOrigemHost, splitDestHost)
cleanPath = '%s%s/' % (splitDestPath, vm1Folder)
r = cleanUp(splitOrigemHost, cleanPath)
r = cleanUp(splitDestHost, cleanPath)
print "\nTotal running time: %f" % (time.clock() - t0)
print " -->> Done"
server = VIServer()
server.connect(vcenter, vcuser, password)
# Actions:
# 1. Shut the VM off
# 2. Delete existing VM snapshots
# 3. Create a new snapshot with VM name and current date.
# 4. Turn the VM back on
vm = server.get_vm_by_name('vm_name')
if vm.is_powered_on():
vm.power_off()
if vm.is_powered_off():
try:
vm.delete_current_snapshot(remove_children=True)
except:
help="specify password")
parser.add_option("-v", dest="vmName", type="string", help="specify new vm")
options, arguments = parser.parse_args()
print
print 'Begin configuration loop for VM %s' % options.vmName
vapp = {}
newconfig = {'add': [], 'edit': [], 'remove': []}
server = VIServer()
print '%s: Connecting to vsphere %s' % (options.vmName, options.vcenter)
server.connect(options.vcenter, options.vcenteruser, options.vcenterpass)
vm = server.get_vm_by_name(options.vmName)
'''
This section enables vApp Options
'''
print '%s: Enabling vApp Options' % options.vmName
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()
vappconfig = spec.new_vAppConfig()
vappconfig.set_element_ovfEnvironmentTransport(['com.vmware.guestInfo'])
spec.set_element_vAppConfig(vappconfig)
class Sphere():
"""
Routins for work with vSphere.
"""
def __init__(self):
try:
LOGGER.info('vSphereTools version used: {}'.format(__version__))
LOGGER.debug('vSphereTools Sphere() class initializing...')
self.vSphereServerInstance = VIServer(
) # Initialize main vSphere Server
self.vSphereServerInstance.connect(
VC_SERVER, VC_LOGIN, VC_PASSWORD) # Connect vSphere Client
self.vmInstance = self.vSphereServerInstance.get_vm_by_name(
VM_NAME) # Get instance of virtual machine
except Exception as e:
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
self.vSphereServerInstance = None
self.vm = None
LOGGER.error(
'Can not connect to vSphere! Maybe incorrect command? Show examples: vspheretools -h'
)
def VMStatus(self):
"""
Get status of virtual machine.
"""
try:
status = self.vmInstance.get_status()
LOGGER.info('Current status of virtual machine "{}": {}'.format(
VM_NAME, status))
except Exception as e:
status = None
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while getting status of virtual machine "{}"!'
.format(VM_NAME))
return status
def VMStart(self):
"""
Starting virtual machine.
"""
try:
status = self.VMStatus()
if status == 'POWERED OFF':
LOGGER.debug('Trying to start VM...')
self.vmInstance.power_on()
status = self.VMStatus()
else:
LOGGER.warning(
'Virtual machine "{}" powered on already!'.format(VM_NAME))
except Exception as e:
status = None
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while starting virtual machine "{}"!'.format(
VM_NAME))
return status
def VMStartWait(self):
"""
Starting virtual machine and wait while guest OS started.
"""
try:
status = self.VMStatus()
if status == 'POWERED OFF':
LOGGER.debug('Trying to start VM...')
self.vmInstance.power_on()
status = self.VMStatus()
LOGGER.debug('Waiting until OS started...')
self.vmInstance.wait_for_tools(timeout=OP_TIMEOUT)
else:
LOGGER.warning(
'Virtual machine "{}" powered on already!'.format(VM_NAME))
except Exception as e:
status = None
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while starting virtual machine "{}" and waiting for guest OS start!'
.format(VM_NAME))
return status
def VMStop(self):
"""
Stopping virtual machine.
"""
try:
status = self.VMStatus()
if status == 'POWERED ON':
LOGGER.debug('Trying to stop VM...')
self.vmInstance.power_off()
status = self.VMStatus()
else:
LOGGER.warning(
'Virtual machine "{}" powered off already!'.format(
VM_NAME))
except Exception as e:
status = None
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while stopping virtual machine "{}"!'.format(
VM_NAME))
return status
def GetVMProperties(self):
"""
Read all VM properties and return dictionary.
"""
try:
properties = self.vmInstance.get_properties(from_cache=False)
LOGGER.info(
'All properties of virtual machine "{}":'.format(VM_NAME))
for key in properties.keys():
if isinstance(properties[key], dict):
LOGGER.info(' {}:'.format(key))
for subKey in properties[key].keys():
if isinstance(properties[key], dict):
LOGGER.info(' {}:'.format(subKey))
for subSubKey in properties[key][subKey].keys():
LOGGER.info(' {}: {}'.format(
subSubKey,
properties[key][subKey][subSubKey]))
else:
LOGGER.info(' {}: {}'.format(
subKey, properties[key][subKey]))
else:
LOGGER.info(' {}: {}'.format(key, properties[key]))
except Exception as e:
properties = None
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while getting properties of virtual machine "{}"!'
.format(VM_NAME))
return properties
def GetVMSnapshotsList(self):
"""
Read and return list of all VM snapshots.
"""
try:
current = self.vmInstance.get_current_snapshot_name()
snapshots = self.vmInstance.get_snapshots()
if current and snapshots:
LOGGER.info(
'Name of current snapshot of virtual machine "{}": "{}"'.
format(VM_NAME, current))
LOGGER.info('List of all snapshots:')
for i, snap in enumerate(snapshots):
LOGGER.info(' {}. "'.format(i + 1) + snap.get_name() +
'"')
else:
LOGGER.warning(
'No snapshots found for virtual machine "{}"!'.format(
VM_NAME))
except Exception as e:
snapshots = None
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while getting list of snapshots of virtual machine "{}"!'
.format(VM_NAME))
return snapshots
def CreateVMSnapshot(self, **kwargs):
"""
Creating VM snapshots.
snapshotName - Snapshot name,
rewrite - rewriting snapshot if True and snapshot name exist already,
fail-if-exist - fail script or not if rewrite=False and snapshot name exist already.
"""
statusCode = 0 # process exit code
snapshotName = None
rewrite = True
failIfExist = False
try:
# --- Checking parameters:
LOGGER.debug('Initialization parameters:')
if 'name' in kwargs.keys():
snapshotName = kwargs['name']
LOGGER.debug(' Parameter "name" = {}'.format(snapshotName))
else:
LOGGER.error(' Parameter "name" not define!')
if 'rewrite' in kwargs.keys():
if kwargs['rewrite'].lower() == 'true':
rewrite = True
else:
rewrite = False
LOGGER.debug(' Parameter "rewrite" = {}'.format(rewrite))
if 'fail-if-exist' in kwargs.keys():
if kwargs['fail-if-exist'].lower() == 'true':
failIfExist = True
else:
failIfExist = False
LOGGER.debug(
' Parameter "fail-if-exist" = {}'.format(failIfExist))
# --- Creating snapshot from current state:
if snapshotName:
snapshots = self.GetVMSnapshotsList()
snapshotList = [snap.get_name() for snap in snapshots]
if snapshotName in snapshotList:
LOGGER.warning(
'Snapshot "{}" already exist!'.format(snapshotName))
if rewrite:
LOGGER.info(
'Removing exist snapshot because rewrite = True, "fail-if-exist" - ignored.'
)
self.vmInstance.delete_named_snapshot(snapshotName)
LOGGER.info(
'Old snapshot "{}" of virtual machine deleted.'.
format(snapshotName))
else:
if failIfExist:
LOGGER.error(
'Fail because fail-if-exist = True and rewrite = False.'
)
statusCode = 2
else:
statusCode = None # To do nothing, see next code "if statusCode is None:" ...
else:
LOGGER.error('Fail because snapshot name not define!')
statusCode = 1
if statusCode == 0:
LOGGER.info('New snapshot "{}" creating in progress...'.format(
snapshotName))
self.vmInstance.create_snapshot(snapshotName)
LOGGER.info(
'New snapshot from current state of virtual machine created successful.'
)
if statusCode is None:
LOGGER.warning(
'To do nothing because snapshot already exist and not rewrite and not fail enabled.'
)
statusCode = 0
except Exception as e:
statusCode = -1
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while creating snapshots of virtual machine "{}"!'
.format(VM_NAME))
return statusCode
def GetVMIPaddress(self):
"""
Read VM property and return ip-adress.
"""
ip = None
try:
startTime = datetime.now()
while not ip and (datetime.now() -
startTime).seconds <= OP_TIMEOUT:
LOGGER.debug(
'Trying to get ip-address (timeout = {})...'.format(
OP_TIMEOUT))
properties = self.vmInstance.get_properties(from_cache=False)
ip = None if 'ip_address' not in properties.keys(
) else properties['ip_address']
time.sleep(1)
if ip:
LOGGER.info('Virtual machine "{}" has ip-address: {}'.format(
VM_NAME, ip))
else:
LOGGER.info(
'Virtual machine "{}" has no ip-address.'.format(VM_NAME))
except Exception as e:
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'Can not set up ip-address of virtual machine "{}" into TeamCity!'
.format(VM_NAME))
return ip
def SetVMIPaddressIntoTeamCityParameter(self, paramName):
"""
Read VM property, get ip-adress and then set up ip into predefine TeamCity parameter, 'vm_ip' by default.
"""
ip = self.GetVMIPaddress()
key = 'vm_ip' if not paramName else paramName
if ip:
TeamCityParamSetter(keyName=str(key), value=ip)
else:
LOGGER.warning('Parameter {} does not set to {}!'.format(key, ip))
def VMRevertToCurrentSnapshot(self):
"""
Revert VM to current snapshot.
"""
statusCode = 0 # process exit code
LOGGER.debug(
'Trying to revert virtual machine "{}" into current snapshot...'.
format(VM_NAME))
try:
current = self.vmInstance.get_current_snapshot_name()
LOGGER.info('Current snapshot: "{}"'.format(current))
self.vmInstance.revert_to_snapshot()
LOGGER.info(
'Virtual machine "{}" revert to current snapshot successful.'.
format(VM_NAME))
self.VMStatus()
except Exception as e:
statusCode = -1
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while revert virtual machine "{}" into current snapshot!'
.format(VM_NAME))
return statusCode
def VMRevertToSnapshot(self, snapshotName=None):
"""
Revert VM to first snapshot by part of its name. If snapshotName not define then used current snapshot.
"""
statusCode = 0 # process exit code
try:
if snapshotName:
LOGGER.debug(
'Trying to revert virtual machine "{}" into snapshot "{}"...'
.format(VM_NAME, snapshotName))
self.vmInstance.revert_to_named_snapshot(name=snapshotName)
LOGGER.info(
'Virtual machine "{}" revert to snapshot "{}" successful.'.
format(VM_NAME, snapshotName))
self.VMStatus()
else:
statusCode = self.VMRevertToCurrentSnapshot()
except Exception as e:
statusCode = -2
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while revert virtual machine "{}" into snapshot "{}"!'
.format(VM_NAME, snapshotName))
return statusCode
def CloneVM(self, cloneName=None):
"""
Clone VM into directory VM_CLONES_DIR. If cloneName not define then name creates automatic.
"""
LOGGER.debug(
'Trying to clone virtual machine "{}" into directory "{}"...'.
format(VM_NAME, VM_CLONES_DIR))
try:
if cloneName:
try:
self.vSphereServerInstance.get_vm_by_name(cloneName)
LOGGER.debug('Name already used: {}'.format(cloneName))
cloneName = None
except Exception as e:
LOGGER.debug(e)
LOGGER.debug('Name not used: {}'.format(cloneName))
i = 1
while not cloneName:
try:
cloneName = 'clone-{}-'.format(i) + VM_NAME
self.vSphereServerInstance.get_vm_by_name(cloneName)
LOGGER.debug('Name already used: {}'.format(cloneName))
cloneName = None
i += 1
except Exception as e:
LOGGER.debug(e)
LOGGER.debug('Name not used: {}'.format(cloneName))
LOGGER.debug('Cloning in progress...')
self.vmInstance.clone(name=cloneName,
folder=VM_CLONES_DIR,
power_on=False)
LOGGER.info(
'Virtual machine "{}" successful clone into directory "{}" with new name "{}".'
.format(VM_NAME, VM_CLONES_DIR, cloneName))
except Exception as e:
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while cloning virtual machine "{}" into directory "{}"!'
.format(VM_NAME, VM_CLONES_DIR))
def DeleteVM(self):
"""
Delete VM by name (VM_NAME).
"""
status = self.VMStatus()
if status != 'POWERED OFF':
LOGGER.warning('Virtual machine must be stopped before deleting!')
status = self.VMStop()
if status != 'POWERED OFF':
LOGGER.error(
'An error occured while stopping virtual machine "{}"!'.format(
VM_NAME))
else:
LOGGER.debug(
'Trying to delete virtual machine "{}"...'.format(VM_NAME))
try:
oK, msg = self.vSphereServerInstance.delete_vm_by_name(
VM_NAME, remove_files=True)
if oK:
LOGGER.info(
'Virtual machine "{}" deleted successful with message: "{}".'
.format(VM_NAME, msg))
else:
LOGGER.warning(
'Virtual machine "{}" NOT delete with message: "{}".'.
format(VM_NAME, msg))
except Exception as e:
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while deleting virtual machine "{}"!'.
format(VM_NAME))
def CopyFileIntoVM(self, srcFile=None, dstFile=None, overwrite=False):
"""
Copy file srcFile into VM with full path dstFile.
"""
status = self.VMStatus()
if status != 'POWERED ON':
raise Exception(
'Virtual machine must be started before copy operation!')
if srcFile and dstFile:
LOGGER.debug(r'Trying to login in guest OS...')
self.vmInstance.login_in_guest(VM_GUEST_LOGIN, VM_GUEST_PASSWORD)
LOGGER.debug(
r'Trying to copy source file "{}" into destination file "{}" inside virtual machine "{}"...'
.format(srcFile, dstFile, VM_NAME))
try:
self.vmInstance.send_file(srcFile, dstFile, overwrite)
LOGGER.info(
'File "{}" on guest OS successful copied as file "{}".'.
format(srcFile, dstFile))
except Exception as e:
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while copying file "{}" into destination file "{}" inside virtual machine "{}"!'
.format(srcFile, dstFile, VM_NAME))
else:
LOGGER.warning(
'Source file and/or destination file not specified!')
def CopyFileFromVM(self, srcFile=None, dstFile=None, overwrite=False):
"""
Copy file srcFile on VM to local file dstFile.
"""
status = self.VMStatus()
if status != 'POWERED ON':
raise Exception(
'Virtual machine must be started before copy operation!')
if srcFile and dstFile:
LOGGER.debug(r'Trying to login in guest OS...')
self.vmInstance.login_in_guest(VM_GUEST_LOGIN, VM_GUEST_PASSWORD)
LOGGER.debug(
r'Trying to copy source file "{}" from virtual machine "{}" into destination local file "{}"...'
.format(srcFile, VM_NAME, dstFile))
try:
self.vmInstance.get_file(srcFile, dstFile, overwrite)
LOGGER.info(
'File "{}" successful copied from VM guest OS as local file "{}".'
.format(srcFile, dstFile))
except Exception as e:
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while copying file "{}" from virtual machine "{}" into destination file "{}"!'
.format(srcFile, VM_NAME, dstFile))
else:
LOGGER.warning(
'Source file and/or destination file not specified!')
def MakeDirectoryOnVM(self, dirPath=None, createSubDirs=True):
"""
Create directory on VM with full path dirPath. If createSubDirs=True all sub-directories in path will create.
"""
status = self.VMStatus()
if status != 'POWERED ON':
raise Exception(
'Virtual machine must be started before creating directory!')
if dirPath:
LOGGER.debug(r'Trying to login in guest OS...')
self.vmInstance.login_in_guest(VM_GUEST_LOGIN, VM_GUEST_PASSWORD)
LOGGER.debug(
r'Trying to create directory "{}" inside virtual machine "{}"...'
.format(dirPath, VM_NAME))
try:
self.vmInstance.make_directory(dirPath, createSubDirs)
LOGGER.info(
'Directory "{}" on guest OS successful created.'.format(
dirPath))
except Exception as e:
LOGGER.debug(e)
trace = traceback.format_exc()
if 'FileAlreadyExistsFault' not in trace:
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while directory "{}" created inside virtual machine "{}"!'
.format(dirPath, VM_NAME))
else:
LOGGER.warning(
'Directory "{}" already exist on VM.'.format(dirPath))
else:
LOGGER.warning('Directory path not specified!')
def MonitoringProcessOnVM(self, pID, remoteLogFile=None):
"""
Search process with given pID on VM and waiting for process finished. Then return stderr, stdout and exit-code.
"""
statusCode = 0 # process exit code
timeTick = 6 # delay time to check process
try:
status = self.VMStatus()
if status != 'POWERED ON':
raise Exception(
'Virtual machine must be started before process monitoring!'
)
LOGGER.info(
'Starting process [PID = {}] monitoring...'.format(pID))
print(
"##teamcity[progressStart 'Executing process with PID = {} on virtual machine']"
.format(pID))
processActive = True
timeCount = 0
while processActive:
time.sleep(timeTick)
timeCount += timeTick
processList = self.vmInstance.list_processes()
for item in processList:
if str(item['pid']) == str(pID):
LOGGER.debug(
r' Process status-line given by VM-tools: {}'.
format(item))
if item['exit_code'] is not None:
statusCode = item['exit_code']
processActive = False
break
print(
"##teamcity[progressFinish 'Executing process with PID = {} on virtual machine']"
.format(pID))
LOGGER.info(
'Process finished successful with exit code = {}. Duration: ~{} sec.'
.format(statusCode, timeCount))
LOGGER.debug('Downloading process log-file from VM...')
logFile = os.path.abspath(
os.path.join(
os.curdir,
os.path.basename(remoteLogFile))) # local log file
if remoteLogFile:
if os.path.exists(logFile):
os.remove(logFile)
self.CopyFileFromVM(srcFile=remoteLogFile,
dstFile=logFile,
overwrite=True)
if os.path.exists(logFile):
with open(logFile, 'r') as fH:
output = fH.readlines()
if output and len(output) > 0:
LOGGER.debug('Process output:')
for line in output:
LOGGER.debug(' {}'.format(line.strip()))
except Exception as e:
LOGGER.debug(e)
LOGGER.error('Unknown exception occurred while process executing!')
LOGGER.error(traceback.format_exc())
statusCode = -1
return statusCode
def ExecuteProgramOnVM(self, **kwargs):
"""
Execute program with given parameters:
program - string path to executable file, e.g. r"C:\Windows\System32\cmd.exe",
args - comma-separated strings with arguments to the program, e.g. r"/T:Green /C echo %aaa% & echo %bbb%",
env - comma-separated strings with environment variables, e.g. r"aaa:10, bbb:20",
cwd - string path to working directory, e.g. r'C:\Windows\System32\',
pythonbin - path to python binary on VM, e.g. r'/python32/python'
wait - wait for process end and then return stderr, stdout and exit code.
"""
returnCode = 0 # process return code
if kwargs:
program = []
cmdArgs = []
env = {}
cwd = ''
wait = False
pythonbin = r'/python32/python'
LOGGER.debug('Initialization parameters:')
if 'program' in kwargs.keys():
program = [r'{}'.format(kwargs['program'])]
LOGGER.debug(' Parameter "program" = {}'.format(program))
if 'args' in kwargs.keys() and kwargs['args']:
cmdArgs = [
r'{}'.format(x.strip()) for x in kwargs['args'].split(',')
] # separate items "arg1, arg2" by comma
LOGGER.debug(' Parameter "args" = {}'.format(cmdArgs))
if 'env' in kwargs.keys() and kwargs['env']:
envList = [x.strip() for x in kwargs['env'].split(',')
] # separate items "foo: bar, varB: B" by comma
for item in envList:
env[item.split(':')[0]] = item.split(':')[
1] # separate one item "foo: bar" by :
LOGGER.debug(' Parameter "env" = {}'.format(env))
if 'cwd' in kwargs.keys():
cwd = kwargs['cwd']
LOGGER.debug(' Parameter "cwd" = {}'.format(cwd))
if 'pythonbin' in kwargs.keys():
pythonbin = kwargs['pythonbin']
LOGGER.debug(' Parameter "pythonbin" = {}'.format(pythonbin))
if 'wait' in kwargs.keys():
if kwargs['wait'].lower() == 'true':
wait = True
LOGGER.debug(' Parameter "wait" = {}'.format(wait))
scriptFile = os.path.abspath(os.path.join(
os.curdir, 'script.py')) # wrapper on local machine
remoteLogFile = os.path.join(os.path.dirname(program[0]),
'vm_process.log') # log file on VM
remoteScriptFile = os.path.join(os.path.dirname(
program[0]), os.path.basename(scriptFile)) # wrapper on VM
script = r"""# -*- coding: utf-8 -*-
#
# Author: Timur Gilmullin, [email protected]
# This is script wrapper using for run user-command on VM side.
import os, sys, subprocess, traceback
returnCode = 0
output = []
if os.path.exists(r'{log}'):
os.remove(r'{log}')
try:
proc = subprocess.Popen(args={args}, shell=True, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, env={env}, cwd={cwd})
proc.wait()
for line in proc.stdout:
line = bytes(line).decode(encoding='utf-8', errors='ignore').strip()
lines = line.split('\r')
for item in lines:
item = item.strip()
if item:
output.append(' ' + item)
returnCode = proc.returncode
except:
output += traceback.format_exc().splitlines()
output.append('Unknown error occured!')
returnCode = -1
finally:
with open(r'{log}', 'w') as fH:
for item in output:
fH.write(item + '\n')
sys.exit(returnCode)
""".format(args=program + cmdArgs,
env=env if env else None,
cwd="r'{}'".format(cwd) if cwd else None,
log=remoteLogFile)
with open(scriptFile, 'w') as fH:
fH.write(script)
status = self.VMStatus()
if status != 'POWERED ON':
raise Exception(
'Virtual machine must be started before starting task!')
if program:
LOGGER.debug(r'Trying to login in guest OS...')
self.vmInstance.login_in_guest(VM_GUEST_LOGIN,
VM_GUEST_PASSWORD)
LOGGER.info('Preparing script to execute...')
self.CopyFileIntoVM(srcFile=scriptFile,
dstFile=remoteScriptFile,
overwrite=True)
LOGGER.debug(
r'Trying to execute program "{}" with args "{}", env "{}" and cwd "{}" inside virtual machine "{}"...'
.format(program, cmdArgs, env, cwd, VM_NAME))
try:
LOGGER.debug(
r'Path to wrapper script file on VM: {}'.format(
remoteScriptFile))
LOGGER.debug(
r'Process log file on VM: {}'.format(remoteLogFile))
pid = self.vmInstance.start_process(
program_path=pythonbin,
args=[remoteScriptFile],
cwd=os.path.dirname(pythonbin))
LOGGER.info(
'Command successful executed. Parent program has PID = {}'
.format(pid))
if wait:
LOGGER.info('Wait for process finished.')
returnCode = self.MonitoringProcessOnVM(
pid, remoteLogFile)
except Exception as e:
returnCode = -1
LOGGER.debug(e)
LOGGER.error(traceback.format_exc())
LOGGER.error(
'An error occured while executing command inside virtual machine!'
)
else:
LOGGER.warning('Path of program to execute not specified!')
else:
raise Exception(
'You must specify at least one argument "program" with path to the program!'
)
return returnCode
