class ESXI():
def __init__(self, host, name, passwd):
self.host = host # the host's ip
self.name = name # the host's name
self.passwd = passwd # the host's password
self.esxiInst = None # the esxi's handler
self.VMBuf = [] # the all vms in the vcenter
self.datastores = {} # the host's datastores
self.hosts = {} # the host's host
self.esxiInst = VIServer() # get init the handles of the host
self.esxiType = "" # the type(esxi or vcneter) of the host connected
self.VGList = [] # the vms you get from the vm's buffer
self.vm = None # the handler of the vm you got
# connect to ESXI
def esxiConnect(self):
if self.esxiInst == None:
logging.fatal("ESXI connect failed...")
return False
try:
if not self.esxiInst.is_connected():
self.esxiInst.connect(self.host, self.name, self.passwd)
self.esxiType = self.esxiInst.get_api_type()
else:
logging.fatal("esxi already connected")
return False
except VIApiException, e:
logging.fatal(str(e))
return False
except error, e:
logging.fatal(str(e) + " " + "Host Unreachable...")
return False
def StartConnect(self):
vc_info = self.GetVcenterInfo()
if vc_info != 1:
Server = VIServer()
try:
Server.connect(**vc_info)
self.server = Server
except Exception, e:
self.VCErrorReport(e.message)
return Server if Server.is_connected() else 1
def connect_to_server(ip,user,pw): server=VIServer() server.connect(ip,user,pw) try: server.is_connected()
class EsxiController(object):
def __init__(self, servername=None, password=None, username='******'):
# Initialize viserver
self.vi_server = VIServer()
# Specify excluding VMs' preffix
self.p = re.compile('xx|yy', re.I)
self.class_name = self.__class__.__name__
self.servername = servername
self.username = username
self.password = password
self.vmlist = []
self.vmstatusdict = {}
self.inUse_vmstatusdict = {}
self.vmfullnamelist = {}
self.inUse_vmfullnamelist = {}
self.vmdict = {}
self.inUseDict = {}
def connect(self):
logging.debug('connecting to %s' % self.servername)
try:
self.vi_server.connect(self.servername,
self.username,
self.password,
trace_file='/tmp/esxi_debug.txt')
except BaseException as e:
logging.debug('Can not connect to %s: %s' % (self.servername, e))
# sys.exit(1)
else:
if self.vi_server.is_connected():
logging.debug('connected to %s successfully' % self.servername)
logging.debug('Currently server version is: %s %s' %
(self.vi_server.get_server_type(),
self.vi_server.get_api_version()))
def disconnect(self):
self.vi_server.disconnect()
logging.debug('To disconnect from server %s\n' % self.servername)
def get_vmlist(self):
self.vmlist = self.vi_server.get_registered_vms()
return self.vmlist
def get_vmstatus(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmstatus = vm.get_status()
vmname = vminfo['name']
self.vmstatusdict[vmname] = vmstatus
return self.vmstatusdict
def get_inuse_vmstatus(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmstatus = vm.get_status()
vmname = vminfo['name']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.inUse_vmstatusdict[vmname] = vmstatus
return self.inUse_vmstatusdict
def get_vmnamelist(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmfullnameinfo = vminfo['guest_full_name']
self.vmfullnamelist[vmname] = vmfullnameinfo
return self.vmfullnamelist
def get_inuse_vmnamelist(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmfullnameinfo = vminfo['guest_full_name']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.inUse_vmfullnamelist[vmname] = vmfullnameinfo
return self.inUse_vmfullnamelist
def get_inuse_vmdict(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None:
self.vmdict[vmname] = vmpath
return self.vmdict
def power_off_all(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
if not vm.is_powered_off():
logging.debug('%s is powered on, now doing power off' % vmPath)
vm.power_off()
def power_on_all(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
if not vm.is_powered_on():
logging.debug('%s is powered off, now doing power on' % vmPath)
vm.power_on()
def power_on_in_use(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None and not vm.is_powered_on():
logging.debug('%s is powered off, now doing power on' % vmname)
vm.power_on()
def power_off_in_use(self):
for vmPath in self.get_vmlist():
vm = self.vi_server.get_vm_by_path(vmPath)
vminfo = vm.get_properties(from_cache=False)
vmname = vminfo['name']
vmpath = vminfo['path']
in_use_vm = self.p.match(vmname)
if in_use_vm is not None and not vm.is_powered_off():
logging.debug('%s is powered on, now doing power off' % vmname)
vm.power_off()
class EsxiServer:
server_ip = ''
user_name = ''
password = ''
connect_flag = False
server = None
def opearte_guest_power(self, src_vm_name, operate):
""""
|##desc: 操作客户机电源（重启、关机、开机）,这种模式不需要vmtools,就是强制操作电源，不走操作系统 ，可能损坏数据
|##:param: >vm1.power_on()
>vm1.reset()
>vm1.suspend() #since pysphere 0.1.5
>vm1.power_off()
|##:return: None
|##@author： jhuang
|##@time：12/12/2017
"""
ovm = self.server.get_vm_by_name(src_vm_name)
if operate == 'power_on':
ovm.power_on()
return True
elif operate == 'reset':
ovm.reset()
return True
elif operate == 'suspend':
ovm.suspend()
return True
elif operate == 'power_off':
ovm.power_off()
return True
else:
print "Operate guest error: operate can noly be set as power_on, reset, suspend, power_off"
return False
def clone(self, src_vm_name, dest_vm_name, datacenter=None, sync_run=True, folder=None, resourcepool=None,
datastore=None, host=None, power_on=True, template=False,
snapshot=None, linked=False):
"""
|##desc: 克隆虚拟机
|##:param: None
|##:return: None
|##@author： jhuang
|##@time：12/12/2017
"""
# get_vm_by_name 在包含2个数据中心的情况下，需要指定参数 datacenter 其中的限定条件为datacenter
# vm1 = server.get_vm_by_path("[DataStore1] Ubantu/Ubantu-10.vmx") 通过路径方法获取对象
logger.debug(src_vm_name)
logger.debug(datacenter)
ovm = self.server.get_vm_by_name(src_vm_name, datacenter)
new_vm = ovm.clone(dest_vm_name)
def create_snapshot(self, src_vm_name, snapShotName):
"""
|##desc: 创建快照
|##:param: None
|##:return: None
|##@author： jhuang
|##@time：12/12/2017
"""
ovm = self.server.get_vm_by_name(src_vm_name)
ovm.create_snapshot(snapShotName)
def set_ssl_no_verify(self):
ssl._create_default_https_context = ssl._create_unverified_context
# 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, ssl_no_verify=True):
logger.debug(ip)
logger.debug(name)
logger.debug(pwd)
self.server_ip = ip
self.user_name = name
self.password = pwd
self.server = VIServer()
if ssl_no_verify:
self.set_ssl_no_verify()
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='ALL', status=None, datacenter=None, cluster=None,
resource_pool=None):
"""
获取注册的主机 （虚拟机）
:param param1: this is a first param
:param param2: this is a second param
:returns: this is a description of what is returned
:raises keyError: raises an exception
@author： jhuang
@time：28/02/2018
"""
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 is 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
# so (might need a new list property in obj to know which VMs are
# fine to shutdown and a UI to specify such exceptions)
# otherwise can skip VM snap and then make a crash-consistent zfs
# snapshot for this VM
log.log(
logging.NOTICE,
"Can't snapshot VM %s that depends on "
"datastore %s and filesystem %s."
" Possibly using PT devices. Skipping.", vm,
vmsnapobj.datastore, fs)
snapvmskips[vmsnapobj].append(vmobj)
except:
log.warn("Snapshot of VM %s failed", vm)
snapvmfails[vmsnapobj].append(vmobj)
snapvms[vmsnapobj].append(vmobj)
if server.is_connected():
server.disconnect()
# At this point we've completed snapshotting VMs.
# Send out email alerts for VMs we tried to snapshot that failed.
# Also put the failures into a sentinel file that the alert
# system can understand.
for vmsnapobj in qs:
if snapvmfails[vmsnapobj]:
try:
with LockFile(VMWARE_FAILS) as lock:
with open(VMWARE_FAILS, 'rb') as f:
fails = pickle.load(f)
except:
fails = {}
# vmitem.get_property('path') is the reverse of server.get_vm_by_path(vm)
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
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
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)
# TODO:
# we can try to shutdown the VM, if the user provided us an ok to do
# so (might need a new list property in obj to know which VMs are
# fine to shutdown and a UI to specify such exceptions)
# otherwise can skip VM snap and then make a crash-consistent zfs
# snapshot for this VM
log.log(logging.NOTICE, "Can't snapshot VM %s that depends on "
"datastore %s and filesystem %s."
" Possibly using PT devices. Skipping.",
vm, vmsnapobj.datastore, fs)
snapvmskips[vmsnapobj].append(vmobj)
except:
log.warn("Snapshot of VM %s failed", vm)
snapvmfails[vmsnapobj].append(vmobj)
snapvms[vmsnapobj].append(vmobj)
if server.is_connected():
server.disconnect()
# At this point we've completed snapshotting VMs.
# Send out email alerts for VMs we tried to snapshot that failed.
# Also put the failures into a sentinel file that the alert
# system can understand.
for vmsnapobj in qs:
if snapvmfails[vmsnapobj]:
try:
with LockFile(VMWARE_FAILS) as lock:
with open(VMWARE_FAILS, 'rb') as f:
fails = pickle.load(f)
except:
fails = {}
# vmitem.get_property('path') is the reverse of server.get_vm_by_path(vm)
class ESXi_Server:
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 connect_to_server(ip,user,pw): server=VIServer() server.connect(ip,user,pw) try: server.is_connected()
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
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
