Пример #1
0
 def pns_map_names (self, unicoded, encoded):
         # index a sequence of names to the index
         names = tuple ((
                 (n, encode (n, 'UTF-8'))
                 for n in netunicode.decode (unicoded)
                 ))
         for n, name in names:
                 stored = self.pns_index.get (index)
                 if stored == None:
                         # insert an entry in the index
                         self.pns_index[name] = encoded + chr (1)
                         self.pns_map_names (n, name)
                 elif (
                         ord (stored[-1]) < self.pns_horizon and
                         stored.find (encoded) < 0
                         ):
                         # update an entry with a new index
                         field = set ()
                         stored = public_names.valid (unicode (
                                 encoded + stored[:-1], 'UTF-8'
                                 ),  field, self.pns_horizon)
                         if len (field) < self.pns_horizon:
                                 # but only below the horizon
                                 self.pns_index[name] = (encode (
                                         stored, 'UTF-8'
                                         ) + chr (len (field)))
         return names
Пример #2
0
        def pns_command (self, model):
                # handle a command from a PNS/TCP session
                assert None == self.log (
                        netstring.encode (model), 'command'
                        )
                if model[1]:
                        if model[2]:
                                # walk subject down to contexts, let the user
                                # agent walk the graph up and down at once to
                                # test and weight a subject against a set of
                                # contexts (and not implement that common walk
                                # into the client, but rather articulate it).
                                #
                                contexts = set (netunicode.decode (
                                        unicode (model[2], 'UTF-8')
                                        ))
                                self.thread_loop_queue ((
                                        self.pns_walk_simplest,
                                        (model, contexts)
                                        ))
                                return

                        # walk down the contexts once, in all contexts
                        self.thread_loop_queue ((
                                self.pns_command_predicate, (model,)
                                ))
                        return

                # walk up the names once, for in contexts
                self.thread_loop_queue ((
                        self.pns_command_object, (model,)
                        ))
Пример #3
0
    def pns_walk_down(self, name, contexts):
        stored = self.pns_routes.get(encode(name, 'UTF-8'))
        if stored and (ord(stored[-1]) < self.pns_horizon):
            return contexts & set(
                netunicode.decode(unicode(stored[:-1], 'UTF-8')))

        return NULL_SET
Пример #4
0
def valid (encoded, field, horizon):
        "validate encoded Public Names in a field and below a given horizon"
        # try to decode the articulated public names, strip voids
        names = tuple (netunicode.decode (encoded, False))
        if not names:
                # inarticulated names
                if encoded in field:
                        # allready in the field
                        return u""
                
                # new in this field
                field.add (encoded)
                return encoded
                        
        # articulated Public Names
        valids = []
        for name in names:
                # recursively validate each articulated name
                name = valid (name, field, horizon)
                if name:
                        valids.append (name)
                        if len (field) >= horizon:
                                break # but only under this horizon
                                
        if len (valids) > 1:
                # sort Public Names and encode
                valids.sort ()
                return netunicode.encode (valids)
                
        if len (valids) > 0:
                # return a "singleton"
                return valids[0]
                
        return u"" # nothing valid to articulate
Пример #5
0
def valid(encoded, field, horizon):
    "validate encoded Public Names in a field and below a given horizon"
    # try to decode the articulated public names, strip voids
    names = tuple(netunicode.decode(encoded, False))
    if not names:
        # inarticulated names
        if encoded in field:
            # allready in the field
            return u""

        # new in this field
        field.add(encoded)
        return encoded

    # articulated Public Names
    valids = []
    for name in names:
        # recursively validate each articulated name
        name = valid(name, field, horizon)
        if name:
            valids.append(name)
            if len(field) >= horizon:
                break  # but only under this horizon

    if len(valids) > 1:
        # sort Public Names and encode
        valids.sort()
        return netunicode.encode(valids)

    if len(valids) > 0:
        # return a "singleton"
        return valids[0]

    return u""  # nothing valid to articulate
Пример #6
0
	def pns_walk_down (self, name, contexts):
                stored = self.pns_routes.get (encode (name, 'UTF-8'))
                if stored and (ord (stored[-1]) < self.pns_horizon):
		        return contexts & set (netunicode.decode (
                                unicode (stored[:-1], 'UTF-8')
                                ))
                
                return NULL_SET
Пример #7
0
 def pns_walk_up(self, names, walked):
     index = {}
     for name in names:
         stored = self.pns_index.get(encode(name, 'UTF-8'))
         if stored and (ord(stored[-1]) < self.pns_horizon):
             for n in (
                     set(netunicode.decode(unicode(stored[:-1], 'UTF-8'))) -
                     walked):
                 index.setdefault(n, set()).add(name)
     return index
Пример #8
0
 def pns_walk_up (self, names, walked):
         index = {}
         for name in names:
                 stored = self.pns_index.get (encode (name, 'UTF-8'))
                 if stored and (ord (stored[-1]) < self.pns_horizon):
                         for n in (set (netunicode.decode (unicode (
                                 stored[:-1], 'UTF-8'
                                 ))) - walked):
                                 index.setdefault (
                                         n, set()
                                         ).add (name)
         return index
Пример #9
0
    def pns_walk_simplest(self, model, contexts):
        subject = unicode(model[0] or model[1], 'UTF-8')
        walked = set((subject, ))
        if subject in contexts:
            routes = {subject: set((subject, ))}
        else:
            routes = {}
        paths = self.pns_walk_down(subject, contexts)
        if paths:
            routes.setdefault(subject, set()).update(paths)
        if len(routes) > 0:
            self.pns_walk_out(model, routes)
            return

        names = list(netunicode.decode(subject)) or [subject]
        self.thread_loop_queue(
            (self.pns_walk_simple, (model, contexts, walked, routes, names)))
Пример #10
0
	def pns_walk_simplest (self, model, contexts):
                subject = unicode (model[0] or model[1], 'UTF-8')
		walked = set ((subject, ))
                if subject in contexts:
                        routes = {subject: set ((subject, ))}
                else:
                        routes = {}
                paths = self.pns_walk_down (subject, contexts)
                if paths:
                        routes.setdefault (subject, set ()).update (paths)
                if len (routes) > 0:
                        self.pns_walk_out (model, routes)
                        return
                        
                names = list (
                        netunicode.decode (subject)
                        ) or [subject]
                self.thread_loop_queue ((
                        self.pns_walk_simple,
                        (model, contexts, walked, routes, names)
                        ))
Пример #11
0
    def pns_command(self, model):
        # handle a command from a PNS/TCP session
        assert None == self.log(netstring.encode(model), 'command')
        if model[1]:
            if model[2]:
                # walk subject down to contexts, let the user
                # agent walk the graph up and down at once to
                # test and weight a subject against a set of
                # contexts (and not implement that common walk
                # into the client, but rather articulate it).
                #
                contexts = set(netunicode.decode(unicode(model[2], 'UTF-8')))
                self.thread_loop_queue(
                    (self.pns_walk_simplest, (model, contexts)))
                return

            # walk down the contexts once, in all contexts
            self.thread_loop_queue((self.pns_command_predicate, (model, )))
            return

        # walk up the names once, for in contexts
        self.thread_loop_queue((self.pns_command_object, (model, )))
Пример #12
0
 def pns_map_names(self, unicoded, encoded):
     # index a sequence of names to the index
     names = tuple(
         ((n, encode(n, 'UTF-8')) for n in netunicode.decode(unicoded)))
     for n, name in names:
         stored = self.pns_index.get(index)
         if stored == None:
             # insert an entry in the index
             self.pns_index[name] = encoded + chr(1)
             self.pns_map_names(n, name)
         elif (ord(stored[-1]) < self.pns_horizon
               and stored.find(encoded) < 0):
             # update an entry with a new index
             field = set()
             stored = public_names.valid(
                 unicode(encoded + stored[:-1], 'UTF-8'), field,
                 self.pns_horizon)
             if len(field) < self.pns_horizon:
                 # but only below the horizon
                 self.pns_index[name] = (encode(stored, 'UTF-8') +
                                         chr(len(field)))
     return names