def __init__(self, client, port):
QObject.__init__(self)
self._client = client
self._port = port
self.game_port = port + 1
self._socket = QTurnSocket(port, self._on_data)
self._socket.state_changed.connect(self.turn_state_changed)
self._client.subscribe_to('connectivity', self)
self.relay_address, self.mapped_address = None, None
self._relay_test = None
self._relays = {}
self.state = None
self.addr = None
def __init__(self, client, port):
QObject.__init__(self)
self._client = client
self._port = port
self.game_port = port + 1
self._socket = QTurnSocket(port, self._on_data)
self._socket.state_changed.connect(self.turn_state_changed)
self._client.subscribe_to("connectivity", self)
self.relay_address, self.mapped_address = None, None
self._relay_test = None
self._relays = {}
self.state = None
self.addr = None
import signal
from PyQt4.QtCore import QCoreApplication, QTimer
from connectivity import QTurnSocket
if __name__ == '__main__':
import logging
logging.getLogger().setLevel(logging.DEBUG)
def sigint_handler(*args):
QCoreApplication.quit()
print("Testing turnclient")
app = QCoreApplication([])
timer = QTimer()
signal.signal(signal.SIGINT, sigint_handler)
timer.start(500)
timer.timeout.connect(lambda: None)
c = QTurnSocket()
c.run()
app.exec_()
class ConnectivityHelper(QObject):
connectivity_status_established = pyqtSignal(str, str)
# Emitted when a peer is bound to a local port
peer_bound = pyqtSignal(str, int, int)
ready = pyqtSignal()
relay_test_finished = pyqtSignal()
relay_test_progress = pyqtSignal(str)
error = pyqtSignal(str)
def __init__(self, client, port):
QObject.__init__(self)
self._client = client
self._port = port
self.game_port = port + 1
self._socket = QTurnSocket(port, self._on_data)
self._socket.state_changed.connect(self.turn_state_changed)
self._client.subscribe_to('connectivity', self)
self.relay_address, self.mapped_address = None, None
self._relay_test = None
self._relays = {}
self.state = None
self.addr = None
@property
def is_ready(self):
return (self.relay_address is not None
and self.relay_address is not [None, None]
and self.mapped_address is not None
and self._socket.state() == QAbstractSocket.BoundState)
def start_test(self):
self.send('InitiateTest', [self._port])
def start_relay_test(self):
if not self._relay_test:
self._relay_test = RelayTest(self._socket)
self._relay_test.finished.connect(self.relay_test_finished.emit)
self._relay_test.progress.connect(self.relay_test_progress.emit)
if not self._socket.turn_state == TURNState.BOUND:
self._socket.connect_to_relay()
self._socket.bound.connect(self._relay_test.start_relay_test,
Qt.UniqueConnection)
def _cleanup():
try:
self._socket.bound.disconnect(
self._relay_test.start_relay_test)
except TypeError:
# For some reason pyqt raises _TypeError_ here
pass
self._relay_test.finished.connect(_cleanup, Qt.UniqueConnection)
else:
self._relay_test.start_relay_test(self.mapped_address)
def turn_state_changed(self, state):
if state == TURNState.BOUND:
self.relay_address = self._socket.relay_address
self.mapped_address = self._socket.relay_address
self.ready.emit()
def handle_SendNatPacket(self, msg):
target, message = msg['args']
host, port = target.split(':')
if self.state is None and self._socket.localPort() == self._port:
self._socket.randomize_port()
self._socket.writeDatagram(b'\x08' + message.encode(),
QHostAddress(host), int(port))
def handle_ConnectivityState(self, msg):
from client import ClientState
state, addr = msg['args']
if state == 'BLOCKED':
self._logger.warning("Outbound traffic is blocked")
QtGui.QMessageBox.warning(
None, "Traffic Blocked",
"Your outbound traffic appears to be blocked. Try restarting FAF. <br/> If the error persists please contact a moderator and send your logs. <br/> We are already working on a solution to this problem."
)
self._client.state = ClientState.NONE
else:
host, port = addr.split(':')
self.state, self.mapped_address = state, (host, port)
self.connectivity_status_established.emit(self.state, self.addr)
self._logger.info(
"Connectivity state is {}, mapped address: {}".format(
state, addr))
def handle_message(self, msg):
command = msg.get('command')
if command == 'CreatePermission':
self._socket.permit(msg['args'])
def bind(self, (host, port), login, peer_id):
host, port = host, int(port)
relay = Relay(self.game_port, login, peer_id,
partial(self.send_udp, (host, port)))
relay.bound.connect(partial(self.peer_bound.emit, login, peer_id))
relay.listen()
self._relays[(host, port)] = relay
class ConnectivityHelper(QObject):
connectivity_status_established = pyqtSignal(str, str)
# Emitted when a peer is bound to a local port
peer_bound = pyqtSignal(str, int, int)
ready = pyqtSignal()
relay_test_finished = pyqtSignal()
relay_test_progress = pyqtSignal(str)
error = pyqtSignal(str)
def __init__(self, client, port):
QObject.__init__(self)
self._client = client
self._port = port
self.game_port = port + 1
self._socket = QTurnSocket(port, self._on_data)
self._socket.state_changed.connect(self.turn_state_changed)
self._client.subscribe_to("connectivity", self)
self.relay_address, self.mapped_address = None, None
self._relay_test = None
self._relays = {}
self.state = None
self.addr = None
def start_test(self):
self.send("InitiateTest", [self._port])
def start_relay_test(self):
if not self._relay_test:
self._relay_test = RelayTest(self._socket)
self._relay_test.finished.connect(self.relay_test_finished.emit)
self._relay_test.progress.connect(self.relay_test_progress.emit)
if not self._socket.turn_state == TURNState.BOUND:
self._socket.connect_to_relay()
self._socket.bound.connect(self._relay_test.start_relay_test, Qt.UniqueConnection)
def _cleanup():
try:
self._socket.bound.disconnect(self._relay_test.start_relay_test)
except TypeError:
# For some reason pyqt raises _TypeError_ here
pass
self._relay_test.finished.connect(_cleanup, Qt.UniqueConnection)
else:
self._relay_test.start_relay_test(self.mapped_address)
def turn_state_changed(self, state):
if state == TURNState.BOUND:
self.relay_address = self._socket.relay_address
self.mapped_address = self._socket.relay_address
self.ready.emit()
def handle_SendNatPacket(self, msg):
target, message = msg["args"]
host, port = target.split(":")
self._socket.writeDatagram(b"\x08" + message.encode(), QHostAddress(host), int(port))
def handle_ConnectivityState(self, msg):
state, addr = msg["args"]
host, port = addr.split(":")
self.state, self.mapped_address = state, (host, port)
self.connectivity_status_established.emit(self.state, self.addr)
self._logger.info("Connectivity state is {}, mapped address: {}".format(state, addr))
def handle_message(self, msg):
command = msg.get("command")
if command == "CreatePermission":
self._socket.permit(msg["args"])
def bind(self, (host, port), login, peer_id):
host, port = host, int(port)
relay = Relay(self.game_port, login, peer_id, partial(self.send_udp, (host, port)))
relay.bound.connect(partial(self.peer_bound.emit, login, peer_id))
relay.listen()
self._relays[(host, port)] = relay
class ConnectivityHelper(QObject):
connectivity_status_established = pyqtSignal(str, str)
# Emitted when a peer is bound to a local port
peer_bound = pyqtSignal(str, int, int)
ready = pyqtSignal()
relay_test_finished = pyqtSignal()
relay_test_progress = pyqtSignal(str)
error = pyqtSignal(str)
def __init__(self, client, port):
QObject.__init__(self)
self._client = client
self._port = port
self.game_port = port + 1
self._socket = QTurnSocket(port, self._on_data)
self._socket.state_changed.connect(self.turn_state_changed)
self._client.subscribe_to('connectivity', self)
self.relay_address, self.mapped_address = None, None
self._relay_test = None
self._relays = {}
self.state = None
self.addr = None
@property
def is_ready(self):
return (self.relay_address is not None
and self.mapped_address is not None
and self._socket.state == QAbstractSocket.BoundState)
def start_test(self):
self.send('InitiateTest', [self._port])
def start_relay_test(self):
if not self._relay_test:
self._relay_test = RelayTest(self._socket)
self._relay_test.finished.connect(self.relay_test_finished.emit)
self._relay_test.progress.connect(self.relay_test_progress.emit)
if not self._socket.turn_state == TURNState.BOUND:
self._socket.connect_to_relay()
self._socket.bound.connect(self._relay_test.start_relay_test,
Qt.UniqueConnection)
def _cleanup():
try:
self._socket.bound.disconnect(
self._relay_test.start_relay_test)
except TypeError:
# For some reason pyqt raises _TypeError_ here
pass
self._relay_test.finished.connect(_cleanup, Qt.UniqueConnection)
else:
self._relay_test.start_relay_test(self.mapped_address)
def turn_state_changed(self, state):
if state == TURNState.BOUND:
self.relay_address = self._socket.relay_address
self.mapped_address = self._socket.relay_address
self.ready.emit()
def handle_SendNatPacket(self, msg):
target, message = msg['args']
host, port = target.split(':')
self._socket.writeDatagram(b'\x08' + message.encode(),
QHostAddress(host), int(port))
def handle_ConnectivityState(self, msg):
state, addr = msg['args']
host, port = addr.split(':')
self.state, self.mapped_address = state, (host, port)
self.connectivity_status_established.emit(self.state, self.addr)
self._logger.info(
"Connectivity state is {}, mapped address: {}".format(state, addr))
def handle_message(self, msg):
command = msg.get('command')
if command == 'CreatePermission':
self._socket.permit(msg['args'])
def bind(self, (host, port), login, peer_id):
host, port = host, int(port)
relay = Relay(self.game_port, login, peer_id,
partial(self.send_udp, (host, port)))
relay.bound.connect(partial(self.peer_bound.emit, login, peer_id))
relay.listen()
self._relays[(host, port)] = relay
import signal
from PyQt4.QtCore import QCoreApplication, QTimer
from connectivity import QTurnSocket
if __name__ == '__main__':
import logging
logging.getLogger().setLevel(logging.DEBUG)
def sigint_handler(*args):
QCoreApplication.quit()
print("Testing turnclient")
app = QCoreApplication([])
timer = QTimer()
signal.signal(signal.SIGINT, sigint_handler)
timer.start(500)
timer.timeout.connect(lambda: None)
c = QTurnSocket()
c.run()
app.exec_()
class ConnectivityHelper(QObject):
connectivity_status_established = pyqtSignal(str, str)
# Emitted when a peer is bound to a local port
peer_bound = pyqtSignal(str, int, int)
ready = pyqtSignal()
relay_test_finished = pyqtSignal()
relay_test_progress = pyqtSignal(str)
error = pyqtSignal(str)
def __init__(self, client, port):
QObject.__init__(self)
self._client = client
self._port = port
self.game_port = port+1
self._socket = QTurnSocket(port, self._on_data)
self._socket.state_changed.connect(self.turn_state_changed)
self._client.subscribe_to('connectivity', self)
self.relay_address, self.mapped_address = None, None
self._relay_test = None
self._relays = {}
self.state = None
self.addr = None
@property
def is_ready(self):
return (self.relay_address is not None
and self.relay_address is not [None, None]
and self.mapped_address is not None
and self._socket.state() == QAbstractSocket.BoundState)
def start_test(self):
self.send('InitiateTest', [self._port])
def start_relay_test(self):
if not self._relay_test:
self._relay_test = RelayTest(self._socket)
self._relay_test.finished.connect(self.relay_test_finished.emit)
self._relay_test.progress.connect(self.relay_test_progress.emit)
if not self._socket.turn_state == TURNState.BOUND:
self._socket.connect_to_relay()
self._socket.bound.connect(self._relay_test.start_relay_test, Qt.UniqueConnection)
def _cleanup():
try:
self._socket.bound.disconnect(self._relay_test.start_relay_test)
except TypeError:
# For some reason pyqt raises _TypeError_ here
pass
self._relay_test.finished.connect(_cleanup, Qt.UniqueConnection)
else:
self._relay_test.start_relay_test(self.mapped_address)
def turn_state_changed(self, state):
if state == TURNState.BOUND:
self.relay_address = self._socket.relay_address
self.mapped_address = self._socket.relay_address
self.ready.emit()
def handle_SendNatPacket(self, msg):
target, message = msg['args']
host, port = target.split(':')
if self.state is None and self._socket.localPort() == self._port:
self._socket.randomize_port()
self._socket.writeDatagram(b'\x08'+message.encode(), QHostAddress(host), int(port))
def handle_ConnectivityState(self, msg):
from client import ClientState
state, addr = msg['args']
if state == 'BLOCKED':
self._logger.warning("Outbound traffic is blocked")
QtGui.QMessageBox.warning(None, "Traffic Blocked", "Your outbound traffic appears to be blocked. Try restarting FAF. <br/> If the error persists please contact a moderator and send your logs. <br/> We are already working on a solution to this problem.")
self._client.state = ClientState.NONE
else:
host, port = addr.split(':')
self.state, self.mapped_address = state, (host, port)
self.connectivity_status_established.emit(self.state, self.addr)
self._logger.info("Connectivity state is {}, mapped address: {}".format(state, addr))
def handle_message(self, msg):
command = msg.get('command')
if command == 'CreatePermission':
self._socket.permit(msg['args'])
def bind(self, (host, port), login, peer_id):
host, port = host, int(port)
relay = Relay(self.game_port, login, peer_id, partial(self.send_udp, (host, port)))
relay.bound.connect(partial(self.peer_bound.emit, login, peer_id))
relay.listen()
self._relays[(host, port)] = relay
