示例#1
0
 def test_account(self):
     proxy_id = get_proxy_id()
     self.assertIsNotNone(proxy_id)
     test_data = 'test string'
     sign_data = sign_proxy_data(test_data)
     data = derive_proxy_data(sign_data)
     self.assertEqual(data, test_data)
示例#2
0
 def get_key_done(future):
     value = future.result()
     self.stop()
     if value:
         addr = derive_proxy_data(value)
         d.callback(tuple(addr.split(',')))
     else:
         d.callback(None)
示例#3
0
    def datagramReceived(self, data, addr):
        msg = msgpack.unpackb(data, raw=False)

        try:
            if msg['type']:
                pass
        except:
            logger.debug("receive wrong message %s from %s" % (str(msg), str(addr)))
            return

        if msg['type'] == 'bootstrap':
            tid = msg['tid']
            sign_tid = msg['sign_tid']

            if tid != derive_proxy_data(sign_tid):
                error = 'wrong signature'
                logger.debug(error)
                response = {
                    'type': 'response',
                    'tid': tid,
                    'data': error
                }

            else:
                peer_ip = (msg['peer_ip'] or addr[0], addr[1])
                peer_id = msg['peer_id']
                peer_info = msg['peer_info']
                peer_conf = msg['peer_conf']

                peer = {
                    'addr': peer_ip,
                    'peer_info': peer_info,
                    'ts': time.time()
                }

                self.peers[peer_id] = peer
                self.peers_lat[peer_id] = 0  # initialize
                self.peers_conf[peer_id] = peer_conf

                response = {
                    'type': 'response',
                    'tid': tid,
                    'data': "bootstrap"
                }
                logger.debug("add peer %s at %s" % (peer_id, str(peer['addr'])))

            self.send_msg(response, addr)

        elif msg['type'] == 'ping':
            tid = msg['tid']

            response = {
                'type': 'response',
                'tid': tid,
                'data': 'pong'
            }
            self.send_msg(response, addr)

        elif msg['type'] == 'pick_peer':
            tid = msg['tid']
            sysconf = msg['sysconf']

            pick_peer = None

            if sysconf:
                pick_peer = search_peer(sysconf, self.peers_conf)
            elif self.peers_lat:
                peer_id = min(self.peers_lat.items(), key=operator.itemgetter(1))[0]
                peer = self.peers[peer_id]
                pick_peer = peer_id

            response = {
                'type': 'response',
                'tid': tid,
                'data': pick_peer
            }

            logger.debug("pick peer %s to %s" % (pick_peer, str(addr)))
            self.send_msg(response, addr)

        elif msg['type'] == 'get_peer':
            tid = msg['tid']
            peer_id = msg['peer_id']

            pick_peer = None
            if peer_id in self.peers:
                peer = self.peers[peer_id]
                pick_peer = (peer['addr'][0], peer['peer_info'])

            response = {
                'type': 'response',
                'tid': tid,
                'data': pick_peer
            }

            logger.debug("get peer %s at %s for %s" % \
                            (peer_id, str(pick_peer), str(addr)))
            self.send_msg(response, addr)

        elif msg['type'] == 'response':
            tid = msg['tid']
            data = msg['data']
            self.accept_response(tid, data)

        else:
            logger.debug("receive wrong message %s from %s" % (str(msg), str(addr)))