/Users/maurits/Documents/studie/afstuderen/biosphere/python/biosphere/xlate.py

Go to the documentation of this file.

from biosphere.types import *
from xml.dom import minidom
import base64

"""The xlate module is used to parse XML into either a bs_definition
class or a bs_service_response class. Since this python package will
only be used on the client side, no bs_service_request functionality
is present.
"""


class XMLParser:
    """Parses the three different Bio-SPHERE XML representations
    into their respective classes."""
    
    def __init__(self):
        """Initialize the XMLParser."""
        self.errorerror = None
    
    def Parse(self, xmldata):
        """Parses a giving buffer with XML data into the correct
        data type. If an error is encountered, None is returned
        and the error can be examined at self.error.
        
        Args:
        xmldata -- A buffer with XML data to parse.
        """
        dom = minidom.parseString(xmldata)
        if dom.documentElement.tagName == 'definitions':
            return self.ParseDefinitionsParseDefinitions(dom)
        elif dom.documentElement.tagName == 'response':
            return self.ParseResponseParseResponse(dom)
        else:
            self.errorerror = (0x00000204, 'Unknown root element')
            return None
    
    def ParseDefinitions(self, dom):
        """Parse a definition XML structure. This method creates
        a bs_definition class which is returned or None if there
        was an error.
        
        Args:
        dom -- The DOM of the XML
        """
        name = dom.documentElement.getAttribute('name')
        bsdef = bs_definition(name)
        
        self.AddTypesAddTypes(dom, bsdef)
        self.AddMessagesAddMessages(dom, bsdef)
        self.AddPortTypesAddPortTypes(dom, bsdef)
        self.AddServicesAddServices(dom, bsdef)
        
        dom.unlink()
        if self.errorerror != None:
            return None
        else:
            self.errorerror = None
            return bsdef
    
    def AddTypes(self, dom, bsdef):
        """Add the data types used in the definition to the given
        bs_definition class.
        
        Args:
        dom -- Part of the DOM with the data types.
        bsdef -- bs_definition class to add types to.
        """
        for type in dom.getElementsByTagName('type'):
            bstype = bs_data_type(type.getAttribute('name'))
            bsdef.types.append(bstype)
    
    def AddMessages(self, dom, bsdef):
        """Add the messages used in the definition to the
        bs_definition class.
        
        Args:
        dom -- Part of the DOM with the data types.
        bsdef -- bs_definition class to add messages to.
        """
        messages = dom.getElementsByTagName('message')
        for msg in messages:
            bsmsg = bs_message(msg.getAttribute('name'))
            self.AddMessagePartsAddMessageParts(msg, bsmsg, bsdef)
            bsdef.messages.append(bsmsg)
    
    def AddMessageParts(self, msg, bsmsg, bsdef):
        """Add the parts of the message, whose DOM is in msg, to the
        bs_message class (bsmsg), searching for the correct type in
        bsdef.
        
        Args:
        msg -- Part of the DOM tree related to the message.
        bsmsg -- bs_message class to add the parts to.
        bsdef -- bs_definition class for cross-referencing.
        """
        parts = msg.getElementsByTagName('part')
        for part in parts:
            name = part.getAttribute('name')
            typename = part.getAttribute('type')
            type = None
            for t in bsdef.types:
                if t.name == typename:
                    type = t
                    break
            if type == None:
                self.errorerror = (0x206, 'Data type unknown')
            bsmsg.parts.append(bs_message_part(name, type))
    
    def AddPortTypes(self, dom, bsdef):
        """Add the port types to the bs_definition class.
        
        Args:
        dom -- Part of the DOM containing the port types.
        bsdef -- bs_definition class to cross-reference.
        """
        pts = dom.getElementsByTagName('portType')
        for pt in pts:
            bspt = bs_port_type(pt.getAttribute('name'))
            self.AddOperationsAddOperations(pt, bspt, bsdef)
            bsdef.porttypes.append(bspt)
    
    def AddOperations(self, pt, bspt, bsdef):
        """Add all the operations in pt (DOM) to the given
        bs_port_type class, while cross-referencing in the
        bs_definition class.
        
        Args:
        pt -- Part of the DOM related to the portType.
        bspt -- bs_port_type class to add operations to.
        bsdef -- bs_definition class to use for crossreferencing.
        """
        ops = pt.getElementsByTagName('operation')
        for op in ops:
            bsop = bs_operation(op.getAttribute('name'))
            
            # Find an optional input tag:
            itag = op.getElementsByTagName('input')
            if itag != []:
                mname = itag[0].getAttribute('message')
                for msg in bsdef.messages:
                    if msg.name == mname:
                        bsop.input = msg
                if bsop.input == None:
                    self.errorerror = (0x200, 'Couldnt find referenced message: %s' % mname)
            # Find an optional output tag:
            otag = op.getElementsByTagName('output')
            if otag != []:
                mname = otag[0].getAttribute('message')
                for msg in bsdef.messages:
                    if msg.name == mname:
                        bsop.output = msg
                if bsop.output == None:
                    self.errorerror = (0x200, 'Couldnt find referenced message: %s' % mname)
            # Find an optional fault message:
            ftag = op.getElementsByTagName('fault')
            if ftag != []:
                mname = ftag[0].getAttribute('message')
                for msg in bsdef.messages:
                    if msg.name == mname:
                        bsop.fault = msg
                if bsop.fault == None:
                    self.errorerror = (0x200, 'Couldnt find referenced message: %s' % mname)
                        
            bspt.operations.append(bsop)
    
    def AddServices(self, dom, bsdef):
        """Add the services to the bs_definition structure.
        
        Args:
        dom -- DOM structure of the definitions.
        bsdef -- bs_definition class to add them to.
        """
        services = dom.getElementsByTagName('service')
        for svc in services:
            bssvc = bs_service(svc.getAttribute('name'))
            self.AddPortsAddPorts(svc, bssvc, bsdef)
            bsdef.services.append(bssvc)
    
    def AddPorts(self, svc, bssvc, bsdef):
        """Add the ports to the service, by using a partially
        completed/parsed bs_definition class as a reference.
        
        Args:
        svc -- Part of the DOM used for searching the services.
        bssvc -- bs_service class to add the ports to.
        bsdef -- bs_definition class to search for port types.
        """
        ports = svc.getElementsByTagName('port')
        for port in ports:
            pname = port.getAttribute('name')
            tname = port.getAttribute('type')
            type = None
            for t in bsdef.porttypes:
                if t.name == tname:
                    type = t
                    break
            if type == None:
                self.errorerror(0x200, 'Couldnt find specified porttype: %s' % tname)
            else:
                bssvc.ports.append(bs_port(pname, type))
    
    def ParseResponse(self, dom):
        uuid = dom.documentElement.getAttribute('uuid')
        resp = bs_service_response(None, None, None, uuid)
        
        self.AddUsedAddUsed(dom, resp)
        
        dom.unlink()
        if self.errorerror != None:
            return None
        else:
            self.errorerror = None
            return resp
    
    def AddUsed(self, dom, resp):
        used = dom.getElementsByTagName('used')[0]
        resp.service = used.getAttribute('service')
        resp.port = used.getAttribute('port')
        resp.operation = used.getAttribute('operation')
        
        output = dom.getElementsByTagName('output')
        if len(output) == 1:
            resp.output = self.AddMessageInstanceAddMessageInstance(dom, output[0],
                                                  'output')
        
        fault = dom.getElementsByTagName('fault')
        if len(fault) == 1:
            resp.fault = self.AddMessageInstanceAddMessageInstance(dom, fault[0],
                                                 'fault')
        
    def AddMessageInstance(self, dom, message, direction):
        name = message.getAttribute('message')
        msg = bs_message_instance(name, direction)
        
        parts = dom.getElementsByTagName('part')
        for part in parts:
            name = part.getAttribute('name')
            type = bs_data_type(part.getAttribute('type'))
            rawdata = ''
            if hasattr(part.firstChild, 'data'):
                rawdata = part.firstChild.data
                if not type.isBuiltin():
                    rawdata = base64.b64decode(rawdata)
            msg.parts.append(bs_part_instance(name, type, rawdata))
            
        return msg
            

---