resume/pause/stop/start work with vm names instead of objects (e1bb719b) · Commits · Mirror / cc-node

ccnode/ccnodehandlers.py

+27 −36

Original line number	Diff line number	Diff line
		@@ -222,34 +222,34 @@ class NodeHandler(RpcHandler):
		:param tags: tags to be returned
		:type tags: :class:`list` of strings
		'''
		vms_info = []
		result = []
		if tags is not None:
		tags = set(tags)
		tags \|= set(('h', 'vm'))
		vm_tags = VM_TAG_WRAP_MAP.keys() if tags is None else tags
		# iter on all VMs or only requested names
		for vm in self.hv_handle.get_vm_names() if vm_names is None else vm_names:
		vm_info = {}
		tags = [] if tags is None else tags
		logging.debug('list_vm: processing tags %s' % tags)
		# ensure that vm name is always returned bu default
		if not tags.__contains__('vm'):
		tags.insert(0, 'vm')
		logging.debug('list_vm: fetching tag list %s' % tags)
		for vm in self.hv_handle.get_vms():
		for tag in tags:
		# direct wrapping
		for tag in vm_tags:
		try:
		vm_info[tag] = self._call_vm_method(vm, tag)
		vm_info[tag] = str(self._call_vm_method(vm, tag))
		except AttributeError:
		logging.warning(TAG_METHOD_ERROR % tag)
		except KeyError:
		logging.warning(TAG_NOT_FOUND_ERROR % tag)
		except NotImplementedError:
		logging.debug('list_vm: method in vm to handle %s' % tag)
		vms_info.append(vm_info)
		vm_info = {}
		if vm_names:
		logging.debug('list_vm: filtering tag results for vms %s' % vm_names)
		filterd_vms = [vm for vm in vms_info if vm['vm'] in vm_names]
		logging.debug('list_vm: returning -> %s' % filterd_vms)
		return filterd_vms
		else:
		logging.debug('list_vm: returning -> %s' % vms_info)
		return vms_info
		logging.debug('list_vm: no method in vm to handle "%s"' % tag)
		# wrapping helpers
		for helper in VM_TAG_HELPER_LIST:
		htags = self._call_vm_helper(vm, helper)
		for tag, val in htags.iteritems():
		if tags is None or tag in tags:
		vm_info.update({tag:val})
		# save tags
		result.append(vm_info)

		return result

		@pure
		def stop_vm(self, vm_names=None, force=False):
		@@ -265,7 +265,7 @@ class NodeHandler(RpcHandler):
		'''
		if vm_names is None:
		#fetch all vm names in hypervisor
		vm_names = gen_vm_names(self.hv_handle)
		vm_names = self.hv_handle.get_vm_names()
		logging.debug('stop_vm: stopping vms %s' % vm_names)
		for vm in vm_names:
		try:
		@@ -285,7 +285,7 @@ class NodeHandler(RpcHandler):
		:type vm_names: :class:`list` of strings
		'''
		if vm_names is None:
		vm_names = gen_vm_names(self.hv_handle)
		vm_names = self.hv_handle.get_vm_names()
		logging.debug('start_vm: starting vms %s' % vm_names)
		for vm in vm_names:
		try:
		@@ -305,7 +305,7 @@ class NodeHandler(RpcHandler):
		:type vm_names: :class:`list` of strings
		'''
		if vm_names is None:
		vm_names = gen_vm_names(self.hv_handle)
		vm_names = self.hv_handle.get_vm_names()
		logging.debug('suspend_vm: suspending vms %s' % vm_names)
		for vm in vm_names:
		try:
		@@ -325,8 +325,8 @@ class NodeHandler(RpcHandler):
		:type vm_names: :class:`str`
		'''
		if vm_names is None:
		vm_names = gen_vm_names(self.hv_handle)
		logging.debug('resume_vm: resuming vms %s' % vm_names)
		vm_names = self.hv_handle.get_vm_names()
		logging.debug('resume_vm: resuming vms "%s"' % vm_names)
		for vm in vm_names:
		try:
		self.hv_handle.resume_vm(vm)
		@@ -346,12 +346,3 @@ class NodeHandler(RpcHandler):
		'''
		result = self.hv_handle.local_execute(command)
		return result


		### Helper Functions

		def gen_vm_names(hypervisor):
		'''
		generates a list of vm names defined in hypervisor
		'''
		return [vm.get_name() for vm in hypervisor._vm_list]

ccnode/libvirtwrapper.py

+53 −45

Original line number	Diff line number	Diff line
		@@ -345,26 +345,23 @@ class LibvirtHypervisor(Hypervisor):
		Builds the lists of all defined vms (running and offline) in the
		current hypervisor
		'''
		self._runing_vm_list = []
		self._offline_vm_list = []
		self._dom_ids = self._con_handle.listDomainsID()
		self._defined_doms = self._con_handle.listDefinedDomains()
		for doms in self._dom_ids:
		vm = self._con_handle.lookupByID(doms)
		self._runing_vm_list.append(LibvirtVm(vm, self))
		for defined_dom in self._defined_doms:
		vm = self._con_handle.lookupByName(defined_dom)
		self._offline_vm_list.append(LibvirtVm(vm, self))
		self._vm_list = []
		self._vm_list = self._runing_vm_list
		self._vm_list.extend(self._offline_vm_list)

		def get_vms(self):
		'''
		Returns a list of :class:`LibvirtVm` objects defining all
		current defined vms in the hypervisor
		'''
		return self._vm_list
		self._vm_list_running = {}
		self._vm_list_offline = {}
		self._vm_list = {}

		self._doms_running_ids = self._con_handle.listDomainsID()
		self._doms_defined_names = self._con_handle.listDefinedDomains()

		for dom in self._doms_running_ids:
		vm = LibvirtVm(self._con_handle.lookupByID(dom), self)
		self._vm_list_running[vm.get_name()] = vm

		for dom in self._doms_defined_names:
		vm = LibvirtVm(self._con_handle.lookupByName(dom), self)
		self._vm_list_running[vm.get_name()] = vm

		self._vm_list = self._vm_list_running
		self._vm_list.update(self._vm_list_offline)

		def get_arch_type(self):
		'''
		@@ -493,11 +490,25 @@ class LibvirtHypervisor(Hypervisor):
		result = " ".join(self._storage.get_volume_names(pool))
		except:
		pass
		return result

		def get_status(self):
		raise NotImplementedError()

		def start_vm(self, name, start_options=DEFAULT_VM_START):
		def get_vm_names(self):
		'''
		Returns a list of :class:`LibvirtVm` objects defining all
		current defined vms in the hypervisor
		'''
		return self._vm_list.keys()

		def get_vm(self, vm_name):
		return self._vm_list[vm_name]

		def get_vm_count(self):
		return len(self._vm_list)

		def start_vm(self, vm_name, start_options=DEFAULT_VM_START):
		'''
		Starts the vm identified by name

		@@ -508,50 +519,47 @@ class LibvirtHypervisor(Hypervisor):
		:type start_options: TODO reference to constants

		'''
		for vm in self._vm_list:
		if vm.get_name() == name:
		vm.start()
		return
		raise VMError('Virtual Machine %s not found: '% name)
		try:
		self._vm_list[vm_name].start()
		except KeyError:
		raise VMError('Virtual machine %s not found: ' % vm_name)

		def stop_vm(self, name, force=False):
		def stop_vm(self, vm_name, force=False):
		'''
		Poweroff the specifed vm with the specified options

		:param name: the name of the vm
		:type name: :class:`str`
		'''
		for vm in self._vm_list:
		if vm.get_name() == name:
		try:
		vm = self._vm_list[vm_name]
		vm.force_poweroff() if force else vm.shutdown()
		return
		raise VMError('Virtual Machine %s not found: ' % name)
		except KeyError:
		raise VMError('Virtual machine %s not found: ' % vm_name)

		def suspend_vm(self, name):
		def suspend_vm(self, vm_name):
		'''
		Suspends the specifed vm

		:param name: the name of the vm
		:type name: :class:`str`
		'''
		for vm in self._vm_list:
		if vm.get_name() == name:
		vm.suspend()
		return
		raise VMError('Virtual machine %s not found: ' % name)
		try:
		self._vm_list[vm_name].suspend()
		except KeyError:
		raise VMError('Virtual machine %s not found: ' % vm_name)

		def resume_vm(self, name):
		def resume_vm(self, vm_name):
		'''
		Resumes the specifed vm

		:param name: the name of the vm
		:type name: :class:`str`
		'''
		for vm in self._vm_list:
		if vm.get_name() == name:
		vm.resume()
		return
		raise VMError('Virtual machine %s not found: ' % name)
		try:
		self._vm_list[vm_name].resume()
		except KeyError:
		raise VMError('Virtual machine %s not found: ' % vm_name)

		def local_execute(self, command):
		'''