#

# Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of the License "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:  

# Annofile class

#

import xml.sax

import os

class Annofile(xml.sax.handler.ContentHandler):

	"""A class to represent an emake anno file"""

	def __init__(self, name, maxagents=30):

		self.name = name

		self.overallAggregateTime = 0

		self.inJob = False

		self.inMetricDuration = False

		self.jobType = ''

		self.nodes = set()

		self.maxagents = maxagents

		parser = xml.sax.make_parser()

		parser.setContentHandler(self)

		try:

			parser.parse(open(name))

		except xml.sax._exceptions.SAXParseException, e:

			print "Error:\n" + str(e)

			print "Ignore that file, parsing continues..."

	def startElement(self, name, attrs):

		if name == 'build':

			# attrs.get() returns unicode type

			self.cm = attrs.get('cm', '')

		elif name == 'job':

			self.inJob = True

			self.jobType = attrs.get('type', '')

		elif name == 'timing':

			# Find agent number

			node = attrs.get('node')

			if node not in self.nodes:

				self.nodes.add(node)

			# Calculate aggregate build time

			# This is the sum of time spending on each node

			# Ideally it equals the build time if there is 

			# only one node

			time = float(attrs.get('completed')) \

				- float(attrs.get('invoked'))

			self.overallAggregateTime += time

			# Calculate parse time

			if self.inJob and self.jobType == 'parse':

				self.parseTime = time

		elif name == 'metric':

			if attrs.get('name') == 'duration':

				self.inMetricDuration = True

	def endElement(self, name):

		if name == 'job':

			self.inJob = False

		elif name == 'metric':

			if self.inMetricDuration:

				self.inMetricDuration = False

		# Parse to the end of XML file

		elif name == 'build':

			self.doFinal()

	def characters(self, ch):

		if self.inMetricDuration:

			self.duration = ch

	# Get class attributes

	def getParseTime(self):

		"""Get the time that emake spends on 

		parsing all makefiles

		"""

		return self.parseTime

	def getOverallDuration(self):

		"""Get the overall build duration"""

		return float(self.duration)

	def getClusterManager(self):

		return self.cm

	def getAggregateTime(self):

		"""This is the sum of time spending on each node.

		Ideally it equals the build time if there is 

		only one node

		"""

		return self.overallAggregateTime

	# Calculate two efficiencies: 

	# first includes makefile parse time; second doesn't 

	def getEfficiency(self):

		"""100% means all nodes are busy from start to finish.

		"""

		at = self.getAggregateTime()

		num = self.maxagents

		d = self.getOverallDuration()

		idealDuration = at / num

		if d != 0:

			efficiency = round(idealDuration / d, 3)

		else:	

			efficiency = 0

		# This is efficiency WITHOUT counting makefile

		# parsing time.  Tempararily still useful.

		pt = self.getParseTime()

		idealD_wo = (at - pt) / num

		if d != pt:

			e_wo = round(idealD_wo / (d - pt), 3)

		else:

			e_wo = 0

		#return str(efficiency * 100) + '%', str(e_wo * 100) + '%'

		return efficiency, e_wo

	def doFinal(self):	

		report = open('anno_report.xml', 'a')

		report.write("<annofile name='%s'>\n" % self.name)	

		report.write("<metric name='agentNumber' value='%s'/>\n" % len(self.nodes))

		report.write("<metric name='makefileParseTime' value='%s'/>\n" \

				% self.getParseTime())

		report.write("<metric name='duration' value='%s'/>\n" \

				% self.getOverallDuration())

		report.write("<metric name='aggregateTime' value='%s'/>\n" \

				% self.getAggregateTime())

		report.write("<metric name='efficiency' value='%f'/>\n" \

				% self.getEfficiency()[0])

		report.write("<metric name='efficiencyNoMakefile' value='%f'/>\n" \

				% self.getEfficiency()[1])

		report.write("</annofile>\n")

		report.close()

	def __str__(self):

		s = " <metric name='agentcount' value='%d' />\n" % len(self.nodes) + \

			" <metric name='maxagents' value='%d' />\n" % self.maxagents + \

			" <metric name='parsetimesecs' value='%s' />\n" % self.getParseTime() + \

			" <metric name='overallduration' value='%s' />\n" % self.getOverallDuration() + \

			" <metric name='aggregatetime' value='%s' />\n" % self.getAggregateTime() + \

			" <metric name='efficiency' value='%s' />\n" % self.getEfficiency()[0] + \

			" <metric name='efficiency_nomake' value='%s' />\n" % self.getEfficiency()[1] 

		return s

if __name__ == '__main__':

	# Work around annoying DOCTYPE error by 

	# creating a dummy DTD file	

	if not os.path.exists('build.dtd'):

		dummy = open('build.dtd', 'w')

		dummy.close()

	################## Edit this basepath ################

	basepath = '92_7952_201022_logs\\output\\logs'

	######################################################

	# Find out all the annofiles

	annofiles = []

	for dirpath, dirs, files in os.walk(basepath):

		for f in files:

			if f.endswith('.anno') or f.endswith('.anno.xml'):

				annofiles.append(dirpath + '\\' + f)

	#print annofiles # debug

	# Parse all the annofiles and generate report

	# Write XML header

	report = open('anno_report.xml', 'w')

	report.write('<?xml version="1.0" encoding="ISO-8859-1"?>\n')

	report.write("<report>\n")

	report.close()

	# Parse each annofile

	#num = 0 # debug

	parser = xml.sax.make_parser()

	for afilename in annofiles:

		parser.setContentHandler(Annofile(afilename))

		try:

			parser.parse(open(afilename))

		except xml.sax._exceptions.SAXParseException, e:

			print "Error:\n" + str(e)

			print "Ignore that file, parsing continues..."

		#num += 1 # <debug> only process num annofiles

		#if num == 3:

		#	break

	# Write XML footer

	report = open('anno_report.xml', 'a')

	report.write("</report>")

	report.close()