def convert_xml_import(cr, module, xmlfile, idref=None, mode='init', noupdate=False, report=None):
doc = etree.parse(xmlfile)
relaxng = etree.RelaxNG(
etree.parse(os.path.join(config['root_path'],'import_xml.rng' )))
try:
relaxng.assert_(doc)
except Exception:
_logger.info("The XML file '%s' does not fit the required schema !", xmlfile.name, exc_info=True)
_logger.info(ustr(relaxng.error_log.last_error))
raise
if idref is None:
idref={}
if isinstance(xmlfile, pycompat.string_types):
xml_filename = xmlfile
else:
xml_filename = xmlfile.name
obj = xml_import(cr, module, idref, mode, report=report, noupdate=noupdate, xml_filename=xml_filename)
obj.parse(doc.getroot(), mode=mode)
return True
def test_xml_files(self):
"Test validity of the xml files of the module"
config = ConfigParser()
with file_open('%s/tryton.cfg' % self.module,
subdir='modules',
mode='r',
encoding='utf-8') as fp:
config.read_file(fp)
if not config.has_option('tryton', 'xml'):
return
with file_open('tryton.rng', subdir='', mode='rb') as fp:
rng = etree.parse(fp)
validator = etree.RelaxNG(etree=rng)
for xml_file in filter(None, config.get('tryton', 'xml').splitlines()):
with self.subTest(xml=xml_file):
with file_open('%s/%s' % (self.module, xml_file),
subdir='modules',
mode='rb') as fp:
tree = etree.parse(fp)
validator.assertValid(tree)
def xml_validate(parent, xmlns, xpath=None, rng=None, sch=None):
"""Validate xml by rng and sch"""
if xpath:
# rng rules
relaxng = None
if rng:
rng_node = etree.XML(rng)
relaxng = etree.RelaxNG(rng_node)
# schematron rules
schematron = None
if sch:
sch_node = etree.XML(sch)
schematron = isoschematron.Schematron(sch_node)
# run validation selected by xpath nodes
for node in parent.xpath(xpath, namespaces=xmlns):
_xml_validate_node(node, relaxng, schematron)
def schema_graph(arch):
""" Check the graph view against its schema
:type arch: etree._Element
"""
global _graph_validator
_graph_validator = view_validation._validators
if _graph_validator is None:
with misc.file_open(
os.path.join('deltatech_graph', 'views',
'graph_view.rng')) as f:
_grid_validator = etree.RelaxNG(etree.parse(f))
if _graph_validator.validate(arch):
return True
for error in _graph_validator.error_log:
_logger.error(ustr(error))
return False
def validate(f, schema="BED"):
"""
Validate a QuakeML file using a given RelaxNG schema
"""
from lxml import etree
# Load schema
schemafile = VALIDATION_SCHEMAS[schema]
schema = etree.parse(schemafile)
rng = etree.RelaxNG(schema)
# Load QuakeML
if isinstance(f, file):
qml = etree.parse(f)
elif isinstance(f, unicode):
qml = etree.fromstring(f.encode())
elif isinstance(f, str):
qml = etree.fromstring(f)
is_valid = rng.validate(qml)
return is_valid
def convert_xml_import(cr,
module,
xmlfile,
idref=None,
mode='init',
noupdate=False,
report=None):
doc = etree.parse(xmlfile)
schema = os.path.join(config['root_path'], 'import_xml.rng')
relaxng = etree.RelaxNG(etree.parse(schema))
try:
relaxng.assert_(doc)
except Exception:
_logger.exception(
"The XML file '%s' does not fit the required schema !",
xmlfile.name)
if jingtrang:
p = subprocess.run(['pyjing', schema, xmlfile.name],
stdout=subprocess.PIPE)
_logger.warn(p.stdout.decode())
else:
for e in relaxng.error_log:
_logger.warn(e)
_logger.info(
"Install 'jingtrang' for more precise and useful validation messages."
)
raise
if isinstance(xmlfile, str):
xml_filename = xmlfile
else:
xml_filename = xmlfile.name
obj = xml_import(cr,
module,
idref,
mode,
report=report,
noupdate=noupdate,
xml_filename=xml_filename)
obj.parse(doc.getroot())
def validate_xml(self, dict_file, parsed_xml_tree, validator_type, validator_name):
# Check that validator is valid
if (
not validator_type in self.Config
or not validator_name in self.Config[validator_type]
):
msg = (
"XML Validator type "
+ validator_type
+ " not found in ConfigManager instance"
)
raise FprimeXmlException(msg)
# Create proper xml validator tool
validator_file_handler = open(
ROOTDIR + self.Config.get(validator_type, validator_name), "r"
)
validator_parsed = etree.parse(validator_file_handler)
validator_file_handler.close()
if validator_type == "schema":
validator_compiled = etree.RelaxNG(validator_parsed)
elif validator_type == "schematron":
validator_compiled = isoschematron.Schematron(validator_parsed)
# Validate XML file
if not validator_compiled.validate(parsed_xml_tree):
if validator_type == "schema":
msg = "XML file {} is not valid according to {} {}.".format(
dict_file,
validator_type,
ROOTDIR + self.Config.get(validator_type, validator_name),
)
raise FprimeXmlException(msg)
elif validator_type == "schematron":
msg = "WARNING: XML file {} is not valid according to {} {}.".format(
dict_file,
validator_type,
ROOTDIR + self.Config.get(validator_type, validator_name),
)
PRINT.info(msg)
def validate_RNG(teipath, rngfile, logfile):
"""
Arguments:
teipath (str): path to the TEI files, e.g. /home/ulrike/Git/conha19/tei/*.xml
rngfile (str): path to the RELAX NG schema file, e.g. /home/ulrike/Git/reference/tei/cligs.rng
logfile (str): path to an output text file, in which the results of the validation are stored, e.g. /home/ulrike/Git/conha19/schema/log-rng.txt
Example call:
from corpus.metadata_encoding import validate_tei
validate_tei.validate_RNG("/home/ulrike/Git/conha19/tei/*.xml", "/home/ulrike/Git/reference/tei/cligs.rng", "/home/ulrike/Git/conha19/schema/log-rng.txt")
"""
print("starting validation...")
# delete old log, if present
if os.path.isfile(logfile):
os.remove(logfile)
print("old logfile removed")
for teifile in glob.glob(teipath):
idno = os.path.basename(teifile)
print("doing " + idno + "...")
parser = etree.XMLParser(recover=True)
teiparsed = etree.parse(teifile, parser)
# RelaxNG validation
rngparsed = etree.parse(rngfile)
rngvalidator = etree.RelaxNG(rngparsed)
validation_rng = rngvalidator.validate(teiparsed)
log_rng = rngvalidator.error_log
with open(logfile, "a", encoding="UTF-8") as outfile:
if validation_rng == True:
outfile.write(idno + ": valid with RNG\n")
else:
outfile.write(idno + ": not valid with RNG\n")
outfile.write(str(log_rng) + "\n")
print("Done!")
def import_help(self):
for this in self:
xmlfile = StringIO(base64.decodestring(this.source_file))
doc = etree.parse(xmlfile)
relaxng = etree.RelaxNG(
etree.parse(os.path.join(config['root_path'],
'import_xml.rng')))
try:
relaxng.assert_(doc)
except Exception:
_logger.info('The XML file does not fit the required schema !',
exc_info=True)
_logger.info(misc.ustr(relaxng.error_log.last_error))
raise
obj = XmlImport(self.env.cr,
self._module,
idref={},
mode='init',
report=None,
noupdate=False,
xml_filename=None)
obj.parse(doc.getroot(), mode='init')
def convert_xml_import(cr,
module,
xmlfile,
idref=None,
mode='init',
noupdate=False,
report=None):
doc = etree.parse(xmlfile)
relaxng = etree.RelaxNG(
etree.parse(os.path.join(config['root_path'], 'import_xml.rng')))
try:
relaxng.assert_(doc)
except Exception:
_logger.error('The XML file does not fit the required schema !')
_logger.error(misc.ustr(relaxng.error_log.last_error))
raise
if idref is None:
idref = {}
obj = xml_import(cr, module, idref, mode, report=report, noupdate=noupdate)
obj.parse(doc.getroot())
return True
def _read(self, file_content):
# read content, raise an error if
# - wrong format (decompression problem)
# - XML not valid
# - invalid signature
try:
signed_content_str = server_command.decompress(file_content)
except:
logger.error("Error reading uploaded license file: {}".format(
process_tools.get_except_info()))
raise LicenseFileReader.InvalidLicenseFile()
signed_content_xml = etree.fromstring(signed_content_str)
# noinspection PyUnresolvedReferences
ng = etree.RelaxNG(etree.fromstring(LIC_FILE_RELAX_NG_DEFINITION))
if not ng.validate(signed_content_xml):
raise LicenseFileReader.InvalidLicenseFile(
"Invalid license file structure")
content_xml = signed_content_xml.find('icsw:license-file',
ICSW_XML_NS_MAP)
signature_xml = signed_content_xml.find('icsw:signature',
ICSW_XML_NS_MAP)
signature_ok = self.verify_signature(content_xml, signature_xml)
if not signature_ok:
raise LicenseFileReader.InvalidLicenseFile("Invalid signature")
# notes about the XML:
# - one or more packages
# - packages may have the same UUID
# - only the packags with the highest date (when having the same UUID) is valid
# print(etree.tostring(content_xml))
# print(ICSW_XML_NS_MAP)
# print(content_xml.xpath(".//icsw:package-name/text()", namespaces=ICSW_XML_NS_MAP))
# print(content_xml.xpath(".//icsw:package-uuid/text()", namespaces=ICSW_XML_NS_MAP))
return content_xml
class GetValidResponsesTest(OpenErpProxyTest):
def _checkBody(self, response, callback):
whenFinished = Deferred()
response.deliverBody(PrinterClient(whenFinished))
whenFinished.addCallback(callback)
return whenFinished
def _checkBodies(self, responses, callback, *params):
deferreds = [Deferred() for r in responses]
for i, (s, r) in enumerate(responses):
r.deliverBody(PrinterClient(deferreds[i]))
dl = DeferredList(deferreds)
dl.addCallback(callback, *params)
return dl
def _isValidFeed(self, s):
events = feedvalidator.validateString(s)['loggedEvents']
fil = "A"
filterFunc = getattr(compatibility, fil)
events = filterFunc(events)
output = Formatter(events)
if output:
print "\n".join(output)
self.assertEqual(len(output), 0)
def _isValidRelaxNg(self, s):
doc = etree.fromstring(s)
relaxng = etree.RelaxNG(doc)
def _isValidXml(self, ((s1, schemaxml), (s2, docxml)), node):
schema = etree.fromstring(schemaxml)
relaxng = etree.RelaxNG(schema)
doc = etree.fromstring(docxml).find(
"{http://www.w3.org/2005/Atom}content").find(node)
valid = relaxng.validate(doc)
if not valid:
log = relaxng.error_log
print log.last_error
self.assertTrue(valid)
def validate_document(self, rng_schema_path):
# Construct the RelaxNG validator
schema = etree.RelaxNG(file=rng_schema_path)
# Parse the XML file
parser = etree.XMLParser(**self.PARSER_OPTIONS)
doc = etree.parse(self.source, parser=parser)
logger.debug("Validating document '%s' with RNG '%s'", self.source,
rng_schema_path)
error_log = None
if not schema.validate(doc):
logger.warning("Validation of document '%s' failed", self.source)
self.rfc7940_checks.error('schema')
error_log = schema.error_log
if len(error_log) == 0:
# Bug in LXML, see https://bugs.launchpad.net/lxml/+bug/1526522
error_log = "CANNOT VALIDATE XML"
self.rfc7940_checks.tested('schema')
return error_log
def schema_gantt(arch, **kwargs):
""" Check the gantt view against its schema
:type arch: etree._Element
"""
global _gantt_validator
if _gantt_validator is None:
with misc.file_open(os.path.join('web_gantt', 'views',
'gantt.rng')) as f:
# gantt.rng needs to include common.rng from the `base/rng/` directory. The idea
# here is to set the base url of lxml lib in order to load relative file from the
# `base/rng` directory.
base_url = os.path.join(get_resource_path('base', 'rng'), '')
_gantt_validator = etree.RelaxNG(etree.parse(f, base_url=base_url))
if _gantt_validator.validate(arch):
return True
for error in _gantt_validator.error_log:
_logger.error(ustr(error))
return False
def get_text(format, request):
'''
@param format:
@type format: string
@param request:
@type request: string
@return:
@rtype: string
'''
print "get text"
params = request.form if request.method == 'POST' else request.args
files = request.files
if format == 'json':
if 'file' in files:
return files['file'].read()
else:
return params.get('text')
elif format == 'tcf':
with open('assets/tcfschema/d-spin-local_0_4.rng', 'r') as f:
if 'file' in files:
text = files['file'].read()
else:
text = params.get('text').encode('utf-8')
relaxng_doc = etree.parse(f)
relaxng = etree.RelaxNG(relaxng_doc)
inputXml = re.sub(">\\s*<", "><", text)
inputXml = re.sub("^\\s*<", "<", inputXml)
doc = etree.parse(StringIO(inputXml))
try:
relaxng.assertValid(doc)
return doc.getroot()[1][0].text
except Exception as e:
raise InvalidUsage(e.message)
else:
raise InvalidUsage('Unknown format ' + format)
def validate_xml_schema(xml_file):
"""Validates XML file based on RNG schema."""
if not xml_file.name.endswith('.xml'):
return # Skip validation for other format files.
is_valid = False
try:
# Could not make it working with a RNC schema, so using RNG instead.
# lxml did not use rnc2rng as described in the documentation:
# https://lxml.de/validation.html#relaxng
schema = ET.fromstring(XML_RNG_SCHEMA.encode())
relaxng = ET.RelaxNG(schema)
hyp_doc = ET.parse(xml_file)
is_valid = relaxng.validate(hyp_doc)
except Exception as error:
_msg = 'XML file invalid: {0}'.format(error)
raise ValidationError(_msg)
if not is_valid:
_msg = 'XML file invalid: {0}. It does not validate against the XML Schema'.format(
xml_file)
raise ValidationError(_msg)
def test_correct():
"""Tests the valid overall process."""
tmp = NamedTemporaryFile(mode="w+")
tmp.write("ValidFaultTree\n\n")
tmp.write("root := g1 | g2 | g3 | g4 | g7 | g9 | g10 | g11 | e1\n")
tmp.write("g1 := e2 & g3 & g5\n")
tmp.write("g2 := h1 & g6\n")
tmp.write("g3 := (g6 ^ e2)\n")
tmp.write("g4 := @(2, [g5, e3, e4])\n")
tmp.write("g5 := ~(e3)\n")
tmp.write("g6 := (e3 | e4)\n\n")
tmp.write("g7 := g8\n\n")
tmp.write("g8 := ~e2 & ~e3\n\n")
tmp.write("g9 := (g8 => g2)\n")
tmp.write("g10 := e1 <=> e2\n")
tmp.write("g11 := #(2, 4, [e1, e2, e3, e4, g5])\n")
tmp.write("p(e1) = 0.1\n")
tmp.write("p(e2) = 0.2\n")
tmp.write("p(e3) = 0.3\n")
tmp.write("s(h1) = true\n")
tmp.write("s(h2) = false\n")
tmp.flush()
fault_tree = parse_input_file(tmp.name)
assert fault_tree is not None
assert len(fault_tree.gates) == 12
assert len(fault_tree.basic_events) == 3
assert len(fault_tree.house_events) == 2
assert len(fault_tree.undefined_events()) == 1
out = NamedTemporaryFile(mode="w+")
out.write("<?xml version=\"1.0\"?>\n")
out.write(fault_tree.to_xml())
out.flush()
relaxng_doc = etree.parse("schemas/2.0d/mef.rng")
relaxng = etree.RelaxNG(relaxng_doc)
with open(out.name, "r") as test_file:
doc = etree.parse(test_file)
assert relaxng.validate(doc)
def init_ag_xml(self):
# validator
_ng = etree.RelaxNG(etree.fromstring(AGGREGATE_NG)) # @UndefinedVariable
_ag_dir = global_config["AGGREGATE_DIR"]
tls = AGTopLevelStruct(self.log)
for _dir, _dirs, _files in os.walk(_ag_dir):
for _file in [_entry for _entry in _files if _entry.startswith("agg") and _entry.endswith(".xml")]:
_file = os.path.join(_dir, _file)
try:
cur_xml = etree.fromstring(file(_file, "rb").read())
except:
self.log(
"error interpreting aggregate file {}: {}".format(
_file,
process_tools.get_except_info(),
)
)
else:
for _xml_num, _xml in enumerate(cur_xml, 1):
_valid = _ng.validate(_xml)
if _valid:
self.log(
"added aggregate #{:d} from {}".format(
_xml_num,
_file,
)
)
tls.add_aggregate(AGObj(_xml))
else:
self.log(
"aggregate #{:d} from {} is invalid: {}".format(
_xml_num,
_file,
str(_ng.error_log),
)
)
self.ag_tls = tls
def load(self):
"""
Read XML description, pass it along to the XSLT processor,
validate it against the schema and finally pass it to the
autogenerated(generateDS) parser.
:return: instance of XML toplevel domain (image)
:rtype: object
"""
self._xsltproc()
try:
schema_doc = etree.parse(Defaults.get_schema_file())
relaxng = etree.RelaxNG(schema_doc)
schematron = isoschematron.Schematron(schema_doc,
store_report=True)
except Exception as e:
raise KiwiSchemaImportError('%s: %s' %
(type(e).__name__, format(e)))
try:
description = etree.parse(self.description_xslt_processed.name)
validation_rng = relaxng.validate(description)
validation_sch = schematron.validate(description)
except Exception as e:
raise KiwiValidationError('%s: %s' % (type(e).__name__, format(e)))
if not validation_rng:
self._get_relaxng_validation_details()
if not validation_sch:
self._get_schematron_validation_details(
schematron.validation_report)
if not validation_rng or not validation_sch:
if self.description:
message = 'Schema validation for {description} failed'.format(
description=self.description)
else:
message = 'Schema validation for XML content failed'
raise KiwiDescriptionInvalid(message)
return self._parse()
def test_view(self):
'Test validity of all views of the module'
pool = Pool()
View = pool.get('ir.ui.view')
views = View.search([
('module', '=', self.module),
('model', '!=', ''),
])
for view in views:
if view.inherit and view.inherit.model == view.model:
view_id = view.inherit.id
else:
view_id = view.id
model = view.model
Model = pool.get(model)
res = Model.fields_view_get(view_id)
assert res['model'] == model
tree = etree.fromstring(res['arch'])
validator = etree.RelaxNG(etree=View.get_rng(res['type']))
# Don't use assert_ because 2to3 convert to assertTrue
validator.assertValid(tree)
tree_root = tree.getroottree().getroot()
for element in tree_root.iter():
if element.tag in ('field', 'label', 'separator', 'group'):
for attr in ('name', 'icon'):
field = element.get(attr)
if field:
assert field in res['fields'], (
'Missing field: %s' % field)
if element.tag == 'button':
button_name = element.get('name')
assert button_name in Model._buttons, (
"Button '%s' is not in %s._buttons"
% (button_name, Model.__name__))
def test_assertXmlValidRelaxNG_relaxng(self):
"""Asserts assertXmlValidRelaxNG raises when schema does not valid XML.
"""
test_case = XmlTestCase(methodName='assertXmlValidRelaxNG')
relaxng = b"""<?xml version="1.0" encoding="utf-8"?>
<rng:element name="root" xmlns:rng="http://relaxng.org/ns/structure/1.0">
<rng:element name="child">
<rng:attribute name="id">
<rng:text />
</rng:attribute>
</rng:element>
</rng:element>
"""
xml_relaxng = etree.RelaxNG(etree.XML(relaxng))
data = b"""<?xml version="1.0" encoding="utf-8"?>
<root>
<child id="valid"/>
</root>
"""
root = test_case.assertXmlDocument(data)
test_case.assertXmlValidRelaxNG(root, xml_relaxng)
data_invalid = b"""<?xml version="1.0" encoding="utf-8"?>
<root>
<child id="valid"/>
<child id="tooManyChild"/>
</root>
"""
root = test_case.assertXmlDocument(data_invalid)
with self.assertRaises(test_case.failureException):
test_case.assertXmlValidRelaxNG(root, xml_relaxng)
def __init__(self, log_com):
self.__compounds = []
self.__log_com = log_com
_ng = etree.RelaxNG(
etree.fromstring(COMPOUND_NG)) # @UndefinedVariable
compound_xml = E.compounds()
_comp_dir = global_config["COMPOUND_DIR"]
for _dir, _dirs, _files in os.walk(_comp_dir):
for _file in [
_entry for _entry in _files
if _entry.startswith("comp") and _entry.endswith(".xml")
]:
_file = os.path.join(_dir, _file)
try:
cur_xml = etree.fromstring(file(_file, "rb").read())
except:
self.log("error interpreting compound file {}: {}".format(
_file,
process_tools.get_except_info(),
))
else:
for _xml_num, _xml in enumerate(cur_xml, 1):
_valid = _ng.validate(_xml)
if _valid:
self.log("added compound #{:d} from {}".format(
_xml_num,
_file,
))
self.__compounds.append(CompoundEntry(_xml))
else:
self.log(
"compound #{:d} from {} is invalid: {}".format(
_xml_num,
_file,
str(_ng.error_log),
))
def validate_structure(self):
relaxng = None
for path in Specfile.RELAXNG_SCHEMA_SEARCH_PATH:
if os.path.exists(path):
relaxng = etree.RelaxNG(file=path)
break
#end for
if relaxng is None:
raise RuntimeError("RELAX NG ruleset not found.")
if not relaxng.validate(self.xml_doc):
errors = []
for err in relaxng.error_log:
errors.append(
"* %s on line %d, column %d: %s" % (os.path.basename(
err.filename), err.line, err.column, err.message))
#end for
msg = "RELAX NG validation failed:\n" + "\n".join(errors)
raise MalformedSpecfile(msg)
#end if
return True
def validate_tei(teipath, rngfile):
valid = 0
invalid = 0
for teifile in glob.glob(teipath):
idno = os.path.basename(teifile)
print(idno)
rngparsed = etree.parse("cligs.rng")
rngvalidator = etree.RelaxNG(rngparsed)
parser = etree.XMLParser(recover=True)
teiparsed = etree.parse(teifile, parser)
#teiparsed = etree.parse(teifile)
validation = rngvalidator.validate(teiparsed)
#log = rngvalidator.error_log
if validation == True:
valid +=1
#print(idno, "valid!")
else:
invalid +=1
print(idno, "sorry, not valid!")
#print(log.last_error)
#print(log.last_error.domain_name)
print("valid:", valid, "-- invalid:", invalid)
if invalid == 0:
print("Congratulations, all of your "+str(valid)+" files are valid!")
def __init__(self):
_inst = InstanceXML(quiet=True)
all_instances = sum([
_inst.xpath(".//config-enums/config-enum/text()")
for _inst in _inst.get_all_instances()
], [])
all_perms = [
_perm.perm_name for _perm in csw_permission.objects.all()
] + ["$$CHECK_FOR_SUPERUSER"]
_content = file(
"{}/menu_relax.xml".format(os.path.join(settings.FILE_ROOT,
"menu")),
"r",
).read()
_content = _content.replace(
"<value>RIGHTSLIST</value>",
"".join(["<value>{}</value>".format(_pn)
for _pn in all_perms])).replace(
"<value>SERVICETYPESLIST</value>", "".join([
"<value>{}</value>".format(_stn)
for _stn in all_instances
]))
# sys.exit(0)
self.ng = etree.RelaxNG(etree.fromstring(_content, ))
def is_schema_valid(self, cr, uid, id, xml) :
"""Checks the validity of the provided XML according to the specified schema
:param xml: root of XML-structure to be checked
:return: Boolean
"""
obj = self.browse(cr, uid, id)
if obj and obj.schema :
parser = etree.XMLParser(no_network=False)
schema_root = etree.parse(obj.schema, parser)
if ".xsd" in obj.schema.lower() :
schema = etree.XMLSchema(schema_root)
elif ".rng" in obj.schema.lower() :
schema = etree.RelaxNG(schema_root)
else :
raise osv.except_osv \
( _("Data Error !")
, _("Unknown schema type: %s" % obj.schema)
)
return schema.validate(xml)
raise osv.except_osv \
( _("Data Error !")
, _("Invalid Template with ID: %s" % id)
)
'iso_dsdl_include.xsl')))
iso_abstract_expand = _etree.XSLT(_etree.parse(
os.path.join(_resources_dir, 'xsl', 'iso-schematron-xslt1',
'iso_abstract_expand.xsl')))
iso_svrl_for_xslt1 = _etree.XSLT(_etree.parse(
os.path.join(_resources_dir,
'xsl', 'iso-schematron-xslt1', 'iso_svrl_for_xslt1.xsl')))
# svrl result accessors
svrl_validation_errors = _etree.XPath(
'//svrl:failed-assert', namespaces={'svrl': SVRL_NS})
# RelaxNG validator for schematron schemas
schematron_schema_valid = _etree.RelaxNG(
file=os.path.join(_resources_dir, 'rng', 'iso-schematron.rng'))
def stylesheet_params(**kwargs):
"""Convert keyword args to a dictionary of stylesheet parameters.
XSL stylesheet parameters must be XPath expressions, i.e.:
* string expressions, like "'5'"
* simple (number) expressions, like "5"
* valid XPath expressions, like "/a/b/text()"
This function converts native Python keyword arguments to stylesheet
parameters following these rules:
If an arg is a string wrap it with XSLT.strparam().
If an arg is an XPath object use its path string.
If arg is None raise TypeError.
def load(self): # noqa: C901
"""
Read XML description, pass it along to the XSLT processor,
validate it against the schema and finally pass it to the
autogenerated(generateDS) parser.
:return: instance of XML toplevel domain (image)
:rtype: object
"""
try:
self._xsltproc()
schema_doc = etree.parse(Defaults.get_schema_file())
relaxng = etree.RelaxNG(schema_doc)
schematron = isoschematron.Schematron(schema_doc,
store_report=True)
except Exception as e:
raise KiwiSchemaImportError('%s: %s' %
(type(e).__name__, format(e)))
try:
description = etree.parse(self.description_xslt_processed.name)
validation_rng = relaxng.validate(description)
validation_sch = schematron.validate(description)
except Exception as e:
raise KiwiValidationError('%s: %s' % (type(e).__name__, format(e)))
if not validation_rng:
self._get_relaxng_validation_details(
Defaults.get_schema_file(),
self.description_xslt_processed.name)
if not validation_sch:
self._get_schematron_validation_details(
schematron.validation_report)
if not validation_rng or not validation_sch:
if self.description:
message = 'Schema validation for {description} failed'.format(
description=self.description)
else:
message = 'Schema validation for XML content failed'
raise KiwiDescriptionInvalid(message)
parse_result = self._parse()
if parse_result.get_extension():
extension_namespace_map = \
description.getroot().xpath('extension')[0].nsmap
for namespace_name in extension_namespace_map:
extensions_for_namespace = description.getroot().xpath(
'extension/{namespace}:*'.format(namespace=namespace_name),
namespaces=extension_namespace_map)
if extensions_for_namespace:
# one toplevel entry point per extension via xmlns
if len(extensions_for_namespace) > 1:
raise KiwiExtensionError(
'Multiple toplevel sections for "{0}" found'.
format(namespace_name))
# store extension xml data parse tree for this namespace
self.extension_data[namespace_name] = \
etree.ElementTree(extensions_for_namespace[0])
# validate extension xml data
try:
xml_catalog = Command.run([
'xmlcatalog', '/etc/xml/catalog',
extension_namespace_map[namespace_name]
])
extension_schema = xml_catalog.output.rstrip().replace(
'file://', '')
extension_relaxng = etree.RelaxNG(
etree.parse(extension_schema))
except Exception as e:
raise KiwiExtensionError(
'Extension schema error: {0}: {1}'.format(
type(e).__name__, e))
validation_result = extension_relaxng.validate(
self.extension_data[namespace_name])
if not validation_result:
xml_data_unformatted = etree.tostring(
self.extension_data[namespace_name],
encoding='utf-8')
xml_data_domtree = minidom.parseString(
xml_data_unformatted)
extension_file = NamedTemporaryFile()
with open(extension_file.name, 'w') as xml_data:
xml_data.write(xml_data_domtree.toprettyxml())
self._get_relaxng_validation_details(
extension_schema, extension_file.name)
raise KiwiExtensionError(
'Schema validation for extension XML data failed')
return parse_result
# RelaxNG validator utility
#
# This script will validate every XML file found inside of the current Splunk
# instance's /etc/apps directory
#
# See README.txt for setup information
#
import lxml.etree as et
import os, re
FOLDER = os.path.dirname(os.path.abspath(__file__))
f = open(os.path.join(FOLDER,'../_support/ipfix.rng'), 'r')
schema = et.parse(f)
relaxng = et.RelaxNG(schema)
f.close()
for root, dirs, files in os.walk(FOLDER):
for name in files:
if name.endswith('.xml'):
print '=' * 80
fullname = os.path.join(root, name).replace("\\","/")
print "Validating file: %s" % fullname
f = open(fullname, 'r')
rootNode = et.parse(f)
isValid = relaxng.validate(rootNode)
if not isValid:
print "Validation error: %s" % name
print str(relaxng.error_log).replace("file:///" + fullname + ":","")
print ''
def load(self) -> Any:
"""
Read XML description, validate it against the schema
and the schematron rules and pass it to the
autogenerated(generateDS) parser.
:return: instance of XML toplevel domain (image)
:rtype: object
"""
try:
schema_doc = etree.parse(Defaults.get_schema_file())
relaxng = etree.RelaxNG(schema_doc)
schematron = isoschematron.Schematron(
schema_doc, store_report=True
)
except Exception as issue:
raise KiwiSchemaImportError(issue)
try:
description = etree.parse(self.description)
validation_rng = relaxng.validate(description)
validation_schematron = schematron.validate(description)
except Exception as issue:
raise KiwiValidationError(issue)
if not validation_rng:
XMLDescription._get_relaxng_validation_details(
Defaults.get_schema_file(),
self.description,
relaxng.error_log
)
if not validation_schematron:
XMLDescription._get_schematron_validation_details(
schematron.validation_report
)
if not validation_rng or not validation_schematron:
raise KiwiDescriptionInvalid(
'Failed to validate schema and/or schematron rules'
)
parse_result = self._parse()
if parse_result.get_extension():
extension_namespace_map = \
description.getroot().xpath('extension')[0].nsmap
for namespace_name in extension_namespace_map:
extensions_for_namespace = description.getroot().xpath(
'extension/{namespace}:*'.format(namespace=namespace_name),
namespaces=extension_namespace_map
)
if extensions_for_namespace:
# one toplevel entry point per extension via xmlns
if len(extensions_for_namespace) > 1:
raise KiwiExtensionError(
'Multiple toplevel sections for "{0}" found'.format(
namespace_name
)
)
# store extension xml data parse tree for this namespace
self.extension_data[namespace_name] = \
etree.ElementTree(extensions_for_namespace[0])
# validate extension xml data
try:
xml_catalog = Command.run(
[
'xmlcatalog', '/etc/xml/catalog',
extension_namespace_map[namespace_name]
]
)
extension_schema = xml_catalog.output.rstrip().replace(
'file://', ''
)
extension_relaxng = etree.RelaxNG(
etree.parse(extension_schema)
)
except Exception as issue:
raise KiwiExtensionError(
'Extension schema error: {0}'.format(issue)
)
validation_result = extension_relaxng.validate(
self.extension_data[namespace_name]
)
if not validation_result:
xml_data_unformatted = etree.tostring(
self.extension_data[namespace_name],
encoding='utf-8'
)
xml_data_domtree = minidom.parseString(
xml_data_unformatted
)
extension_file = Temporary().new_file()
with open(extension_file.name, 'w') as xml_data:
xml_data.write(xml_data_domtree.toprettyxml())
XMLDescription._get_relaxng_validation_details(
extension_schema,
extension_file.name,
extension_relaxng.error_log
)
raise KiwiExtensionError(
'Schema validation for extension XML data failed'
)
return parse_result
