python.trfValidation.ignorePatterns Class Reference

Class of patterns that can be ignored from athena logfiles. More...

Inheritance diagram for python.trfValidation.ignorePatterns:

Collaboration diagram for python.trfValidation.ignorePatterns:

Public Member Functions
	__init__ (self, files=['atlas_error_mask.db'], extraSearch=[])
	Load error patterns from files.
	structuredPatterns (self)
	searchPatterns (self)

Protected Member Functions
	_initalisePatterns (self, files)
	_initialiseSerches (self, searchStrings=[])

Protected Attributes
list	_structuredPatterns = []
list	_searchPatterns = []

Detailed Description

Class of patterns that can be ignored from athena logfiles.

Definition at line 30 of file trfValidation.py.

Constructor & Destructor Documentation

__init__()

python.trfValidation.ignorePatterns.__init__	(		self,
			files = ['atlas_error_mask.db'],
			extraSearch = [] )

Load error patterns from files.

Load regular expressions to be used in logfile parsing Files to load up structured error patterns from

Parameters

extraSearch

Extra regexp strings to search against

Definition at line 36 of file trfValidation.py.

    def __init__(self, files=['atlas_error_mask.db'], extraSearch = []):
        # Setup structured search patterns
        self._structuredPatterns = []
        self._initalisePatterns(files)
 
        # Setup extra search patterns
        self._searchPatterns = []
        self._initialiseSerches(extraSearch)
 

Member Function Documentation

_initalisePatterns()

python.trfValidation.ignorePatterns._initalisePatterns ( self, files )

protected

Definition at line 53 of file trfValidation.py.

    def _initalisePatterns(self, files):
        for patternFile in files:
            if patternFile == "None":
                continue
            fullName = trfUtils.findFile(os.environ['DATAPATH'], patternFile)
            if not fullName:
                msg.warning('Error pattern file {0} could not be found in DATAPATH'.format(patternFile))
                continue
            try:
                with open(fullName) as patternFileHandle:
                    msg.debug('Opened error file {0} from here: {1}'.format(patternFile, fullName))
 
                    for line in patternFileHandle:
                        line = line.strip()
                        if line.startswith('#') or line == '':
                            continue
                        try:
                            # N.B. At the moment release matching is not supported!
                            (who, level, message) = [ s.strip() for s in line.split(',', 2) ]
                            if who == "":
                                # Blank means match anything, so make it so...
                                who = "."
                            reWho = re.compile(who)
                            reMessage = re.compile(message)
                        except ValueError:
                            msg.warning('Could not parse this line as a valid error pattern: {0}'.format(line))
                            continue
                        except re.error as e:
                            msg.warning('Could not parse valid regexp from {0}: {1}'.format(message, e))
                            continue
 
                        msg.debug('Successfully parsed: who={0}, level={1}, message={2}'.format(who, level, message))
 
                        self._structuredPatterns.append({'service': reWho, 'level': level, 'message': reMessage})
 
            except OSError as xxx_todo_changeme:
                (errno, errMsg) = xxx_todo_changeme.args
                msg.warning('Failed to open error pattern file {0}: {1} ({2})'.format(fullName, errMsg, errno))
 
 

_initialiseSerches()

python.trfValidation.ignorePatterns._initialiseSerches ( self, searchStrings = [] )

protected

Definition at line 93 of file trfValidation.py.

    def _initialiseSerches(self, searchStrings=[]):
        for string in searchStrings:
            try:
                self._searchPatterns.append(re.compile(string))
                msg.debug('Successfully parsed additional logfile search string: {0}'.format(string))
            except re.error as e:
                msg.warning('Could not parse valid regexp from {0}: {1}'.format(string, e))
 
 
 

searchPatterns()

python.trfValidation.ignorePatterns.searchPatterns

(

self

)

Definition at line 50 of file trfValidation.py.

    def searchPatterns(self):
        return self._searchPatterns
 

structuredPatterns()

python.trfValidation.ignorePatterns.structuredPatterns

(

self

)

Definition at line 46 of file trfValidation.py.

    def structuredPatterns(self):
        return self._structuredPatterns
 

Member Data Documentation

_searchPatterns

list python.trfValidation.ignorePatterns._searchPatterns = []

protected

Definition at line 42 of file trfValidation.py.

_structuredPatterns

list python.trfValidation.ignorePatterns._structuredPatterns = []

protected

Definition at line 38 of file trfValidation.py.

---

The documentation for this class was generated from the following file:

• trfValidation.py