Esempio n. 1
0
    def processVm(self, session, vm, snapshot):
        xenrt.TEC().logverbose("shutdownwatcher processing VM %s" % vm)
        xenrt.TEC().logverbose(
            "vm %s has power_state=%s and seenrunning=%s and seenshutdown=%s" %
            (vm, snapshot['power_state'], vm in self.seenrunning, vm
             in self.seenshutdown))

        if snapshot['power_state'] == "Running":
            self.seenrunning[vm] = True
            self.seenshutdown[vm] = False
            xenrt.TEC().logverbose("vm %s is running" % vm)
        elif snapshot[
                'power_state'] == "Halted" and vm in self.seenrunning and not self.seenshutdown[
                    vm]:
            xenrt.TEC().logverbose(
                "vm %s is halted and was previously running and not previously shut down"
                % vm)
            t = libperf.formattime(libperf.timenow())
            name = snapshot['name_label']
            line = "%s %s" % (name, t)
            xenrt.TEC().logverbose("SHUTDOWN %s" % line)
            libperf.outputToResultsFile(self.logFile, line)
            self.previousShutdownTime = time.time()
            self.seenshutdown[vm] = True

            self.num_seen_shutdowns = self.num_seen_shutdowns + 1
            if self.num_seen_shutdowns == self.num_expected_shutdowns:
                self.complete = True
            xenrt.TEC().logverbose(
                "seen %d shutdowns of %d expected, hence complete=%s" %
                (self.num_seen_shutdowns, self.num_expected_shutdowns,
                 self.complete))
Esempio n. 2
0
    def run(self):
        xenrt.TEC().logverbose("shutdownwatcher running")
        n = libperf.formattime(libperf.timenow())
        zero = "zero"
        line = "%s %s %s" % (zero, n, n)
        xenrt.TEC().logverbose("SHUTDOWN %s" % line)
        libperf.outputToResultsFile(self.logFile, line)

        session = self.host.getAPISession(secure=False)

        try:
            self.watchEventsOnVm(session)
        finally:
            self.host.logoutAPISession(session)
Esempio n. 3
0
    def run(self):
        xenrt.TEC().logverbose("shutdownwatcher running")
        n = libperf.formattime(libperf.timenow())
        zero = "zero"
        line = "%s %s %s" % (zero, n, n)
        xenrt.TEC().logverbose("SHUTDOWN %s" % line)
        libperf.outputToResultsFile(self.logFile, line)

        session = self.host.getAPISession(secure=False)

        try:
            self.watchEventsOnVm(session)
        finally:
            self.host.logoutAPISession(session)
Esempio n. 4
0
    def run(self, arglist=None):
        self.vm = self.prepareVM()

        # Create a logfile for the downtimes
        migrateLogfile = libperf.createLogName("downtime")
        xenrt.TEC().comment("downtime logfile: %s" % migrateLogfile)

        libperf.outputToResultsFile(migrateLogfile,
                                    "# iter	pingable	running total-duration")

        for i in range(0, self.numiters):
            xenrt.TEC().logverbose("migration iteration %d of %d" %
                                   (i, self.numiters))
            timesStr = self.timeMigrate()
            line = "%d	%s" % (i, timesStr)
            libperf.outputToResultsFile(migrateLogfile, line)
Esempio n. 5
0
    def run(self, arglist=None):
        # Create the clones, recording how long it takes to do so
        self.clones = self.createMPSVMs(self.numdesktops, self.goldvm)
        self.configureAllVMs()

        # Set up log files for REQ226
        bootwatcherLogfile = libperf.createLogName("bootwatcher")
        starterLogfile = libperf.createLogName("starter")
        shutdownwatcherLogfile = libperf.createLogName("shutdownwatcher")
        xenrt.TEC().comment("bootwatcher logfile: %s" % bootwatcherLogfile)
        xenrt.TEC().comment("starter logfile: %s" % starterLogfile)
        xenrt.TEC().comment("shutdownwatcher logfile: %s" %
                            shutdownwatcherLogfile)

        # Begin to collect stats from NetApp, for REQ246,248
        self.startNetAppStatGather()

        # Start watching for shutdowns
        sdw = ShutdownWatcher(self, len(self.clones), shutdownwatcherLogfile)
        sdw.start()
        xenrt.TEC().logverbose("started shutdownwatcher")

        # Now start the VMs, for REQ226
        numthreads = len(self.normalHosts)
        self.timeStartVMs(
            numthreads,
            self.clones,
            starterLogfile,
            bootwatcherLogfile,
            awaitParam=None)  # awaitParam=None -> don't use a BootWatcher

        # Wait for all the VMs to shut down
        # TODO this is broken
        sdw.join()
        xenrt.TEC().logverbose("shutdownwatcher has completed")
        if sdw.error:
            raise xenrt.XRTError("shutdownwatcher completed with error")

        # Now gather the final stats from the NetApp, for REQ246,248
        stats = self.finishNetAppStatGather()
        netappLogFile = libperf.createLogName("netapp")
        libperf.outputToResultsFile(netappLogFile, stats)
Esempio n. 6
0
    def run(self, arglist=None):
        # Create the clones, recording how long it takes to do so
        self.clones = self.createMPSVMs(self.numdesktops, self.goldvm)
        self.configureAllVMs()

        # Set up log files for REQ226
        bootwatcherLogfile = libperf.createLogName("bootwatcher")
        starterLogfile = libperf.createLogName("starter")
        xenrt.TEC().comment("bootwatcher logfile: %s" % bootwatcherLogfile)
        xenrt.TEC().comment("starter logfile: %s" % starterLogfile)

        # Begin to collect stats from NetApp, for REQ246,248
        self.startNetAppStatGather()
        
        # Now start the VMs, for REQ226
        numthreads = len(self.normalHosts)
        self.timeStartVMs(numthreads, self.clones, starterLogfile, bootwatcherLogfile)

        # Now gather the final stats from the NetApp, for REQ246,248
        stats = self.finishNetAppStatGather()
        netappLogFile = libperf.createLogName("netapp")
        libperf.outputToResultsFile(netappLogFile, stats)
Esempio n. 7
0
    def processVm(self, session, vm, snapshot):
        xenrt.TEC().logverbose("shutdownwatcher processing VM %s" % vm)
        xenrt.TEC().logverbose("vm %s has power_state=%s and seenrunning=%s and seenshutdown=%s" % (vm, snapshot['power_state'], vm in self.seenrunning, vm in self.seenshutdown))

        if snapshot['power_state'] == "Running":
            self.seenrunning[vm] = True
            self.seenshutdown[vm] = False
            xenrt.TEC().logverbose("vm %s is running" % vm)
        elif snapshot['power_state'] == "Halted" and vm in self.seenrunning and not self.seenshutdown[vm]:
            xenrt.TEC().logverbose("vm %s is halted and was previously running and not previously shut down" % vm)
            t = libperf.formattime(libperf.timenow())
            name = snapshot['name_label']
            line = "%s %s" % (name, t)
            xenrt.TEC().logverbose("SHUTDOWN %s" % line)
            libperf.outputToResultsFile(self.logFile, line)
            self.previousShutdownTime = time.time()
            self.seenshutdown[vm] = True

            self.num_seen_shutdowns = self.num_seen_shutdowns + 1
            if self.num_seen_shutdowns == self.num_expected_shutdowns:
                self.complete = True
            xenrt.TEC().logverbose("seen %d shutdowns of %d expected, hence complete=%s" % (self.num_seen_shutdowns, self.num_expected_shutdowns, self.complete))
Esempio n. 8
0
    def run(self, arglist=None):
        # Create the clones, recording how long it takes to do so
        self.clones = self.createMPSVMs(self.numdesktops, self.goldvm)
        self.configureAllVMs()

        # Set up log files for REQ226
        bootwatcherLogfile = libperf.createLogName("bootwatcher")
        starterLogfile = libperf.createLogName("starter")
        xenrt.TEC().comment("bootwatcher logfile: %s" % bootwatcherLogfile)
        xenrt.TEC().comment("starter logfile: %s" % starterLogfile)

        # Begin to collect stats from NetApp, for REQ246,248
        self.startNetAppStatGather()

        # Now start the VMs, for REQ226
        numthreads = len(self.normalHosts)
        self.timeStartVMs(numthreads, self.clones, starterLogfile,
                          bootwatcherLogfile)

        # Now gather the final stats from the NetApp, for REQ246,248
        stats = self.finishNetAppStatGather()
        netappLogFile = libperf.createLogName("netapp")
        libperf.outputToResultsFile(netappLogFile, stats)
Esempio n. 9
0
    def run(self, arglist=None):
        # Create the clones, recording how long it takes to do so
        self.clones = self.createMPSVMs(self.numdesktops, self.goldvm)
        self.configureAllVMs()

        # Set up log files for REQ226
        bootwatcherLogfile = libperf.createLogName("bootwatcher")
        starterLogfile = libperf.createLogName("starter")
        shutdownwatcherLogfile = libperf.createLogName("shutdownwatcher")
        xenrt.TEC().comment("bootwatcher logfile: %s" % bootwatcherLogfile)
        xenrt.TEC().comment("starter logfile: %s" % starterLogfile)
        xenrt.TEC().comment("shutdownwatcher logfile: %s" % shutdownwatcherLogfile)

        # Begin to collect stats from NetApp, for REQ246,248
        self.startNetAppStatGather()
        
        # Start watching for shutdowns
        sdw = ShutdownWatcher(self, len(self.clones), shutdownwatcherLogfile)
        sdw.start()
        xenrt.TEC().logverbose("started shutdownwatcher")

        # Now start the VMs, for REQ226
        numthreads = len(self.normalHosts)
        self.timeStartVMs(numthreads, self.clones, starterLogfile, bootwatcherLogfile, awaitParam=None) # awaitParam=None -> don't use a BootWatcher

        # Wait for all the VMs to shut down
        # TODO this is broken
        sdw.join()
        xenrt.TEC().logverbose("shutdownwatcher has completed")
        if sdw.error:
            raise xenrt.XRTError("shutdownwatcher completed with error")

        # Now gather the final stats from the NetApp, for REQ246,248
        stats = self.finishNetAppStatGather()
        netappLogFile = libperf.createLogName("netapp")
        libperf.outputToResultsFile(netappLogFile, stats)
Esempio n. 10
0
    def run(self, arglist=None):

        self.xenhost = self.host.getIP()
        xenrt.TEC().logverbose("hostname is [%s]" % self.xenhost)

        # Restart the 'Citrix Pool Management service' on the DDC. This clears out any previous state about which hosts were in which pools.
        if self.useXenDesktop:
            self.restartPoolManagementService(self.ddc)

            # Clean up
            if self.startwithcleanslate:
                xenrt.TEC().logverbose("Deleting all existing desktop groups")
                self.deleteAllDesktopGroups()

        rundirpath = None

        # Register the VMs in a new desktop group with the DDC
        groupname = "xenrt%s" % self.randomid
        try:
            if self.useXenDesktop:
                xenrt.TEC().logverbose("Registering VMs with DDC in desktop group %s" % groupname)
                self.registerVMsWithDDC(groupname, self.clones)

            hostobjs = [self.tec.gec.registry.hostGet(h) for h in self.normalHosts]

            # Use the master for the host for the launchers
            launcherhostobj = hostobjs.pop(0)
            xenrt.TEC().logverbose("Nominated host %s as the launcher host" % launcherhostobj.getName())
            numthreads = self.numhostsfordesktops

            # Select the relevant number of hosts for desktops
            hostobjsfordesktops = hostobjs[0:self.numhostsfordesktops]
            hostnamesfordesktops = [h.getName() for h in hostobjsfordesktops]
            xenrt.TEC().logverbose("Names of hosts for desktop VMs are %s" % hostnamesfordesktops)

            # Now spin up the VMs
            xenrt.TEC().logverbose("Starting VMs")
            bootwatcherLogfile = libperf.createLogName("bootwatcher")
            starterLogfile = libperf.createLogName("starter")

            self.timeStartVMs(numthreads, self.clones, starterLogfile, bootwatcherLogfile, queueHosts=hostnamesfordesktops, awaitParam="PV_drivers_version", awaitKey="major")

            # Now make some launcher VMs
            numlaunchers = int(math.ceil(self.numdesktops / self.vmsperlauncher))
            xenrt.TEC().logverbose("VMs per launcher is %d; number of desktops is %d; hence using %d launcher VMs" % (self.vmsperlauncher, self.numdesktops, numlaunchers))

            launchers = []
            for i in range(0, numlaunchers):
                launchername = "mylauncher%d" % i
                xenrt.TEC().logverbose("Making launcher VM %d on host %s..." % (i, launcherhostobj.getName()))
                # TODO could import the first and then clone the rest?
                launchervmobj = self.makeLauncherVM(launchername, useICA=self.useXenDesktop, host=launcherhostobj)
                launchers.append(launchervmobj)

            # Create a 'run' directory. The returned path is valid on self.guest.
            rundirpath = self.createFreshResultsDir()

            # Now tell the launcher to start ICA sessions to the VMs.
            # The VMs then log in and LoginVSI kicks in.
            # (We assume that by this stage the VMs' VDAs have registered with the DDC.)

            refbasedir = self.mountRefBase(self.guest.execguest)

            # Begin to collect stats from NetApp, for REQ247,249
            self.startNetAppStatGather()

            for i in range(0, self.numdesktops):
                launcherindex = i % numlaunchers
                if self.useXenDesktop:
                    user = "******" % (i+1)

                    xenrt.TEC().logverbose("Logging in to desktop group %s with user %s on launcher %d" % (groupname, user, launcherindex))
                    self.logInToVMsWfica(refbasedir, launchers[launcherindex], groupname, user, "xenroot!!1!")
                else:
                    # Get the IP address of the ith desktop VM
                    xenrt.TEC().logverbose("Finding IP of %dth desktop VM..." % i)

                    # We need to know the host that the ith desktop VM is running on
                    # TODO Temporary hack: assume it's the second host in self.normalHosts!
                    h = self.normalHosts[1]
                    xenrt.TEC().logverbose("host is [%s]" % h)
                    vmuuid = self.clones[i].getUUID()
                    ip = self.getVMIP(h, vmuuid)
                    xenrt.TEC().logverbose("IP of %dth VM is %s" % (i, ip))

                    xenrt.TEC().logverbose("Logging in to %dth VM with on launcher %d" % (i, launcherindex))
                    self.logInToVMsRdesktop(refbasedir, launchers[launcherindex], ip, "Administrator", xenrt.TEC().lookup(["WINDOWS_INSTALL_ISOS", "ADMINISTRATOR_PASSWORD"]))

            xenrt.TEC().logverbose("Started all %d sessions!" % self.numdesktops)

            # Wait for the sessions to complete
            latestTime = time.time() + 50*60 # allow 50 mins for all sessions to complete
            for i in range(1, self.numdesktops+1):
                xenrt.TEC().logverbose("Waiting for the %dth session of %d to complete..." % (i, self.numdesktops))
                self.waitForResultsToAppear(rundirpath, i, self.numreadings, latestTime)

            xenrt.TEC().logverbose("All %d sessions have completed (or timed out)!" % self.numdesktops)

            # Now gather the final stats from the NetApp, for REQ247,249
            stats = self.finishNetAppStatGather()
            netappLogFile = libperf.createLogName("netapp")
            libperf.outputToResultsFile(netappLogFile, stats)

            xenrt.TEC().logverbose("All good.")
        finally:
            xenrt.TEC().logverbose("FINALLY")

            if not rundirpath is None:
                # Get the results.
                xenrt.TEC().logverbose("Copying logs from %s..." % rundirpath)
                self.copyRunDirToLogs(rundirpath)
        
            if self.useXenDesktop:
                # Clean up
                if self.cleanup:
                    xenrt.TEC().logverbose("Deleting desktop group %s" % groupname)
                    self.deleteDesktopGroup(groupname)
Esempio n. 11
0
 def log(self, filename, msg):
     """Logs to a file and console"""
     xenrt.TEC().logverbose(msg)
     if filename is not None:
         libperf.outputToResultsFile(libperf.createLogName(filename), msg)
Esempio n. 12
0
 def log(self, filename, msg):
     """Logs to a file and console"""
     xenrt.TEC().logverbose(msg)
     if filename is not None:
         libperf.outputToResultsFile(libperf.createLogName(filename), msg)