Python Node.get方法代码示例

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [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 get [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)

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [as 别名]
 def syncManagedNode(self, node):
     for managedNode in self.get('data/managed_nodes'):
         managedNode = Node(managedNode)
         if managedNode.get('public_key') == node.get('public_key'):
             managedNode.sync(node.get())
             self.save()
             return managedNode.get()
     return None

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [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 get [as 别名]
 def getFriend(self, public_key):
     friend = self.db.friends.find({'public_key': self.get('public_key'), 'friend_public_key': public_key}, {'friend': 1})
         
     if friend.count() > 0:
         return friend[0]['friend']
     else:
         try:
             friend = Node({}, {'name': 'temp'})
             friend.get().update(self.publicKeyLookup(public_key)[0])
             return self.db.friends.find({'public_key': friend.get('public_key'), 'friend_public_key': public_key}, {'friend': 1})[0]['friend']
         except:
             return []

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [as 别名]
 def handleFriendRequest(self, packet):
     
     friendRequest = Node(packet)
     
     if 'routed_public_key' in packet:
         node = self.matchFriend(friendRequest)
         managedNodeRelationship = self.publicKeyLookup(packet['routed_public_key'])
         node = self.chooseRelationshipNode(managedNodeRelationship, self.get(), impersonate = True)
         node = self.getClassInstanceFromNodeForNode(node.get())
         node.addFriendRequest(friendRequest.get())
     else:
         self.addFriend(copy.deepcopy(friendRequest.get()))
         logging.debug('added new friend to friends list')
     return super(YadaServer, self).respondWithRelationship(friendRequest)

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [as 别名]
 def chooseRelationshipNode(self, relationship, inboundNode, impersonate = False):
     
     r = relationship
     
     if len(r) == 1:
         return self.getClassInstanceFromNodeForNode(Node(r[0]).get())
             
     #this or clause is only for the case where yada server is in the friendship and 
     #the managed node only has yada server as a friend
         
     if Node(r[0]).get('public_key') == self.get('public_key'):
         server = r[0]
         managedNode = r[1]
     else:
         server = r[1]
         managedNode = r[0]
     
     if len(Node(managedNode).get('data/friends')) == 1:
         if len(inboundNode.get('data/friends')) == 1:
             if impersonate:
                 return self.getClassInstanceFromNodeForNode(Node(managedNode).get())
             else:
                 return self.getClassInstanceFromNodeForNode(Node(server).get())
         else:
             if impersonate:
                 return self.getClassInstanceFromNodeForNode(Node(server).get())
             else:
                 return self.getClassInstanceFromNodeForNode(Node(managedNode).get())
                     
     
     for node in r:
         p = Node(node)
         
         intersection = set([x['public_key'] for x in p.getFriendPublicKeyList()]) & set([x['public_key'] for x in inboundNode.get('data/friends')])
         
         if impersonate:
             if len(intersection) > 1:
                 return self.getClassInstanceFromNodeForNode(p.get())
         else:
             if len(intersection) == 1:
                 return self.getClassInstanceFromNodeForNode(p.get())
     
     for node in r:
         p = Node(node)
         
         if p.get('public_key') != inboundNode.get('public_key'):
             return self.getClassInstanceFromNodeForNode(p.get())

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [as 别名]
 def syncManagedNode(self, node):
     try:
         managedNode = Node(self.getManagedNode(node.get('public_key')))
         managedNode.sync(node.get())
         managedNode.save()
         return managedNode.get()
     except:
         raise InvalidIdentity("cannot sync invalid node in managed nodes")

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [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 get [as 别名]
 def addManagedNode(self, data):
     try:
         #using node class to validate the node data before inserting it into managed users
         node = Node(data)
         #adding user to the database
         self.add('data/managed_nodes', node.get())
         self.save()
     except:
         raise InvalidIdentity("cannot add invalid node to managed nodes")

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [as 别名]
 def chooseRelationshipNode(self, r, inboundNode, impersonate = False):
     
     node0 = Node({}, {'name': '0'})
     node1 = Node({}, {'name': '1'})
     
     result = self.db.managed.find({"friend_public_key" : {"$in": inboundNode.getFriendPublicKeysArray()}})
     
     if r.count() == 1:
         if result.count() == 0: #inbound is not hosted here
             node0.get().update(r[0]) #here we hard-coded to return node0, so we have to make sure the node we return is not the inbound
             return node0
     
     if r.count() == 2:
         node0.get().update(r[0])
         node1.get().update(r[1])
         
         if result.count() == 1: #inbound is hosted here
             if r[0]['public_key'] == self.get('public_key'): #is this node the server
                 return node0 #we return the server because now we know inbound is not the server because result is not empty
             elif r[1]['public_key'] == self.get('public_key'): #is this node the server
                 return  node1 #we return the server because now we know inbound is not the server because result is not empty
             elif r[0]['public_key'] == result[0]['managed_public_key']: #neither node is the server 
                 return node1
             elif r[1]['public_key'] == result[0]['managed_public_key']: #neither node is the server
                 return node0
         else: #inbound is not hosted here
             if r[0]['public_key'] == self.get('public_key'): #is this node the server
                 return node0 #we return the server because now we know inbound is not the server because result is not empty
             elif r[1]['public_key'] == self.get('public_key'): #is this node the server
                 return  node1 #we return the server because now we know inbound is not the server because result is not empty

# 需要导入模块: from node import Node [as 别名]
# 或者: from node.Node import get [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 get [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 get [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 get [as 别名]
 def hostedUserUpdate(self, jsonDict, request=None):
     idQuery = self.getManagedNode(jsonDict['public_key'])
     #check to see if a hosted user is trying to replicate self
     if idQuery:
                     
         id = Node(idQuery)#p
         decryptedIncomingIdentity = decrypt(id.get('private_key'), id.get('private_key') ,jsonDict['data'].replace(' ', '+'))
         incomingId = Node(json.loads(decryptedIncomingIdentity))#user
         
         InternalId = Node(self.getManagedNode(id.get('public_key')))#data
         if InternalId.get():
             try:
                 InternalId.dedupIP()
             except:
                 logging.warning("an error occured when running dedupIP() method")
             InternalId.sync(incomingId.get(), True, {})
         self.updateManagedNode(InternalId)
     elif jsonDict.get('status', None) and jsonDict['status'] == "MANAGE_REQUEST":
         #replace spaces with plus symbols, this was a problem early on
         data = b64decode(jsonDict['data'].replace(' ', '+'))
         #attemped to load data into memory structure
         data = json.loads(data)
         self.addManagedNode(data)
         return "node is now managed by this node manager"