Haizea

from haizea.lwf.analysis import LWFAnalyser

                                         """))      

class haizea_lwf_stats(Command):

    name = "haizea-lwf-stats"

    def __init__(self, argv):

        Command.__init__(self, argv)

        self.optparser.add_option(Option("-i", "--in", action="store",  type="string", dest="inf", required=True,

                                         help = """

                                         Input file

                                         """))

        self.optparser.add_option(Option("-l", "--utilization-length", action="store", type="string", dest="utilization_length",

                                         help = """

                                         Length of the utilization interval in format DD:HH:MM:SS. Default is until

                                         the time the last lease is requested.

                                         """))          

    def run(self):

        self.parse_options()      

        infile = self.opt.inf

        utilization_length = self.opt.utilization_length

        if utilization_length != None:

            utilization_length = Parser.DateTimeDeltaFromString(utilization_length)

        analyser = LWFAnalyser(infile, utilization_length)

        analyser.analyse()

    def seed(self, x):

        self.__distribution.seed(x)

        lease_workload = LeaseWorkload.from_xml_file(tracefile, self.starttime)

        self.requests = lease_workload.get_leases()

        site_elem = ET.parse(lwf_file).getroot().find("site")

        if site_elem == None:

            return None # LWF file does not contain a <site> element

        else:

            return cls.__from_xml_element(site_elem)        

        resources = resource_str[1]

    def to_xml(self):

        """Returns an ElementTree XML representation of the nodes

        See the Haizea documentation for details on the

        lease XML format.

        """   

        site = ET.Element("site")

        resource_types = ET.SubElement(site, "resource-types")

        resource_types.set("names", " ".join(self.resource_types))

        site.append(self.nodes.to_xml())

        return site    

    DiskImageSoftwareEnvironment, Site

    SITE_OPT = "site"    

        self.interval_dist = self._get_dist(LWFGenerator.NUMLEASES_SEC)

        site = self.config.get(LWFGenerator.GENERAL_SEC, LWFGenerator.SITE_OPT)

        if site.startswith("file:"):

            sitefile = site.split(":")

            site = Site.from_xml_file(sitefile[1])

        else:

            site = Site.from_resources_string(site)

        lwf.append(site.to_xml())

        requests = ET.SubElement(lwf, "lease-requests")   

            max_utilization = 0

            for res in site.nodes.get_all_nodes().values():

                for i in range(1,res.get_ninstances("CPU") + 1):

                    max_utilization += res.get_quantity_instance("CPU", i) * last_request.seconds

            target_utilization = int(max_utilization * utilization)

            accum_utilization = 0

                lease = self.__gen_lease()

                leases.append(lease)

                duration = lease.duration.requested.seconds

                lease_utilization = 0

                for res in lease.requested_resources.values():

                    for i in range(1,res.get_ninstances("CPU") + 1):

                        lease_utilization += res.get_quantity_instance("CPU", i) * duration                

                accum_utilization += lease_utilization

            time = TimeDelta(seconds=0)            

            avg_interval = int(last_request.seconds / len(leases))

                interval = avg_interval + TimeDelta(seconds=self._get_interval())

                time = max(time + interval, TimeDelta(seconds=0))

                l.start.requested += time

                lease_request.append(l.to_xml())                            

        tree = ET.ElementTree(lwf)

        outfile = open(self.outfile, "w")

        tree.write(outfile)

        outfile.close()

# -------------------------------------------------------------------------- #

from mx.DateTime import DateTime

from haizea.core.leases import LeaseWorkload, Site

class LWFAnalyser(object):

    def __init__(self, lwffile, utilization_length):

        # Arbitrary start time

        self.starttime = DateTime(2006,11,25,13)

        self.workload = LeaseWorkload.from_xml_file(lwffile, self.starttime)

        self.site = Site.from_lwf_file(lwffile)

        if utilization_length == None:

            self.utilization_length = self.workload.get_leases()[-1].submit_time - self.starttime

        else:

            self.utilization_length = utilization_length

        print self.utilization_length

    def analyse(self):

        utilization = 0

        for lease in self.workload.get_leases():

            if lease.start.requested + lease.duration.requested > self.starttime + self.utilization_length:

                duration = self.starttime + self.utilization_length - lease.start.requested

            else: 

                duration = lease.duration.requested.seconds

            for res in lease.requested_resources.values():

                for i in range(1,res.get_ninstances("CPU") + 1):

                    utilization += res.get_quantity_instance("CPU", i) * duration

        if self.site != None:

            max_utilization = 0

            duration = self.utilization_length.seconds

            for res in self.site.nodes.get_all_nodes().values():

                for i in range(1,res.get_ninstances("CPU") + 1):

                    max_utilization += res.get_quantity_instance("CPU", i) * duration

        print "Utilization: %.2f%%" % (utilization / max_utilization)

c = commands.haizea_lwf_generate(sys.argv)

#!/usr/bin/python

from haizea.cli import commands

import sys

c = commands.haizea_lwf_stats(sys.argv)

c.run()