Esempio n. 1
0
    def listResources(remoteHashValue, projectUUID="None", sliceUUID="None"):
        logging.debug("Enter listResources")
        infoRspec = XmlHelper.getSimpleInformation()
        servers = VTDriver.getAllServers()
        baseVM = copy.deepcopy(infoRspec.response.information.resources.server[0].virtual_machine[0])
        if not servers:
            logging.debug("No VTServers available")
            infoRspec.response.information.resources.server.pop()
            resourcesString = XmlHelper.craftXmlClass(infoRspec)
            localHashValue = str(hash(resourcesString))
        else:
            for sIndex, server in enumerate(servers):
                if sIndex == 0:
                    baseServer = copy.deepcopy(infoRspec.response.information.resources.server[0])
                if sIndex != 0:
                    newServer = copy.deepcopy(baseServer)
                    infoRspec.response.information.resources.server.append(newServer)

                InformationDispatcher.__ServerModelToClass(
                    server, infoRspec.response.information.resources.server[sIndex]
                )
                if projectUUID is not "None":
                    vms = server.getVMs(projectId=projectUUID)
                else:
                    vms = server.getVMs()
                if not vms:
                    logging.debug("No VMs available")
                    if infoRspec.response.information.resources.server[sIndex].virtual_machine:
                        infoRspec.response.information.resources.server[sIndex].virtual_machine.pop()
                elif sliceUUID is not "None":
                    vms = vms.filter(sliceId=sliceUUID)
                    if not vms:
                        logging.error("No VMs available")
                        infoRspec.response.information.resources.server[sIndex].virtual_machine.pop()
                for vIndex, vm in enumerate(vms):
                    if vIndex != 0:
                        newVM = copy.deepcopy(baseVM)
                        infoRspec.response.information.resources.server[sIndex].virtual_machine.append(newVM)
                    InformationDispatcher.__VMmodelToClass(
                        vm, infoRspec.response.information.resources.server[sIndex].virtual_machine[vIndex]
                    )

            resourcesString = XmlHelper.craftXmlClass(infoRspec)
            localHashValue = str(hash(resourcesString))
        try:
            rHashObject = resourcesHash.objects.get(projectUUID=projectUUID, sliceUUID=sliceUUID)
            rHashObject.hashValue = localHashValue
            rHashObject.save()
        except:
            rHashObject = resourcesHash(hashValue=localHashValue, projectUUID=projectUUID, sliceUUID=sliceUUID)
            rHashObject.save()

        if remoteHashValue == rHashObject.hashValue:
            return localHashValue, ""
        else:
            return localHashValue, resourcesString
Esempio n. 2
0
	def processProvisioning(provisioning):
		logging.debug("PROVISIONING STARTED...\n")
		for action in provisioning.action:
			actionModel = ActionController.ActionToModel(action,"provisioning")
			logging.debug("ACTION type: %s with id: %s" % (actionModel.type, actionModel.uuid))
			try:
				RuleTableManager.Evaluate(action,RuleTableManager.getDefaultName())
			except Exception as e:
				MAX_CHARS_ALLOWED = 200
				XmlRpcClient.callRPCMethod(threading.currentThread().callBackURL,"sendAsync",XmlHelper.craftXmlClass(XmlHelper.getProcessingResponse(Action.FAILED_STATUS, action,str(e)[0:MAX_CHARS_ALLOWED-1])))
				return None
			try:
				ProvisioningDispatcher.logger.debug("virtualization_type = " + action.server.virtualization_type)
				controller = VTDriver.getDriver(action.server.virtualization_type)
				
				#XXX:Change this when xml schema is updated
				ProvisioningDispatcher.logger.debug("XXX action.server.uuid = " + str(action.server.uuid))
				server = VTDriver.getServerByUUID(action.server.uuid)
				ProvisioningDispatcher.logger.debug("server.id = " + str(server.id))
				#if actionModel.getType() == Action.PROVISIONING_VM_CREATE_TYPE:
				#	server = VTDriver.getServerByUUID(action.virtual_machine.server_id)
				#else:
				#	server = VTDriver.getVMbyUUID(action.virtual_machine.uuid).Server.get()
			except Exception as e:
				logging.error(e)
				raise e
			try:	
				#PROVISIONING CREATE
				if actionModel.getType() == Action.PROVISIONING_VM_CREATE_TYPE:
					try:
						vm = ProvisioningDispatcher.__createVM(controller, actionModel, action)
					except:
						vm = None
						raise
				#PROVISIONING DELETE, START, STOP, REBOOT
				else :
					ProvisioningDispatcher.__deleteStartStopRebootVM(controller, actionModel, action)
				XmlRpcClient.callRPCMethod(server.getAgentURL() ,"send", UrlUtils.getOwnCallbackURL(), 1, server.getAgentPassword(),XmlHelper.craftXmlClass(XmlHelper.getSimpleActionQuery(action)) )
				logging.debug("PROVISIONING FINISHED...")
				return
			except Exception as e:
				logging.warn(traceback.format_exc())
				if actionModel.getType() == Action.PROVISIONING_VM_CREATE_TYPE:
					# If the VM creation was interrupted in the network
					# configuration, the created VM won't be returned
					try:
						if not vm:
							vm = controller.getVMbyUUID(action.server.virtual_machines[0].uuid)
						controller.deleteVM(vm)
						# Keep actions table up-to-date after each deletion
						actionModel.delete()
					except Exception as e:
						print "Could not delete VM. Exception: %s" % str(e)
				#XmlRpcClient.callRPCMethod(threading.currentThread().callBackURL,"sendAsync",XmlHelper.craftXmlClass(XmlHelper.getProcessingResponse(Action.FAILED_STATUS, action, str(e))))
		logging.debug("PROVISIONING FINISHED...")
		return
Esempio n. 3
0
	def processUpdateVMsListFromCallback(vmUUID,state,rspec):
		from vt_manager_kvm.models.VirtualMachine import VirtualMachine
		try:
			VM = VirtualMachine.objects.get(uuid = vmUUID)
		except Exception as e:
			VMMonitor.logger.error(traceback.format_exc())
			raise e
		if state == 'Started':
			VM.setState(VirtualMachine.RUNNING_STATE)
			ZabbixHelper.sendVMStatus(VM, True)
		elif state == 'Stopped':
			VM.setState(VirtualMachine.STOPPED_STATE)
			ZabbixHelper.sendVMStatus(VM, False)
		else:
			VM.setState(VirtualMachine.UNKNOWN_STATE)
			ZabbixHelper.sendVMStatus(VM, False)
		
		#XXX: Maybe there better palces to send to expedient this update state...	
		XmlRpcClient.callRPCMethod(VM.getCallBackURL(), "sendAsync", XmlHelper.craftXmlClass(rspec))
		return
Esempio n. 4
0
	def sendUpdateVMs(server):
		#Recover from the client the list of active VMs
		obj = XmlHelper.getListActiveVMsQuery()
	
		#Create new Action 
		action = ActionController.createNewAction(Action.MONITORING_SERVER_VMS_TYPE,Action.QUEUED_STATUS,server.getUUID(),"") 
		obj.query.monitoring.action[0].id = action.getUUID() 
		obj.query.monitoring.action[0].server.virtualization_type = server.getid = server.getVirtTech() 
		XmlRpcClient.callRPCMethod(server.getAgentURL(),"send",UrlUtils.getOwnCallbackURL(),0,server.agentPassword,XmlHelper.craftXmlClass(obj))
		connection.close()
		return
    def processResponse(rspec):
        logging.debug("PROCESSING RESPONSE processResponse() STARTED...")
        for action in rspec.response.provisioning.action:
            try:
                actionModel = ActionController.getAction(action.id)
            except Exception as e:
                logging.error("No action in DB with the incoming uuid\n%s", e)
                return

            """
			If the response is for an action only in QUEUED or ONGOING status, SUCCESS or FAILED actions are finished
			"""
            # if str(actionModel.callBackUrl) == str(SfaCommunicator.SFAUrl): #Avoiding unicodes
            # 	event = pull(str(action.id))
            # 	event.send('continue')
            # 	return

            if actionModel.getStatus() is Action.QUEUED_STATUS or Action.ONGOING_STATUS:
                logging.debug(
                    "The incoming response has id: %s and NEW status: %s" % (actionModel.uuid, actionModel.status)
                )
                was_creating = False
                was_created = False
                actionModel.status = action.status
                actionModel.description = action.description
                actionModel.save()
                # Complete information required for the Plugin: action type and VM
                ActionController.completeActionRspec(action, actionModel)

                # XXX:Implement this method or some other doing this job
                vm = VTDriver.getVMbyUUID(actionModel.getObjectUUID())
                if vm.state == "creating...":
                    was_creating = True
                elif vm.state == "starting...":
                    was_created = True
                controller = VTDriver.getDriver(vm.Server.get().getVirtTech())
                failedOnCreate = 0
                # Update VM model with new status from OXAD
                if actionModel.getStatus() == Action.SUCCESS_STATUS:
                    ProvisioningResponseDispatcher.__updateVMafterSUCCESS(actionModel, vm)
                elif actionModel.getStatus() == Action.ONGOING_STATUS:
                    ProvisioningResponseDispatcher.__updateVMafterONGOING(actionModel, vm)
                elif actionModel.getStatus() == Action.FAILED_STATUS:
                    failedOnCreate = ProvisioningResponseDispatcher.__updateVMafterFAILED(actionModel, vm)
                else:
                    vm.setState(VirtualMachine.UNKNOWN_STATE)
                try:
                    created = False
                    vm_started = False
                    if vm.state == "created (stopped)":
                        created = True
                    elif vm.state == "running":
                        vm_started = True
                    logging.debug("Sending response to plug-in in sendAsync")
                    if str(vm.callBackURL) == "SFA.OCF.VTM":
                        logging.debug("callback: %s" % vm.callBackURL)
                        print "-------------->PRD: Created:", created, "Was_creating:", was_creating, "vm_started:", vm_started
                        print "-------------->PRD Action:", action, action.server.__dict__
                        # Start VM just after creating sliver/VM
                        if created and was_creating:
                            from vt_manager_kvm.communication.sfa.drivers.VTSfaDriver import VTSfaDriver

                            driver = VTSfaDriver(None)
                            driver.crud_slice(vm.sliceName, vm.projectName, "start_slice")
                            ProvisioningResponseDispatcher.__clean_up_reservations(vm.uuid)
                            return
                            # if was_created and vm_started:
                        if vm_started:
                            ifaces = vm.getNetworkInterfaces()
                            for iface in ifaces:
                                if iface.isMgmt:
                                    ip = iface.ip4s.all()[0].ip
                                    # Contextualize VMs
                            ProvisioningResponseDispatcher.__contextualize_vm(vm, ip)
                            # Cleaning up reservation objects
                            return
                    XmlRpcClient.callRPCMethod(vm.getCallBackURL(), "sendAsync", XmlHelper.craftXmlClass(rspec))
                    if failedOnCreate == 1:
                        controller.deleteVM(vm)
                        # Keep actions table up-to-date after each deletion
                        actionModel.delete()
                except Exception as e:
                    logging.error("Could not connect to Plugin in sendAsync\n%s", e)
                return

                # If response is for a finished action
            else:
                try:
                    # XXX: What should be done if this happen?
                    logging.error("Received response for an action in wrong state\n")
                    XmlRpcClient.callRPCMethod(
                        vm.getCallBackURL(),
                        "sendAsync",
                        XmlHelper.getProcessingResponse(
                            Action.FAILED_STATUS, action, "Received response for an action in wrong state"
                        ),
                    )
                except Exception as e:
                    logging.error(e)
                return
    def processresponseSync(rspec):
        """
		Thread-free implementation.
		"""
        logging.debug("PROCESSING RESPONSE processResponseSync() STARTED...")
        for action in rspec.response.provisioning.action:
            try:
                actionModel = ActionController.getAction(action.id)
            except Exception as e:
                logging.error("No action in DB with the incoming uuid\n%s", e)
                return

        """
		If the response is for an action only in QUEUED or ONGOING status, SUCCESS or FAILED actions are finished
		"""
        # if str(actionModel.callBackUrl) == str(SfaCommunicator.SFAUrl): #Avoiding unicodes
        # 	   event = pull(str(action.id))
        # 	   event.send('continue')
        # 	   return

        logging.debug(
            "................................ actionModel.getStatus(): %s ................."
            % str(actionModel.getStatus())
        )
        if actionModel.getStatus() is Action.QUEUED_STATUS or Action.ONGOING_STATUS:
            logging.debug(
                "The incoming response has id: %s and NEW status: %s" % (actionModel.uuid, actionModel.status)
            )
            actionModel.status = action.status
            actionModel.description = action.description
            actionModel.save()
            # Complete information required for the Plugin: action type and VM
            ActionController.completeActionRspec(action, actionModel)

            # XXX:Implement this method or some other doing this job
            vm = VTDriver.getVMbyUUID(actionModel.getObjectUUID())
            controller = VTDriver.getDriver(vm.Server.get().getVirtTech())
            failedOnCreate = 0
            if actionModel.getStatus() == Action.SUCCESS_STATUS:
                ProvisioningResponseDispatcher.__updateVMafterSUCCESS(actionModel, vm)
            elif actionModel.getStatus() == Action.ONGOING_STATUS:
                ProvisioningResponseDispatcher.__updateVMafterONGOING(actionModel, vm)
            elif actionModel.getStatus() == Action.FAILED_STATUS:
                failedOnCreate = ProvisioningResponseDispatcher.__updateVMafterFAILED(actionModel, vm)
            else:
                vm.setState(VirtualMachine.UNKNOWN_STATE)

            try:
                logging.debug("Sending response to Plugin in sendAsync")
                if str(actionModel.callBackUrl) == "SFA.OCF.VTM":
                    logging.debug(">>>>>>> SFA.OCF.VTM\n\n\n")
                    if failedOnCreate:
                        logging.debug("........... failedOnCreate.........")
                        expiring_slices = vm.objects.filter(sliceName=vm.sliceName, projectName=vm.projectName)
                        logging.debug("........... expiring_slices: %s ..........." % str(expiring_slices))
                        if len(expiring_slices) == 1:
                            expiring_slices[0].delete()

                            # Cleaning up reservation objects
                ProvisioningResponseDispatcher.__clean_up_reservations(vm.name)

                XmlRpcClient.callRPCMethod(vm.getCallBackURL(), "sendSync", XmlHelper.craftXmlClass(rspec))
                if failedOnCreate == 1:
                    controller.deleteVM(vm)
                    # Keep actions table up-to-date after each deletion
                    actionModel.delete()
            except Exception as e:
                logging.error("Could not connect to Plugin in sendSync. Exception: %s", e)
            return

            # If response is for a finished action
        else:
            try:
                # XXX: What should be done if this happen?
                logging.error("Received response for an action in wrong state")
                XmlRpcClient.callRPCMethod(
                    vm.getCallBackURL(),
                    "sendSync",
                    XmlHelper.getProcessingResponse(
                        Action.FAILED_STATUS, action, "Received response for an action in wrong state"
                    ),
                )
            except Exception as e:
                logging.error(e)
            return