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 __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 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 __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 __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)
class Node(object):
def __init__(self, syncObj, nodeAddr):
self.__syncObj = weakref.ref(syncObj)
self.__nodeAddr = nodeAddr
self.__ip = globalDnsResolver().resolve(nodeAddr.split(':')[0])
self.__port = int(nodeAddr.split(':')[1])
self.__shouldConnect = syncObj._getSelfNodeAddr() > nodeAddr
self.__encryptor = syncObj._getEncryptor()
self.__conn = None
if self.__shouldConnect:
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 _destroy(self):
self.__shouldConnect = False
self.__syncObj = None
if self.__conn is not None:
self.__conn.disconnect()
self.__onDisconnected()
self.__terminating = True
def __onConnected(self):
self.__status = NODE_STATUS.CONNECTED
if self.__encryptor:
self.__conn.recvRandKey = os.urandom(32)
self.__conn.send(self.__conn.recvRandKey)
return
self.__conn.send(self.__syncObj()._getSelfNodeAddr())
def __onDisconnected(self):
self.__status = NODE_STATUS.DISCONNECTED
def __onMessageReceived(self, message):
if self.__encryptor and not self.__conn.sendRandKey:
self.__conn.sendRandKey = message
self.__conn.send(self.__syncObj()._getSelfNodeAddr())
return
self.__syncObj()._onMessageReceived(self.__nodeAddr, message)
def onPartnerConnected(self, conn):
if self.__terminating:
return
self.__conn = conn
conn.setOnMessageReceivedCallback(self.__onMessageReceived)
conn.setOnDisconnectedCallback(self.__onDisconnected)
self.__status = NODE_STATUS.CONNECTED
def getStatus(self):
return self.__status
def isConnected(self):
return self.__status == NODE_STATUS.CONNECTED
def getAddress(self):
return self.__nodeAddr
def getSendBufferSize(self):
return self.__conn.getSendBufferSize()
def send(self, message):
if self.__status != NODE_STATUS.CONNECTED:
return False
self.__conn.send(message)
if self.__status != NODE_STATUS.CONNECTED:
return False
return True
def connectIfRequired(self):
if not self.__shouldConnect:
return
if self.__status != NODE_STATUS.DISCONNECTED:
return
if time.time() - self.__lastConnectAttemptTime < self.__syncObj(
)._getConf().connectionRetryTime:
return
self.__status = NODE_STATUS.CONNECTING
self.__lastConnectAttemptTime = time.time()
if not self.__conn.connect(self.__ip, self.__port):
self.__status = NODE_STATUS.DISCONNECTED
return
class Node(object):
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 _destroy(self):
self.__shouldConnect = False
self.__syncObj = None
if self.__conn is not None:
self.__conn.disconnect()
self.__onDisconnected()
self.__terminating = True
def __onConnected(self):
self.__status = NODE_STATUS.CONNECTED
if self.__encryptor:
self.__conn.recvRandKey = os.urandom(32)
self.__conn.send(self.__conn.recvRandKey)
return
selfAddr = self.__syncObj()._getSelfNodeAddr()
if selfAddr is not None:
self.__conn.send(selfAddr)
else:
self.__conn.send('readonly')
def __onDisconnected(self):
self.__status = NODE_STATUS.DISCONNECTED
def __onMessageReceived(self, message):
if self.__encryptor and not self.__conn.sendRandKey:
self.__conn.sendRandKey = message
self.__conn.send(self.__syncObj()._getSelfNodeAddr())
return
self.__syncObj()._onMessageReceived(self.__nodeAddr, message)
def onPartnerConnected(self, conn):
if self.__terminating:
return
self.__conn = conn
conn.setOnMessageReceivedCallback(self.__onMessageReceived)
conn.setOnDisconnectedCallback(self.__onDisconnected)
self.__status = NODE_STATUS.CONNECTED
def getStatus(self):
return self.__status
def isConnected(self):
return self.__status == NODE_STATUS.CONNECTED
def getAddress(self):
return self.__nodeAddr
def getSendBufferSize(self):
return self.__conn.getSendBufferSize()
def send(self, message):
if self.__status != NODE_STATUS.CONNECTED:
return False
self.__conn.send(message)
if self.__status != NODE_STATUS.CONNECTED:
return False
return True
def connectIfRequired(self):
if not self.__shouldConnect:
return
if self.__status != NODE_STATUS.DISCONNECTED:
return
if time.time() - self.__lastConnectAttemptTime < self.__syncObj()._getConf().connectionRetryTime:
return
self.__status = NODE_STATUS.CONNECTING
self.__lastConnectAttemptTime = time.time()
if not self.__conn.connect(self.__ip, self.__port):
self.__status = NODE_STATUS.DISCONNECTED
return
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)
def handle_stream(self, stream, address): conn = TcpConnection(self.io_loop, stream, address) self._connections[conn.name] = conn conn.set_connection_callback(self._connection_cb) conn.set_message_callback(self._message_cb) conn.set_write_complete_callback(self._write_complete_cb) conn.set_close_callback(self._remove_connection) conn.connect_established()
class Utility(object):
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 __onMessageReceived(self, message):
if self.__connection.encryptor and not self.__connection.sendRandKey:
self.__connection.sendRandKey = message
self.__connection.send(self.__data)
return
self.__result = message
self.__connection.disconnect()
def __onDisconnected(self):
self.__isConnected = False
def __onConnected(self):
if self.__connection.encryptor:
self.__connection.recvRandKey = os.urandom(32)
self.__connection.send(self.__connection.recvRandKey)
return
self.__connection.send(self.__data)
def getResult(self):
return self.__result
def __getData(self, args):
parser = Parser()
data = parser.parse(args)
if not self.__checkCorrectAdress(data.connection):
self.__result = 'invalid adress to connect'
return False
self.__host, self.__port = data.connection.split(':')
self.__port = int(self.__port)
self.__password = data.password
if data.status and data.add is None and data.remove is None:
self.__data = ['status']
return True
elif data.add is not None and data.remove is None and not data.status:
if not self.__checkCorrectAdress(data.add):
self.__result = 'invalid adress to command add'
return False
self.__data = ['add', data.add]
return True
elif data.remove is not None and data.add is None and not data.status:
if not self.__checkCorrectAdress(data.remove):
self.__result = 'invalid adress to command remove'
return False
self.__data = ['remove', data.remove]
return True
else:
self.__result = 'invalid command'
return False
def __checkCorrectAdress(self, adress):
try:
host, port = adress.split(':')
port = int(port)
assert (port > 0 and port < 65536)
return True
except:
return False
class Utility(object):
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 __onMessageReceived(self, message):
if self.__connection.encryptor and not self.__connection.sendRandKey:
self.__connection.sendRandKey = message
self.__connection.send(self.__data)
return
self.__result = message
self.__connection.disconnect()
def __onDisconnected(self):
self.__isConnected = False
def __onConnected(self):
if self.__connection.encryptor:
self.__connection.recvRandKey = os.urandom(32)
self.__connection.send(self.__connection.recvRandKey)
return
self.__connection.send(self.__data)
def getResult(self):
return self.__result
def __getData(self, args):
parser = Parser()
data = parser.parse(args)
if not self.__checkCorrectAdress(data.connection):
self.__result = 'invalid adress to connect'
return False
self.__host, self.__port = data.connection.split(':')
self.__port = int(self.__port)
self.__password = data.password
if data.status and data.add is None and data.remove is None:
self.__data = ['status']
return True
elif data.add is not None and data.remove is None and not data.status:
if not self.__checkCorrectAdress(data.add):
self.__result = 'invalid adress to command add'
return False
self.__data = ['add', data.add]
return True
elif data.remove is not None and data.add is None and not data.status:
if not self.__checkCorrectAdress(data.remove):
self.__result = 'invalid adress to command remove'
return False
self.__data = ['remove', data.remove]
return True
else:
self.__result = 'invalid command'
return False
def __checkCorrectAdress(self, adress):
try:
host, port = adress.split(':')
port = int(port)
assert (port > 0 and port < 65536)
return True
except:
return False
