Python xenrt.sleep函数代码示例

    def enableNonDefaultDS(self, host):
        xenrt.TEC().logverbose("Get the number of data sources in a fresh install")
        numBeforeEnable=self.getNumberofDS(host=host)
        xenrt.TEC().logverbose("The number of data sources in a fresh install is %s" % 
                                numBeforeEnable)

        # Enable the non-default DS, the number should then go up
        host.execdom0("xe-enable-all-plugin-metrics true")
        # Sleep for sometime to let the changes take effect
        xenrt.sleep(120)
        numAfterEnable=self.getNumberofDS(host)
        xenrt.TEC().logverbose("The number of data sources when non-default DS enabled is %s" % 
                                numAfterEnable)

        com=[]
        noncom=[]
        # Compare the ones that are same and print the extra metrics
        newDSList=self.getDSList(host=host)
        for item in newDSList:
            if item in self.dsList:
                com.append(item)
            else:
                noncom.append(item)
        xenrt.TEC().logverbose("The extra DS after enabling the epic metrics are %s " % 
                                noncom)

        if not noncom and numAfterEnable<=numBeforeEnable:
            raise xenrt.XRTFailure("No extra data sources found after anabling the non-default metrics")

    def __init__(self, device, options=None, mtype=None, retry=True):
        self.mounted = 0
        exceptiondata = None
        try:
            self.mountpoint = tempfile.mkdtemp("", "xenrt", "/tmp")
            xenrt.TEC().logverbose("Created mountpoint %s" % (self.mountpoint))
            xenrt.TEC().gec.registerCallback(self)
            os.chmod(self.mountpoint, stat.S_IRWXU | stat.S_IRWXG | stat.S_IROTH | stat.S_IXOTH)
            for i in range(6):
                cmd = ["sudo", "mount"]
                if options:
                    cmd.append("-o%s" % (options))
                if mtype:
                    cmd.append("-t %s" % (mtype))
                cmd.append(device)
                cmd.append(self.mountpoint)
                try:
                    xenrt.util.command(string.join(cmd))
                    self.mounted = 1
                except xenrt.XRTFailure, e:
                    exceptiondata = e.data
                if self.mounted == 1:
                    break
                if not retry:
                    break
                # wait a bit then try again
                xenrt.sleep(120)

            if not self.mounted:
                xenrt.TEC().logverbose("Error mounting %s at %s" % (device, self.mountpoint))
                raise xenrt.XRTError("Unable to mount %s" % (device), exceptiondata)
            xenrt.TEC().logverbose("Mounted %s at %s" % (device, self.mountpoint))

 def prepare(self, arglist=None):
     #Get the Host 0
     self.targetHost = self.getHost("RESOURCE_HOST_0")
     self.host0 = self.getHost("RESOURCE_HOST_1")
     self.MAXLUNS = int(self.host0.lookup("MAX_MULTIPATH_LUN"))
     self.CONCURRENT_MAXLUNS = int(self.host0.lookup("CONCURRENT_MAX_MULTIPATH_LUN"))
     #Loop created to have MAXLUNS luns
     for i in range(self.MAXLUNS):
         #This will create an iSCSI VM along with LUNS
         lun = xenrt.ISCSIVMLun(sizeMB = self.LUNSIZE, totalSizeMB = (self.MAXLUNS * self.LUNSIZE))
         self.LUNs.append(lun)
         #This will take the instance of SR for host0
         sr = xenrt.lib.xenserver.ISCSIStorageRepository(self.host0, "iscsi%d" % i)
         self.SRs.append(sr)
         #This will attach the iSCSI SR to the host0
         sr.create(lun, subtype="lvm", multipathing=True, noiqnset=True, findSCSIID=True)
         
         pbd = self.host0.parseListForUUID("pbd-list", "sr-uuid", sr.uuid, "host-uuid=%s" % (self.host0.getMyHostUUID()))
         scsiID = self.host0.genParamGet("pbd", pbd, "device-config", "SCSIid")
         xenrt.sleep(60)
         #Check Multipathing
         mp = self.host0.getMultipathInfo()
         if len(mp[scsiID]) != self.MAXPATHS:
             raise xenrt.XRTError("Only found %u/%u paths in multipath output" % (len(mp[scsiID]),self.MAXPATHS))
         #Check the multiple active paths
         mp = self.host0.getMultipathInfo(onlyActive=True)
         if len(mp[scsiID]) != self.MAXPATHS:
             raise xenrt.XRTError("Only %u/%u paths active before test started" % (len(mp[scsiID]),self.MAXPATHS))

    def prioMsgEmailChk(self, host, pool, testname, testPriority, isReceived, mailMinPriority= None):

        # Set other-config:mail-min-priority to options.get("mail-min-priority")
        if mailMinPriority != None:
            pool.setPoolParam("other-config:mail-min-priority", mailMinPriority)
        
        # Create a message of priority level 'priority'
        host.messageCreate(testname, "Test message (priority %d)" % testPriority, priority=testPriority)
        
        #wait then check for mail and clear mailbox.
        xenrt.sleep(30) 
        mail = self.smtpServer.getMail()
        self.smtpServer.clearMail()
        
        if isReceived == True:        
            # verify an email is received 
            if len(mail) == 0:
                raise xenrt.XRTFailure("%s : No email sent for priority %d message" % (testname, testPriority))
            elif len(mail) > 1:
                raise xenrt.XRTFailure("%s : Received multiple emails for one message" % testname)
            self.check(host, mail[0], testname)
        else:
            # verify email is not recieved 
            if len(mail) > 0:
                raise xenrt.XRTFailure("%s : Received email for priority %d message" % (testname, testPriority))

    def run(self):
        xenrt.sleep(90)
        self.shutdownAllVMs()
        while self.getAvailableSpace(self.sr):
            xenrt.TEC().logverbose("Starting to move vdis to generate IO on SR %s" % self.sr)

            vdis=self.cli.execute("vdi-list", "name-label=\"Created by XenRT\" sr-uuid=%s --minimal" %
                           self.sr ).strip()
            xenrt.TEC().logverbose("Found the following vdis to be moved - %s " % vdis)
            if not vdis:
                sys.exit()
            try:
                vdis=vdis.split(",")
                for uuid in vdis:
                    newvdi=self.cli.execute("vdi-copy", "sr-uuid=%s uuid=%s" %
                                                (self.sr, uuid)).strip()
                    self.created.append(newvdi)
                    xenrt.sleep(20)
                    xenrt.TEC().logverbose("Created so many vdis - %s " % self.created)
                    if len(self.created) > 10:
                        # Delete vdis
                        self.deleteVDIs()
            except SystemExit, e:
                xenrt.log("Thread is here, it is a stale thread")
                return
            except Exception, e:
                xenrt.TEC().logverbose("Caught exception in thread " + str(e))
                # Delete all the created vdis to create more space
                self.deleteVDIs()

 def connect(self, ip, port, username, password, timeout):
     if self.debug:
         xenrt.TEC().logverbose("connect")
     sock = socket.create_connection((ip, port), timeout)
         
     # Create SSH transport.
     if self.debug:
         xenrt.TEC().logverbose("transport")
     self.trans = paramiko.Transport(sock)
     self.trans.set_log_channel("")
         
     # Negotiate SSH session synchronously.
     if xenrt.TEC().lookup("OPTION_RETRY_SSH2", False, boolean=True):
         goes = 3
     else:
         goes = 1
     while goes > 0:
         try:
             if self.debug:
                 xenrt.TEC().logverbose("start_client")
             self.trans.start_client()
             goes = 0
         except Exception, e:
             goes = goes - 1
             if goes > 0:
                 xenrt.TEC().warning("Retrying SSHSession connection")
                 xenrt.sleep(10)
             else:
                 raise e

 def on(self):
     xenrt.TEC().logverbose("Turning on machine %s" % (self.machine.name))
     # Wait a random delay to try to avoid power surges when testing
     # with multiple machines.
     if self.antiSurge:
         xenrt.sleep(random.randint(0, 20))
     self.ilo("on")

 def setupMelioDisk(self):
     # Setup a melio disk on the scsi device
     disk = self.hosts[0].execdom0("realpath %s" % self.device).strip()[5:]
     with self.getMelioClient(self.hosts[0]) as melioClient:
         deadline = xenrt.timenow() + 600
         while True:
             data = melioClient.get_all()
             unmanaged = data.get('unmanaged_disk')
             xenrt.TEC().logverbose("Unmanaged disks: %s" % json.dumps(unmanaged, indent=2))
             if unmanaged:
                 disksToManage = [x for x in unmanaged if x['system_name'] == disk]
             else:
                 disksToManage = []
             if disksToManage:
                 diskToManage = disksToManage[0]
                 break
             if xenrt.timenow() > deadline:
                 raise xenrt.XRTError("Timed out waiting for disk to appear")
             xenrt.sleep(10)
         melioClient.manage_disk(diskToManage['system_name'])
         deadline = xenrt.timenow() + 600
         while True:
             managedDisks = melioClient.get_all()['managed_disk']
             guid = [x for x in managedDisks.keys() if managedDisks[x]['system_name'] == disk][0]
             if int(managedDisks[guid]['state']) == 2:
                 break
             if xenrt.timenow() > deadline:
                 raise xenrt.XRTError("Timed out waiting for disk to get to state 2")
             xenrt.sleep(10)
         self.guid = melioClient.create_volume(guid.lstrip("_"), managedDisks[guid]['free_space'])
     self.getSanDeviceForHost(self.hosts[0])
     tasks = [xenrt.PTask(self.rebootAndWait, x) for x in self.hosts[1:]]
     xenrt.pfarm(tasks)

 def checkCluster(self):
     # Check every host can see every other host in the cluster
     if len(self.hosts) == 1:
         return
     deadline = xenrt.timenow() + 600
     while True:
         ready = True
         for checkHost in self.hosts:
             with self.getMelioClient(checkHost) as melioClient:
                 # See which other servers we're connected to
                 servers = melioClient.get_all()['network_session']
             # We don't always get a dictionary back if it's empty
             if not isinstance(servers, dict):
                 ready = False
             else:
                 # Check we're connected to every other host (except ourselves)
                 for expectedHost in self.hosts:
                     if expectedHost == checkHost:
                         continue
                     if not expectedHost.getName() in [x['computer_name'] for x in servers.values()]:
                         ready = False
                         # No point in continuing
                         break
             if not ready:
                 # No point in continuing
                 break
         if ready:
             # All done
             break
         if xenrt.timenow() > deadline:
             raise xenrt.XRTError("Timed out waiting for all of the cluster to appear")
         # Sleep for 20 seconds before trying again
         xenrt.sleep(20)

    def waitForReady(self, timeout=600, pollPeriod=20):
        """This method check the CP host state, CP System VM state and checks that the agent is running"""
        isReady = False
        startTime = datetime.now()
        msAgentState = None
        msVMState = None
        agentRunning = None
        while (datetime.now() - startTime).seconds < timeout:
            systemVmData = self.getSystemVMData()
            if msVMState != systemVmData.state:
                xenrt.TEC().logverbose('[%s] MS VM state changed from %s to %s' % (self.name, msVMState, systemVmData.state))
                msVMState = systemVmData.state
            hostData = self.getManSvrVMData()
            if msAgentState != hostData.state:
                xenrt.TEC().logverbose('[%s] MS Agent state changed from %s to %s' % (self.name, msAgentState, hostData.state))
                msAgentState = hostData.state
            running = self.isAgentRunning()
            if agentRunning != running:
                xenrt.TEC().logverbose('[%s] Agent transitioned from Running: %s to Running: %s' % (self.name, agentRunning, running))
                agentRunning = running

            if msVMState == 'Running' and msAgentState == 'Up' and agentRunning:
                xenrt.TEC().logverbose('System VM [%s] reached ready state in %d seconds' % (self.name, (datetime.now() - startTime).seconds))
                isReady = True
                break

            xenrt.sleep(pollPeriod)

        if not isReady:
            raise xenrt.XRTFailure('System VM [%s] failed to reach ready state in %d seconds' % (self.name, timeout))

    def postOutageCheck(self):

        xenrt.sleep(900)
        if self.csHost.state != 'Down':
            raise xenrt.XRTFailure("Host %s is not reported Down by Cloud" % self.csHost.name)

        self.cloud.healthCheck(ignoreHosts=[self.csHost])

    def waitForHostState(self, podid, state, timeout=300, pollPeriod=20):
        """Wait for all Hosts (associated with the Pod) to reach the specified state"""
        allHostsReachedState = False
        startTime = datetime.now()
        while (datetime.now() - startTime).seconds < timeout:
            hostData = self.cloud.marvin.cloudApi.listHosts(type='Routing', podid=podid)
            allHypervisorsUp = True
            for host in hostData:
                if host.hypervisor == 'XenServer':
                    try:
                        h = filter(lambda x:x.getName() == host.name, self.getAllHosts())[0]
                        h.checkHealth()
                    except Exception, e:
                        xenrt.TEC().logverbose('Health check for host: %s failed' % (host.name))
                        allHypervisorsUp = False

            hostsNotInState = filter(lambda x:x.state != state, hostData)
            if len(hostsNotInState) == 0 and allHypervisorsUp:
                allHostsReachedState = True
                break

            if len(hostsNotInState) > 0:
                xenrt.TEC().logverbose('Waiting for the following Hosts to reach state %s: %s' % (state, pformat(map(lambda x:(x.name, x.state), hostsNotInState))))
            self.logCloudHostInfo()
            xenrt.sleep(pollPeriod)

    def run(self, arglist=None):
        xapiRdpObj = XapiRdp(self.guest)

        # Enable RDP on the guest 
        if not xapiRdpObj.enableRdp():
            raise xenrt.XRTFailure("XAPI failed to enable the RDP on the guest %s with tools installed" % (self.guest))
        xenrt.TEC().logverbose("XAPI successfully enabled the RDP for the guest: %s " % (self.guest))

        # win_guest_agent takes at max 10 seconds to update RDP status change to XAPI
        xenrt.sleep(10)

        if not xapiRdpObj.isRdpEnabled():
            raise xenrt.XRTFailure("Guest agent does not updated  data/ts about the RDP status change for the guest %s " % (self.guest))
        xenrt.TEC().logverbose("Guest agent updated the RDP status in data/ts successfully for the guest %s" % (self.guest))

        # Disable the RDP on the guest 
        step("Test trying to disable RDP on the guest by setting  windows registry key fDenyTSConnections to 1")
        self.guest.winRegAdd('HKLM', 'System\\CurrentControlSet\\Control\\Terminal Server\\', 'fDenyTSConnections',"DWORD", 1)
        xenrt.sleep(10)

        if xapiRdpObj.isRdpEnabled():
            raise xenrt.XRTFailure("Guest agent does not updated data/ts about the RDP status change for the guest %s " % (self.guest))
        xenrt.TEC().logverbose("Guest agent updated the RDP status in data/ts successfully for the guest %s" % (self.guest))

        self.guest.checkHealth()

    def run(self, arglist=None):
        host = self.getDefaultHost()

        host.execdom0("xe-enable-all-plugin-metrics true")

        self.guest.workloads = self.guest.startWorkloads(self.WORKLOADS)

        xenrt.sleep(10)
        xenrt.TEC().logverbose("Check rrd2csv iops_total output.")
        host.execdom0("nohup rrd2csv iops_total_%s > iopslog.txt &" % (self.sr[0].split('-')[0]))
        xenrt.sleep(60)
        host.execdom0("pkill rrd2csv")

        self.guest.stopWorkloads(self.guest.workloads)

        results = []
        try:
            for i in range(int(host.execdom0("cat iopslog.txt | wc -l"))-1):
                parsedReply = host.execdom0("head -%s iopslog.txt | tail -1" % (str(i+2))).split('Z, ')[1]
                # Unexpected result in log sometimes.
                if parsedReply != 'N/A':
                    iops = float(parsedReply)
                    results.append(iops)
        except Exception, e:
            if "list index out of range" in str(e):
                raise xenrt.XRTFailure("iops_total metric not found: %s" % (str(e)))
            else:
                raise xenrt.XRTFailure("Exception occured while fetching iops_total metric.. %s" % (str(e)))

 def connectToSwitch(self):
     log("initialising telnet to switch (%s)" % self.ip)
     i = 0
     while True:
         i += 1
         try:
             self.telnet = Telnet(self.ip, 23, timeout=self.CONNECT_TIMEOUT)
             break
         except:
             if i >= self.CONNECT_ATTEMPTS:
                 raise
             xenrt.sleep(self.CONNECT_TIMEOUT)
     log("Connected, sending username")
     self.telnet.read_until('Username:', timeout=self.TIMEOUT)
     self.telnet.write('%s\r' % self.login)
     log("Sending password")
     self.telnet.read_until('Password:', timeout=self.TIMEOUT)
     self.telnet.write('%s\r' % self.password)
     log("Waiting for prompt")
     out = self.telnet.read_until('#', timeout=self.TIMEOUT)
     re_prompt = re.compile('^([a-zA-Z0-9-]+)#$', re.MULTILINE)
     m_prompt = re_prompt.search(out)
     if m_prompt:
         self.prompt = m_prompt.group(1)
     else: 
         log("Unexpected output returned by the switch:\n'%s'" % out)
         raise xenrt.XRTError("Unexpected string returned by the switch")
     log("Sending enable")
     self.sendEnable()
     log("Setting terminal settings")
     self.command("terminal length 0")
     self.command("terminal width 0")
     
     log("Successfully connected to the switch.")