def resolveFiles(self, fileSignature):
"""
@return: list(asm_file_system.ResolvedConfigFile)
"""
fileLocations = fileSignature.FileLocations if hasattr(fileSignature, 'FileLocations') else None
filename = fileSignature.name
fileContentSignature = fileSignature.FileContent if hasattr(fileSignature, 'FileContent') else None
files = []
_, undefinedVariables = ExpressionResolver.checkVariable(self.variableResolver, filename)
if undefinedVariables:
logger.debug('Skip configuration file %s because following variable%s no value:' %
(filename, 's have' if len(undefinedVariables) > 1 else ' has'), ', '.join(undefinedVariables))
elif fileLocations:
paths = fileLocations.children
for path in paths:
if not OSType.match(path.os, self.shell):
logger.debug('Skip path %s because expect os type %s but actual is %s' %
(path.text, path.os, OSType.fromShell(self.shell)))
continue
for resolvedPath, resolvedFilename in self.resolvePath(path.text, filename):
found = asm_file_system.getConfigFilesFromPath(self.shell, resolvedPath, resolvedFilename, path.includeSub)
if found:
files.extend(found)
elif fileContentSignature:
fileContent = ExpressionResolver.resolve(self.variableResolver, fileContentSignature.text)
file = asm_file_system.ResolvedConfigFile(None, filename, fileContent)
files.append(file)
return files
def processRegex(regExpSignature, input, variableResolver):
pattern = ExpressionResolver.resolve(variableResolver, regExpSignature.expr, ExpressionResolver.REGULAR_EXPRESSION)
if not pattern:
logger.debug('Skip ', regExpSignature)
return
flags = getFlags(regExpSignature)
try:
compiledRegex = re.compile('(%s)' % pattern, flags)
except Exception, e:
logger.debug('Skip %s because regex %s is invalid:' % (regExpSignature, ExpressionResolver.quote(pattern)), e)
return
def _process(cls, variableSignature, variableResolver, input):
processor, context = input
xpath = ExpressionResolver.resolve(variableResolver, getattr(variableSignature, ATTR_XPATH, None) or variableSignature.relativePath,
ExpressionResolver.XPATH)
if not xpath:
logger.debug('Skip ', variableSignature)
return
try:
result = processor.evaluate(xpath, context)
if result:
logger.debug('Found result for xpath %s:' % ExpressionResolver.quote(xpath), result)
else:
logger.debug('No matches for xpath:', xpath)
result = ''
return result
except Exception, e:
logger.debug('Skip %s because fail to evaluate xpath %s:' % (variableSignature, ExpressionResolver.quote(xpath)), e)
def resolvePath(self, filePath, filename):
"""
@type path: str
@type filename: str
@return: list(str,str)
"""
resolvedPaths = []
_, undefinedVariables = ExpressionResolver.checkVariable(self.variableResolver, filePath)
if undefinedVariables:
logger.debug('Skip path %s because following variable%s was not defined:' %
(filePath, 's' if len(undefinedVariables) > 1 else ''), ', '.join(undefinedVariables))
else:
fullPath = '|'.join((filePath, filename))
paths = ExpressionResolver.resolve(self.variableResolver, fullPath, ExpressionResolver.STRING_LITERAL_LIST)
for path in paths:
resolvedPaths.append(path.split('|'))
return resolvedPaths
def process(self, fileSignature, configFile):
"""
@type configFile: asm_file_system.ResolvedConfigFile
"""
fileContent = configFile.getContent()
try:
self._prepareFile(fileContent)
except:
e = sys.exc_info()[1]
logger.debug('Error occurred when preparing config file %s:' % ExpressionResolver.quote(configFile.getName()), e)
return
logger.debug('Processing configuration file %s found in path %s' % (
ExpressionResolver.quote(configFile.getName()), ExpressionResolver.quote(configFile.getPath())))
for signature in fileSignature.children:
if signature.getType() == TAG_REGEX:
processRegex(signature, fileContent, self.variableResolver)
elif signature.getType() == TAG_SYSTEM_VARIABLE or signature.getType() == TAG_PYTHON_VARIABLE:
processVariable(signature, self.variableResolver, self.shell, False)
elif signature.getType() != TAG_FILE_LOCATIONS:
self._processVariable(signature)
def _processVariable(self, signature):
if signature.getType() == TAG_XPATH:
xpaths = ExpressionResolver.resolve(self.variableResolver, signature.xpath, ExpressionResolver.STRING_LITERAL_LIST)
if not xpaths:
logger.debug('Skip ', signature)
return
for xpath in xpaths:
items = []
try:
items = self.processor.evaluateItem(xpath)
except Exception, e:
logger.debug('Fail to evaluate xpath %s:' % ExpressionResolver.quote(xpath), e)
return
if not items:
logger.debug('No matches for xpath:', xpath)
for item in items:
logger.debug('Found result for xpath %s:' % ExpressionResolver.quote(xpath), item)
for var in signature.children:
if var.getType() == TAG_REGEX:
if hasattr(var, ATTR_RELATIVE_PATH):
relativePath = ExpressionResolver.resolve(self.variableResolver, var.relativePath, ExpressionResolver.XPATH)
if not relativePath:
logger.debug('Skip ', var)
continue
try:
values = self.processor.evaluate(relativePath, item)
except Exception, e:
logger.debug('Fail to evaluate relative xpath %s:' % ExpressionResolver.quote(relativePath), e)
continue
if items:
logger.debug('Found result for relative xpath %s:' % ExpressionResolver.quote(relativePath), values)
else:
logger.debug('No matches for relative xpath:', relativePath)
else:
values = [item.getStringValue()]
for value in values:
processRegex(var, value, self.variableResolver)
elif var.getType() == TAG_VARIABLE:
XPathVariableProcessor.process(var, self.variableResolver, (self.processor, item), True)
def buildSCP(scpSignature, variableResolver):
scpData = {}
sizes = {}
for attr in SCP_ATTRIBUTES.keys():
value = []
if hasattr(scpSignature, attr):
value.extend(ExpressionResolver.resolve(variableResolver, getattr(scpSignature, attr), ExpressionResolver.STRING_LITERAL_LIST))
if not value and attr != 'context':
logger.debug('Skip %s because %s is required' % (scpSignature, attr))
return []
scpData[attr] = value
sizes[attr] = len(value)
maxCount = max(sizes.values())
# Check length of attribute value lists
for attr in SCP_ATTRIBUTES.keys():
size = sizes[attr]
if size > 1 and size != maxCount:
# check size. the list length should be same or less than 2
logger.debug('Skip %s because the size of attributes mismatch:' % scpSignature,
', '.join(['%s[%d]' % (attr, sizes[attr]) for attr in SCP_ATTRIBUTES]))
return []
scps = []
for index in range(maxCount):
params = {}
# Fill scp attributes
for attr in SCP_ATTRIBUTES.keys():
size = sizes[attr]
if size == 0:
value = None
elif size == 1:
value = scpData[attr][0]
else:
value = scpData[attr][index]
params[attr] = value
for attr in SCP_ATTRIBUTES.keys():
if not params[attr] and SCP_ATTRIBUTES[attr]:
logger.debug('Skip SCP %s because attribute "%s" is required' % (params, attr))
params = None
break
if params:
logger.debug('Build Service Connection Point:', params)
scps.append(params)
return scps
def processExecuteCommand(shell, execSignature, variableResolver):
cmdline = ExpressionResolver.resolve(variableResolver, execSignature.cmdline)
if not cmdline:
logger.debug('Skip ', execSignature)
return
if not OSType.match(execSignature.os, shell):
logger.debug('Skip command execution %s because expect os type "%s" but actual is "%s"' %
(cmdline, execSignature.os, OSType.fromShell(shell)))
return
result = None
error = None
try:
result = shell.execCmd(cmdline)
if shell.getLastCmdReturnCode():
error = 'error code:%d' % shell.getLastCmdReturnCode()
except Exception, e:
error = e
def processCommandLine(cmdlineSignature, application, shell, processMap, variableResolver):
processes = list(application.getProcesses())
if cmdlineSignature.includeParentProcesses:
for process in processes:
processes.extend(getParentProcesses(process, processMap))
for signature in cmdlineSignature.children:
if signature.getType() == TAG_REGEX:
regex = signature.expr
if not OSType.match(signature.os, shell):
logger.debug('Skip command line pattern %s because expect os type "%s" but actual is %s' %
(ExpressionResolver.quote(regex), signature.os, OSType.fromShell(shell)))
continue # ignore the expression because os type mismatch
for process in processes:
logger.debug('Check process command line %s with pattern:' % process.commandLine, regex)
processRegex(signature, process.commandLine, variableResolver)
elif TAG_VARIABLE in signature.getType():
processVariable(signature, variableResolver, shell, False)
elif signature.getType() == TAG_EXECUTE:
processExecuteCommand(shell, signature, variableResolver)
def _process(cls, variableSignature, variableResolver, input):
key = ExpressionResolver.resolve(variableResolver, variableSignature.key, ExpressionResolver.STRING_LITERAL)
if not key:
logger.debug('Skip ', variableSignature)
return
return input.getProperty(key) or ''
def processRegex(regExpSignature, input, variableResolver):
pattern = ExpressionResolver.resolve(variableResolver, regExpSignature.expr, ExpressionResolver.REGULAR_EXPRESSION)
if not pattern:
logger.debug('Skip ', regExpSignature)
return
flags = getFlags(regExpSignature)
try:
compiledRegex = re.compile('(%s)' % pattern, flags)
except Exception, e:
logger.debug('Skip %s because regex %s is invalid:' % (regExpSignature, ExpressionResolver.quote(pattern)), e)
return
match = compiledRegex.findall(input)
if match:
logger.debug('Found match string for regex %s:' % ExpressionResolver.quote(pattern), ', '.join([m[0] for m in match]))
for variable in regExpSignature.children:
RegexVariableProcessor.process(variable, variableResolver, match, len(regExpSignature.children) > 1)
else:
logger.debug('No match string found for regex %s' % ExpressionResolver.quote(pattern))
def getFlags(regExpSignature):
flags = 0
flagAttrValue = getattr(regExpSignature, ATTR_REGEX_FLAG, None)
if flagAttrValue:
for flag in flagAttrValue.split(','):
flagValue = getattr(re, flag.strip().upper(), None)
if flagValue:
flags |= flagValue
else:
