def room_rendezvous(self, message_type, room_name_1): client = clt.Client() if (message_type == "host"): self.ip_port_seed = client.init_client( consts.ASK_HOST, room_name=room_name_1, seed=numpy.random.randint(9)) self.myTurn = True self.peer = peer.Peer(server_port=self.ip_port_seed[1], my_port=self.ip_port_seed[1]) self.peer.client_peer.active = True self.peer.server_peer.active = True elif (room_name_1 == ""): self.ip_port_seed = client.init_client(consts.ASK_ANY_OPP, room_name="") self.myTurn = False self.peer = peer.Peer(my_ip=self.ip_port_seed[0], server_port=self.ip_port_seed[1], my_port=self.ip_port_seed[1], listening=False) else: self.ip_port_seed = client.init_client(consts.ASK_ESP_OPP, room_name=room_name_1) self.myTurn = False self.peer = peer.Peer(my_ip=self.ip_port_seed[0], server_port=self.ip_port_seed[1], my_port=self.ip_port_seed[1], listening=False) self.deck = deck.Deck(self.ip_port_seed[2]) self.room_ui.room_window.hide() self.ui.main_window.show() self.ui.set_all_buttons(self.myTurn) self.play_control()
def online_vs(): """ Sig: None Pre: None Post: A game played between against a remote player """ while True: name, human = get_online_name() choice = input("Are you the first to start the game? [" + g.color("G", "Y") + "]es [" \ + g.color("R", "N") + "]no\n[" + g.color("R", "Q") + "]uit ") if choice == "Y" or choice == "y": # Create peer which will act as server c = peer.Peer(True) c.accept_client() while True: # Name, peer, Human, Server win = game.online_vs(name, c, human, True) win = playOnlineVersusTournament(True, c, name, 'test') if win != "DRAW": break else: g.make_header("Game draw! Replay game") if win == name: g.make_header("You've won!") else: g.make_header("You've lost!") c.teardown() break elif choice == "N" or choice == "n": # Create peer which will act as client c = peer.Peer(False) c.connect_to_server() while True: # Name, peer, Human, Server win = game.online_vs(name, c, human, False) if win != "DRAW": break else: g.make_header("Game draw! Replay game") # Name, peer, Human = True, Server = False if win == name: g.make_header("You've won!") else: g.make_header("You've lost!") c.teardown() break elif choice == "Q" or choice == "q": sys.exit() else: print("Invalid choice, try again")
def updatePeerList(self, peers): offset = 0 updatedPeerList = [] while offset < len(peers): # Unpack bytes for IP from byte-string, as big-endian integers and get the first element from the tuple ip_unpacked = struct.unpack_from("!i", peers, offset)[0] # Pack read bytes into a single IP and convert to standard 32-bit IP notation ip = socket.inet_ntoa(struct.pack("!i", ip_unpacked)) # Update offset to read the corresponding port offset += 4 # Unpack bytes for port and join them as Big-endian uint16 to form port port = struct.unpack_from("!H", peers, offset)[0] # Update offset for next peer offset += 2 # Add parsed peer to peerlist newpeer = p.Peer(ip, port, self.tManager, self) if (newpeer not in updatedPeerList and newpeer not in self.activePeerList): updatedPeerList.append(newpeer) self.peerList = updatedPeerList """ Implementer's Note: Even 30 peers is plenty, the official client version 3 in fact only actively forms new connections if it has less than 30 peers and will refuse connections if it has 55. """ # Start thread for all peers for index in range(len(self.peerList)): self.threadFutures.append( self.executor.submit(self.peerList[index].mainLoop))
def add_peers(time, peer_id_batch, all_peers, env, logger, network, all_query_groups, all_prefixes, settings, override_settings, sync_groups, query_group_id): if ('id_length' in override_settings or 'prefix_length' in override_settings or 'initial_reputation' in override_settings or 'max_desired_group_size' in override_settings or 'reward_attenuation' in override_settings or 'no_penalty_reputation' in override_settings or 'timeout_query_penalty' in override_settings or 'failed_query_penalty' in override_settings or 'successful_query_reward' in override_settings): raise Exception('Can\'t override settings that have to be the same for' ' all peers.') peer_settings = copy.deepcopy(settings) peer_settings.update(override_settings) added_peers = [] for peer_id in peer_id_batch: peer = p.Peer(env, logger, network, peer_id, all_query_groups, all_prefixes, peer_settings) all_peers[peer_id] = peer added_peers.append(peer) prefix = peer_id[:settings['prefix_length']] sync_groups.setdefault(prefix, util.SortedIterSet()).add(peer) all_prefixes.setdefault(prefix, 0) all_prefixes[prefix] += 1 env.process(request_generator(env, all_peers, peer)) logger.log(an.PeerAdd(env.now, peer.peer_id, peer.prefix, None)) logger.log( an.UncoveredSubprefixes( env.now, peer.peer_id, util.SortedIterSet(peer.uncovered_subprefixes()), None)) for sync_peer in sync_groups[prefix]: peer.introduce(sync_peer.info()) sync_peer.introduce(peer.info()) if settings['force_one_group']: assert query_group_id is not None for peer in added_peers: query_group = all_query_groups[query_group_id] query_group[peer.peer_id] = p.QueryPeerInfo( peer.info(), settings['initial_reputation']) peer.query_groups[query_group_id] = copy.deepcopy(query_group) for qpi in query_group.infos(): all_peers[qpi.peer_id]\ .query_groups[query_group_id][peer.peer_id]\ = p.QueryPeerInfo(peer.info(), settings['initial_reputation']) logger.log( an.QueryGroupAdd(time, peer.peer_id, query_group_id, None)) else: assert query_group_id is None for peer in added_peers: for other_peer in random.sample( list(all_peers.values()), settings['num_random_introductions']): peer.introduce(other_peer.info()) for peer in added_peers: peer.start_missing_query_peer_search()
def test_init(self): # must return empty peer_o = peer.Peer(table_id, peer_id, invalid_host, invalid_port, timestamp) self.assertEqual(peer_o.ts, timestamp) self.assertEqual(peer_o.table_id, table_id) self.assertEqual(peer_o.peer_id, peer_id) self.assertEqual(peer_o.host, invalid_host) self.assertEqual(peer_o.port, invalid_port)
def connect_peers(self): for sock_addr in self.addresses: new_peer = peer.Peer(int(self.torrent.number_of_pieces), sock_addr[0], sock_addr[1]) if not new_peer.connect(): continue print('Connected to ', (len(self.connected_peers))) self.connected_peers[new_peer.__hash__()] = new_peer if len(self.connected_peers) > 2: break
def _create_server_protocol(self): ph = mn1.SshServerProtocol(self.loop) ph.server_key = self.node.node_key p = mnpeer.Peer(self) p.protocol = ph # self.pending_connections.append(p) return ph
def peer_with_prefix(self, prefix_str, start_processes=False): peer_id = self.id_with_prefix(prefix_str) peer = p.Peer(self.env, self.logger, self.network, peer_id, self.all_query_groups, self.all_prefixes, self.settings, start_processes) self.all_sync_groups.setdefault(peer.prefix, set()).add(peer) for sync_peer in self.all_sync_groups[peer.prefix]: sync_peer.introduce(peer.info()) peer.introduce(sync_peer.info()) return peer
def try_peer_connect(self): for ip, port in self.list_ip_port: print '> len connected_peers : ', len(self.connected_peers) if len(self.connected_peers) > 8: break if not ip in self.banned_ips: new_peer = peer.Peer(self.torrent, ip, port) if not new_peer.connect(): self.banned_ips.append(ip) else: self.connected_peers.append(new_peer)
def run_client(): c = peer.Peer(False) c.connect_to_server() data = c.receive() c.send(data) data = c.receive() c.send(data) data = c.receive() c.send(data) c.teardown() return
def initpeer(self, sock): ''' Creates a new peer object for a nvalid socket and adds it to reactor's listen list ''' location_json = requests.request( "GET", "http://freegeoip.net/json/" + sock.getpeername()[0]).content location = json.loads(location_json) tpeer = peer.Peer(sock, self.reactor, self, location) self.peer_dict[sock] = tpeer self.reactor.select_list.append(tpeer)
def try_peer_connect(self): logging.info("Trying to connect to %d peer(s)" % len(self.dict_sock_addr)) for _, sock_addr in self.dict_sock_addr.items(): if len(self.connected_peers) >= MAX_PEERS_CONNECTED: break new_peer = peer.Peer(int(self.torrent.number_of_pieces), sock_addr.ip, sock_addr.port) if not new_peer.connect(): continue print('Connected to %d/%d peers' % (len(self.connected_peers), MAX_PEERS_CONNECTED)) self.connected_peers[new_peer.__hash__()] = new_peer
def client_side_tournament(): """ Sig: None Pre: None Post: A tournament played between local, and remote players. And termination of program """ # Setup c = peer.Peer(False) c.connect_to_server() player_list, human_dict = decide_online_tour_players(c, True) # Sync player lists c.send(player_list) player_list = c.receive() c.send(human_dict) human_dict = c.receive() c.send("ACK") # Sync with remote data = c.receive() # Get initial tournament bracket while True: g.make_header("Tournament Standings") print(data["tour"]) # End tournament if data["instruction"] == "COMPLETE": g.make_header(data["player"] + " has won the tournament!") c.teardown() sys.exit() elif data["instruction"] == "PLAY": players = data["players"] g.make_header("Up next: Local " + players[1] + " vs remote " + players[0]) while True: winner = game.online_vs(players[1], c, human_dict[players[1]], False) if winner != "DRAW": break else: g.make_header("Game draw! Replay game") if winner == players[1]: # If local player won g.make_header(winner + " has advanced to the next round!") else: # If remote player won g.make_header(players[0] + " has advanced to the next round!") data = c.receive()
def send_handshake(self, host, port): handshake = self.generate_handshake() sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((host, port)) sock.send(handshake) data = sock.recv(len(handshake)) try: data = sock.recv(68) # Peer response handshake if data: print(data) peer_id = md5(host.encode() + str(port).encode()).hexdigest() temp_peer = pr.Peer(sock, self, peer_id) self.peer_dict[peer_id] = temp_peer # TODO: handshake completed initiate download after this. except: print("ERROR: Did not recieve proper return handshake from peer")
def test_data_integrity(self): s = peer.Peer(True) t = Thread(target=run_client, args=()) t.start() time.sleep(0.2) s.accept_client() data_orig = [1,2,3] s.send(data_orig) data = s.receive() self.assertEqual(data, data_orig) data_orig = "test string" s.send(data_orig) data = s.receive() self.assertEqual(data, data_orig) data_orig = 123 s.send(data_orig) data = s.receive() self.assertEqual(data, data_orig) s.teardown()
def server_side_tournament(): """ Sig: None Pre: None Post: A tournament played between local, and remote players. And termination of program Notes ----- If multiple messages are sent in a row without being received, they will be concatenated in the pipeline \ and the receiving end will be unable to process the message. Therefor it is sometime needed to send \ junk messages to sync the clients """ # Setup c = peer.Peer(True) c.accept_client() player_list, human_dict = decide_online_tour_players(c, False) print("Waiting for remote list of players...") # Sync player lists remote_player_list = c.receive() player_list = player_list + remote_player_list c.send(player_list) remote_human_dict = c.receive() human_dict.update(remote_human_dict) c.send(human_dict) c.receive() # Block needed here to ensure clients are synced # Create tournament and setup instructions t = tour.Tournament(player_list) data = {} # Dictionary containing various data needed by remote peer data["instruction"] = None # Instructions in the form of strings data["players"] = None # players to play next game data["tour"] = t.get_scoreboard( ) # String representing current tournament bracket c.send(data) # Send initial tournament bracket winner = "" while True: g.make_header("Tournament Standings") data["tour"] = t.get_scoreboard() print(data["tour"]) end = t.winner_state players = t.opponents winners = [] # Completed tournament if end == 1: data["instruction"] = "COMPLETE" data["player"] = winner c.send(data) g.make_header(winner + " Has won the tournament!") c.teardown() sys.exit() else: # Setup game g.make_header("Up next: Local " + players[0] + " vs remote " + players[1]) data["players"] = players data["instruction"] = "PLAY" c.send(data) while True: winner = game.online_vs(players[0], c, human_dict[players[0]], True) if winner != "DRAW": break else: g.make_header("Game draw! Replay game") if winner == players[0]: # If local player won winners.append(winner) g.make_header(winner + " has advanced to the next round!") else: # If remote player won winner = players[1] winners.append(winner) g.make_header(winner + " has advanced to the next round!") t.next_game(winner)
__author__ = 'ohell_000' import socket import threading import start import peer s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(('', 51234)) s.listen(4) lock = threading.Lock() start.start_game() while True: temp_socket, temp_address = s.accept() peer.Peer(temp_socket, temp_address, lock).start() s.close()
# Pieces being downloaded, randomly choose up to 5 pieces in_progress = [] num_prog = min(5, torrent.num_pieces) for i in range(num_prog): r = random.randint(0, torrent.num_pieces - 1) while r in in_progress: r = random.randint(0, torrent.num_pieces - 1) in_progress.append(r) # Actual data received from peers data = {} for f in in_progress: data[f] = '' # This is for testing purposes, I'll have to figure out how to properly get this started again sometime p = peer.Peer('192.168.2.3', 6889, torrent.num_pieces, torrent.piece_len) peers.append(p) # Map ips to peers for peer in peers: addr_to_peer[peer.ip] = peer # Get info_hash hash = hashlib.sha1() bencoded_info = bencode.bencode(torrent.info) hash.update(bencoded_info) info_hash = hash.digest() # Start listening for incoming connections listen_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) listen_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) own_ip = socket.gethostbyname(socket.gethostname())
import config import peer if __name__ == "__main__": cfg = config.Config("Common.cfg") with open('PeerInfo.txt', 'r') as f: peer_info = [] for line in f.readlines(): [peer_id, hostname, port, has_file] = line.strip().split(' ') port = int(port) peer_ = peer.Peer(int(peer_id), hostname, port, int(has_file), cfg, peer_info) peer_.start() peer_info.append((hostname, port))
NUM_PEERS = 1 SIM_DURATION = 1000 # create env env = simpy.Environment() # network net = network.Network(env,2) #create peers nodes = [] teste = env.timeout(200) proc_0 = processor.Processor(env, 0, 3) dri_0 = driver.Driver(net, proc_0) peer_0 = peer.Peer(dri_0, 0) env.process(dri_0.run()) env.process(peer_0.wait_then_publish_message('TEST', 'Hello World!', 100)) proc_1 = processor.Processor(env, 1, 3) dri_1 = driver.Driver(net, proc_1) peer_1 = peer.Peer(dri_1, 1) env.process(dri_1.run()) env.process(peer_1.dds_read_test()) env.run(until=SIM_DURATION)
""" This is a peer-to-peer connection. """ import peer if __name__ == '__main__': user = peer.Peer()
def _connect_peer(self, dbpeer): if log.isEnabledFor(logging.INFO): log.info("Connecting to peer (id={}, addr=[{}])."\ .format(dbpeer.id, dbpeer.address)) address = dbpeer.address p0 = address.rindex(':') host = address[:p0] port = address[p0 + 1:] peer = mnpeer.Peer(self, dbpeer) if self.node.tormode: peer.address = dbpeer.address client = self.loop.create_connection(\ partial(self._create_client_protocol, peer),\ host, port) def dbcall(dbpeer): with self.node.db.open_session() as sess: self.node.db.lock_table(sess, Peer) dbpeer = sess.query(Peer).get(dbpeer.id) if dbpeer.connected: if log.isEnabledFor(logging.DEBUG): log.debug(\ "Peer [{}] connected to us in the mean time."\ .format(dbpeer.id)) return False dbpeer.connected = True dbpeer.last_connect_attempt = mutil.utc_datetime() sess.commit() return True r = yield from self.loop.run_in_executor(None, dbcall, dbpeer) if not r: if peer.protocol: peer.protocol.close() return None try: yield from client except Exception as ex: log.info("Connection to Peer (dbid=[{}]) failed: {}: {}"\ .format(dbpeer.id, type(ex), ex)) # An exception on connect; update db, Etc. def dbcall(dbpeer): with self.node.db.open_session() as sess: dbpeer = sess.query(Peer).get(dbpeer.id) dbpeer.connected = False sess.commit() yield from self.loop.run_in_executor(None, dbcall, dbpeer) if peer.protocol: peer.protocol.close() return None if dbpeer.node_id: if not self.add_to_peers(peer): log.warning("Already connected to Peer (id={})."\ .format(peer.dbid)) peer.protocol.close() return None return peer
handlers = [console_handler] logging.basicConfig(level = logging.INFO, format = '[%(levelname)s] [%(module)10s] %(message)s', handlers = handlers ) NUM_PEERS = 2 SIM_DURATION = 300 # create env env = simpy.Environment() # network net = network.Network(env,2) #create peers nodes = [] teste = env.timeout(200) for i in range (NUM_PEERS): proc = processor.Processor(env, i, 3) dri = driver.Driver(net, proc) new_peer = peer.Peer(dri, i) nodes.append(new_peer) env.process(dri.run()) env.run(until=SIM_DURATION)
if o['_class'] == 'KBucket': bucket = KBucket(o['prefix']) for x in o['peers']: bucket.append(x) return bucket else: return peer.Peer.JSONDecode(o) if __name__ == '__main__': import keystore import peer import json bucket = KBucket('') for x in range(20): d = keystore.Keystore() p = peer.Peer(d.addr,d.pk) bucket.append(p) print(len(bucket)) s = json.dumps(bucket, indent = 4, default = KBucket.JSONEncode) # print(s) # b = json.loads(s,object_hook = KBucket.JSONDecode) print(vars(b)) # p = json.dumps(bucket.getK(10),indent = 4,default = KBucketJSONEncode) # print(p) #R = bucket.split() #print(json.dumps(bucket,indent = 4, default = KBucketJSONEncode)) #print('---------------------------------------------------------') #print(json.dumps(R,indent = 4, default = KBucketJSONEncode)) #print('---------------------------------------------------------')
def playOnlineVersus(host, player1, player2): running = True connection = peer.Peer(host) board = boardLogic.createBoard() pieces = boardLogic.createPieces() firstTurn = True if (host): turn = Turn.PLAYER connection.accept_client() # First turn (just handing a piece) prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) prints.printPieceToGive(pieces) piece = userInput.askForPiece(pieces) turn = Turn.OPPONENT connection.send([piece, pieces, board]) firstTurn = False else: turn = Turn.OPPONENT connection.connect_to_server() prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) while (running): if (firstTurn): [piece, pieces, board] = connection.receive() turn = Turn.PLAYER prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) #Show given piece and place it prints.printPieceToPlace(piece, turn) coords = userInput.askWhereToPlace(board) boardLogic.updateBoard(board, piece, int(coords[0]), int(coords[1])) connection.send([piece, pieces, board]) # Pick a piece for opponent prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) prints.printPieceToGive(pieces) piece = userInput.askForPiece(pieces) connection.send([piece, pieces, board]) firstTurn = False turn = Turn.OPPONENT else: turn = Turn.OPPONENT prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) [piece, pieces, board] = connection.receive() boardLogic.endGame(board, piece, turn, player1, player2) prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) [piece, pieces, board] = connection.receive() turn = Turn.PLAYER # Show given piece, place it prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) prints.printPieceToPlace(piece, turn) coords = userInput.askWhereToPlace(board) boardLogic.updateBoard(board, piece, int(coords[0]), int(coords[1])) connection.send([piece, pieces, board]) boardLogic.endGame(board, piece, turn, player1, player2) # Pick a piece for opponent prints.printFancyBoard(board, turn, player1, player2) prints.printPieces(pieces) prints.printPieceToGive(pieces) piece = userInput.askForPiece(pieces) turn = Turn.OPPONENT connection.send([piece, pieces, board])
def __init__(self, pos_x, pos_y, index, mode, amount, cell_size_x=100, cell_size_y=100, dimension_x=20, dimension_y=20, v=20): self.stream_pos = False # For logging results. self.amount = amount self.mode = mode # Index of the vehicle (for separate connections). self.index = index # Position and velocity relative to coordinate system. self.pos = Vec2(pos_x, pos_y) self.v = v # Goal position in coordinates. self.goal = Vec2(pos_x, pos_y) # Sockets for transmitting position information and receiving destinations. self.sender = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sender.settimeout(None) while True: try: self.sender.connect(('127.0.0.1', 500 + self.index)) except socket.error as e: #print(self.index, end=': ') #print(e) continue break # Receive pos and goal from socket. self.receiver = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.receiver.bind(('127.0.0.1', 100 + self.index)) self.receiver_thread = threading.Thread(target=self.receiver_function) self.receiver_thread.start() self.receiver_thread.join() # Path in cells. self.cell_size = Vec2(cell_size_x, cell_size_y) self.cell = Vec2(math.floor(self.pos.x / self.cell_size.x), math.floor(self.pos.y / self.cell_size.y)) self.path = [] self.rented_path = [] self.dimensions = Vec2(dimension_x + 5, dimension_y + 5) self.rent_thread = threading.Thread() self.time_per_cell = 60 # Peer object for V2V communication. self.peer = peer.Peer(self.index, self.mode) self.done = False self.rent_done = False if not self.mode == 3: self.create_path(self.goal.x, self.goal.y) self.start_time = time.time() self.logged_time = False self.start_pos = self.pos
numpeer = 10000 #skala = 183*24*3600 #1/2 tahun * 366 hari * 24 jam * 3600 detik skala = 7 * 24 * 3600 expected = 360 #360 peer per hour multiple_of = range(100000) interval = (7200) counter = 0 TIMELINE_LENGTH = 24 * 3600 if __name__ == '__main__': # generate peers peer_list = [] for p in range(numpeer): np = peer.Peer(p, this_cdn, cache_size, upload_bw, download_bw) peer_list.append(np) this_cdn.set_peer_list(peer_list) print 'masuk generate request' # generate request events #request_events = shelve.open('request_events-3600-60') #for k in request_events: # del request_events[k] #request_events.sync() #request_events['heads'] = [0] #request_events['0'] = [] request_list_size = 0 skala = int(skala)
def __init__(self, file_name, destination): self.file_name = file_name self.destination = destination self.metafile_dict = {} self.info_dict = OrderedDict( ) # OrderedDict is mandatory to get correct value of info_dict_hash self.request_parameters = {} self.tracker_response_dict = {} self.peer_ips = [] self.peer_table = { } # Dictionary with key being peer's ip address and value being 'peer' object self.conn_table = { } # Dictionary with key being 'client_address' and value being 'connection' socket object self.ip = get_my_ip() self.port = MY_PORT # Hard coded for the sake of testing self.output_files = [] self.response = None self.response_string = '' self.metafile = open(file_name, 'r', encoding="ISO-8859-1") if self.metafile.read(1) == 'd': print("Parsing metafile") self.metafile_dict = parser.get_dict(self.metafile) print("Parsing metafile complete") self.metafile.close() self.info_dict = self.metafile_dict['info'] self.info_dict_hash = hashlib.sha1( parser.bencode_dict(self.info_dict).encode('utf-8')).digest() self.peer_id = "piTorrentTestPeer001" if len(self.peer_id) > 20: self.peer_id = self.peer_id[:20] else: while len(self.peer_id) != 20: self.peer_id += '0' self.send_tracker_request() if 'peers' in self.tracker_response_dict: self.get_peers() else: print("Tracker returned no peers") return if self.peer_ips: for i in self.peer_ips: self.peer_table[i[0]] = peer.Peer(i[0], i[1], self.info_dict_hash, self.peer_id) print('Peers dict is', self.peer_table) else: print("No peers found to start handshake") return self.create_empty_files() self.listener_object = listener.Listener(self.ip, self.port, self.info_dict_hash, self.peer_table, self.conn_table) listen_thread = threading.Thread( target=self.listener_object.listen_for_peers) listen_thread.daemon = False # [TODO] Getting some weird error when made True listen_thread.start() for address, peer_object in self.peer_table.items(): peer_object.handshake()