コード例 #1
0
ファイル: presencepeer.py プロジェクト: madsdk/presence
class PresencePeer(object):
    def __init__(self, name="unnamed", address=0):
        super(PresencePeer, self).__init__()
        self._name = NodeName(name)
        self._address = UInt32()
        self.address = address
        
    def name(): #@NoSelf
        doc = """Property for name."""
        def fget(self):
            return self._name.name
        def fset(self, value):
            self._name.name = value
        return locals()
    name = property(**name())

    def address(): #@NoSelf
        doc = """Property for address."""
        def fget(self):
            return self._address.value
        def fset(self, value):
            self._address.value = value
        def fdel(self):
            del self._address
        return locals()
    address = property(**address())
    
    def address_str(): #@NoSelf
        doc = """Address property that returns a string representation."""
        def fget(self):
            return self._address.pack()
        return locals()
    address_str = property(**address_str())
    
    def unpack(self, string_repr):
        """Unpacks a PresencePeer object from a serialized string representation.
        This implementation assumes that the given string is valid - otherwise 
        exceptions will be thrown when unpacking."""
        try:
            idx = self._name.unpack(string_repr)
            idx += self._address.unpack(string_repr[idx:])
            return idx
        except (UnpackingError, ValidationError), excep:
            raise UnpackingError('Error unpacking peer address. Message was="%s"', excep.args[0])
コード例 #2
0
ファイル: presencepeer.py プロジェクト: madsdk/presence
 def __init__(self, name="unnamed", address=0):
     super(PresencePeer, self).__init__()
     self._name = NodeName(name)
     self._address = UInt32()
     self.address = address
コード例 #3
0
ファイル: presence.py プロジェクト: madsdk/presence
                                self.__command_queue.put((packet_type, ""))

                            elif packet_type == PresenceDefines.ERROR:
                                try:
                                    (error_number,) = struct.unpack("!B", packet[idx : idx + 1])
                                    idx += 1
                                    error_message = MaxLengthCString(PresenceDefines.MAX_COMMAND_SIZE - 4)
                                    idx += error_message.unpack(packet[idx:])
                                    self.__command_queue.put((packet_type, (error_number, error_message)))
                                except Exception, e:
                                    self.__handle_monitor_error(False, e)
                                    break

                            elif packet_type == PresenceDefines.NODE_NAME:
                                try:
                                    node_name = NodeName()
                                    idx += node_name.unpack(packet[idx:])
                                    self.__command_queue.put((packet_type, node_name.name))
                                except Exception, e:
                                    self.__handle_monitor_error(False, e)
                            else:
                                logger.info("Received invalid message. Type was = %i" % packet_type)
                                break
            except Exception, e:
                # A fatal error has occurred.
                self.__sock.close()
                self.__sock = None
                self.__callbacks = {}
                self.__command_queue = Queue.Queue()
                self.__shutdown = False
                self.__handle_monitor_error(True, e)