def UpdatePeer(self, peer):
     Called when a peer has changed.
     peer_id = peer.id_
     old_peer = self.peers[peer_id]
     self.peers[peer_id] = peer
     # Compare the peer's old services to its new ones...
     new_ids = set([_service.id_ for _service in peer.GetServices()])
     old_ids = set([_service.id_ for _service in old_peer.GetServices()])
     # Notify removed services
     for service_id in old_ids - new_ids:
             plugin = self.plugins[service_id]
         except KeyError:
     # Notify added services
     for service_id in new_ids - old_ids:
             plugin = self.plugins[service_id]
         except KeyError:
             plugin.NewPeer(peer, peer.GetService(service_id))
     # Notify updated services
     for service_id in new_ids & old_ids:
             plugin = self.plugins[service_id]
         except KeyError:
             plugin.ChangedPeer(peer, peer.GetService(service_id))
    def Merge(self, other):
        Merges the other history store into this one.
        The other history store takes precedence when there is a conflict.
        this_peers = set(self.entries)
        other_peers = set(other.entries)
        for peer_id in other_peers - this_peers:
#             print "new", peer_id
            self.entries[peer_id] = other.entries[peer_id].Copy()
        for peer_id in other_peers & this_peers:
#             print "merge", peer_id
Example #3
 def StripMessage(self, message, version=None):
     Strip unnecessary parameters from message.
     version = version or message.version
         _req = REQUESTS[version][message.request]
     except KeyError:
         raise EventParsingError("Unknown request '%s' in version '%s'" % (message.request, str(version)))
     required_args = set([ATTRIBUTE_NAMES[arg_id] for arg_id in _req])
     args = message.args
     for k in set(args.__dict__) - required_args:
         delattr(args, k)
    def __init__(self):
        self.oldseen = {}
        self.seen = {}
        self.unknown = {}
        self.seenids = {}

        self.dispatch = {
            types.ModuleType: self.rlen_module,
            dict: self.rlen_dict,
            list: self.rlen_seq,
            tuple: self.rlen_seq,
            set: self.rlen_seq,
            # frozenset and deque do not exist in Python 2.3
            #frozenset: self.rlen_seq,
            #deque: self.rlen_seq,
        self.ignores = set()
            import zope.interface.interface as i
            import zope.interface.declarations as d
            import twisted.python.components as c
        except ImportError:
            for mod in (i, d, c):
                for k in dir(mod):
                    v = getattr(mod, k)
                    if isinstance(v, type):
    def __init__(self, app, world, config_data, menu, *args, **kwds): = app = world
        self.config_data = config_data = menu

        # Item index => peer
        self.item_map = {}
        # Peer IDs
        self.selected_items = set()
        # Menu items
        self.menu_items = []

        # begin wxGlade: BookmarksDialog.__init__
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)
        self.panel_1 = wx.Panel(self, -1)

        # Tool Bar
        self.toolbar = wx.ToolBar(self, -1, style=wx.TB_HORIZONTAL|wx.TB_TEXT|wx.TB_HORZ_LAYOUT|wx.TB_HORZ_TEXT)
        self.toolbar.AddLabelTool(TOOL_ADD_BOOKMARK, _("Add bookmark"), (TB(wx.ART_ADD_BOOKMARK)), wx.NullBitmap, wx.ITEM_NORMAL, _("Remember one of your current neighbours"), "")
        self.toolbar.AddLabelTool(TOOL_DEL_BOOKMARK, _("Remove"), (TB(wx.ART_DEL_BOOKMARK)), wx.NullBitmap, wx.ITEM_NORMAL, _("Remove selected bookmark"), "")
        self.toolbar.AddLabelTool(TOOL_PROPERTIES, _("Information"), (TB(wx.ART_FILE_OPEN)), wx.NullBitmap, wx.ITEM_NORMAL, _("Get bookmark information"), "")
        # Tool Bar end
        self.list_ctrl = wx.ListCtrl(self.panel_1, -1, style=wx.LC_REPORT|wx.LC_VRULES|wx.SUNKEN_BORDER)
        self.button_close = wx.Button(self.panel_1, wx.ID_CLOSE, "")


        self.Bind(wx.EVT_TOOL, self.OnAddBookmark, id=TOOL_ADD_BOOKMARK)
        self.Bind(wx.EVT_TOOL, self.OnDelBookmark, id=TOOL_DEL_BOOKMARK)
        self.Bind(wx.EVT_TOOL, self.OnProperties, id=TOOL_PROPERTIES)
        self.Bind(wx.EVT_LIST_ITEM_DESELECTED, self.OnDeselectItem, self.list_ctrl)
        self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.OnSelectItem, self.list_ctrl)
        self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnActivateItem, self.list_ctrl)
        self.Bind(wx.EVT_BUTTON, self.OnClose, id=wx.ID_CLOSE)
        # end wxGlade
        self.Bind(wx.EVT_SHOW, self.OnShow)
        self.Bind(wx.EVT_CLOSE, self.OnClose)

        # Calculate colour for URLs, by dimming
        # between default text and background colours
        # (note: doesn't work on GTK and Aqua backends)
        rgb_front = self.GetForegroundColour().Get()
        rgb_back = self.GetBackgroundColour().Get()
        c = [f * 0.7 + b * 0.3 for (f, b) in zip(rgb_front, rgb_back)]
        self.url_colour = wx.Colour(*c)

        # Fill UI with data
 def OnAddBookmark(self, event): # wxGlade: BookmarksDialog.<event_handler>
     all_peers =
     bookmarked_peers = set([peer.id_ for peer in self.bookmarks.GetAllPeers()])
     peers = [peer for peer in all_peers if peer.id_ not in bookmarked_peers]
     dialog = wx.SingleChoiceDialog(parent=self,
         message=_("Please choose the peer to add to your bookmarks list."),
         caption=_("Add bookmark"),
         choices=[peer.pseudo for peer in peers])
     if dialog.ShowModal() == wx.ID_OK:
         peer = peers[dialog.GetSelection()]
Example #7
    def __init__(self, viewport):
        BaseWorld.__init__(self, viewport)
        self.charset = GetCharset()
        self.repository = images.ImageRepository()
        self.avatars = AvatarRepository()

        self.sounds = sounds.SoundRepository()
        self.human_peers = set()
Example #8
    def Init(self, local_ip):
        self.avatars = AvatarRepository()
        self.reactor = self.service_api.GetReactor() = local_ip
        self.port = 7780 + random.randrange(0, 100)

        # Network address container: { peer_id => (host, port) }
        self.hosts = {}
        self.node_avatar_hash = None
        self.node_id = None

        # Peers for which we have received an avatar hash but whose
        # address we don't know yet
        self.pending_peers = set()
    def _NecessaryPeers(self, max_angle=None):
        Returns id's of peers that are necessary for our global connectivity.
        if len(self.peers) < 3:
            return self.peers.keys()
        if max_angle is None:
            max_angle = self.max_angle
        _angles = self.angle_peers
        pi2 = 2.0 * math.pi

        result = set()
        prev_angle, _ = _angles[-2]
        angle, id_ = _angles[-1]
        # For each peer, we check the angle between the predecessor and
        # the successor. If the angle is greater than the desired max angle,
        # then this peer is necessary.
        for next_angle, next_id in _angles:
            if (next_angle - prev_angle) % pi2 >= max_angle:
            prev_angle = angle
            angle, id_ = next_angle, next_id

        return result
Example #10
 def PeersSet(self):
     Returns a set of all peer ids.
     return set(self.peers.iterkeys())
Example #11
    def ParseMessage(self, data, parse_only=False):
        Parse and extract message from protocol data.
        # Parse raw data to construct message (strip empty lines)
        lines = data.split(self.line_separator)
        # If message is empty, return false
        if not lines:
            return None
        # Parse request line
        m = self.request_syntax.match(lines[0])
        if m is None:
            raise EventParsingError("Invalid request syntax: " + repr(lines[0]))

        # Request is first word of the first line (e.g. NEAREST, or BEST ...)
        request =
        # Extract protocol version
        version = float(

        # Version check
        if version > VERSION:
            raise EventParsingError("Unexpected protocol version: %s" % str(version))
        elif version < VERSION:
  "Received message from older protocol version: %s" % str(version))
        # Request check
        if not request in REQUESTS[version]:
            raise EventParsingError("Unknown request: " + request)

        # Get args for this request
        mandatory_args = REQUESTS[version][request]
        missing_args = set(mandatory_args)
        args = {}

        # Now let's parse each parameter line in turn
        for nb_line in xrange(1, len(lines)):
            line = lines[nb_line]
            if len(line) == 0:
            # Get arg name and arg value
            t = line.split(':', 1)
            if len(t) != 2:
                raise EventParsingError("Invalid message syntax:\r\n" + data)
            name = t[0].strip()
            value = t[1].strip()

            # Each arg has its own syntax-checking regex
                arg_id = PROTOCOL_STRINGS.get_reverse(name)
                arg_syntax = ARGS_SYNTAX[arg_id]
            except KeyError:
                raise EventParsingError("Unknown arg '%s'" % (name))
            if not arg_syntax.match(value):
                raise EventParsingError("Invalid arg syntax for '%s': '%s'" % (name, value))

            # The syntax is correct => add this arg to the arg list
            if arg_id in args:
                raise EventParsingError("Duplicate value for arg '%s'" % name)

            # Build argument value from its registered constructor
            if not parse_only:
                args[arg_id] = ARGS_FROM_STRING[arg_id](value)

            # Log optional arguments
            except KeyError:
                self.logger.debug("Unexpected argument '%s' in message '%s'" % (name, request))

        # Is there a payload ?
        if nb_line + 1 < len(lines):
            payload = self.line_separator.join(lines[nb_line+1:])
            if payload:
                if ARG_PAYLOAD in missing_args:
                    self.logger.debug("Optional payload in message '%s'" % request)
                # Note: we don't try to convert the payload to unicode when
                # receiving, because it could really be a binary string.
                # This makes the message handling slightly asymetric.
                args[ARG_PAYLOAD] = payload

        # Check that all required fields have been encountered
        if missing_args:
            raise EventParsingError("Missing arguments (%s) in message '%s'"
                    % (",".join([PROTOCOL_STRINGS[arg] for arg in missing_args]), request))

        # Everything's ok
        if not parse_only:
            message = Message()
            message.request = request
            message.version = version
            for arg_id, value in args.iteritems():
                setattr(message.args, ATTRIBUTE_NAMES[arg_id], value)
            return message
            return True
 def Reset(self):
     self.plugins = {}
     self.peers = {}
     self.enabled_services = set()