def Test(tester): tester.startGroup("instantiation of runNode") base = Uri.OsPathToUri(__file__, attemptAbsolute=True) src_uri = Uri.Absolutize('addr_book1.xml', base) sty_uri = Uri.Absolutize('addr_book1.xsl', base) tester.startTest("without whitespace preservation") p = Processor.Processor() node = Domlette.NonvalidatingReader.parseUri(src_uri) isrc = InputSource.DefaultFactory.fromUri(sty_uri) p.appendStylesheet(isrc) res = p.runNode(node, src_uri, ignorePis=True, preserveSrc=False) tester.compare(expected, res, func=TreeCompare.TreeCompare) tester.testDone() tester.startTest("with whitespace preservation") p = Processor.Processor() node = Domlette.NonvalidatingReader.parseUri(src_uri) isrc = InputSource.DefaultFactory.fromUri(sty_uri) p.appendStylesheet(isrc) res = p.runNode(node, src_uri, ignorePis=True, preserveSrc=True) tester.compare(expected, res, func=TreeCompare.TreeCompare) tester.testDone() tester.groupDone() return
def uixml(scwin, uixslt): extidx = uixslt.rindex('.') xslt2 = uixslt[:extidx] + "Post" + uixslt[extidx:] sctemplate = XMLHelper.writexml(scwin.asXML(True), UnicodeStringIO(), '', '\t', '\n') try: source = DefaultFactory.fromString(sctemplate, "urn:pass1") xsltUri = OsPathToUri(uixslt) transform = DefaultFactory.fromUri(xsltUri) processor = Processor.Processor() processor.appendStylesheet(transform) uixmlstr = processor.run(source) if os.path.exists(xslt2): source = DefaultFactory.fromString(uixmlstr, "urn:pass2") xsltUri = OsPathToUri(xslt2) transform = DefaultFactory.fromUri(xsltUri) processor = Processor.Processor() processor.appendStylesheet(transform) uixmlstr = processor.run(source) except Exception, e: QMessageBox.critical(None, 'Error!', 'Error with XSLT transform!\n\n' + str(e), 'OK') return
def editConfig(self, defaultoperation, testoption, erroroption, target, confignode, targetnode=None): """ Apply a edit-config request from the confignode to the targetnode. @type defaultoperation: MERGE_OPERATION | REPLACE_OPERATION | NONE_OPERATION @param defaultoperation : as specified in NETCONF protocol @type testoption : SET | TEST_AND_SET @param testoption : as specified in NETCONF protocol @type erroroption : STOP_ON_ERROR | IGNORE_ERROR | ROLL_BACK_ON_ERROR @param erroroption : as specified in NETCONF protocol @type target : RUNNING_TARGET | CANDIDATE_TARGET | STARTUP_TARGET @param target : as specified in NETCONF protocol @type targetnode : string @param targetnode : if the target is RUNNING_TARGET or STARTUP_TARGET it will be ignored otherwise should be the node of the CANDIDATE_TARGET that this module should procees @rtype: ModuleReply @return: It returns a success or error message. ** Relates to the netconf edit-config operation """ try: # Generate a stylesheet equivalent to the edit-config df = InputSource.DefaultFactory editXMLRequest = df.fromString( util.convertNodeToString(confignode), 'urn:dummy') stylesheet = df.fromUri("file:" + metaFile, 'urn:sty') p = Processor.Processor() p.appendStylesheet(stylesheet) wr = DomWriter.DomWriter() p.run(editXMLRequest, writer=wr) generatedStyleSheet = wr.getResult() # Apply the generated stylesheet to the source document inputStyleSheet = df.fromString( util.convertNodeToString(generatedStyleSheet), 'urn:sty') oldXMLDocument = self.getConfig(target).getXMLNodeReply() inputDocument = df.fromString( util.convertNodeToString(oldXMLDocument), 'urn:dummy') p = Processor.Processor() p.appendStylesheet(inputStyleSheet) wr = DomWriter.DomWriter() p.run(inputDocument, writer=wr) newXMLDoc = wr.getResult() # Copy the new document over the old one xmlReply = self.copyConfig("config", target, sourceNode=newXMLDoc) return xmlReply except Exception, exp: print str(exp) moduleReply = ModuleReply(error_type=ModuleReply.APPLICATION, error_tag=ModuleReply.OPERATION_FAILED, error_severity=ModuleReply.ERROR, error_message=str(exp)) return moduleReply
def __init__(self, transform): from Ft.Xml.Xslt import Processor from Ft.Xml import InputSource self.processor = Processor.Processor() trans_source = InputSource.DefaultFactory.fromString( transform, "CONVERTER") self.processor.appendStylesheet(trans_source)
def render(self, source_xml, content_type): """Render document using 4suite. """ #pubUrl = self.REQUEST['PUBLISHED'].absolute_url() pubUrl = self.REQUEST['URL'] proc = Processor.Processor() resolver = ZBaseUriResolver(self) factory = InputSource.InputSourceFactory(resolver=resolver) source = factory.fromString(self().encode(self.char_encoding), '/'.join(self.getPhysicalPath())) proc.appendStylesheet(source) if content_type in ['text/xml','text/html']: writer = XmlWriter.XmlWriter(proc.outputParams,StringIO.StringIO()) else: writer = StringWriter.StringWriter(proc.outputParams, StringIO.StringIO()) # Apply the stylesheet to the XMLTemplate. The result is # written to the output stream attribute of the writer so # grab that and send it back to the caller. proc.run(factory.fromString(source_xml),pubUrl,writer=writer) return writer.getStream().getvalue()
def Test(tester): tester.startGroup('pick stylesheet from xml-stylesheet PIs') for tup in tests: (title_st, source_st, expected_st) = tup[:3] errcode = None media = None if len(tup) > 3: errcode = tup[3] if len(tup) > 4: media = tup[4] expected = expected_st or '' source = test_harness.FileInfo(string=source_st, baseUri=uri) if media: proc = Processor.Processor() proc.mediaPref = media tester.startTest(title_st) isrc = DefaultFactory.fromString(source_st, uri) result = proc.run(isrc, ignorePis=0) tester.compare(expected_st, result, func=TreeCompare.TreeCompare) tester.testDone() del proc, isrc, result else: test_harness.XsltTest(tester, source, [], expected, exceptionCode=errcode, title=title_st, ignorePis=0) tester.groupDone() return
def xml_xslt(self, transform, params=None, output=None): """ Apply an XSLT transform directly to the bindery object This function is quite limited, and will only handle the simplest transforms. If you find your transform does not work with it, serialize using xml() then use Ft.Xml.Xslt.transform, which is fully XSLT compliant. output - optional file-like object to which output is written (incrementally, as processed) if stream is given, output to stream, and return value is None If stream is not given return value is the transform result as a Python string (not Unicode) params - optional dictionary of stylesheet parameters, the keys of which may be given as unicode objects if they have no namespace, or as (uri, localname) tuples if they do. """ from Ft.Xml.Xslt import Processor, _AttachStylesheetToProcessor from Ft.Xml import InputSource from Ft.Lib import Uri, Uuid from Ft.Xml.Lib.XmlString import IsXml params = params or {} processor = Processor.Processor() _AttachStylesheetToProcessor(transform, processor) return processor.runNode(self, topLevelParams=params, outputStream=output)
def test(): #Test generating a file and running it #Test a simple addrbook #Build a ADDRBOOK xml file print "Address Book" src = ADDRBOOK_XML_1 + (ADDRBOOK_XML_ENTRY*5000) + ADDRBOOK_XML_2 s = time.time() StylesheetCompilier.CompileString(ADDRBOOK,outFileName='addrbook') e = time.time() t = e - s print "Compile Time: %f" % (t) import addrbook st = addrbook.Stylesheet() s = time.time() st.executeString(src) e = time.time() cTime = e - s print "Compile Time: %f" % (cTime) from Ft.Xml.Xslt import Processor p = Processor.Processor() p.appendStylesheetString(ADDRBOOK) s = time.time() p.runString(src) e = time.time() pTime = e - s print "Processor Time: %f" % (pTime) print "Difference %f" % (pTime - cTime) print "Increase %f" % (100.0*(pTime - cTime)/pTime)
def pipp_map_view(context, xslt_file): ctx = context.processor.extensionParams[(NAMESPACE, 'context')] #-- # Create the XSLT processor object. For efficiency there is a cache of these. #-- xslt_file = ctx.abs_in_path(Conversions.StringValue(xslt_file)) ctx.add_depends(xslt_file[len(ctx.in_root):]) processor = processors.get(xslt_file) if not processor: processor = Processor.Processor() processor.registerExtensionModules(['pipp_xslt']) processor.appendStylesheet( InputSource.DefaultFactory.fromString( open(xslt_file).read(), xslt_file)) processor.extensionParams[(NAMESPACE, 'context')] = ctx #-- # Run the processor against state.xml and return the output. # If successful, store the processor object in a cache #-- input = InputSource.DefaultFactory.fromUri(OsPathToUri(ctx.state_xml)) output = processor.run(input) processors[xslt_file] = processor return output
def processor(self): if not self._processor: _processor = Processor.Processor( stylesheetAltUris=[OsPathToUri(pipp_dir + os.path.sep)]) _processor.registerExtensionModules(['pipp_xslt']) stylesheet = InputSource.DefaultFactory.fromUri( OsPathToUri(self.in_root + self.stylesheet_fname)) _processor.appendStylesheet(stylesheet) self._processor = _processor return self._processor
def run_test(outFile, xmlFile, stylesheets): tempFileName = tempfile.mktemp() p = Processor.Processor() prof = profile.Profile() prof.runctx("profile_test(p,xmlFile,stylesheets)", globals(), locals()) prof.dump_stats(tempFileName) return tempFileName
def render_document(self, document, stylesheet, outfile): """ This method is responsible for using 'stylesheet' to transform 'document' to the file 'outfile'. Override this method to use a different XSLT rendering engine. """ from Ft.Xml.InputSource import DefaultFactory from Ft.Xml.Xslt import Processor # Get a "clean" processor object if self._xslt_processor is None: self._xslt_processor = Processor.Processor() else: self._xslt_processor.reset() # Add the stylesheet to the processor object. isrc = DefaultFactory.fromUri(stylesheet.uri) try: self._xslt_processor.appendStylesheet(isrc) finally: isrc.close() params = { 'name': self.distribution.get_name(), 'version': self.distribution.version, 'fullname': self.distribution.get_fullname(), 'author': self.distribution.author, 'author-email': self.distribution.author_email, } params.update(document.params) # Render the document isrc = DefaultFactory.fromUri(document.uri) try: if self.dry_run: stream = cStringIO.StringIO() else: self.mkpath(os.path.dirname(outfile)) stream = open(outfile, 'w') try: try: self._xslt_processor.run(isrc, topLevelParams=params, outputStream=stream) stream.write('\n') finally: stream.close() except: if not self.dry_run: os.remove(outfile) raise finally: isrc.close() return
def _transform_feed(self, feeduri, encoding): document = InputSource.DefaultFactory.fromUri(feeduri) # Set encode to feedparser's guess to prevent unexpected # tokens for feeds with mismatching encoding declared. document.encoding = encoding stylesheet = InputSource.DefaultFactory.fromUri(RSS_2_RDF_XSL) processor = Processor.Processor() processor.appendStylesheet(stylesheet) logging.debug("Applying XSL transformation...") rdfstring = processor.run(document) return rdfstring
def transform(self, node): from Ft.Xml.Xslt import Processor, StylesheetReader, DomWriter from Ft.Xml import InputSource processor = Processor.Processor() xreader = StylesheetReader.StylesheetReader() style = xreader.fromDocument(self.applyElt.dom, baseUri="dummy") processor.appendStylesheetInstance(style) factory = InputSource.DefaultFactory isrc = factory.fromString("dummy", "dummy") resWriter = DomWriter.DomWriter() processor.execute(node, isrc, ignorePis=1, writer=resWriter) dom = resWriter.getResult() #print dom.firstChild.nodeValue return dom.firstChild
def applyEditToXMLNode(self, confignode, target): metaFile = "Modules/meta.xsl" try: # Generate a stylesheet equivalent to the edit-config df = InputSource.DefaultFactory editXMLRequest = df.fromString( util.convertNodeToString(confignode), 'urn:dummy') stylesheet = df.fromUri("file:" + C.YENCAP_HOME + "/" + metaFile, 'urn:sty') p = Processor.Processor() p.appendStylesheet(stylesheet) wr = DomWriter.DomWriter() p.run(editXMLRequest, writer=wr) generatedStyleSheet = wr.getResult() # Apply the generated stylesheet to the source document inputStyleSheet = df.fromString( util.convertNodeToString(generatedStyleSheet), 'urn:sty') inputDocument = df.fromString(util.convertNodeToString(target), 'urn:dummy') p = Processor.Processor() p.appendStylesheet(inputStyleSheet) wr = DomWriter.DomWriter() p.run(inputDocument, writer=wr) newXMLDoc = wr.getResult() # Return the transformed document return newXMLDoc except Exception, exp: moduleReply = ModuleReply(error_type=ModuleReply.APPLICATION, error_tag=ModuleReply.OPERATION_FAILED, error_severity=ModuleReply.ERROR, error_message=str(exp)) return moduleReply
def parseConfigReport(self, filename, scxmldoc): processor = Processor.Processor() source = InputSource.DefaultFactory.fromString( XMLHelper.writexml(scxmldoc, UnicodeStringIO(), '', '\t', '\n'), "uri:sctemplate") try: xsltUri = OsPathToUri(filename) transform = InputSource.DefaultFactory.fromUri(xsltUri) processor.appendStylesheet(transform) self.reportHtml = processor.run(source) except Exception, e: QMessageBox.critical( None, 'Error!', 'Error composing report ' + filename + "\n\n" + str(e), 'OK') return
def transform(self, xmlData, xslData, base_url=""): """ @param xmlData: the xml data to transform @param styleData: the xsl style sheet data to use in transform @return: a string version of the transformed document """ try: processor = Processor.Processor() transform = InputSource.DefaultFactory.fromString( xslData, "http://spam.com/identity.xslt") source = InputSource.DefaultFactory.fromString( xmlData, "http://spam.com/doc.xml") processor.appendStylesheet(transform) result = processor.run(source) return result except: traceback.print_exc(file=sys.stdout) return ""
def run(self, xslfile, xmlfile, outfile, opts=None, params=None): proc = Processor.Processor() proc.msgPrefix = "" proc.msgSuffix = "\n" factory = self.factory uri = OsPathToUri(xmlfile) xml = factory.fromUri(uri) uri = OsPathToUri(xslfile) xslt = factory.fromUri(uri, processIncludes=False) o = open(outfile, "w") proc.appendStylesheet(xslt) if params: rc = proc.run(xml, outputStream=o, topLevelParams=params) else: rc = proc.run(xml, outputStream=o) o.close()
def parse_dom(self): super(XmlQuery, self).parse_dom() query_dom = self.dom name = query_dom.getAttribute('name') if name == '': return target = query_dom.getElementsByTagName('target') xsl = query_dom.getElementByTagName('xsl') if len(target) > 0 and len(xsl) > 0: target = target[0] xsl = xsl[0] else: raise Exception( "Either a URL or file for XML input must be specified") self.processor = Processor.Processor() if target.find('://') < 0: target = OsPathToUri(target) if xsl.find('://') < 0: xsl = OsPathToUri(xsl) self.target = target xsl_source = InputSource.DefaultFactory.fromUri(xsl) self.processor.appendStylesheet(transform) inputs_dom = query_dom.getElementsByTagName('inputs') inputs_dom = [i for i in inputs_dom if i in query_dom.childNodes] results_dom = query_dom.getElementsByTagName('results')[0] results_inputs_dom = results_dom.getElementsByTagName('inputs') self.function = self.find_function(results_dom) inputs = Inputs(inputs_dom) results_inputs = Inputs(results_inputs_dom) self.metadata['target_url'] = target self.metadata['xsl'] = xsl self.metadata['inputs'] = inputs self.metadata['results_inputs'] = results_inputs parse_attributes(self.metadata, query_dom)
def applyXSLT(self, netconfReply): try: # Generate a stylesheet equivalent to the edit-config df = InputSource.DefaultFactory xmldoc = df.fromString(netconfReply, 'urn:dummy') xsldoc = df.fromUri("file:" + self.xsldocuri, 'urn:sty') p = Processor.Processor() p.appendStylesheet(xsldoc) wr = DomWriter.DomWriter() p.run(xmldoc, writer=wr) newHTMLDoc = wr.getResult() # Copy the new document over the old one return util.convertNodeToString(newHTMLDoc.documentElement) except Exception, exp: import traceback traceback.print_exc() return "Exception while applying XSLT of module %s: \n%s" % ( self.name, str(exp))
def Transform(source, stylesheet, params=None, output=None): """ Convenience function for applying an XSLT transform. Returns a string. source - XML source document in the form of a a string (not Unicode object), file-like object (stream), file path, URI or Ft.Xml.InputSource.InputSource instance. If string or stream it must be self-contained XML (i.e. not requiring access to any other resource such as external entities or includes) stylesheet - XSLT document in the form of a string, stream, URL, file path or Ft.Xml.InputSource.InputSource instance params - optional dictionary of stylesheet parameters, the keys of which may be given as unicode objects if they have no namespace, or as (uri, localname) tuples if they do. output - optional file-like object to which output is written (incrementally, as processed) """ #do the imports within the function: a tad bit less efficient, but #avoid circular crap from Ft.Xml.Xslt import Processor from Ft.Xml import InputSource from Ft.Lib import Uri, Uuid from Ft.Xml.Lib.XmlString import IsXml params = params or {} processor = Processor.Processor() _AttachStylesheetToProcessor(stylesheet, processor) if isinstance(source, InputSource.InputSource): pass elif hasattr(source, 'read'): #Create dummy Uri to use as base dummy_uri = 'urn:uuid:' + Uuid.UuidAsString(Uuid.GenerateUuid()) source = InputSource.DefaultFactory.fromStream(source, dummy_uri) elif IsXml(source): dummy_uri = 'urn:uuid:' + Uuid.UuidAsString(Uuid.GenerateUuid()) source = InputSource.DefaultFactory.fromString(source, dummy_uri) elif Uri.IsAbsolute(source): # or not os.path.isfile(source): source = InputSource.DefaultFactory.fromUri(source) else: source = InputSource.DefaultFactory.fromUri(Uri.OsPathToUri(source)) return processor.run(source, topLevelParams=params, outputStream=output)
def format(xmltext, template_filename=None, template_source=None): """ Processes an XML text according to a template, and returns the result. The template can be given either by name (or by path) or by source. If source is given, name is ignored. bibformat_xslt_engine will look for template_filename in standard directories for templates. If not found, template_filename will be assumed to be a path to a template. If none can be found, return None. @param xmltext: The string representation of the XML to process @param template_filename: The name of the template to use for the processing @param template_source: The configuration describing the processing. @return: the transformed XML text. """ if processor_type == -1: # No XSLT processor found sys.stderr.write('No XSLT processor could be found.') #sys.exit(1) # Retrieve template and read it if template_source: template = template_source elif template_filename: try: path_to_templates = (CFG_BIBFORMAT_TEMPLATES_PATH + os.sep + template_filename) if os.path.exists(path_to_templates): template = file(path_to_templates).read() elif os.path.exists(template_filename): template = file(template_filename).read() else: sys.stderr.write(template_filename + ' does not exist.') return None except IOError: sys.stderr.write(template_filename + ' could not be read.') return None else: sys.stderr.write(template_filename + ' was not given.') return None # Some massaging of the input to avoid the default namespace issue # in XPath. More elegant solution might be found though. xmltext = xmltext.replace('xmlns="http://www.loc.gov/MARC21/slim"', '') # For older MARCXML records stored in bibfmt with empty indicators xmltext = xmltext.replace('ind1=""', 'ind1=" "') xmltext = xmltext.replace('ind2=""', 'ind2=" "') result = "" if processor_type == 0: # libxml2 & libxslt # Register BibFormat functions for use in XSL libxslt.registerExtModuleFunction("creation_date", CFG_BIBFORMAT_FUNCTION_NS, get_creation_date_libxslt) libxslt.registerExtModuleFunction("modification_date", CFG_BIBFORMAT_FUNCTION_NS, get_modification_date_libxslt) libxslt.registerExtModuleFunction("eval_bibformat", CFG_BIBFORMAT_FUNCTION_NS, eval_bibformat_libxslt) # Load template and source template_xml = libxml2.parseDoc(template) processor = libxslt.parseStylesheetDoc(template_xml) source = libxml2.parseDoc(xmltext) # Transform result_object = processor.applyStylesheet(source, None) try: result = processor.saveResultToString(result_object) except SystemError: # Catch an exception thrown when result is empty, # due to a bug in libxslt result = '' # Deallocate processor.freeStylesheet() source.freeDoc() result_object.freeDoc() elif processor_type == 1: # 4suite # Init processor = Processor.Processor() # Register BibFormat functions for use in XSL processor.registerExtensionFunction(CFG_BIBFORMAT_FUNCTION_NS, "creation_date", get_creation_date_4suite) processor.registerExtensionFunction(CFG_BIBFORMAT_FUNCTION_NS, "modification_date", get_modification_date_4suite) processor.registerExtensionFunction(CFG_BIBFORMAT_FUNCTION_NS, "eval_bibformat", eval_bibformat_4suite) # Load template and source transform = InputSource.DefaultFactory.fromString(template, uri=CFG_SITE_URL) source = InputSource.DefaultFactory.fromString(xmltext, uri=CFG_SITE_URL) processor.appendStylesheet(transform) # Transform result = processor.run(source) else: sys.stderr.write("No XSLT processor could be found") return result
def process(doc, out_enc): proc = Processor.Processor() stylesheet = xslt_identity % (out_enc, ) proc.appendStylesheetString(stylesheet) return proc.runNode(doc)
return None # Transform result_object = processor.applyStylesheet(source, None) result = processor.saveResultToString(result_object) # Deallocate processor.freeStylesheet() source.freeDoc() result_object.freeDoc() elif processor_type == 1: # 4suite # Init processor = Processor.Processor() # Register BibConvert functions for use in XSL processor.registerExtensionFunction(CFG_BIBCONVERT_FUNCTION_NS, "format", bibconvert_function_4suite) # Load template and source transform = InputSource.DefaultFactory.fromString(template, uri=CFG_SITE_URL) source = InputSource.DefaultFactory.fromString(xmltext, uri=CFG_SITE_URL) try: processor.appendStylesheet(transform) except XsltException, e: sys.stderr.write('Parsing XSL template failed:\n' + str(e))
def __init__(self, quiet): self.xslt_processor = Processor.Processor() self.xslt_params = {} self.quiet = quiet
def XsltTest(tester, sourceXml, stylesheets, expected, compareFunc=None, ignorePis=1, topLevelParams=None, extensionModules=None, exceptionClass=XsltException, exceptionCode=None, stylesheetInputFactory=None, documentInputFactory=None, stylesheetAltUris=None, title='', funcArgs=None): """ Common function to perform an XSLT transformation and compare the results through the tester. title is a short name that describes the test. tester is an Ft.Lib.TestSuite.Tester instance. sourceXml is a FileInfo instance for the source document. stylesheets is a list of FileInfo instances for the stylesheet(s). expected is a string to compare the actual transformation result to. compareFunc is a cmp()-like function to use to do the comparison. It defaults to whatever the tester's default is; usually cmp(). funcArgs is a dictionary of keyword arguments to pass to the comparison function, if it accepts keyword arguments. ignorePis, topLevelParams, extensionModules, stylesheetAltUris are as documented in Ft.Xml.Xslt.Processor.Processor. exceptionCode is the expected exception code, if the test is intended to generate an exception. documentInputFactory, stylesheetInputFactory are InputSource factories to use when resolving references to external URIs from within the source document or stylesheet(s), respectively. Defaults for both are Ft.Xml.InputSource.DefaultFactory. """ # reset the counter for generate-id g_idmap.clear() if not title: title = 'Source %(source)s' % (tester.test_data) tester.startTest(title) # Create the processor processor = Processor.Processor(stylesheetAltUris=stylesheetAltUris) processor.registerExtensionModules([__name__]) if extensionModules: processor.registerExtensionModules(extensionModules) # Setup document input for the processor factory = documentInputFactory or InputSource.DefaultFactory reader = Domlette._Reader(tester.test_data['module'].NonvalParse, kwargs={'readExtDtd': READ_EXTERNAL_DTD}) reader.inputSourceFactory = factory processor.setDocumentReader(reader) # Do the transformation try: # Add the stylesheets to the processor factory = stylesheetInputFactory or InputSource.DefaultFactory for stylesheet in stylesheets: processor.appendStylesheet(stylesheet.toInputSource(factory)) result = processor.run(sourceXml.toInputSource(factory), ignorePis=ignorePis, topLevelParams=topLevelParams) except exceptionClass, exception: if exceptionCode is None: # No exception was expected estr = _PrettifyException(exceptionClass, exception.errorCode) tester.exception('Unexpected exception ' + estr) else: # Compare the exception result expected = _PrettifyException(exceptionClass, exceptionCode) compared = _PrettifyException(exceptionClass, exception.errorCode) tester.compare(expected, compared, stackLevel=2)
def editConfig(self, defaultoperation, testoption, erroroption, target, confignode, targetnode=None): """ Apply a edit-config request from the confignode to the targetnode. @type defaultoperation: MERGE_OPERATION | REPLACE_OPERATION | NONE_OPERATION @param defaultoperation : as specified in NETCONF protocol @type testoption : SET | TEST_AND_SET @param testoption : as specified in NETCONF protocol @type erroroption : STOP_ON_ERROR | IGNORE_ERROR | ROLL_BACK_ON_ERROR @param erroroption : as specified in NETCONF protocol @type target : RUNNING_TARGET | CANDIDATE_TARGET | STARTUP_TARGET @param target : as specified in NETCONF protocol @type targetnode : string @param targetnode : if the target is RUNNING_TARGET or STARTUP_TARGET it will be ignored otherwise should be the node of the CANDIDATE_TARGET that this module should procees @rtype: ModuleReply @return: It returns a success or error message. ** Relates to the netconf edit-config operation """ try: # Generate a stylesheet equivalent to the edit-config df = InputSource.DefaultFactory editXMLRequest = df.fromString( util.convertNodeToString(confignode), 'urn:dummy') stylesheet = df.fromUri("file:" + metaFile, 'urn:sty') p = Processor.Processor() p.appendStylesheet(stylesheet) wr = DomWriter.DomWriter() p.run(editXMLRequest, writer=wr) generatedStyleSheet = wr.getResult() # Apply the generated stylesheet to the source document inputStyleSheet = df.fromString( util.convertNodeToString(generatedStyleSheet), 'urn:sty') oldXMLDocument = self.getConfig(target).getXMLNodeReply() inputDocument = df.fromString( util.convertNodeToString(oldXMLDocument), 'urn:dummy') p = Processor.Processor() p.appendStylesheet(inputStyleSheet) wr = DomWriter.DomWriter() p.run(inputDocument, writer=wr) newXMLDoc = wr.getResult() newOLSRRootNode = newXMLDoc.childNodes[0] # Copy the data to the olsr config file file_generator = Generator(self.namespace) file_generator.transform(newOLSRRootNode) print "new OLSR config is \n" PrettyPrint(newXMLDoc.childNodes[0]) if (newOLSRRootNode != None): xmlreply = ModuleReply(replynode=newOLSRRootNode) else: xmlreply = ModuleReply( error_type=ModuleReply.APPLICATION, error_tag=ModuleReply.OPERATION_NOT_SUPPORTED, error_severity=ModuleReply.ERROR, error_message= "Config generator from Module %s replied with None." % self.name) return xmlreply # (Re)start the olsr process on the device, if it is running # p = OLSR_System() # p.start_new_olsr_instance() # xmlReply = self.copyConfig("config", target, sourceNode = newXMLDoc) # return xmlReply except Exception, exp: print str(exp) moduleReply = ModuleReply(error_type=ModuleReply.APPLICATION, error_tag=ModuleReply.OPERATION_FAILED, error_severity=ModuleReply.ERROR, error_message=str(exp)) return moduleReply
def Run(options, args): stacktrace_on_error = options.has_key('stacktrace-on-error') # -- Set up output streams (will die if files unwritable) ---------- # (assumes output destinations have been checked for uniqueness) if options.has_key('compile'): output_flags = "wb" else: output_flags = "w" out_file = options.has_key('outfile') \ and open(options['outfile'], output_flags) or sys.stdout trace_file = None if options.has_key('trace'): trace_file_name = options.get('trace-file') if trace_file_name: trace_file_name = os.path.abspath(trace_file_name) out_file_name = options.get('outfile') if out_file_name: out_file_name = os.path.abspath(out_file_name) trace_file = options.has_key('trace-file') \ and open(options['trace-file'], 'w') or sys.stderr # -- Set up XSLT processor (without stylesheets) ------------------- # gather alt base URIs for xsl:include/import resolution # # An ordered list of absolute URIs is derived from these sources: # 1. command-line option(s) alt-sty-uri=../../foo.xml # 2. command-line option(s) alt-sty-path=C:\foo.xml # 3. environment variable XSLTINCLUDE=\a\b\foo.xml alt_sty_uris = options.get('alt-sty-uri', []) if type(alt_sty_uris) != list: alt_sty_uris = [alt_sty_uris] alt_sty_paths = options.get('alt-sty-path', []) if type(alt_sty_paths) != list: alt_sty_paths = [alt_sty_paths] more_sty_uris = [ OsPathToUri(path, attemptAbsolute=1) for path in alt_sty_paths ] alt_sty_uris.extend(more_sty_uris) if os.environ.has_key('XSLTINCLUDE'): more_sty_uris = [ OsPathToUri(path, attemptAbsolute=1) for path in os.environ["XSLTINCLUDE"].split(os.pathsep) ] alt_sty_uris.extend(more_sty_uris) del more_sty_uris # tracing requires special setup. if options.has_key('trace'): from Ft.Xml.Xslt import ExtendedProcessingElements, StylesheetHandler processor = ExtendedProcessingElements.ExtendedProcessor( stylesheetAltUris=alt_sty_uris) processor._4xslt_trace = True processor._4xslt_traceStream = trace_file StylesheetHandler._ELEMENT_MAPPING = ExtendedProcessingElements.GetMappings( ) else: processor = Processor.Processor(stylesheetAltUris=alt_sty_uris) # media prefs affect xsl:stylesheet PI selection processor.mediaPref = options.get('media', None) # register extension modules moduleList = os.environ.get("EXTMODULES") if moduleList: processor.registerExtensionModules(moduleList.split(":")) # set up the source document reader from Ft.Xml import Domlette validate_flag = options.has_key('validate') if validate_flag: reader = Domlette.ValidatingReader else: reader = Domlette.NonvalidatingReader processor.setDocumentReader(reader) #Customize message behavior if options.has_key('no-messages'): processor.messageControl(1) else: processor.messageControl(0) if options.has_key('msg-prefix'): prefix = options['msg-prefix'] prefix = prefix.replace('\\n', '\n') prefix = prefix.replace('\\r', '\r') prefix = prefix.replace('\\t', '\t') processor.msgPrefix = prefix if options.has_key('msg-suffix'): suffix = options['msg-suffix'] suffix = suffix.replace('\\n', '\n') suffix = suffix.replace('\\r', '\r') suffix = suffix.replace('\\t', '\t') processor.msgSuffix = suffix # -- Handle compile operation -------------------------------------- if options.has_key('compile'): xinclude = not options.has_key('noxinclude') all_source_args = [args['source-uri']] + args['stylesheet-uri'] try: sty_isrcs = map( lambda arg: StySourceArgToInputSource( arg, DefaultFactory, processIncludes=xinclude, stylesheetAltUris=alt_sty_uris), all_source_args) for isrc in sty_isrcs: processor.appendStylesheet(isrc) CloseStream(isrc, quiet=True) # use better pickle format in Python 2.3 and up if hasattr(cPickle, 'HIGHEST_PROTOCOL'): cPickle.dump(processor.stylesheet.root, out_file, cPickle.HIGHEST_PROTOCOL) else: cPickle.dump(processor.stylesheet.root, out_file, 1) except Exception, e: ReportFatalException(e, stacktrace_on_error) CloseStream(out_file, quiet=True) if out_file is sys.stdout: dest = 'standard output' elif hasattr(out_file, 'name'): dest = out_file.name elif options.has_key('outfile'): dest = options['outfile'] else: dest = 'unknown destination(!)' sys.stderr.write('Compiled stylesheet written to %s.\n' % dest) sys.stderr.flush() return