Changeset 437

Show
Ignore:
Timestamp:
02/05/03 01:09:46 (6 years ago)
Author:
sholloway
Message:

*** empty log message ***

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/RBFoundation/RBFoundation/XMLBuilder.py

    r435 r437  
    119119        """Part of the tree-style template method, called at the before the beginning of an XML node parse  
    120120        to manage namespaces.""" 
     121        # Don't forget to substitute our namespace synonyms! 
     122        uri = self.NamespaceSynonyms.get(uri or None, uri)  
     123        # Add the prefix/uri to our current namespace mapping 
    121124        self._current_namespacemap.setxmlns(prefix, uri) 
    122125 
    …… 
    143146        """Part of the tree-style template method, called at the closing of an XML node parse. 
    144147        Simply notifies the element that it is complete.""" 
    145         self._current_namespacemap = self._current_namespacemap.newchain(-1) 
    146148 
    147149        if self._elements: 
    …… 
    152154            except AttributeError: result = element 
    153155            else: result = xmlGetElement() 
    154         else: result = None 
     156            self._current_namespacemap = self._current_namespacemap.nextmap 
     157        else:  
     158            result = None 
     159            self._current_namespacemap = XMLNamespaceMap() 
    155160        return result 
    156161 
    …… 
    170175            namespace = combined[0:idx] 
    171176            name = combined[idx + len(self._seperator):] 
    172         namespace = self.NamespaceSynonyms.get(namespace, namespace) 
     177        namespace = self.NamespaceSynonyms.get(namespace or None, namespace) 
    173178        return namespace, name 
    174179 

  • trunk/RBFoundation/RBFoundation/XMLNode.py

    r436 r437  
    128128    def __init__(self, node, namespace=None, prefix='', default_namespaces=None, attrlookup=None): 
    129129        self.enableattrlookup(attrlookup) 
    130         self.namespaces = (default_namespaces or self.default_namespaces).copy() 
     130        if default_namespaces: self.namespaces = default_namespaces 
     131        else: self.namespaces = self.default_namespaces.copy() 
    131132        self.elems = self.default_elements[:] 
    132133        self.attrs = self.default_attributes.copy() 
    …… 
    247248        else: return self.addnode(*elem) 
    248249 
    249     def setxmlns(self, prefix, namespace): 
    250         self.namespaces.setxmlns(prefix, namespace) 
     250    def setxmlns(self, *args, **kw): 
     251        return self.namespaces.setxmlns(*args, **kw) 
    251252 
    252253    #~ iteration over elements ~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    253254 
    254     def enumdata(self, match=None): 
     255    def enumdata(self, match=None, idxonly=True): 
    255256        """Returns a generator to iterate through the matching data indices in xmlnode""" 
    256257        if not match: match = _any 
    …… 
    260261            if isinstance(each, basestring): 
    261262                if each == match: 
    262                     yield idx 
     263                    if idxonly: yield idx 
     264                    else: yield idx, each 
    263265            idx += 1 
    264266 
    …… 
    292294    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    293295 
    294     def enumnodes(self, node=_any, namespace=_any, prefix=_any): 
     296    def enumnodes(self, node=_any, namespace=_any, prefix=_any, idxonly=True): 
    295297        """Returns a generator to iterate through the matching child node indicies of xmlnode""" 
    296298        idx = 0 
    …… 
    298300            if not isinstance(each, basestring): 
    299301                if node == each.node and namespace == each.namespace and prefix == each.prefix: 
    300                     yield idx 
     302                    if idxonly: yield idx 
     303                    else: yield idx, each 
    301304            idx += 1 
    302305 
    …… 
    376379    def _getnamespace(self): 
    377380        """Returns the namespace of the xmlnode""" 
    378         return self.namespaces.get(self.prefix or '', None) 
     381        return self.namespaces.xmlns(self.prefix or '') 
    379382    def _setnamespace(self, namespace): 
    380383        """Sets the namespace of the xmlnode""" 
    381384        if isinstance(namespace, tuple): 
    382385            if len(namespace) == 1: 
    383                 self.prefix, namespace = namespace[0], None 
     386                self.prefix, namespace = namespace[0], '' 
    384387            else: 
    385388                self.prefix, namespace = namespace 
     389        self.prefix = self.prefix or '' 
    386390        if namespace is not None: 
    387             self.namespaces.setxmlns(self.prefix or '', namespace) 
     391            self.namespaces.setxmlns(self.prefix, namespace) 
    388392    def _delnamespace(self): 
    389393        """Removes the namespace of the xmlnode""" 
    …… 
    463467 
    464468        def __init__(self, owner, parent, node, attributes, namespacemap): 
    465             try: 
    466                 prefix = namespacemap.prefix(node[0], False) 
    467                 xmlnode.__init__(self, node[1], node[0], prefix, default_namespaces=namespacemap) 
    468             except KeyError: 
    469                 xmlnode.__init__(self, node[1], default_namespaces=namespacemap) 
     469            prefix = namespacemap.prefix(node[0]) 
     470            if node[0] in namespacemap: 
     471                nodename, xmlns = node[1], node[0] 
     472            else: nodename, xmlns = node[1], None 
     473            xmlnode.__init__(self, nodename, xmlns, prefix, default_namespaces=namespacemap) 
    470474 
    471475            for key, value in attributes.iteritems(): 
    …… 
    495499 
    496500        def __init__(self, owner, parent, node, attributes, namespacemap): 
    497             try: 
    498                 prefix = namespacemap.prefix(node[0], False) 
    499                 self.result = xmlnode(node[1], node[0], prefix, default_namespaces=namespacemap) 
    500             except KeyError: 
    501                 self.result = xmlnode(node[1], default_namespaces=namespacemap) 
     501            prefix = namespacemap.prefix(node[0]) 
     502            if node[0] in namespacemap or not namespacemap.nextmap: 
     503                nodename, xmlns = node[1], node[0] 
     504            else: nodename, xmlns = node[1], None 
     505            self.result = xmlnode(nodename, xmlns, prefix, default_namespaces=namespacemap) 
    502506 
    503507            for key, value in attributes.iteritems(): 

  • trunk/RBTelepathy/RBTelepathy/Connection.py

    r433 r437  
    5656    def OnRoutedPacket(self, packet, *args, **kw): 
    5757        self.log.debug('Received Routed packet (%s, %s)', packet.namespace, packet.node) 
     58        #print '>>>', packet.toxml() 
    5859 
    5960        # Lookup our packet handler 
    …… 
    7071    def OnStreamPacket(self, packet, *args, **kw): 
    7172        self.log.debug('Received Stream packet (%s, %s)', packet.namespace, packet.node) 
     73        #print '>>>', packet.toxml() 
    7274 
    7375        # Lookup our packet handler 

  • trunk/RBTelepathy/RBTelepathy/Packet/AuthenticationHandler.py

    r433 r437  
    7070            AuthType = packet.attrs['type'] 
    7171        except KeyError: 
    72             print packet.toxml(True) 
    7372            raise ErrorTypes.AuthenticationError('Sequence type not specified') 
     73 
    7474        try: 
    7575            OnAuthType = self._ValidTypes[AuthType] 
    …… 
    9191            xml += ">" + XMLBody + "</authentication>" 
    9292        else: xml += "/>" 
    93         #print '* '*10 
    94         #print xml 
    95         #print 
    9693        connection.SendPacket(xml) 
    9794 

  • trunk/RBTelepathy/RBTelepathy/Packet/Builder.py

    r433 r437  
    7979            raise ErrorTypes.PacketInvalidXMLError(str(e)) 
    8080        except StandardError, e: 
    81             # Change these to PacketErrors 
     81            # XXX: Change these to PacketErrors 
    8282            #raise ErrorTypes.PacketError(str(e)) 
    8383            raise 

  • trunk/RBTelepathy/RBTelepathy/Packet/Elements.py

    r433 r437  
    120120class RouteableRootElement(RootElementBase): 
    121121    def GetAddresses(self, nodename='to'): 
    122         existing = self._getElements(node=nodename, namespace=RBMessagingNamespace) 
     122        existing = self.iternodes(nodename, RBMessagingNamespace) 
    123123        result = [each.addr for each in existing] 
    124124        return result 
    125125 
    126126    def SetAddresses(self, addresses, nodename='to'): 
     127        print "XXX: RouteableRootElement.SetAddresses needs work" 
    127128        # Figure out which addresses we are to maintain 
    128         existing = self._getElements(node=nodename, namespace=RBMessagingNamespace) 
    129         if existing: 
    130             idxAddresses = self._getElementIndex(existing[0]) 
    131         else: idxAddresses = 0 
     129        #existing = self.iternodes(nodename, RBMessagingNamespace) 
     130        #if existing: 
     131        #    idxAddresses = self._getElementIndex(existing[0]) 
     132        #else: idxAddresses = 0 
     133        #idxAddresses = 0 
    132134 
    133         existing = [(each.addr, each) for each in existing if each.addr in addresses] 
    134         existing = dict(existing) 
     135        #existing = [(each.addr, each) for each in existing if each.addr in addresses] 
     136        #existing = dict(existing) 
    135137 
    136         # Remove all existing addresses 
    137         self._delElements(node=nodename, namespace=RBMessagingNamespace) 
     138        ## Remove all existing addresses 
     139        #self.delnodes(nodename, RBMessagingNamespace) 
    138140 
    139         for address in addresses: 
    140             element = existing.get(address) 
    141             if element is None: 
    142                 # Create a new element 
    143                 element = self._addNewElement(self.namespace, nodename, klass=URIAddressElement)[-1] 
    144                 element.addr = address 
    145                 element._xmlInitStarted() 
    146                 element._xmlInitComplete() 
    147             else: 
    148                 self._addObjectifiedElement(element) 
    149              
    150             self._elements.insert(idxAddresses, self._elements.pop()) 
     141        #for address in addresses: 
     142        #    element = existing.get(address) 
     143        #    if element is None: 
     144        #        # Create a new element 
     145        #        element = self.addnode(nodename, self.namespace, klass=URIAddressElement) 
     146        #        element.addr = address 
     147        #        element._xmlInitStarted() 
     148        #        element._xmlInitComplete() 
     149        #    else: 
     150        #        self._addObjectifiedElement(element) 
     151        #     
     152        #    self._elements.insert(idxAddresses, self._elements.pop()) 
    151153 
    152154#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

  • trunk/RBTelepathy/RBTelepathy/Packet/MessageHandler.py

    r433 r437  
    7575    def OnRoutedPacket(self, connection, packet, addresses): 
    7676        # Copy the root level packet, so we can adjust it's addresses 
    77         packet = copy.copy(packet) 
     77        #packet = copy.copy(packet) 
    7878        # Change the address lists in the packet 
    7979        packet.SetAddresses(addresses) 

  • trunk/RBTelepathy/RBTelepathy/Routing/RouterBase.py

    r406 r437  
    2323#~ Imports  
    2424#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
     25 
     26from RBMessaging import ErrorTypes 
    2527 
    2628#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    5961        """Returns the default destination for an otherwise unrouteable address. 
    6062        Can return None, raise an error, or return a valid destination.""" 
    61         raise KeyError, "No route found for '%s'" % (address,) 
     63        raise ErrorTypes.RoutingError("No route found for '%s'" % (address,)) 
    6264 
    6365    def FindRouteDestinations(self, address): 

  • trunk/RBTelepathy/RBTelepathy/Routing/SimpleRouter.py

    r415 r437  
    2525 
    2626from RouterBase import RouterBase 
     27from RBMessaging import ErrorTypes 
    2728 
    2829#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 

  • trunk/RBTelepathy/RBTelepathy/Stream/Protocol.py

    r433 r437  
    4343    currentpacket = None 
    4444    packetbuilder = None 
     45    completepackets = () 
    4546    log = logging.getLogger('StreamProtocol') 
    4647 
    …… 
    6263    def OnRecvStreamData(self, streamdata): 
    6364        """Called from Stream object to introduce more raw stream bytes into the system""" 
    64         if self.data:  
    65             self.data += streamdata 
    66         else:  
    67             self.data = streamdata 
     65        if streamdata: 
     66            if self.data:  
     67                self.data += streamdata 
     68            else:  
     69                self.data = streamdata 
    6870 
    6971        while self.ProcessData(): 
    …… 
    9193            self._BuildData() 
    9294 
     95        if self.completepackets: 
     96            self._SendCompleteStreamPacket(self.completepackets.pop(0)) 
     97 
    9398        return self.data and True or False 
    9499 
    …… 
    106111            if error.shutdown or forceshutdown: 
    107112                self.stream.shutdown('local') 
     113                del self.data 
    108114        else: 
    109115            self.log.critical(str(error), exc_info=1) 
    …… 
    114120            if forceshutdown: 
    115121                self.stream.shutdown('local') 
    116         return False 
     122                del self.data 
     123 
     124        # Reraise any non-RBMessaging error 
     125        return isinstance(error, ErrorTypes.RBMessagingError) 
    117126 
    118127    def OnStreamPacket(self, packet): 
    …… 
    145154        if self.currentpacket is not None:  
    146155            try: 
    147                 self.data = self.currentpacket.OnStreamData(self.data, self._OnStreamPacket) 
     156                self.data = self.currentpacket.OnStreamData(self.data, self._OnStreamPacket) or '' 
    148157            except ErrorTypes.RBMessagingError, rbError: 
    149158                if self.StreamError(rbError) is False: 
    …… 
    154163 
    155164    def _OnStreamPacket(self, packet): 
     165        if self.completepackets: 
     166            self.completepackets.append(packet) 
     167        else: self.completepackets = [packet] 
    156168        del self.currentpacket 
     169 
     170    def _SendCompleteStreamPacket(self, packet): 
    157171        try: 
    158172            self.OnStreamPacket(packet) 

  • trunk/RBTelepathy/RBTelepathy/Stream/SocketAdaptor.py

    r432 r437  
    4040    _sendData = "" 
    4141    isshutdown = False 
     42    _isshutdown_send = False 
     43    _isshutdown_recv = False 
    4244    log = logging.getLogger('SocketStream') 
    4345 
    …… 
    4850    def __init__(self, socket): 
    4951        self.socket = socket 
     52        try: 
     53            del self.isshutdown 
     54            del self._isshutdown_send 
     55            del self._isshutdown_recv 
     56        except AttributeError: pass 
    5057 
    5158    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    5764        return self._sendData 
    5865    def _setSendData(self, data): 
    59         self._sendData = data 
     66        if self._isshutdown_send: 
     67            raise ErrorTypes.StreamError('Cannot write to stream after shutdown') 
     68        else: 
     69            self._sendData = data 
    6070    def _delSendData(self): 
    6171        del self._sendData 
    …… 
    6777    write = send 
    6878 
    69     def shutdown(self, how='local', allowread=False, allowwrite=True): 
     79    def shutdown(self, how='local', *args, **kw): 
    7080        try: 
    7181            if not self.isshutdown: 
    7282                self.OnShutdown(how) 
    7383                self.log.info('Connection closed by "%s" on %s', how, self.socket.getpeername()) 
    74             self.isshutdown |= (allowread << 1) | (allowwrite << 0) 
    75             if self.isshutdown > 0: 
    76                 self.socket.shutdown(self.isshutdown-1) 
     84                self.isshutdown = True 
     85            return self._SocketShutdown(*args, **kw) 
    7786        except socket.error, exc: 
    7887            self.log.exception("Socket error on shutdown") 
    …… 
    101110        # if we've been marked to shutdown 
    102111        if self.isshutdown: 
    103             # and all data is sent out 
    104             if not self._sendData: 
    105                 # then we are done 
    106                 return True 
     112            # and all data is sent out, or there is no more sending allowed 
     113            return (not self._sendData) or self._isshutdown_send 
    107114        return False 
    108115 
    109116    def _NeedsRead(self):  
    110         return self.socket and True 
     117        return self.socket and not self._isshutdown_recv 
    111118 
    112119    def _ProcessRead(self, *args, **kw):  
    …… 
    114121        if not data: 
    115122            # The remote side shutdown the connection 
    116             self.shutdown('remote', False, True) 
     123            self.shutdown('remote') 
    117124        self.OnRecvStreamData(data) 
    118125 
    119126    def _NeedsWrite(self):  
    120         return self.socket and self._sendData and True or False 
     127        if self._isshutdown_send:  
     128            return False 
     129        else:  
     130            return self.socket and self._sendData 
    121131 
    122132    def _ProcessWrite(self, *args, **kw): 
    123133        nSent = self._SocketSend(self._sendData, *args, **kw) 
    124134        self._sendData = self._sendData[nSent:] 
    125         if self.isshutdown and not self._sendData: 
     135        if self.isshutdown: 
    126136            # Ok, we're shutdown, but were still sending data 
    127             # Now that we are done, shutdown the connection. 
    128             self.shutdown('local', True, False) 
     137            if not self._sendData: 
     138                # Now that we are done, shutdown the connection. 
     139                self._SocketShutdown(False, True) 
    129140 
    130141    def _NeedsError(self):  
    …… 
    132143 
    133144    def _ProcessError(self):  
    134         pass 
     145        self.log.critical('Received an error on SocketAdaptor.socket') 
    135146 
    136147    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
    …… 
    149160            if not self._SetSocketError(exc): 
    150161                raise 
     162 
     163    def _SocketShutdown(self, disallowrecv=True, disallowsend=False): 
     164        assert self.isshutdown, '_SocketShutdown assumes shutdown has already been called' 
     165        try: 
     166            self._isshutdown_recv |= disallowrecv and 1 or 0 
     167            self._isshutdown_send |= disallowsend and 1 or 0 
     168            flags = (self._isshutdown_send << 1) | (self._isshutdown_recv << 0) 
     169            if flags > 0:  
     170                self.socket.shutdown(flags-1) 
     171        except socket.error, exc: 
     172            self.log.exception("Socket error on shutdown") 
    151173 
    152174    def _SetSocketError(self, exc): 
    …… 
    154176        del self._sendData 
    155177        del exc 
    156         self.shutdown('error', False, False) 
     178        self.shutdown('error') 
    157179        # We've logged it and taken care of the stream,  
    158180        # therefore don't propigate.  If you want to do