Python Node.set方法代码示例

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
 def addManagedNode(self, data, friendNode):
     try:
         node = Node(data)
         for friend in node.get('data/friends'):
             node.addFriend(friend)
         node.set('data/friends', [])
         self.db.managed.insert({'managed_public_key': node.get('public_key'), 'friend_public_key': friendNode.get('public_key')})
         self.col.insert(node.get())
         return "ok"
     except:
         raise InvalidIdentity("cannot add invalid node to managed nodes")

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
    def add_node(self, node_or_ID, **kwds):
        """ Adds a node to the graph.
        """
        if not isinstance(node_or_ID, Node):
            nodeID = str( node_or_ID )
            if nodeID in self.nodes:
                node = self.nodes[ self.nodes.index(nodeID) ]
            else:
                if self.default_node is not None:
                    node = self.default_node.clone_traits(copy="deep")
                    node.ID = nodeID
                else:
                    node = Node(nodeID)
                self.nodes.append( node )
        else:
            node = node_or_ID
            if node in self.nodes:
                node = self.nodes[ self.nodes.index(node_or_ID) ]
            else:
                self.nodes.append( node )

        node.set( **kwds )

        return node

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
 def forceJoinNodes(self, sourceNode, destNode):
     
     newFriendRequest = Node({}, sourceNode.get('data/identity'), sourceNode.getFriendPublicKeysDict())
     newFriendRequest.set('status', 'FRIEND_REQUEST', True)
     
     newIndexerFriendRequest = Node({}, destNode.get('data/identity'), destNode.getFriendPublicKeysDict())
     newIndexerFriendRequest.set('public_key', newFriendRequest.get('public_key'))
     newIndexerFriendRequest.set('private_key', newFriendRequest.get('private_key'))
     
     #checks to see if the user has already "friended" this indexer
     res = self.col.find({ '$and' : [{'public_key':destNode.get('public_key')},{'data.friends.data.friends.public_key':newFriendRequest.getFriendPublicKeysDict()[0]['public_key']}]})
     if not res.count():
         newFriendRequest.replaceIdentityOfFriendsWithPubKeys()
         destNode.add('data/friends', newFriendRequest.get())
         destNode.save()
     
     #checks to see if the indexer has already "friended" this user
     res = self.col.find({ '$and': [{'public_key':sourceNode.get('public_key')},{'data.friends.data.friends.public_key':newIndexerFriendRequest.getFriendPublicKeysDict()[0]['public_key']}]})
     if not res.count():
         newIndexerFriendRequest.replaceIdentityOfFriendsWithPubKeys()
         sourceNode.add('data/friends', newIndexerFriendRequest.get())
         sourceNode.save()

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
 def forceJoinNodes(self, sourceNode, destNode):
     
     newFriendRequest = Node({}, sourceNode.get('data/identity'), sourceNode.getFriendPublicKeysDict())
     newFriendRequest.set('status', 'FRIEND_REQUEST', True)
     
     newIndexerFriendRequest = Node({}, destNode.get('data/identity'), destNode.getFriendPublicKeysDict())
     newIndexerFriendRequest.set('public_key', newFriendRequest.get('public_key'))
     newIndexerFriendRequest.set('private_key', newFriendRequest.get('private_key'))
     
     #checks to see if the user has already "friended" this indexer
     res = destNode.matchFriend(sourceNode)
     if not res:
         newFriendRequest.replaceIdentityOfFriendsWithPubKeys()
         destNode.add('data/friends', newFriendRequest.get())
         destNode.save()
     
     #checks to see if the indexer has already "friended" this user
     res = sourceNode.matchFriend(destNode)
     if not res:
         newIndexerFriendRequest.replaceIdentityOfFriendsWithPubKeys()
         sourceNode.add('data/friends', newIndexerFriendRequest.get())
         sourceNode.save()
     
     return newFriendRequest.get()

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
 def routeRequestForNode(self, destNode, destinationPublicKey, name='new friend', avatar=''):
     
     newFriend = Node({}, {'name':'Just created for the new keys'})
     
     selectedFriend = Node(self.node.getFriend(destinationPublicKey))
     selectedFriend.set('routed_public_key', destinationPublicKey, True)
     selectedFriend.set('public_key', newFriend.get('public_key'))
     selectedFriend.set('private_key', newFriend.get('private_key'))
     selectedFriend.setModifiedToNow()
     selectedFriend.set('source_indexer_key', destNode.get('public_key'), True)
     
     destNode.add('data/friends', selectedFriend.get())
     
     sourceNodeCopy = Node(copy.deepcopy(destNode.get()))
     sourceNodeCopy.set('routed_public_key', destinationPublicKey, True)
     sourceNodeCopy.set('source_indexer_key', destNode.get('public_key'), True)
     
     
     data = b64decode(encrypt(destNode.get('private_key'), 
                              destNode.get('private_key'), 
                              json.dumps(sourceNodeCopy.get())))
     
     self.node.updateFromNode(destNode.get(), preserve_key=selectedFriend.get('public_key'))
     self.updateRelationship(destNode)
     
     packet = self._buildPacket(destNode, destNode, data, status="ROUTED_FRIEND_REQUEST")
     
     self.handlePacket(json.loads(packet))
     
     return selectedFriend.get()

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
 def requestFriend(self, host, source_node = None, dest_node = None):
             
     #save the manager friend to the node
     friendPublicKey = unicode(uuid4())
     friendPrivateKey = unicode(uuid4())
     friendNode = Node({}, {"name" : "new manager" })
     friendNode.set('public_key', friendPublicKey)
     friendNode.set('private_key', friendPrivateKey)
     if source_node and dest_node:
         friendNode.set('source_node_key', source_node['public_key'], True)
         friendNode.set('dest_node_key', dest_node['public_key'], True)
     friendNode.add('data/identity/ip_address', self.node.createIPAddress(host))
     
     self.node.addFriend(friendNode.get())
     
     #build the friend request
     meToSend = Node(copy.deepcopy(self.node.get()))
     meToSend.set('public_key', friendPublicKey)
     meToSend.set('private_key', friendPrivateKey)
     if source_node and dest_node:
         meToSend.set('source_node_key', source_node['public_key'], True)
         meToSend.set('dest_node_key', dest_node['public_key'], True)
     friendNode.add('data/friends', meToSend.get())
     
     #send the friend request to the manager
     friendResponses = self._doRequest(meToSend, friendNode, json.dumps(meToSend.get()), status="FRIEND_REQUEST")
     for response in friendResponses:
         try:
             self.handlePacket(json.loads(response))
         except:
             print "Friend does not auto approve friend requests. There was no response from friend request."
     return friendNode

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
    def routeRequestThroughNode(self, destNode, destinationPublicKey, name='new friend', avatar=''):
        
        newFriend = Node({}, {'name':'Just created for the new keys'})
        
        selectedFriend = Node({}, {"name" : name, 'avatar': avatar})
                
        sourceNodeCopy = Node(copy.deepcopy(self.node.get()))
        sourceNodeCopy.add('data/friends', selectedFriend.get())
        sourceNodeCopy.set('routed_public_key', destinationPublicKey, True)

        selectedFriend.set('routed_public_key', destinationPublicKey, True)
        selectedFriend.set('public_key', newFriend.get('public_key'))
        selectedFriend.set('private_key', newFriend.get('private_key'))
        selectedFriend.setModifiedToNow()
        selectedFriend.set('source_indexer_key', destNode.get('public_key'), True)
        
        self.node.addFriend(selectedFriend.get())
        self.node.add('data/friends', selectedFriend.get())
        self.updateRelationship(destNode)
        
        sourceNodeCopy.set('public_key', newFriend.get('public_key'))
        sourceNodeCopy.set('private_key', newFriend.get('private_key'))
        
        sourceNodeCopy.set('source_indexer_key', destNode.get('public_key'), True)
        sourceNodeCopy.replaceIdentityOfFriendsWithPubKeys()
        
        data = b64decode(encrypt(destNode.get('private_key'), destNode.get('private_key'), json.dumps(sourceNodeCopy.get())))
        
        return self._doRequest(destNode, destNode, data, status="ROUTED_FRIEND_REQUEST")

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import set [as 别名]
 def updateFriendInIdentity(self, inbound, p):
     
     if not isinstance(inbound, Node):
         raise InvalidIdentity("inbound parameter not an instance of Identity class")
     
     if not isinstance(p, Node):
         raise InvalidIdentity("p parameter not an instance of Identity class")
     
     if 'status' in inbound.get() and inbound.get('status')=='FRIEND_REQUEST':
         inbound.delKey('status')
         
     if 'status' in inbound.get() and inbound.get('status')=='ROUTED_FRIEND_REQUEST':
         pass
     
     friend = Node(p.getFriend(inbound.get('public_key')))
             
     if 'permissions' in inbound.get():
         if not 'permissions' in friend.get():
             friend.set('permissions_approved', "0", True)
             friend.set('permissions', inbound.get('permissions'))
         else:
             if set(inbound.get('permissions')) != set(friend.get('permissions')):
                 friend.set('permissions_approved', "0")
                 friend.set('permissions', inbound['permissions'])
                 
     if not 'modified' in friend.get() or float(friend.get('modified')) < float(inbound.get('modified')):
         friend.set('data', inbound.get('data'))
         if "web_token" in inbound.get():
             friend.set('web_token', inbound.get('web_token'))
         self.updateManagedNode(p)
     p.updateFriend(inbound)