def check(self): super(zstack_vcenter_image_file_checker, self).check() server = VIServer() server.connect(vcenter_ip, domain_name, password) all_vms = server._get_managed_objects(MORTypes.VirtualMachine) for mor, name in all_vms.iteritems(): if name == sync_image_name: return self.judge(True) else: return self.judge(False)
def check(self): super(zstack_vcenter_image_file_checker, self).check() server = VIServer() server.connect(vcenter_ip, domain_name, password) all_vms = server._get_managed_objects(MORTypes.VirtualMachine) for mor, name in all_vms.iteritems(): if name == sync_image_name: return self.judge(True) else: return self.judge(False)
class Server: """Vsphere server that a client can connect to""" SUPPORTED_FILTER_KEYWORDS = ["uuidSpec", "pathSpec", "nameSpec"] url = os.getenv("VSPHERE_URL") """URL of vSphere endpoint""" # : vSphere account username username = os.getenv("VSPHERE_USER") # : vSphere account password password = os.getenv("VSPHERE_PASSWORD") def __init__(self, url=None, username=None, password=None): """Constructs an Server instance with given endpoint and credentials :param url: end point hostname/URL to connect to. As of this release, url must be an http url with port 80, e.g. like this: http://vsphere.example.com :param username: vSphere account username :param password: vSphere account password """ self._server = VIServer() self._vm_datacenters = {} # don't set to None if already set from environment if url: self.url = url if username: self.username = username if password: self.password = password def connect(self, url=None, username=None, password=None): """Connects to vSphere server using optional arguments that may override those in Server constructor. If arguments are not given, previously specified arguments will be used for connection in this order: * last connect arguments (if specified) * constructor arguments (if specified) * environment variables If none of the above is specified, the exception MissingArgumentException is raised :type url: string :param url: end point hostname/URL to connect to :type username: string :param username: vSphere account username :type password: string :param password: vSphere account password :type password: string :param password: vSphere account password """ if url: self.url = url if username: self.username = username if password: self.password = password # check if all needed properties available for connect argErrors = [] if not self.url: argErrors.append("url unknown") if not self.username: argErrors.append("username unknown") if not self.password: argErrors.append("password unknown") if argErrors: raise MissingArgumentError(" ".join(argErrors)) # parse host from url host = urlparse(self.url).hostname # perform connect logger.debug("connect: %s; %s" % (url, username)) self._server.connect(host, self.username, self.password, trace_file=prototrace_file) def disconnect(self): """Disconnects from vSphere server""" self._server.disconnect() self._server = [] def power_on_vm(self, instanceUuid, sync_run=True, host=None): """Powers on a virtual machine for a given instanceUuid""" return self._get_instance(instanceUuid).power_on(sync_run, host) def power_off_vm(self, instanceUuid, sync_run=True): """Powers off a virtual machine for a given instanceUuid""" return self._get_instance(instanceUuid).power_off(sync_run) def clone_vm(self, instanceUuid, name=None, sync_run=True, host=None): """Clones a virtual machine for a given instanceUuid. :param instanceUuid: instanceUuid of VM to clone :param name: name to give to the cloned machine. if None, a new name will be generated using the original instance name with time stamp appended, e.g.: 'ubuntu_csk1_08-1349968939' """ import time instance = self._get_instance(instanceUuid) if not name: name = "%s-%d" % (instance.get_property("name"), time.time()) return instance.clone(name, sync_run, host=host) def reset_vm(self, instanceUuid, sync_run=True): """Powers off a virtual machine for a given instanceUuid""" return self._get_instance(instanceUuid).reset(sync_run) def suspend_vm(self, instanceUuid, sync_run=True): """Suspends a virtual machine for a given instanceUuid""" return self._get_instance(instanceUuid).suspend(sync_run) def list_instances(self, instanceUuid=None, filter=None, datacenter=None): """Lists all vmware instances that match the given filter. :type instanceUuid: string :param instanceUuid: InstanceUuid to filter on. This is a convenience parameter that will override a corresponding value in filter, if it exists. :param datacenter: name of datacenter to filter VMs registered in that datacenter :type filter: dict :param filter: represents a filter specification and can consist of any valid properties, such as { 'config.instanceUuid': [ '50398c64-55ad-7eb2-f14a-6f70b6903b06' ] } or {'runtime.powerState': ['poweredOn']} or {'runtime.powerState': ['poweredOff'], 'config.instanceUuid': [ '50398c64-55ad-7eb2-f14a-6f70b6903b06' ] } :rtype: list :return: A list of :class:`vmware.vsphere.VM` """ # get the vm paths if instanceUuid and len(instanceUuid): if not isinstance(instanceUuid, str): raise BadParameterError("instanceUuid parameter must be a string") if not filter: filter = {} filter["config.instanceUuid"] = [instanceUuid] self._vmspaths = self._server.get_registered_vms(datacenter, advanced_filters=filter) logger.debug("list_instances: retrieved %d vm paths" % len(self._vmspaths)) # instantiate instances for vm paths self.vms = [] for p in self._vmspaths: self.vms.append(VM(p, self)) # first time this function runs, fetch information about vm to datacenter mapping self._fetch_datacenter_vms() return self.vms def get_hosts(self, datacenter=None): """Returns a dictionary of the existing hosts keys are their names and values their ManagedObjectReference object. Example usage: >>> server.get_hosts() {'host-23': '108.61.71.220', 'host-19': '108.61.71.219', 'host-36': '173.71.195.168'} >>> server.get_hosts('datacenter-12') >>> from catosphere import Server >>> server = Server() >>> server.connect() >>> server.get_datacenters() {'datacenter-12': 'csk3', 'datacenter-2': 'csk1', 'datacenter-7': 'csk2'} >>> server.get_hosts('datacenter-2') {'host-23': '108.61.71.220', 'host-19': '108.61.71.219'} >>> server.get_hosts('datacenter-7') {'host-36': '173.71.195.168'} >>> server.get_hosts('datacenter-12') {} >>> server.get_hosts() {'host-23': '108.61.71.220', 'host-19': '108.61.71.219', 'host-36': '173.71.195.168'} >>> server.disconnect() :return: a dict e.g. {'host-23': '108.61.71.220', 'host-19': '108.61.71.219', 'host-36': '173.71.195.168'} if not hosts are found, empty dict is returned. """ if datacenter: hosts = self._server._get_managed_objects(MORTypes.HostSystem, from_mor=datacenter) else: hosts = self._server.get_hosts() return hosts def get_datacenters(self): """Returns a dictionary of the existing datacenters. keys are their ManagedObjectReference objects and values their names. :return: a dict e.g. {'datacenter-12': 'csk3', 'datacenter-2': 'csk1', 'datacenter-7': 'csk2'} """ return self._server.get_datacenters() # ****************************************************** # ***************** Private Methods ******************* # ****************************************************** def _fetch_datacenter_vms(self): """ Fetch/cache datacenter vm mapping information. This can be later used to retrieve datacenter information for each VM. """ if not self._vm_datacenters: dcs = self.get_datacenters() for name in dcs.keys(): self._vm_datacenters[name] = self._server._get_managed_objects(MORTypes.VirtualMachine, from_mor=name) # logger.debug(': _vm_datacenters: %s' % self._vm_datacenters) def _get_instance(self, instanceUuid): """ Retrieves instance by its instanceUuid. TODO: make this faster by caching instances. """ instances = self.list_instances(instanceUuid) if not instances: raise InstanceNotFoundError("Instance %s not found" % instanceUuid) else: return instances[0]
vcip = '10.1.8.50' logger.debug("Trying to connect %s" % vcip) vc.connect(vcip,'sbgcf\\svc_report','VMwar3!!') cur_region = region try: host_d = {} vm_d = {} for c_mor, c_name in vc.get_clusters().items(): if(not c_name in clstrname_d): continue logger.debug("Fetching cluster '%s'",c_name) for h_mor,h_name in vc.get_hosts(from_mor=c_mor).items(): logger.debug("Fetching host %s",h_name) host_d[h_name] = c_name for v_mor, v_name in vc._get_managed_objects(MORTypes.VirtualMachine, from_mor=h_mor).items(): vm_d[v_name] = h_name except: raise Exception("Failed to query VM list from vCenter %s" % vcip) is_replica = re.match('.+REPLICA',appid) 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 num_args == 11: oneview_build_number = str(sys.argv[8]) oneview_passbuild_id = str(sys.argv[9]) is_purge = str(sys.argv[10]) vm_munged_name_prefix = vm_name_prefix + version + "_P" + oneview_passbuild_id + "_" + oneview_build_number else: oneview_build_number = "" vm_munged_name_prefix = vm_name_prefix + version log("Connecting to vCenter %s..." % server_name) server = VIServer() server.connect(server_name, user_name, password) # Get a reference to the folder in which VM needs to be created folders_list = server._get_managed_objects(MORTypes.Folder) for key in folders_list.keys(): if folders_list[key] == folder_name: folder_mor = key break else: raise Exception("Folder not found") # folder_filter = {"parent": folder_mor} clusters_list = server.get_clusters() for cluster_key in clusters_list.keys(): if clusters_list[cluster_key] == cluster_name: resourcepool = server.get_resource_pools(cluster_key).keys()[0] # WPST folder_mor = [ mor for mor, name in server._get_managed_objects(
pass print("k and v = %s %s" % (k, v)) print("Couldn't find folder '%s'" % (folder_name)) #look for the resource pool whose path is rp_path for ds, ds_name in s.get_datastores().items(): print ds_name if ds_name == DATASTORE: print "Found Datacenter: %s" % DATASTORE pprint(ds) #VMs should be created by a folder, in ESX always uses the vm folder vmfmor = [ k for k, v in s._get_managed_objects(MORTypes.Folder).items() if v == "vm" ][0] print "vmfmor = %s" % vmfmor #look for the resource pool whose path is rp_path rpmor = [k for k, v in s.get_resource_pools().items() if v == rp_path][0] print "rpmor = %s" % rpmor #ESXs have just one host, so use that one hostmor = s.get_hosts().keys()[0] print "hostmor = %s" % hostmor create_folder_request = VI.CreateFolderRequestMsg() config = VI.folder #config = create_folder_request.new_config() create_folder_request.set_element_config(config)