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
def	__init__ (self, files=['atlas_error_mask.db'], extraSearch=[])
	Load error patterns from files. More...
def	structuredPatterns (self)
def	searchPatterns (self)

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

Private Attributes
	_structuredPatterns
	_searchPatterns

Detailed Description

Class of patterns that can be ignored from athena logfiles.

Definition at line 100 of file trfValidation.py.

Constructor & Destructor Documentation

__init__()

def 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 106 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()

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

private

Definition at line 123 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()

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

private

Definition at line 163 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()

def python.trfValidation.ignorePatterns.searchPatterns

(

self

)

Definition at line 120 of file trfValidation.py.

    def searchPatterns(self):
        return self._searchPatterns
 

structuredPatterns()

def python.trfValidation.ignorePatterns.structuredPatterns

(

self

)

Definition at line 116 of file trfValidation.py.

    def structuredPatterns(self):
        return self._structuredPatterns
 

Member Data Documentation

_searchPatterns

python.trfValidation.ignorePatterns._searchPatterns

private

Definition at line 112 of file trfValidation.py.

_structuredPatterns

python.trfValidation.ignorePatterns._structuredPatterns

private

Definition at line 108 of file trfValidation.py.

---

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

• trfValidation.py