def __init__(self, syncObj, nodeAddr, shouldConnect = None):
self.__syncObj = weakref.ref(syncObj)
self.__nodeAddr = nodeAddr
if shouldConnect is not None:
self.__shouldConnect = shouldConnect
else:
self.__shouldConnect = syncObj._getSelfNodeAddr() > nodeAddr
self.__encryptor = syncObj._getEncryptor()
self.__conn = None
if self.__shouldConnect:
self.__ip = globalDnsResolver().resolve(nodeAddr.split(':')[0])
self.__port = int(nodeAddr.split(':')[1])
self.__conn = TcpConnection(poller=syncObj._poller,
onConnected=self.__onConnected,
onMessageReceived=self.__onMessageReceived,
onDisconnected=self.__onDisconnected,
timeout=syncObj._getConf().connectionTimeout,
sendBufferSize=syncObj._getConf().sendBufferSize,
recvBufferSize=syncObj._getConf().recvBufferSize)
self.__conn.encryptor = self.__encryptor
self.__lastConnectAttemptTime = 0
self.__lastPingTime = 0
self.__status = NODE_STATUS.DISCONNECTED
self.__terminating = False
def add_peers(self, message_body):
for peer_data in message_body.values():
try:
if peer_data['id'] != self.my_id and peer_data[
'id'] not in self.peers:
tcp_connection = TcpConnection()
tcp_connection.connect(peer_data['ip'], peer_data['port'])
tcp_connection.send(
(19).to_bytes(CODE_SIZE, byteorder='big') +
(self.info_hash + self.my_id).encode('utf-8'))
if int.from_bytes(tcp_connection.receive(),
byteorder='big') == 11:
peer = Peer.start(peer_data['id'], tcp_connection,
self.actor_ref, self.file_object,
self.pieces_map)
self.peers[peer_data['id']] = {
'actor_ref': peer,
'downloaded_bytes': 0,
'state': 'not_interested'
}
print(
colored(
f"added new peer with id: {peer_data['id']}",
'yellow'))
if len(self.peers) == 1:
self.timer = Timer(TIMER_INTERVAL, self.actor_ref)
self.timer.daemon = True
self.timer.start()
except:
pass
def __onNewConnection(self, descr, event):
if event & POLL_EVENT_TYPE.READ:
try:
sock, addr = self.__socket.accept()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF,
self.__sendBufferSize)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF,
self.__recvBufferSize)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
sock.setblocking(0)
conn = TcpConnection(poller=self.__poller,
socket=sock,
timeout=self.__connectionTimeout,
sendBufferSize=self.__sendBufferSize,
recvBufferSize=self.__recvBufferSize)
self.__onNewConnectionCallback(conn)
except socket.error as e:
if e.errno not in (socket.errno.EAGAIN,
socket.errno.EWOULDBLOCK):
self.unbind()
return
if event & POLL_EVENT_TYPE.ERROR:
self.unbind()
return
def __init__(self, args):
self.__result = None
if self.__getData(args):
self.__poller = createPoller('auto')
self.__connection = TcpConnection(
self.__poller,
onDisconnected=self.__onDisconnected,
onMessageReceived=self.__onMessageReceived,
onConnected=self.__onConnected)
if self.__password is not None:
self.__connection.encryptor = getEncryptor(self.__password)
self.__isConnected = self.__connection.connect(
self.__host, self.__port)
if not self.__isConnected:
self.__result = 'can\'t connected'
while self.__isConnected:
self.__poller.poll(0.5)
def loop(self, sub_reactors):
self.__is_looping = True
logger.simple_log('正在接受玩家连接')
while self.__is_looping:
try:
events = self.__epoll.poll(10)
if not events:
logger.simple_log('暂时没有新玩家连接')
continue
# 有玩家连接
for i in range(len(events)):
client_sock, client_addr = self.__acceptor.accept()
new_conn = TcpConnection(client_sock)
new_conn.handle_connection_callback()
sub_reactors.assign_new_conn(new_conn)
except IOError as error:
if error.errno == errno.EINTR:
continue
pass
def run(self):
while True:
try:
client_socket, address = self.server_socket.accept()
print(f"Connection from {address} has been established!")
tcp_connection = TcpConnection(client_socket)
status, peer_id = self.handle_request(tcp_connection)
if status is True:
tcp_connection.send((11).to_bytes(CODE_SIZE,
byteorder='big'))
self.main_controller.tell({
'header': 8,
'body': (peer_id, tcp_connection)
})
else:
tcp_connection.send((12).to_bytes(CODE_SIZE,
byteorder='big'))
tcp_connection.close()
except Exception as e:
print(e)
tcp_connection.close()
def run(self):
data = {}
data['info_hash'] = self.info_hash
data['peer_id'] = self.my_id
data['ip'] = self.ip
data['port'] = self.port
data['event'] = 'start'
tcp_connection = TcpConnection()
try:
tcp_connection.connect(self.tracker_ip, self.tracker_port)
tcp_connection.send(json.dumps(data).encode('utf-8'))
response_message = json.loads(
tcp_connection.receive().decode('utf-8'))
tcp_connection.close()
except Exception as e:
print(e)
tcp_connection.close()
self.main_controller.tell({
'header': 13,
'body': 'Connection error with tracker'
})
return
if response_message['status_code'] == '0':
self.main_controller.tell({
'header':
13,
'body':
'Received status code 0 from tracker'
})
return
self.main_controller.tell({
'header': 9,
'body': response_message['peers']
})
interval = int(float(response_message['interval']) / 1000) - 1
data['event'] = 'update'
while True:
time.sleep(interval)
try:
tcp_connection = TcpConnection()
tcp_connection.connect(self.tracker_ip, self.tracker_port)
tcp_connection.send(json.dumps(data).encode('utf-8'))
response_message = json.loads(
tcp_connection.receive().decode('utf-8'))
tcp_connection.close()
except Exception as e:
print(e)
tcp_connection.close()
self.main_controller.tell({
'header':
13,
'body':
'Connection error with tracker'
})
return
if response_message['status_code'] == '0':
self.main_controller.tell({
'header':
13,
'body':
'Received status code 0 from tracker'
})
return
self.main_controller.tell({
'header': 9,
'body': response_message['peers']
})
def send_message_to_tracker(request_message, tracker_ip, tracker_port):
tcp_connection = TcpConnection()
tcp_connection.connect(tracker_ip, tracker_port)
tcp_connection.send(request_message.encode('utf-8'))
response_message = tcp_connection.receive().decode('utf-8')
print(response_message)
