#!/usr/bin/env python3
# Copyright (c) 2011-2014, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
#
# 3. Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""
Generate a coverage report by parsing parameter framework log.
The coverage report contains the:
- domain
- configuration
- rule
- criterion
basic coverage statistics.
"""
import xml.dom.minidom
import sys
import re
import logging
FORMAT = '%(levelname)s: %(message)s'
logging.basicConfig(stream=sys.stderr, level=logging.WARNING, format=FORMAT)
logger = logging.getLogger("Coverage")
class CustomError(Exception):
pass
class ChildError(CustomError):
def __init__(self, parent, child):
self.parent = parent
self.child = child
class ChildNotFoundError(ChildError):
def __str__(self):
return 'Unable to find the child "%s" in "%s"' % (self.child, self.parent)
class DuplicatedChildError(ChildError):
def __str__(self):
return 'Add existing child "%s" in "%s".' % (self.child, self.parent)
class Element():
"""Root class for all coverage elements"""
tag = "element"
def __init__(self, name):
self.parent = None
self.children = []
self.nbUse = 0
self.name = name
self.debug("New element")
def __str__(self):
return "%s (%s)" % (self.name, self.tag)
def __eq__(self, compared):
return (self.name == compared.name) and (self.children == compared.children)
def getName(self, default=""):
return self.name or default
def hasChildren(self):
return bool(self.children)
def getChildren(self):
return self.children
def _getDescendants(self):
for child in self.children:
yield child
for descendant in child._getDescendants() :
yield descendant
def getChildFromName(self, childName):
for child in self.children :
if child.getName() == childName :
return child
self.debug('Child "%s" not found' % childName, logging.ERROR)
self.debug("Child list :")
for child in self.children :
self.debug(" - %s" % child)
raise ChildNotFoundError(self, childName)
def addChild(self, child):
self.debug("new child: " + child.name)
self.children.append(child)
child._adoptedBy(self)
def _adoptedBy(self, parent):
assert(not self.parent)
self.parent = parent
def _getElementNames(self, elementList):
return (substate.name for substate in elementList)
def _description(self, withCoverage, withNbUse):
description = self.name
if withNbUse or withCoverage :
description += " has been used " + str(self.nbUse) + " time"
if withCoverage :
description += self._coverageFormating(self._getCoverage())
return description
def _getCoverage(self):
"""Return the coverage of the element between 0 and 1
If the element has no coverage dependency (usually child) return 0 or 1.
otherwise the element coverage is the dependency coverage average"""
coverageDependanceElements = list(self._getCoverageDependanceElements())
nbcoverageDependence = len(coverageDependanceElements)
if nbcoverageDependence == 0:
if self.nbUse == 0:
return 0
else:
return 1
coverageDependenceValues = (depElement._getCoverage()
for depElement in coverageDependanceElements)
return sum(coverageDependenceValues) / nbcoverageDependence
def _getCoverageDependanceElements(self):
return self.children
def _coverageFormating(self, coverage):
# If no coverage provided
if not coverage :
return ""
# Calculate coverage
return " (%s coverage)" % self._number2percent(coverage)
@staticmethod
def _number2percent(number):
"""Format a number to a integer % string
example: _number2percent(0.6666) -> "67%"
"""
return "{0:.0f}%".format(100 * number)
def _dumpDescription(self, withCoverage, withNbUse):
self.debug("yelding description")
yield RankedLine(self._description(withCoverage, withNbUse), lineSuffix="")
for dumped in self._dumpPropagate(withCoverage, withNbUse) :
yield dumped
def _dumpPropagate(self, withCoverage, withNbUse):
for child in self.children :
for dumpedDescription in child._dumpDescription(withCoverage, withNbUse) :
yield dumpedDescription.increasedRank()
def dump(self, withCoverage=False, withNbUse=True):
return "\n".join(
str(dumpedDescription) for dumpedDescription in
self._dumpDescription(withCoverage, withNbUse))
def exportToXML(self, document, domElement=None):
if domElement == None:
domElement = document.createElement(self.tag)
self._XMLaddAttributes(domElement)
for child in self.children :
domElement.appendChild(child.exportToXML(document))
return domElement
def _XMLaddAttributes(self, domElement):
attributes = self._getXMLAttributes()
coverage = self._getCoverage()
if coverage != None :
attributes["Coverage"] = self._number2percent(coverage)
for key, value in attributes.items():
domElement.setAttribute(key, value)
def _getXMLAttributes(self):
return {
"Name": self.name,
"NbUse": str(self.nbUse)
}
def _incNbUse(self):
self.nbUse += 1
def childUsed(self, child):
self._incNbUse()
# Propagate to parent
self._tellParentThatChildUsed()
def _tellParentThatChildUsed(self):
if self.parent :
self.parent.childUsed(self)
def parentUsed(self):
self._incNbUse()
# Propagate to children
for child in self.children :
child.parentUsed()
def hasBeenUsed(self):
return self.nbUse > 0
def operationOnChild(self, path, operation):
if path:
return self._operationPropagate(path, operation)
else :
self.debug("operating on self")
return operation(self)
def _operationPropagate(self, path, operation):
childName = path.pop(0)
child = self.getChildFromName(childName)
return child.operationOnChild(path, operation)
def debug(self, stringOrFunction, level=logging.DEBUG):
"""Print a debug line on stderr in tree form
If the debug line is expensive to generate, provide callable
object, it will be called if log is enable for this level.
This callable object should return the logline string.
"""
if logger.isEnabledFor(level):
# TODO: use buildin callable if python >= 3.2
if hasattr(stringOrFunction, "__call__"):
string = stringOrFunction()
else:
string = stringOrFunction
rankedLine = DebugRankedLine("%s: %s" % (self, string))
self._logDebug(rankedLine, level)
def _logDebug(self, rankedLine, level):
if self.parent:
self.parent._logDebug(rankedLine.increasedRank(), level)
else :
logger.log(level, str(rankedLine))
class FromDomElement(Element):
def __init__(self, DomElement):
self._initFromDom(DomElement)
super().__init__(self.name)
def _initFromDom(self, DomElement):
self.name = DomElement.getAttribute("Name")
class DomElementLocation():
def __init__(self, classConstructor, path=None):
self.classConstructor = classConstructor
if path :
self.path = path
else :
self.path = []
self.path.append(classConstructor.tag)
class DomPopulatedElement(Element):
"""Default child populate
Look for each dom element with tag specified in self.tag
and instantiate it with the dom element
"""
childClasses = []
def populate(self, dom):
for childDomElementLocation in self.childClasses :
self.debug("Looking for child %s in path %s" % (
childDomElementLocation.path[-1], childDomElementLocation.path))
for childDomElement in self._findChildFromTagPath(dom, childDomElementLocation.path) :
childElement = childDomElementLocation.classConstructor(childDomElement)
self.addChild(childElement)
childElement.populate(childDomElement)
def _findChildFromTagPath(self, dom, path):
if not path :
yield dom
else :
# Copy list
path = list(path)
tag = path.pop(0)
# Find element with tag
self.debug("Going to find elements with tag %s in %s" % (tag, dom))
self.debug(lambda: "Nb of solutions: %s" % len(dom.getElementsByTagName(tag)))
for elementByTag in dom.getElementsByTagName(tag) :
self.debug("Found element: %s" % elementByTag)
# If the same tag is found
if elementByTag in dom.childNodes :
# Yield next level
for element in self._findChildFromTagPath(elementByTag, path) :
yield element
class Rule(Element):
def usedIfApplicable(self, criteria):
childApplicability = (child.usedIfApplicable(criteria)
for child in self.children)
isApplicable = self._isApplicable(criteria, childApplicability)
if isApplicable :
self._incNbUse()
self.debug("Rule applicability: %s" % isApplicable)
assert(isApplicable == True or isApplicable == False)
return isApplicable
def _isApplicable(self, criteria, childApplicability):
"""Return the rule applicability depending on children applicability.
If at least one child is applicable, return true"""
# Lazy evaluation as in the PFW
return all(childApplicability)
class CriterionRule(FromDomElement, DomPopulatedElement, Rule):
tag = "SelectionCriterionRule"
childClasses = []
isApplicableOperations = {
"Includes" : lambda criterion, value: criterion.stateIncludes(value),
"Excludes" : lambda criterion, value: not criterion.stateIncludes(value),
"Is" : lambda criterion, value: criterion.stateIs(value),
"IsNot" : lambda criterion, value: not criterion.stateIs(value)
}
def _initFromDom(self, DomElement):
self.selectionCriterion = DomElement.getAttribute("SelectionCriterion")
self.matchesWhen = DomElement.getAttribute("MatchesWhen")
self.value = DomElement.getAttribute("Value")
self.name = "%s %s %s" % (self.selectionCriterion, self.matchesWhen, self.value)
applicableOperationWithoutValue = self.isApplicableOperations[self.matchesWhen]
self.isApplicableOperation = lambda criterion: applicableOperationWithoutValue(criterion, self.value)
def _isApplicable(self, criteria, childApplicability):
return criteria.operationOnChild([self.selectionCriterion],
self.isApplicableOperation)
class CompoundRule(FromDomElement, DomPopulatedElement, Rule):
"""CompoundRule can be of type ALL or ANY"""
tag = "CompoundRule"
# Declare childClasses but define it at first class instantiation
childClasses = None
def __init__(self, dom):
# Define childClasses at first class instantiation
if self.childClasses == None :
self.childClasses = [DomElementLocation(CriterionRule),
DomElementLocation(CompoundRule)]
super().__init__(dom)
def _initFromDom(self, DomElement):
type = DomElement.getAttribute("Type")
self.ofTypeAll = {"All" : True, "Any" : False}[type]
self.name = type
def _isApplicable(self, criteria, childApplicability):
if self.ofTypeAll :
applicability = super()._isApplicable(criteria, childApplicability)
else:
# Lazy evaluation as in the PFW
applicability = any(childApplicability)
return applicability
class RootRule(DomPopulatedElement, Rule):
tag = "RootRule"
childClasses = [DomElementLocation(CompoundRule)]
def populate(self, dom):
super().populate(dom)
self.debug("Children: %s" % self.children)
# A configuration can only have one or no rule
assert(len(self.children) <= 1)
def _getCoverageDependanceElements(self):
return self._getDescendants()
class CriteronStates(Element):
"""Root of configuration application criterion state"""
tag = "CriterionStates"
def parentUsed(self, criteria):
"""Add criteria to child if not exist, if exist increase it's nbUse"""
self._incNbUse()
matches = [child for child in self.children if child == criteria]
assert(len(matches) <= 1)
if matches :
self.debug("Criteria state has already been encounter")
currentcriteria = matches[0]
else :
self.debug("Criteria state has never been encounter, saving it")
currentcriteria = criteria
self.addChild(criteria)
currentcriteria.parentUsed()
class Configuration(FromDomElement, DomPopulatedElement):
tag = "Configuration"
childClasses = []
class IneligibleConfigurationAppliedError(CustomError):
def __init__(self, configuration, criteria):
self.configuration = configuration
self.criteria = criteria
def __str__(self):
return ("Applying ineligible %s, "
"rule:\n%s\n"
"Criteria current state:\n%s" % (
self.configuration,
self.configuration.rootRule.dump(withCoverage=False, withNbUse=False),
self.criteria.dump(withCoverage=False, withNbUse=False)
))
def __init__(self, DomElement):
super().__init__(DomElement)
self.rootRule = RootRule("RootRule")
self.addChild(self.rootRule)
self.criteronStates = CriteronStates("CriterionStates")
self.addChild(self.criteronStates)
def populate(self, dom):
# Delegate to rootRule
self.rootRule.populate(dom)
def _getCoverage(self):
# Delegate to rootRule
return self.rootRule._getCoverage()
def used(self, criteria):
self._incNbUse()
# Propagate use to parents
self._tellParentThatChildUsed()
# Propagate to criterion coverage
self.criteronStates.parentUsed(criteria.export())
# Propagate to rules
if not self.rootRule.usedIfApplicable(criteria) :
self.debug("Applied but rule does not match current "
"criteria (parent: %s) " % self.parent.name,
logging.ERROR)
raise self.IneligibleConfigurationAppliedError(self, criteria.export())
def _dumpPropagate(self, withCoverage, withNbUse):
self.debug("Going to ask %s for description" % self.rootRule)
for dumpedDescription in self.rootRule._dumpDescription(
withCoverage=withCoverage,
withNbUse=withNbUse) :
yield dumpedDescription.increasedRank()
self.debug("Going to ask %s for description" % self.criteronStates)
for dumpedDescription in self.criteronStates._dumpDescription(
withCoverage=False,
withNbUse=withNbUse) :
yield dumpedDescription.increasedRank()
class Domain(FromDomElement, DomPopulatedElement):
tag = "ConfigurableDomain"
childClasses = [DomElementLocation(Configuration, ["Configurations"])]
class Domains(DomPopulatedElement):
tag = "Domains"
childClasses = [DomElementLocation(Domain, ["ConfigurableDomains"])]
class RankedLine():
def __init__(self, string,
stringPrefix="|-- ",
rankString="| ",
linePrefix="",
lineSuffix="\n"):
self.string = string
self.rank = 0
self.stringPrefix = stringPrefix
self.rankString = rankString
self.linePrefix = linePrefix
self.lineSuffix = lineSuffix
def increasedRank(self):
self.rank += 1
return self
def __str__(self):
return self.linePrefix + \
self.rank * self.rankString + \
self.stringPrefix + \
self.string + \
self.lineSuffix
class DebugRankedLine(RankedLine):
def __init__(self, string, lineSuffix=""):
super().__init__(string,
stringPrefix="",
rankString=" ",
linePrefix="",
lineSuffix=lineSuffix)
class CriterionState(Element):
tag = "CriterionState"
def used(self):
self._incNbUse()
class Criterion(Element):
tag = "Criterion"
inclusivenessTranslate = {True: "Inclusive", False: "Exclusive"}
class ChangeRequestToNonAccessibleState(CustomError):
def __init__(self, requestedState, detail):
self.requestedState = requestedState
self.detail = detail
def __str__(self):
return ("Change request to non accessible state %s. Detail: %s" %
(self.requestedState, self.detail))
def __init__(self, name, isInclusif,
stateNamesList, currentStateNamesList,
ignoreIntegrity=False):
super().__init__(name)
self.isInclusif = isInclusif
for state in stateNamesList :
self.addChild(CriterionState(state))
self.currentState = []
self.initStateNamesList = list(currentStateNamesList)
self.changeState(self.initStateNamesList, ignoreIntegrity)
def reset(self):
# Set current state as provided at initialisation
self.changeState(self.initStateNamesList, ignoreIntegrity=True)
def changeState(self, subStateNames, ignoreIntegrity=False):
self.debug("Changing state from: %s to: %s" % (
list(self._getElementNames(self.currentState)),
subStateNames))
if not ignoreIntegrity and not self.isIntegre(subStateNames):
raise self.ChangeRequestToNonAccessibleState(subStateNames,
"An exclusive criterion must have a non empty state")
newCurrentState = []
for subStateName in subStateNames :
subState = self.getChildFromName(subStateName)
subState.used()
newCurrentState.append(subState)
self.currentState = newCurrentState
self._incNbUse()
self._tellParentThatChildUsed()
def isIntegre(self, subStateNames):
return self.isInclusif or len(subStateNames) == 1
def childUsed(self, child):
self.currentState = child
super().childUsed(child)
def export(self):
subStateNames = self._getElementNames(self.currentState)
return Criterion(self.name, self.isInclusif, subStateNames, subStateNames,
ignoreIntegrity=True)
def stateIncludes(self, subStateName):
subStateCurrentNames = list(self._getElementNames(self.currentState))
self.debug("Testing if %s is included in %s" % (subStateName, subStateCurrentNames))
isIncluded = subStateName in subStateCurrentNames
self.debug("IsIncluded: %s" % isIncluded)
return isIncluded
def stateIs(self, subStateNames):
if len(self.currentState) != 1 :
return False
else :
return self.stateIncludes(subStateNames)
def _getXMLAttributes(self):
attributes = super()._getXMLAttributes()
attributes["Type"] = self.inclusivenessTranslate[self.isInclusif]
return attributes
class Criteria(Element):
tag = "Criteria"
class DuplicatedCriterionError(DuplicatedChildError):
pass
def export(self):
self.debug("Exporting criteria")
assert(self.children)
exported = Criteria(self.name)
for child in self.children :
exported.addChild(child.export())
return exported
def addChild(self, child):
if child in self.children:
raise self.DuplicatedCriterionError(self, child)
super().addChild(child)
class ConfigAppliedWithoutCriteriaError(CustomError):
def __init__(self, configurationName, domainName):
self.configurationName = configurationName
self.domainName = domainName
def __str__(self):
return ('Applying configuration "%s" from domain "%s" before declaring criteria' %
(self.configurationName, self.domainName))
class ParsePFWlog():
MATCH = "match"
ACTION = "action"
class ChangeRequestOnUnknownCriterion(CustomError):
def __init__(self, criterion):
self.criterion = criterion
def __str__(self):
return ("Change request on an unknown criterion %s." %
self.criterion)
def __init__(self, domains, criteria, ErrorsToIgnore=()):
self.domains = domains;
self.criteria = criteria;
self.ErrorsToIgnore = ErrorsToIgnore
configApplicationRegext = r""".*Applying configuration "(.*)" from domain "([^"]*)"""
matchConfigApplicationLine = re.compile(configApplicationRegext).match
criterionCreationRegext = ", ".join([
r""".*Criterion name: (.*)""",
r"""type kind: (.*)""",
r"""current state: (.*)""",
r"""states: {(.*)}"""
])
matchCriterionCreationLine = re.compile(criterionCreationRegext).match
changingCriterionRegext = r""".*Selection criterion changed event: Criterion name: (.*), current state: ([^\n\r]*)"""
matchChangingCriterionLine = re.compile(changingCriterionRegext).match
self.lineLogTypes = [
{
self.MATCH: matchConfigApplicationLine,
self.ACTION: self._configApplication
}, {
self.MATCH: matchCriterionCreationLine,
self.ACTION: self._criterionCreation
}, {
self.MATCH: matchChangingCriterionLine,
self.ACTION: self._changingCriterion
}
]
@staticmethod
def _formatCriterionList(liststring, separator):
list = liststring.split(separator)
if len(list) == 1 and list[0] == "<none>":
list = []
return list
def _criterionCreation(self, matchCriterionCreation):
# Unpack
criterionName, criterionType, currentCriterionStates, criterionStates = matchCriterionCreation.group(1, 2, 3, 4)
criterionStateList = self._formatCriterionList(criterionStates, ", ")
criterionIsInclusif = {"exclusive" : False, "inclusive" : True}[criterionType]
currentcriterionStateList = self._formatCriterionList(currentCriterionStates, "|")
logger.info("Creating criterion: " + criterionName +
" (" + criterionType + ") " +
" with current state: " + str(currentcriterionStateList) +
", possible states:" + str(criterionStateList))
try:
self.criteria.addChild(Criterion(
criterionName,
criterionIsInclusif,
criterionStateList,
currentcriterionStateList
))
except self.criteria.DuplicatedCriterionError as ex:
logger.debug(ex)
logger.warning("Reseting criterion %s. Did you reset the PFW ?" % criterionName)
self.criteria.operationOnChild(
[criterionName],
lambda criterion: criterion.reset()
)
def _changingCriterion(self, matchChangingCriterion):
# Unpack
criterionName, newCriterionSubStateNames = matchChangingCriterion.group(1, 2)
newCriterionState = self._formatCriterionList(newCriterionSubStateNames, "|")
logger.info("Changing criterion %s to %s" % (criterionName , newCriterionState))
path = [criterionName]
changeCriterionOperation = lambda criterion : criterion.changeState(newCriterionState)
try:
self.criteria.operationOnChild(path, changeCriterionOperation)
except ChildNotFoundError:
raise self.ChangeRequestOnUnknownCriterion(criterionName)
def _configApplication(self, matchConfig):
# Unpack
configurationName, domainName = matchConfig.group(1, 2)
# Check that at least one criterion exist
if not self.criteria.hasChildren() :
logger.error("Applying configuration before declaring criteria")
logger.info("Is the log starting at PFW boot ?")
raise ConfigAppliedWithoutCriteriaError(configurationName, domainName)
# Change criterion state
path = [domainName, configurationName]
usedOperation = lambda element : element.used(self.criteria)
logger.info("Applying configuration %s from domain %s" % (
configurationName, domainName))
self.domains.operationOnChild(path, usedOperation)
def _digest(self, lineLogType, lineLog):
match = lineLogType[self.MATCH](lineLog)
if match :
lineLogType[self.ACTION](match)
return True
return False
def parsePFWlog(self, lines):
for lineNb, lineLog in enumerate(lines, 1): # line number starts at 1
logger.debug("Parsing line :%s" % lineLog.rstrip())
digested = (self._digest(lineLogType, lineLog)
for lineLogType in self.lineLogTypes)
try:
success = any(digested)
# Catch some exception in order to print the current parsing line,
# then raise the exception again if not continue of error
except CustomError as ex:
logger.error('Error raised while parsing line %s: "%s"' %
(lineNb, repr(lineLog)))
# If exception is a subclass of ErrorsToIgnore, log it and continue
# otherwise raise it again.
if not issubclass(type(ex), self.ErrorsToIgnore):
raise ex
else:
logger.error('Ignoring exception:"%s", '
'can not guarantee database integrity' % ex)
else:
if not success:
logger.debug("Line does not match, dropped")
class Root(Element):
tag = "CoverageReport"
def __init__(self, name, dom):
super().__init__(name)
# Create domain tree
self.domains = Domains("Domains")
self.domains.populate(dom)
self.addChild(self.domains)
# Create criterion list
self.criteria = Criteria("CriterionRoot")
self.addChild(self.criteria)
def exportToXML(self):
"""Export tree to an xml document"""
impl = xml.dom.minidom.getDOMImplementation()
document = impl.createDocument(namespaceURI=None, qualifiedName=self.tag, doctype=None)
super().exportToXML(document, document.documentElement)
return document
# ============================
# Command line argument parser
# ============================
class ArgumentParser:
"""class that parse command line arguments with argparse library
Result of parsing are the class attributes.
"""
levelTranslate = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
def __init__(self):
try:
# As argparse is only in the stdlib since python 3.2,
# testing its availability
import argparse
except ImportError:
logger.warning("Unable to import argparse "
"(parser for command-line options and arguments), "
"using default argument values:")
logger.warning(" - InputFile: stdin")
self.inputFile = sys.stdin
logger.warning(" - OutputFile: stdout")
self.outputFile = sys.stdout
try:
self.domainsFile = sys.argv[1]
except IndexError as ex:
logger.fatal("No domain file provided (first argument)")
raise ex
else:
logger.warning(" - Domain file: " + self.domainsFile)
logger.warning(" - Output format: xml")
self.XMLreport = True
logger.warning(" - Debug level: error")
self.debugLevel = logging.ERROR
else :
myArgParser = argparse.ArgumentParser(description='Generate PFW report')
myArgParser.add_argument(
'domainsFile',
type=argparse.FileType('r'),
help="the PFW domain XML file"
)
myArgParser.add_argument(
'pfwlog', nargs='?',
type=argparse.FileType('r'), default=sys.stdin,
help="the PFW log file, default stdin"
)
myArgParser.add_argument(
'-o', '--output',
dest="outputFile",
type=argparse.FileType('w'), default=sys.stdout,
help="the coverage report output file, default stdout"
)
myArgParser.add_argument(
'-v', '--verbose',
dest="debugLevel", default=0,
action='count',
help="print debug warnings from warning (default) to debug (-vv)"
)
outputFormatGroupe = myArgParser.add_mutually_exclusive_group(required=False)
outputFormatGroupe.add_argument(
'--xml',
dest="xmlFlag",
action='store_true',
help=" XML coverage output report"
)
outputFormatGroupe.add_argument(
'--raw',
dest="rawFlag",
action='store_true',
help="raw coverage output report"
)
myArgParser.add_argument(
'--ignore-unknown-criterion',
dest="unknwonCriterionFlag",
action='store_true',
help="ignore unknown criterion"
)
myArgParser.add_argument(
'--ignore-incoherent-criterion-state',
dest="incoherentCriterionFlag",
action='store_true',
help="ignore criterion transition to incoherent state"
)
myArgParser.add_argument(
'--ignore-ineligible-configuration-application',
dest="ineligibleConfigurationApplicationFlag",
action='store_true',
help="ignore application of configuration with a false rule "
"(not applicable configuration)"
)
# Process command line arguments
options = myArgParser.parse_args()
# Mapping to attributes
self.inputFile = options.pfwlog
self.outputFile = options.outputFile
self.domainsFile = options.domainsFile
# Output report in xml if flag not set
self.XMLreport = not options.rawFlag
# Setting logger level
levelCapped = min(options.debugLevel, len(self.levelTranslate) - 1)
self.debugLevel = self.levelTranslate[levelCapped]
# Setting ignore options
errorToIgnore = []
if options.ineligibleConfigurationApplicationFlag :
errorToIgnore.append(Configuration.IneligibleConfigurationAppliedError)
if options.incoherentCriterionFlag:
errorToIgnore.append(Criterion.ChangeRequestToNonAccessibleState)
if options.unknwonCriterionFlag:
errorToIgnore.append(ParsePFWlog.ChangeRequestOnUnknownCriterion)
self.errorToIgnore = tuple(errorToIgnore)
def main():
errorDuringLogParsing = -1
errorDuringArgumentParsing = 1
try:
commandLineArguments = ArgumentParser()
except LookupError as ex:
logger.error("Error during argument parsing")
logger.debug(str(ex))
sys.exit(errorDuringArgumentParsing)
# Setting logger level
logger.setLevel(commandLineArguments.debugLevel)
logger.info("Log level set to: %s" %
logging.getLevelName(commandLineArguments.debugLevel))
# Create tree from XML
dom = xml.dom.minidom.parse(commandLineArguments.domainsFile)
# Create element tree
root = Root("DomainCoverage", dom)
# Parse PFW events
parser = ParsePFWlog(root.domains, root.criteria, commandLineArguments.errorToIgnore)
try:
parser.parsePFWlog(commandLineArguments.inputFile.readlines())
except CustomError as ex:
logger.fatal("Error during parsing log file %s: %s" %
(commandLineArguments.inputFile, ex))
sys.exit(errorDuringLogParsing)
# Output report
outputFile = commandLineArguments.outputFile
if not commandLineArguments.XMLreport :
outputFile.write("%s\n" % root.dump(withCoverage=True, withNbUse=True))
else :
outputFile.write(root.exportToXML().toprettyxml())
if __name__ == "__main__" :
""" Execute main if the python interpreter is running this module as the main program """
main()