class RuleDictionary ():
'''
This class is designed encapsulate the dictionary object for
rules.
@author: ekkehard j. koch
@note: None
@change: 2015-02-25 - ekkehard - Original Implementation
'''
def __init__(self):
self.unittestprefix = 'zzzTestRule'
self.initlist = ['__init__.py', '__init__.pyc', '__init__.pyo']
self.environ = Environment()
self.environ.setdebugmode(False)
self.environ.setverbosemode(True)
self.effectiveUserID = self.environ.geteuid()
self.config = Configuration(self.environ)
self.logdispatch = LogDispatcher(self.environ)
self.statechglogger = StateChgLogger(self.logdispatch, self.environ)
self.scriptPath = self.environ.get_script_path()
self.stonixPath = self.environ.get_resources_path()
self.rulesPath = self.environ.get_rules_path()
self.unittestpath = self.scriptPath + "/"
self.ruledictionary = {}
self.keys = None
self.key = None
self.keyIndexNumber = 0
self.keysNumberOf = 0
self.dictinaryItem = None
self.initializeRuleInfo()
self.initializeRuleUnitTestData()
self.initializeRuleContextData()
def gotoFirstRule(self):
self.keyIndexNumber = 0
self.keys = sorted(self.ruledictionary.keys())
self.keysNumberOf = len(self.keys)
self.key = self.keys[self.keyIndexNumber]
self.dictinaryItem = self.ruledictionary[self.key]
def gotoNextRule(self):
self.keyIndexNumber = self.keyIndexNumber + 1
self.keys = sorted(self.ruledictionary.keys())
self.keysNumberOf = len(self.keys)
if (self.keysNumberOf - 1) < self.keyIndexNumber:
self.keyIndexNumber = 0
self.dictinaryItem = None
else:
self.key = self.keys[self.keyIndexNumber]
self.dictinaryItem = self.ruledictionary[self.key]
def getCorrectEffectiveUserid(self):
return self.ruledictionary[self.key]["rulecorrecteffectiveuserid"]
def getCurrentRuleItem(self):
return self.dictinaryItem
def getIsApplicable(self):
return self.ruledictionary[self.key]["ruleisapplicable"]
def getHasRule(self):
return self.ruledictionary[self.key]["rulefound"]
def getHasUnitTest(self):
return self.ruledictionary[self.key]["unittestfound"]
def getRuleName(self):
return self.ruledictionary[self.key]["rulename"]
def getRuleNumber(self):
return self.ruledictionary[self.key]["rulenumber"]
def getTestName(self):
return self.ruledictionary[self.key]["unittestname"]
def initializeRuleInfo(self):
'''
Fill in all the rule information
@author: ekkehard j. koch
@note: None
'''
success = True
messagestring = "--------------------------------- start"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
self.validrulefiles = []
self.modulenames = []
self.classnames = []
rulefiles = os.listdir(str(self.rulesPath))
for rfile in rulefiles:
rule_class = None
if rfile in self.initlist:
continue
elif re.search("\.py$", rfile):
rulename = rfile.replace('.py', '')
rulefilename = rfile
ruleclassname = 'rules.' + rulename + '.' + rulename
ruleclasspath = self.rulesPath + "/" + rfile
parts = ruleclassname.split(".")
rulemoduleimportstring = "stonix_resources." + \
".".join(parts[:-1])
ruleinstanciatecommand = "rule_class = mod." + ruleclassname
unittestname = self.unittestprefix + rulename
unittestfilename = self.unittestprefix + rfile
unittestclasspath = self.unittestpath + unittestfilename
unittestclassname = unittestname + "." + unittestname
unittestmoduleimportstring = unittestname
unittestinstanciatecommand = "unittest_class = mod." + \
unittestclassname
self.initializeDictoniaryItem(rulename)
self.ruledictionary[rulename]["rulename"] = rulename
self.ruledictionary[rulename]["ruleclassname"] = ruleclassname
self.ruledictionary[rulename]["ruleclasspath"] = ruleclasspath
self.ruledictionary[rulename]["rulefilename"] = rulefilename
self.ruledictionary[rulename]["ruleclassname"] = ruleclassname
self.ruledictionary[rulename]["rulemoduleimportstring"] = rulemoduleimportstring
self.ruledictionary[rulename]["ruleinstanciatecommand"] = ruleinstanciatecommand
self.ruledictionary[rulename]["ruleobject"] = None
self.ruledictionary[rulename]["ruleisapplicable"] = True
self.ruledictionary[rulename]["rulecorrecteffectiveuserid"] = True
self.ruledictionary[rulename]["rulefound"] = True
self.ruledictionary[rulename]["unittestname"] = unittestname
self.ruledictionary[rulename]["unittestclasspath"] = unittestclasspath
self.ruledictionary[rulename]["unittestfilename"] = unittestfilename
self.ruledictionary[rulename]["unittestclassname"] = unittestclassname
self.ruledictionary[rulename]["unittestmoduleimportstring"] = unittestmoduleimportstring
self.ruledictionary[rulename]["unittestinstanciatecommand"] = unittestinstanciatecommand
self.ruledictionary[rulename]["unittestobject"] = None
self.ruledictionary[rulename]["unittestfound"] = False
self.ruledictionary[rulename]["errormessage"] = []
try:
mod = __import__(rulemoduleimportstring)
except Exception:
trace = traceback.format_exc()
messagestring = "Error importing rule: " + rulename + " " + \
rulemoduleimportstring + " - " + trace
self.ruledictionary[rulename]["errormessage"].append(messagestring)
self.logdispatch.log(LogPriority.ERROR, messagestring)
continue
try:
exec(ruleinstanciatecommand)
# rule_class = getattr(mod, classimportname)
# exec("rule_class = mod.rules." + name + "." + name)
except Exception:
trace = traceback.format_exc()
messagestring = "Error importing rule: " + rulename + " " + \
rulemoduleimportstring + " - " + trace
self.logdispatch.log(LogPriority.ERROR,
"Error finding rule class reference: "
+ trace)
continue
try:
self.rule = rule_class(self.config,
self.environ,
self.logdispatch,
self.statechglogger)
self.ruledictionary[rulename]["ruleobject"] = self.rule
except Exception:
trace = traceback.format_exc()
messagestring = "Error initializing rule: " + rulename + \
" - " + trace
self.ruledictionary[rulename]["errormessage"].append(messagestring)
self.logdispatch.log(LogPriority.ERROR, messagestring)
continue
else:
continue
return success
def initializeRuleUnitTestData(self):
'''
Fill in all the unit test data
@author: ekkehard j. koch
@note: None
'''
success = True
messagestring = "--------------------------------- start"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
ruletestfiles = os.listdir(str(self.unittestpath))
for rtfile in ruletestfiles:
if rtfile in self.initlist:
continue
elif re.search("\.py$", rtfile):
if rtfile.startswith(self.unittestprefix):
unittestmodule = rtfile.replace('.py', '')
module = unittestmodule.replace(self.unittestprefix, "")
if self.findDictonaryItem(module):
self.dictinaryItem["unittestfound"] = True
else:
self.dictinaryItem["rulename"] = module
self.dictinaryItem["rulefound"] = False
self.dictinaryItem["unittestname"] = unittestmodule
self.dictinaryItem["unittestfound"] = True
else:
continue
return success
def initializeRuleContextData(self):
'''
Make sure you have all the contextual data for rules
@author: ekkehard j. koch
@note: None
'''
success = True
messagestring = "--------------------------------- start"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
keys = sorted(self.ruledictionary.keys())
for key in keys:
ruleclassname = self.ruledictionary[key]["ruleclassname"]
classimportname = "." + ruleclassname
rulename = self.ruledictionary[key]["rulename"]
ruleclasspath = self.ruledictionary[key]["ruleclasspath"]
rule_class = self.ruledictionary[key]["ruleobject"]
rulemoduleimportstring = \
self.ruledictionary[key]["rulemoduleimportstring"]
ruleclasspath = \
self.ruledictionary[key]["ruleclasspath"]
ruleinstanciatecommand = \
self.ruledictionary[key]["ruleinstanciatecommand"]
try:
mod = __import__(rulemoduleimportstring)
except Exception:
trace = traceback.format_exc()
messagestring = "Error importing rule: " + rulename + " " + \
rulemoduleimportstring + " - " + trace
self.ruledictionary[key]["errormessage"].append(messagestring)
self.logdispatch.log(LogPriority.ERROR, messagestring)
continue
try:
exec(ruleinstanciatecommand)
# rule_class = getattr(mod, classimportname)
# exec("rule_class = mod.rules." + rulename + "." + rulename)
except Exception:
trace = traceback.format_exc()
messagestring = "Error importing rule: " + rulename + " " + \
rulemoduleimportstring + " - " + trace
self.logdispatch.log(LogPriority.ERROR,
"Error finding rule class reference: "
+ trace)
continue
try:
self.rule = rule_class(self.config,
self.environ,
self.logdispatch,
self.statechglogger)
rulenumber = self.rule.getrulenum()
self.ruledictionary[key]["rulenumber"] = rulenumber
messagestring = str(key) + "(" + str(rulenumber) + ") initialized!"
isapplicable = self.rule.isapplicable()
isRootRequired = self.rule.getisrootrequired()
if not isapplicable:
self.ruledictionary[key]["ruleisapplicable"] = False
messagestring = messagestring + " is not applicable."
else:
self.ruledictionary[key]["ruleisapplicable"] = True
messagestring = messagestring + " is applicable."
if self.effectiveUserID == 0 and isRootRequired:
self.ruledictionary[key]["rulecorrecteffectiveuserid"] = True
messagestring = messagestring + " is running in " + \
"correct context."
elif not self.effectiveUserID == 0 and not isRootRequired:
self.ruledictionary[key]["rulecorrecteffectiveuserid"] = True
messagestring = messagestring + " is running in " + \
"correct context."
else:
self.ruledictionary[key]["rulecorrecteffectiveuserid"] = False
messagestring = messagestring + " is not running in " + \
"correct context."
self.logdispatch.log(LogPriority.INFO, str(messagestring))
except Exception:
trace = traceback.format_exc()
messagestring = "Error initializing rule: " + rulename + \
" - " + trace
self.ruledictionary[key]["errormessage"].append(messagestring)
self.logdispatch.log(LogPriority.ERROR, messagestring)
continue
return success
def findDictonaryItem(self, rulename):
self.dictinaryItem = self.ruledictionary[rulename]
if self.dictinaryItem == None:
success = False
else:
success = True
return success
def initializeDictoniaryItem(self, rulename):
success = True
item = {"rulename": "",
"rulenumber": 0,
"ruleclassname": "",
"ruleclasspath": "",
"rulefilename": "",
"ruleclassname": "",
"rulemoduleimportstring": "",
"ruleinstanciatecommand": "",
"ruleobject": "",
"ruleisapplicable": False,
"rulecorrecteffectiveuserid": False,
"rulefound": False,
"unittestname": "",
"unittestclasspath": "",
"unittestfilename": "",
"unittestclassname": "",
"unittestmoduleimportstring": "",
"unittestinstanciatecommand": "",
"unittestobject": None,
"unittestfound": False,
"errormessage": []}
self.ruledictionary[rulename] = item
self.dictinaryItem = self.ruledictionary[rulename]
return success
def ruleReport(self):
success = True
messagestring = "start --------------------------------------------"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
self.gotoFirstRule()
messagestring = "stonixtest rule tested: --------------------------------------------------"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
while not (self.getCurrentRuleItem() == None):
ruleName = self.getRuleName()
ruleNumber = self.getRuleNumber()
ruleTestName = self.getTestName()
ruleCorrectEffectiveUserid = self.getCorrectEffectiveUserid()
ruleIsApplicable = self.getIsApplicable()
if ruleIsApplicable and ruleCorrectEffectiveUserid:
messagestring = str(ruleName) + "(" + str(ruleNumber) + "):" + \
str(ruleTestName) + " - isApplicable=" + \
str(ruleIsApplicable) + " - CorrectEffectiveUserid=" + \
str(ruleCorrectEffectiveUserid) + ";"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
self.gotoNextRule()
self.gotoFirstRule()
messagestring = "stonixtest rule not tested: --------------------------------------------------"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
while not (self.getCurrentRuleItem() == None):
ruleName = self.getRuleName()
ruleNumber = self.getRuleNumber()
ruleTestName = self.getTestName()
ruleCorrectEffectiveUserid = self.getCorrectEffectiveUserid()
ruleIsApplicable = self.getIsApplicable()
if not(ruleIsApplicable) or not(ruleCorrectEffectiveUserid):
messagestring = str(ruleName) + "(" + str(ruleNumber) + "):" + \
str(ruleTestName) + " - isApplicable=" + \
str(ruleIsApplicable) + " - CorrectEffectiveUserid=" + \
str(ruleCorrectEffectiveUserid) + ";"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
self.gotoNextRule()
messagestring = "end --------------------------------------------"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
return success
class FrameworkDictionary():
def __init__(self):
self.unittestprefix = 'zzzTestFramework'
self.initlist = ['__init__.py', '__init__.pyc', '__init__.pyo']
self.environ = Environment()
self.environ.setdebugmode(False)
self.environ.setverbosemode(True)
self.effectiveUserID = self.environ.geteuid()
self.config = Configuration(self.environ)
self.logdispatch = LogDispatcher(self.environ)
self.statechglogger = StateChgLogger(self.logdispatch, self.environ)
self.scriptPath = self.environ.get_script_path()
self.stonixPath = self.environ.get_resources_path()
self.rulesPath = self.environ.get_rules_path()
self.frameworkpath = self.stonixPath + "/"
self.frameworkdictionary = {}
self.keys = None
self.key = None
self.keyIndexNumber = 0
self.keysNumberOf = 0
self.dictinaryItem = None
self.initializeDictionary()
def gotoFirstItem(self):
self.keyIndexNumber = 0
self.keys = sorted(self.frameworkdictionary.keys())
self.keysNumberOf = len(self.keys)
self.key = self.keys[self.keyIndexNumber]
self.dictinaryItem = self.frameworkdictionary[self.key]
def gotoNextItem(self):
self.keyIndexNumber = self.keyIndexNumber + 1
self.keys = sorted(self.frameworkdictionary.keys())
self.keysNumberOf = len(self.keys)
if (self.keysNumberOf - 1) < self.keyIndexNumber:
self.keyIndexNumber = 0
self.dictinaryItem = None
else:
self.key = self.keys[self.keyIndexNumber]
self.dictinaryItem = self.frameworkdictionary[self.key]
def getCurrentItem(self):
return self.dictinaryItem
def getTestPath(self):
return self.dictinaryItem["path"]
def getTestName(self):
return self.dictinaryItem["name"]
def initializeDictionary(self):
'''
Fill in all the rule information
@author: ekkehard j. koch
@note: None
'''
success = True
messagestring = "--------------------------------- start"
self.logdispatch.log(LogPriority.INFO, str(messagestring))
self.validrulefiles = []
self.modulenames = []
self.classnames = []
rulefiles = os.listdir(str(self.frameworkpath))
for rfile in rulefiles:
rule_class = None
if rfile in self.initlist:
continue
elif re.search("\.py$", rfile):
modulename = rfile.replace('.py', '')
if modulename.startswith(self.unittestprefix):
self.initializeDictoniaryItem(modulename)
self.dictinaryItem["name"] = modulename
self.dictinaryItem["found"] = True
else:
continue
return success
def initializeDictoniaryItem(self, name):
success = True
item = {"name": "",
"path": self.frameworkpath,
"found": False,
"errormessage": []}
self.frameworkdictionary[name] = item
self.dictinaryItem = self.frameworkdictionary[name]
return success
