def disconnect_from_the_splitter(self):
# {{{
Peer_FNS.disconnect_from_the_splitter(self)
def __init__(self):
try:
colorama.init()
except Exception:
pass
_print_("Running in", end=' ')
if __debug__:
print("debug mode")
else:
print("release mode")
# {{{ Args handling and object instantiation
parser = argparse.ArgumentParser(
description='This is the peer node of a P2PSP team.')
parser.add_argument(
'--chunk_loss_period',
help=
'0 -> no chunk loss, 1 -> lost all chunks, 2, lost half of the chunks ... Default = {}'
.format(Lossy_Peer.CHUNK_LOSS_PERIOD))
parser.add_argument(
'--max_chunk_loss',
help=
'The maximun number of times that other peer can not send a chunk to this peer. Defaut = {}'
.format(Peer_DBS.MAX_CHUNK_LOSS))
parser.add_argument(
'--player_port',
help='Port to communicate with the player. Default = {}'.format(
Peer_IMS.PLAYER_PORT))
parser.add_argument(
'--splitter_host',
help='IP address or hostname of the splitter. Default = {}.'.
format(Peer_IMS.SPLITTER_ADDR))
parser.add_argument(
'--splitter_port',
help='Listening port of the splitter. Default = {}.'.format(
Peer_IMS.SPLITTER_PORT))
parser.add_argument(
'--port',
help=
'Port to communicate with the peers. Default {} (the OS will chose it).'
.format(Peer_IMS.PORT))
parser.add_argument(
'--use_localhost',
action="store_true",
help=
'Forces the peer to use localhost instead of the IP of the adapter to connect to the splitter.'
)
#args = parser.parse_known_args()[0]
args = parser.parse_args()
if args.splitter_host:
Peer_IMS.SPLITTER_ADDR = socket.gethostbyname(args.splitter_host)
print('SPLITTER_ADDR =', Peer_IMS.SPLITTER_ADDR)
if args.splitter_port:
Peer_IMS.SPLITTER_PORT = int(args.splitter_port)
print('SPLITTER_PORT =', Peer_IMS.SPLITTER_PORT)
if args.port:
Peer_IMS.PORT = int(args.port)
print('(Peer) PORT =', Peer_IMS.PORT)
if args.player_port:
Peer_IMS.PLAYER_PORT = int(args.player_port)
print('PLAYER_PORT =', Peer_IMS.PLAYER_PORT)
if args.max_chunk_loss:
Peer_DBS.MAX_CHUNK_LOSS = int(args.max_chunk_loss)
print('MAX_CHUNK_LOSS =', Peer_DBS.MAX_CHUNK_LOSS)
if args.use_localhost:
Peer_IMS.USE_LOCALHOST = True
print('Using localhost!')
peer = Peer_IMS()
peer.wait_for_the_player()
peer.connect_to_the_splitter()
peer.receive_the_mcast_endpoint()
peer.receive_the_header_size()
peer.receive_the_chunk_size()
peer.receive_the_header()
peer.receive_the_buffer_size()
#peer.receive_configuration()
_print_("IP Multicast address =", peer.mcast_addr)
# A multicast address is always received, even for DBS peers.
if peer.mcast_addr == "0.0.0.0":
# {{{ This is an "unicast" peer.
peer = Peer_DBS(peer)
peer.receive_my_endpoint()
peer.receive_the_number_of_peers()
print("===============> number_of_peers =", peer.number_of_peers)
print("===============> is_a_monitor =", peer.am_i_a_monitor())
peer.listen_to_the_team()
peer.receive_the_list_of_peers()
if peer.am_i_a_monitor():
#peer = Monitor_DBS(peer)
#peer = Monitor_FNS(peer)
peer = Monitor_LRS(peer)
else:
peer = Peer_FNS(peer)
if args.chunk_loss_period:
Lossy_Peer.CHUNK_LOSS_PERIOD = int(args.chunk_loss_period)
print('CHUNK_LOSS_PERIOD =', Lossy_Peer.CHUNK_LOSS_PERIOD)
if int(args.chunk_loss_period) != 0:
peer = Lossy_Peer(peer)
#peer.receive_my_endpoint()
# }}}
else:
peer.listen_to_the_team()
# }}}
# {{{ Run!
peer.disconnect_from_the_splitter()
peer.buffer_data()
peer.start()
print("+-----------------------------------------------------+")
print("| Received = Received kbps, including retransmissions |")
print("| Sent = Sent kbps |")
print("| (Expected values are between parenthesis) |")
print("------------------------------------------------------+")
print()
print(
" Time | Received (Expected) | Sent (Expected) | Team description"
)
print(
"---------+-------------------------+--------------------------+-----------------..."
)
last_chunk_number = peer.played_chunk
if hasattr(peer, 'sendto_counter'):
last_sendto_counter = 0
else:
peer.sendto_counter = 0
last_sendto_counter = 0
if not hasattr(peer, 'peer_list'):
peer.peer_list = []
last_recvfrom_counter = peer.recvfrom_counter
while peer.player_alive:
time.sleep(1)
kbps_expected_recv = ((peer.played_chunk - last_chunk_number) *
peer.chunk_size * 8) / 1000
last_chunk_number = peer.played_chunk
kbps_recvfrom = ((peer.recvfrom_counter - last_recvfrom_counter) *
peer.chunk_size * 8) / 1000
last_recvfrom_counter = peer.recvfrom_counter
team_ratio = len(peer.peer_list) / (len(peer.peer_list) + 1.0)
kbps_expected_sent = int(kbps_expected_recv * team_ratio)
kbps_sendto = ((peer.sendto_counter - last_sendto_counter) *
peer.chunk_size * 8) / 1000
last_sendto_counter = peer.sendto_counter
if kbps_recvfrom > 0 and kbps_expected_recv > 0:
nice = 100.0 / float(
(float(kbps_expected_recv) / kbps_recvfrom) *
(len(peer.peer_list) + 1))
else:
nice = 0.0
_print_('|', end=Color.none)
if kbps_expected_recv < kbps_recvfrom:
sys.stdout.write(Color.red)
elif kbps_expected_recv > kbps_recvfrom:
sys.stdout.write(Color.green)
print(repr(kbps_expected_recv).rjust(12), end=Color.none)
print(('(' + repr(kbps_recvfrom) + ')').rjust(12), end=' | ')
#print(("{:.1f}".format(nice)).rjust(6), end=' | ')
#sys.stdout.write(Color.none)
if kbps_expected_sent > kbps_sendto:
sys.stdout.write(Color.red)
elif kbps_expected_sent < kbps_sendto:
sys.stdout.write(Color.green)
print(repr(kbps_sendto).rjust(12), end=Color.none)
print(('(' + repr(kbps_expected_sent) + ')').rjust(12), end=' | ')
#sys.stdout.write(Color.none)
#print(repr(nice).ljust(1)[:6], end=' ')
print(len(peer.peer_list), end=' ')
counter = 0
for p in peer.peer_list:
if (counter < 5):
print(p, end=' ')
counter += 1
else:
break
print()
def say_goodbye(self, node):
# {{{
Peer_FNS.say_goodbye(self, node)
def say_hello(self, node):
# {{{
Peer_FNS.say_hello(self, node)
def disconnect_from_the_splitter(self):
# {{{
Peer_FNS.disconnect_from_the_splitter(self)
def say_goodbye(self, node):
# {{{
Peer_FNS.say_goodbye(self, node)
def say_hello(self, node):
# {{{
Peer_FNS.say_hello(self, node)
