def get_msg():
t = Torrent('../torrent/flagfromserver.torrent')
t.make_request()
# make request, get response, handle response
r = requests.get(t.request)
rh = ResponseHandler(r)
rh.get_peer_ip()
# get handshake
h = Handshake(t)
#pick ip and port from peers
ip = rh.ips[-1][0]
port = rh.ips[-1][1]
# socket connection and send data
s = socket.socket()
s.connect((ip, port))
s.sendall(str(h))
# receive data back and pretty print
recv = s.recv(100)
print 'Handshake received: %s' % (recv.__repr__(), )
s.sendall(send_interested())
recv = s.recv(10000)
prefix, message = message_decode(recv)
return recv
def _getTorrentObj(self, torrentId):
failureMsg = None
torrent = None
#try to load torrent data from the usual place
torrentFilePath = self._getTorrentFilePath(torrentId)
self.log.debug('Torrent %i: trying to read torrent data from "%s"', torrentId, torrentFilePath)
try:
fl = open(torrentFilePath, 'rb')
with fl:
torrentFileData = fl.read()
except (IOError, OSError):
failureMsg = 'Could not read torrent file from "%s"' % encodeStrForPrinting(torrentFilePath)
if failureMsg is None:
#successfully read the torrent data
self.log.debug('Torrent %i: trying to parse read torrent data', torrentId)
torrent = Torrent()
try:
torrent.load(torrentFileData)
except TorrentException, e:
failureMsg = e.reason
except:
async def testiz(path):
tor = Torrent(path)
print(tor.get_torrent_data())
print(tor.get_torrent_ind_size())
print(tor.get_torrent_piece_length())
print(tor.get_torrent_name().decode())
for tracker in tor.get_torrent_announce_list():
test_tracker = Tracker.Tracker_udp(tor, tracker[0])
try:
loop.run_until_complete(test_peer_comm(test_tracker))
break
except Exception as e:
print("tracker {0} did not work, exception was: {1}".format(tracker[0], e))
loop.close()
print("finishing")
def main():
if len(sys.argv) < 2 :
print "Illegal USAGE! USAGE : python driver.py <torrent_file> "
return
torrent_file = sys.argv[1]
if not os.path.exists(torrent_file):
print "Torrent File not exist! Quit "
return
file_to_write = open("test", "w+")
this_torrent = Torrent(torrent_file, file_to_write)
peer_list = this_torrent.get_peer_list()
print peer_list
this_factory = Factory(this_torrent)
thread.start_new_thread(disconnect_thread, (this_factory, "", ) )
thread.start_new_thread(connect_thread, (this_factory, peer_list, ) )
while 1:
input = raw_input('>')
cmd = input.split(' ')
cmd = cmd[0]
if cmd == 'help' or cmd == 'h' :
print "Valid commands: info, peers, status, quit"
elif cmd == 'info' or cmd == 'i' :
print "Torrent file's information: "
print " total length (in byte): ", this_torrent.length
print " total number of pieces: ", this_torrent.get_num_pieces()
print " total number of blocks: ", int(this_torrent.get_total_num_blocks())
elif cmd == 'peers' or cmd == 'p' :
print peer_list
elif cmd == 'status' or cmd == 's' :
this_torrent.get_statistics()
elif cmd == 'quit' or cmd == 'q' :
exit(1)
else:
print "Valid commands: info, peers, status, quit"
def __init__(self, addr, reactor):
'Initializes all the variables'
self.torrent = Torrent(addr, reactor)
n = 6
self.ips = []
for i in xrange(0, len(bs), n):
ip = '.'.join([str(b) for b in bs[i:i+n-2]])
port = bs[i+(n-2)] * 256 + bs[i+(n-1)]
self.ips.append((ip, port))
def __repr__(self):
print_fields = ['_content',
'ips',
'peers',
'status_code',
'url']
return '\n'.join(['%s:\t%r' % (field, getattr(self, field), ) for field in print_fields])
if __name__ == '__main__':
try:
filename = sys.argv[1]
except IndexError:
filename = '../torrent/flagfromserver.torrent'
#filename = '../torrent/linuxmint-16-cinnamon-dvd-64bit.torrent'
t = Torrent(filename)
t.make_request()
response = requests.get(t.request)
response_handler = ResponseHandler(response)
response_handler.get_peer_ip()
strSearchString = input()
print("Search String: " + strSearchString)
params = dict(
q = strSearchString,
field = "seeder",
sorter = "desc",
page = "1"
)
jsonReply = requests.get(url = rootURL, params=params).json()
searchResults = []
for searchResult in jsonReply["list"]:
searchResults.append(Torrent(searchResult))
table = []
counter = 1
for Torrent in searchResults:
table.append([str(counter) + ". " + Torrent.getTitle(), Torrent.getSeeders(), Torrent.getSizeInGB()])
counter+= 1
print(tabulate(table))
userInput = input(">> ")
myHash = searchResults[int(userInput) + 1].getHash()
# os.system("wget -O /tmp/tcli.torrent \"" + link + "\"")
try:
loop.run_until_complete(test_peer_comm(test_tracker))
break
except Exception as e:
print("tracker {0} did not work, exception was: {1}".format(tracker[0], e))
loop.close()
print("finishing")
if __name__ == '__main__':
loop = asyncio.get_event_loop()
# loop.set_debug(True)
# loop.slow_callback_duration = 0.001
# tor = Torrent("C:\\temp\\big-buck-bunny.torrent")
tor = Torrent("C:\\temp\\gimp.torrent")
print(tor.get_torrent_data())
print(tor.get_torrent_ind_size())
print(tor.get_torrent_piece_length())
print(tor.get_torrent_name().decode())
for tracker in tor.get_torrent_announce_list():
test_tracker = Tracker.Tracker_udp(tor, tracker[0])
try:
loop.run_until_complete(test_peer_comm(test_tracker))
break
except Exception as e:
print("tracker {0} did not work, exception was: {1}".format(tracker[0], e))
loop.close()
print("finishing")
# class test(Enum):
})
return response
def process_error(self, payload, trans):
message = struct.unpack("!8s", payload)
raise TrackerResponseException("Error Response: {0}".format(message))
if __name__ == '__main__':
loop = asyncio.get_event_loop()
# debugging
# loop.set_debug(True)
# loop.slow_callback_duration = 0.001
test_torrent = Torrent("C:\\temp\\wired-cd.torrent")
print(test_torrent.get_torrent_tracker())
print(test_torrent.get_torrent_name().decode())
for tracker in test_torrent.get_torrent_announce_list():
test_tracker = Tracker_udp(test_torrent, tracker[0])
try:
#loop.run_until_complete(test_tracker.request_peers_http())
#loop.run_until_complete(test_tracker.connect_udp())
#loop.run_until_complete(test_tracker.announce_udp())
#loop.run_until_complete(test_tracker.scrape_udp())
break
except Exception as e:
print("tracker {0} did not work, exception was: {1}".format(
tracker[0], e))
loop.close()
print("finishing")
nodes = [node1, node2, node3, node4, node5, node6]
for node in nodes:
network.addNode(node)
node1.join([], network)
node2.join([node1], network)
node3.join([node1, node2], network)
node4.join([node3, node2], network)
node5.join([node3, node1], network)
files = [os.path.basename(x) for x in glob.glob(f"{PATH}*.mp3")]
#popula com torrents de exemplo
torrents = [Torrent(filename ,PATH, [randomIp() for _ in range(1,3)]) for filename in files]
for tor in torrents:
node1.store(tor.getID(), tor)
#printa topologia atual
top = node1.getSortedTopology()
for node in top:
print(f"Nó {node.ip}:")
for k, _ in node.getContents():
print(f"--{k}")
#cria nó da aplicação e insere na DHT
myNode = DHTnode("100.110.120.130","10000")
myNode.join([node1], network)
print("Insira algum identificador presente na DHT (impresso no terminal) para encontrar arquivo")
t1.run()
t2.run()
t3.run()
c1 = h1.spawn("Andrea_Peer", PushPullPeer)
c2 = h1.spawn("Hector_Peer", PushPullPeer)
c3 = h1.spawn("Clara_Peer", PushPullPeer)
c1.run()
c2.run()
c3.run()
c1.set_download_folder("Andrea")
c2.set_download_folder("Hector")
c3.set_download_folder("Clara")
c1.add_torrent(Torrent("palabra.json"))
c2.add_torrent(Torrent("palabra.json"))
c3.add_torrent(Torrent("palabra.json"))
c1.add_torrent(Torrent("frase.json"))
c2.add_torrent(Torrent("frase.json"))
c3.add_torrent(Torrent("frase.json"))
c1.add_torrent(Torrent("parrafo.json"))
c2.add_torrent(Torrent("parrafo.json"))
c3.add_torrent(Torrent("parrafo.json"))
serve_forever()
def main():
# peer_id = generate_peer_id('PY', '0001')
peer_id = b'-PY0001-286714788296'
print('peer id: ', peer_id)
torrent = Torrent(
'torrents/2021-01-11-raspios-buster-armhf-lite.zip.torrent')
print('info hash: ', torrent.info_hash)
tracker = Tracker(torrent, peer_id)
print('Torrent: ', torrent.metadata)
print('torrent.length = ', torrent.metadata['info']['length'])
print('torrent.piece_hashes = ', torrent.piece_hashes)
print('torrent.piece_length = ', torrent.piece_length)
print('torrent.number_of_pieces = ', torrent.number_of_pieces)
print(
'------------------------------ Pieces/Blocks --------------------------------------------'
)
piece_manager = PieceManager(torrent)
piece_manager.init_pieces()
# piece_manager.print_pieces()
#test_block = Messages.Piece(1752, 32768, b'')
#piece_manager.block_received(test_block)
#piece_manager.print_pieces()
tracker.make_request_to_tracker()
print('tracker response: ', tracker.response)
tracker.get_peers_from_response()
print('number of peers: ', len(tracker.peers))
print('list of peers: ', tracker.peers)
peers_manager = PeersManager(torrent)
for peer in tracker.peers:
p = Peer(torrent, piece_manager, peer_id, peer)
peers_manager.add_peer(p)
if len(peers_manager.peers) >= 30:
break
print(
'--------------------------------- Main Loop -----------------------------------------------'
)
block_num = 0
attempts = 0
for i in range(0, 20):
peers_manager.connect_to_random_peer()
while not piece_manager.is_complete():
for piece in piece_manager.pieces:
if piece.is_complete:
print(f'piece is already complete: {piece}')
continue
#if len(peers_manager.connected_peers) < 20:
# peers_manager.connect_to_random_peer()
# sleep(.5)
# continue
peers_manager.find_peers_with_piece(piece.index)
for block in piece.blocks:
if block.is_complete:
continue
sleep(.3)
#block = piece.blocks[block_num]
#peers_manager.find_peers_with_piece(piece.index)
for peer in peers_manager.peers_with_piece:
if attempts > 50:
# if block_num >= piece.number_of_blocks:
# block_num = 0
# else:
# block_num += 1
# attempts = 0
# break
continue
peer.express_interest()
#sleep(.5)
if peer.has_piece(piece.index) and peer.can_download_block(
): # currently gets stuck here "peer has the requested piece"
req = Messages.Request(piece.index, block.offset,
block.length)
peer.send_msg(req.encode())
response = peer.receive_msg()
if not response:
print('failed to receive message from peer')
attempts += 1
#sleep(.5)
continue
msg = peer.decode_msg()
if msg is None:
print('failed to decode peer\'s response')
attempts += 1
#sleep(.5)
continue
peer.handle_msg(msg)
#block_num += 1
else:
peer.receive_msg()
msg = peer.decode_msg()
if msg is not None:
peer.handle_msg(msg)
attempts += 1
if len(peers_manager.connected_peers) < 20:
peers_manager.connect_to_random_peer()
peers_manager.connect_to_random_peer()
#sleep(.5)
piece_manager.write_pieces_to_file()
peers_manager.disconnect_from_peers()
"""
print "Missing package bitarray https://pypi.python.org/pypi/bitarray"
subprocess.call("./freePeerPorts.sh", shell=True)
set_context()
h = create_host("http://192.168.1.101:6970")
type = [PushPeer, PullPeer, PushPullPeer]
for i in range(3, 5):
# sleep(randint(1, 5) / 10)
# client = h.spawn("Peer" + str(i), choice(type))
client = h.spawn("Peer" + str(i), PushPullPeer)
client.set_download_folder("Peer" + str(i))
client.add_torrent(Torrent("palabra.json"))
client.add_torrent(Torrent("frase.json"))
client.add_torrent(Torrent("parrafo.json"))
client.run()
for i in range(0, 1):
genesis = h.spawn("Genesis" + str(i), PushPullPeer)
genesis.set_download_folder("Genesis" + str(i))
genesis.add_torrent(Torrent("palabra.json"))
genesis.add_torrent(Torrent("frase.json"))
genesis.add_torrent(Torrent("parrafo.json"))
genesis.run()
while True:
sleep(60 * 5)
export_csv()
break
async def gather_test(self):
while True:
await asyncio.sleep(2)
print("gather in action")
async def drain(self):
await asyncio.wait_for(self.writer.drain(), 5)
def close(self):
self.end = 1
self.connected = False
if self.writer is not None:
self.writer.close()
if __name__ == '__main__':
tor = Torrent("C:\\temp\\big-buck-bunny.torrent")
Path = File("big.txt", r"C:\temp\big.txt")
print(tor.get_torrent_num_of_pieces())
print(tor.get_torrent_piece_length())
print(tor.get_torrent_last_piece_length())
print(tor.get_torrent_size())
peer = Peer('187.189.62.77', '51413', tor, Path)
print(len(peer.peer_have_pieces))
loop = asyncio.get_event_loop()
loop.run_until_complete(peer.listen())
loop.close()
