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()
