class Server(QWidget):
def __init__(self):
QWidget.__init__(self)
self.serverOpen = False
self.tcpServer = None
self.tcpServerConnection = None
self.textEdit = None
self.lineEdit = None
self.create_widgets()
def create_widgets(self):
self.tcpServer = QTcpServer()
self.textEdit = QTextEdit()
self.textEdit.setReadOnly(True)
self.lineEdit = QLineEdit()
self.lineEdit.setPlaceholderText("Enter response")
self.lineEdit.setMaxLength(50)
self.lineEdit.setEnabled(True)
vBox = QVBoxLayout()
vBox.addWidget(self.textEdit)
vBox.addWidget(self.lineEdit)
self.setLayout(vBox)
self.tcpServer.newConnection.connect(self.accept_connection)
def add_message(self, message):
self.textEdit.moveCursor(QTextCursor.End)
self.textEdit.insertPlainText(message)
self.textEdit.moveCursor(QTextCursor.End)
def open_server(self):
if (len(self.lineEdit.text()) == 0):
self.add_message("You must enter a response\n")
QMessageBox.critical(self, "Error", "You must enter a response")
return False
self.tcpServer.listen(QHostAddress(__serverUrl__), 9000)
self.serverOpen = self.tcpServer.isListening()
if (self.serverOpen):
serverAddress = self.tcpServer.serverAddress().toString()
serverPort = self.tcpServer.serverPort()
self.add_message("Server opened on %s on port %d\n" %
(serverAddress, serverPort))
self.lineEdit.setEnabled(False)
else:
self.add_message(self.tcpServer.errorString())
QMessageBox.critical(self, "Error", self.tcpServer.errorString())
return True
def accept_connection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.receive_data)
self.tcpServerConnection.disconnected.connect(self.socket_disconnected)
peerAddress = self.tcpServerConnection.peerAddress().toString()
peerPort = self.tcpServerConnection.peerPort()
self.add_message("Connected to %s on port %d\n" %
(peerAddress, peerPort))
def receive_data(self):
rxData = self.tcpServerConnection.readAll()
self.add_message("Received '" + rxData.data().decode('utf8') + "'\n")
txString = self.lineEdit.text()
self.tcpServerConnection.write(txString.encode())
self.add_message("Wrote '" + txString + "'\n")
def socket_disconnected(self):
self.add_message("Disconnected from client\n")
def close_server(self):
if (self.serverOpen):
self.tcpServer.close()
self.lineEdit.setEnabled(True)
class Server(QDialog):
FORTUNES = (
"You've been leading a dog's life. Stay off the furniture.",
"You've got to think about tomorrow.",
"You will be surprised by a loud noise.",
"You will feel hungry again in another hour.",
"You might have mail.",
"You cannot kill time without injuring eternity.",
"Computers are not intelligent. They only think they are.")
def __init__(self, parent=None):
super(Server, self).__init__(parent)
self.tcpServer = None
self.networkSession = None
self.statusLabel = QLabel()
quitButton = QPushButton("Quit")
quitButton.setAutoDefault(False)
manager = QNetworkConfigurationManager()
if manager.capabilities() & QNetworkConfigurationManager.NetworkSessionRequired:
settings = QSettings(QSettings.UserScope, 'QtProject')
settings.beginGroup('QtNetwork')
id = settings.value('DefaultNetworkConfiguration', '')
settings.endGroup()
config = manager.configurationFromIdentifier(id)
if config.state() & QNetworkConfiguration.Discovered == 0:
config = manager.defaultConfiguration()
self.networkSession = QNetworkSession(config, self)
self.networkSession.opened.connect(self.sessionOpened)
self.statusLabel.setText("Opening network session.")
self.networkSession.open()
else:
self.sessionOpened()
quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.sendFortune)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle("Fortune Server")
def sessionOpened(self):
if self.networkSession is not None:
config = self.networkSession.configuration()
if config.type() == QNetworkConfiguration.UserChoice:
id = self.networkSession.sessionProperty('UserChoiceConfiguration')
else:
id = config.identifier()
settings = QSettings(QSettings.UserScope, 'QtProject')
settings.beginGroup('QtNetwork')
settings.setValue('DefaultNetworkConfiguration', id)
settings.endGroup();
self.tcpServer = QTcpServer(self)
if not self.tcpServer.listen():
QMessageBox.critical(self, "Fortune Server",
"Unable to start the server: %s." % self.tcpServer.errorString())
self.close()
return
for ipAddress in QNetworkInterface.allAddresses():
if ipAddress != QHostAddress.LocalHost and ipAddress.toIPv4Address() != 0:
break
else:
ipAddress = QHostAddress(QHostAddress.LocalHost)
ipAddress = ipAddress.toString()
self.statusLabel.setText("The server is running on\n\nIP: %s\nport %d\n\n"
"Run the Fortune Client example now." % (ipAddress, self.tcpServer.serverPort()))
def sendFortune(self):
fortune = self.FORTUNES[random.randint(0, len(self.FORTUNES) - 1)]
block = QByteArray()
out = QDataStream(block, QIODevice.WriteOnly)
out.setVersion(QDataStream.Qt_4_0)
out.writeUInt16(0)
out.writeQString(fortune)
out.device().seek(0)
out.writeUInt16(block.size() - 2)
clientConnection = self.tcpServer.nextPendingConnection()
clientConnection.disconnected.connect(clientConnection.deleteLater)
clientConnection.write(block)
clientConnection.disconnectFromHost()
class Server(QDialog):
FORTUNES = ("You've been leading a dog's life. Stay off the furniture.",
"You've got to think about tomorrow.",
"You will be surprised by a loud noise.",
"You will feel hungry again in another hour.",
"You might have mail.",
"You cannot kill time without injuring eternity.",
"Computers are not intelligent. They only think they are.")
def __init__(self, parent=None):
super(Server, self).__init__(parent)
self.tcpServer = None
self.networkSession = None
self.statusLabel = QLabel()
quitButton = QPushButton("Quit")
quitButton.setAutoDefault(False)
manager = QNetworkConfigurationManager()
if manager.capabilities(
) & QNetworkConfigurationManager.NetworkSessionRequired:
settings = QSettings(QSettings.UserScope, 'QtProject')
settings.beginGroup('QtNetwork')
id = settings.value('DefaultNetworkConfiguration', '')
settings.endGroup()
config = manager.configurationFromIdentifier(id)
if config.state() & QNetworkConfiguration.Discovered == 0:
config = manager.defaultConfiguration()
self.networkSession = QNetworkSession(config, self)
self.networkSession.opened.connect(self.sessionOpened)
self.statusLabel.setText("Opening network session.")
self.networkSession.open()
else:
self.sessionOpened()
quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.sendFortune)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle("Fortune Server")
def sessionOpened(self):
if self.networkSession is not None:
config = self.networkSession.configuration()
if config.type() == QNetworkConfiguration.UserChoice:
id = self.networkSession.sessionProperty(
'UserChoiceConfiguration')
else:
id = config.identifier()
settings = QSettings(QSettings.UserScope, 'QtProject')
settings.beginGroup('QtNetwork')
settings.setValue('DefaultNetworkConfiguration', id)
settings.endGroup()
self.tcpServer = QTcpServer(self)
if not self.tcpServer.listen():
QMessageBox.critical(
self, "Fortune Server", "Unable to start the server: %s." %
self.tcpServer.errorString())
self.close()
return
for ipAddress in QNetworkInterface.allAddresses():
if ipAddress != QHostAddress.LocalHost and ipAddress.toIPv4Address(
) != 0:
break
else:
ipAddress = QHostAddress(QHostAddress.LocalHost)
ipAddress = ipAddress.toString()
self.statusLabel.setText(
"The server is running on\n\nIP: %s\nport %d\n\n"
"Run the Fortune Client example now." %
(ipAddress, self.tcpServer.serverPort()))
def sendFortune(self):
fortune = self.FORTUNES[random.randint(0, len(self.FORTUNES) - 1)]
block = QByteArray()
out = QDataStream(block, QIODevice.WriteOnly)
out.setVersion(QDataStream.Qt_4_0)
out.writeUInt16(0)
out.writeQString(fortune)
out.device().seek(0)
out.writeUInt16(block.size() - 2)
clientConnection = self.tcpServer.nextPendingConnection()
clientConnection.disconnected.connect(clientConnection.deleteLater)
clientConnection.write(block)
clientConnection.disconnectFromHost()
class Dialog(QDialog):
TotalBytes = 50 * 1024 * 1024
PayloadSize = 65536
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.tcpServer = QTcpServer()
self.tcpClient = QTcpSocket()
self.bytesToWrite = 0
self.bytesWritten = 0
self.bytesReceived = 0
self.clientProgressBar = QProgressBar()
self.clientStatusLabel = QLabel("Client ready")
self.serverProgressBar = QProgressBar()
self.serverStatusLabel = QLabel("Server ready")
self.startButton = QPushButton("&Start")
self.quitButton = QPushButton("&Quit")
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.startButton.clicked.connect(self.start)
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.acceptConnection)
self.tcpClient.connected.connect(self.startTransfer)
self.tcpClient.bytesWritten.connect(self.updateClientProgress)
self.tcpClient.error.connect(self.displayError)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.clientProgressBar)
mainLayout.addWidget(self.clientStatusLabel)
mainLayout.addWidget(self.serverProgressBar)
mainLayout.addWidget(self.serverStatusLabel)
mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Loopback")
def start(self):
self.startButton.setEnabled(False)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.bytesWritten = 0
self.bytesReceived = 0
while not self.tcpServer.isListening() and not self.tcpServer.listen():
ret = QMessageBox.critical(
self,
"Loopback",
"Unable to start the test: %s." % self.tcpServer.errorString(),
QMessageBox.Retry | QMessageBox.Cancel,
)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText("Listening")
self.clientStatusLabel.setText("Connecting")
self.tcpClient.connectToHost(QHostAddress(QHostAddress.LocalHost),
self.tcpServer.serverPort())
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.updateServerProgress)
self.tcpServerConnection.error.connect(self.displayError)
self.serverStatusLabel.setText("Accepted connection")
self.tcpServer.close()
def startTransfer(self):
self.bytesToWrite = Dialog.TotalBytes - self.tcpClient.write(
QByteArray(Dialog.PayloadSize, "@"))
self.clientStatusLabel.setText("Connected")
def updateServerProgress(self):
self.bytesReceived += self.tcpServerConnection.bytesAvailable()
self.tcpServerConnection.readAll()
self.serverProgressBar.setMaximum(Dialog.TotalBytes)
self.serverProgressBar.setValue(self.bytesReceived)
self.serverStatusLabel.setText("Received %dMB" % (self.bytesReceived /
(1024 * 1024)))
if self.bytesReceived == Dialog.TotalBytes:
self.tcpServerConnection.close()
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
def updateClientProgress(self, numBytes):
self.bytesWritten += numBytes
if self.bytesToWrite > 0:
self.bytesToWrite -= self.tcpClient.write(
QByteArray(min(self.bytesToWrite, Dialog.PayloadSize), "@"))
self.clientProgressBar.setMaximum(Dialog.TotalBytes)
self.clientProgressBar.setValue(self.bytesWritten)
self.clientStatusLabel.setText("Sent %dMB" % (self.bytesWritten /
(1024 * 1024)))
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(
self,
"Network error",
"The following error occured: %s." % self.tcpClient.errorString(),
)
self.tcpClient.close()
self.tcpServer.close()
self.clientProgressBar.reset()
self.serverProgressBar.reset()
self.clientStatusLabel.setText("Client ready")
self.serverStatusLabel.setText("Server ready")
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
class Server(QObject):
debug = True
log = sys.stderr
username = '******'
password = '******'
stopServing = pyqtSlot()
def __init__(self, parent=None):
super(Server, self).__init__(parent)
self.proxy_server = QTcpServer(self)
self.proxy_server.listen(QHostAddress.Any, 8000)
self.proxy_server.newConnection.connect(self.manage_request)
if self.debug:
self.log.write('Server running on localhost port %s\n\n' %
self.port())
def port(self):
return self.proxy_server.serverPort()
def addr(self):
return self.proxy_server.serverAddress().toString()
def stopServing(self):
if self.debug:
self.log.write('Service is stopping...\n\n')
# does not "close" the server, just stop listening...
self.proxy_server.close()
if self.proxy_server.hasPendingConnections():
socket = self.proxy_server.nextPendingConnection()
while socket:
socket.abort()
socket = self.proxy_server.nextPendingConnection()
def manage_request(self):
proxy_server = self.sender()
# Qt docs says that the caller of nextPendingConnection()
# is the parent of the socket
socket = proxy_server.nextPendingConnection()
socket.readyRead.connect(self.process_request)
socket.disconnected.connect(socket.deleteLater)
def authorize_request(self, request_data):
return True
header = QHttpRequestHeader(QString(request_data))
if self.debug:
self.log.write(header.toString())
auth = header.value('Proxy-Authorization')
if not auth:
return False
challenge = base64.b64encode(self.username + ':' + self.password)
return challenge == str(auth).split()[1]
def process_request(self):
socket = self.sender()
request_data = socket.readAll()
if not self.authorize_request(request_data):
socket.write('HTTP/1.1 407 Proxy Authentication Required\r\n')
if self.debug:
self.log.write('407 Proxy Authentication Required\n\n')
socket.write('Proxy-Authenticate: Basic realm="test"\r\n')
socket.write('\r\n')
socket.disconnectFromHost()
return
else:
# remove Proxy-Authorization header
start = request_data.indexOf('Proxy-Authorization:')
end = request_data.lastIndexOf('\r\n')
request_data.remove(start, end)
request_data.append('\r\n')
pos = request_data.indexOf('\r\n')
request_line = request_data.left(pos)
request_data.remove(0, pos + 2)
entries = request_line.split(' ')
method = entries[0]
address = entries[1]
version = entries[2]
port = '80'
if address.count(':') > 1:
protocol, host, port = address.split(':')
else:
protocol, host = address.split(':')
print('address' + str(address))
#url = QUrl( protocol + host )
url = QUrl.fromEncoded(address)
#url.setHost( host )
#url.setPort( int(port) )
if not url.isValid():
if self.debug:
self.log.write('Invalid URL: %s\n\n', url)
socket.disconnectFromHost()
return
host = url.host()
port = 80 if (url.port() < 0) else url.port()
req = url.encodedPath()
if url.hasQuery():
req.append('?').append(url.encodedQuery())
request_line = method + ' ' + req + ' ' + version + '\r\n'
request_data.prepend(request_line)
if self.debug:
self.log.write(method + ' ' + address + ' ' + version + '\n\n')
key = host + ':' + QString.number(port)
proxy_socket = socket.findChild(QTcpSocket, key)
if proxy_socket:
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.write(request_data)
else:
proxy_socket = QTcpSocket(socket)
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.connected.connect(self.send_request)
proxy_socket.readyRead.connect(self.transfer_data)
proxy_socket.disconnected.connect(self.close_connection)
proxy_socket.error.connect(self.close_connection)
proxy_socket.connectToHost(host, port)
def send_request(self):
proxy_socket = self.sender()
request_data = proxy_socket.property('request_data').toByteArray()
proxy_socket.write(request_data)
def transfer_data(self):
proxy_socket = self.sender()
socket = proxy_socket.parent()
socket.write(proxy_socket.readAll())
def close_connection(self):
proxy_socket = self.sender()
if proxy_socket:
socket = proxy_socket.parent()
if isinstance(socket, QTcpSocket) and socket:
socket.disconnectFromHost()
if proxy_socket.error() != QTcpSocket.RemoteHostClosedError:
url = proxy_socket.property('url').toUrl()
error_string = proxy_socket.errorString()
if self.debug:
self.log.write('Error for %s %s\n\n' % (url, error_string))
proxy_socket.deleteLater()
class ServerSocket(QObject):
"""Class defining a socket for the server."""
listening = pyqtSignal(tuple)
message_received = pyqtSignal(tuple)
client_disconnected = pyqtSignal(str)
def __init__(self):
"""Constructor."""
QObject.__init__(self)
self.__tcpServer = QTcpServer()
self.__active_sockets = []
self.__tcpServer.newConnection.connect(self.__new_connection)
def __new_connection(self):
"""Method handling a new connection to the server."""
# Connecting the new client
client = self.__tcpServer.nextPendingConnection()
client.readyRead.connect(self.read_message)
client.disconnected.connect(self.__find_disconnected_client)
client.disconnected.connect(client.deleteLater) # Not sure
self.__active_sockets.append(client) # Hyper important !!!
print("A new client connected from address '{}'.".format(
client.peerAddress().toString()))
def __find_disconnected_client(self):
"""Method trying to find the disconnected client."""
self.client_disconnected.emit(self.sender().localAddress().toString())
self.__active_sockets = []
for socket in self.__tcpServer.children()[1:]:
if int(socket.socketDescriptor()) <= 10000: # Socket is active
self.__active_sockets.append(socket)
def get_available_ips(self):
"""Method returning the list of available ips."""
return QNetworkInterface.allAddresses()
def listen(self, host=None, port=3000):
"""Method making the server listening to a given address."""
# If no address was specified: trying to give the best one
if host is None:
for ip in self.get_available_ips():
if ip != QHostAddress.LocalHost and ip.toIPv4Address():
host = ip
if host is None: # No suitable address was found
host = QHostAddress.LocalHost
# The address was given as string
if type(host) == str:
host = QHostAddress(host)
# For printing...
address = "{}:{}".format(host.toString(), port)
# Launching server
if not self.__tcpServer.listen(host, port):
self.__tcpServer.close()
print("Unable to listen on address '{}': {}.".format(
address, self.__tcpServer.errorString()))
raise ConnectionError(self.__tcpServer.errorString())
else:
print("Server is listening on address '{}'.".format(address))
self.listening.emit((host, port))
def read_message(self):
"""Method handling the messages."""
for socket in self.__active_sockets:
instr = socket.readAll()
message = str(instr, encoding="utf8")
if message:
self.message_received.emit((message, socket))
def __send_msg(self, message, socket):
"""Method effectively sending a message."""
socket.write(bytes(message, encoding="utf8"))
socket.flush()
def send_message(self, message, recipient=None):
"""Method used to send a message to the clients."""
if recipient: # A single recipient was provided
if type(recipient) is not str: # Given socket directly
self.__send_msg(message, recipient)
else: # Given ip address
for socket in self.__active_sockets:
if socket.peerAddress().toString() == recipient:
self.__send_msg(message, socket)
else: # Send for everyone
for socket in self.__active_sockets:
self.__send_msg(message, socket)
# block = QByteArray()
# out = QDataStream(block, QIODevice.ReadWrite)
# out.setVersion(QDataStream.Qt_5_0)
# out.writeUInt16(0)
# message = bytes(message, encoding="utf8")
# out.writeString(message)
# out.device().seek(0)
# out.writeUInt16(block.size() - 2)
# socket.write(block)
def get_address(self):
"""Method returning the adress."""
return self.__tcpServer.serverAddress()
def get_port(self):
"""Method returning the port."""
return self.__tcpServer.serverPort()
class GameSession(QObject):
ready = pyqtSignal()
gameFullSignal = pyqtSignal()
def __init__(self, client, connectivity):
QObject.__init__(self)
self._state = GameSessionState.OFF
self._rehost = False
self.game_uid = None
self.game_name = None
self.game_mod = None
self.game_visibility = None
self.game_map = None
self.game_password = None
# Subscribe to messages targeted at 'game' from the server
client.lobby_dispatch.subscribe_to('game', self.handle_message)
# Connectivity helper
self.connectivity = connectivity
self.connectivity.ready.connect(self.ready.emit)
self.connectivity.peer_bound.connect(self._peer_bound)
# Keep a parent pointer so we can use it to send
# relay messages about the game state
self._client = client # type: Client
self.me = client.me
self.game_port = client.gamePort
# Use the normal lobby by default
self.init_mode = 0
self._joins, self._connects = [], []
# 'GPGNet' TCP listener
self._game_listener = QTcpServer(self)
self._game_listener.newConnection.connect(self._new_game_connection)
self._game_listener.listen(QHostAddress.LocalHost)
# We only allow one game connection at a time
self._game_connection = None
self._process = instance # type:'GameProcess'
self._process.started.connect(self._launched)
self._process.finished.connect(self._exited)
@property
def relay_port(self):
return self._game_listener.serverPort()
@property
def state(self):
return self._state
@state.setter
def state(self, val):
self._state = val
def listen(self):
"""
Start listening for remote commands
Call this in good time before hosting a game,
e.g. when the host game dialog is being shown.
"""
assert self.state == GameSessionState.OFF
self.state = GameSessionState.LISTENING
if self.connectivity.is_ready:
self.ready.emit()
else:
self.connectivity.prepare()
def _needs_game_connection(fn):
def wrap(self, *args, **kwargs):
if self._game_connection is None:
logger.warning(
"{}.{}: tried to run without a game connection".format(
self.__class__.__name__, fn.__name__))
else:
return fn(self, *args, **kwargs)
return wrap
@_needs_game_connection
def handle_message(self, message):
command, args = message.get('command'), message.get('args', [])
if command == 'SendNatPacket':
addr_and_port, message = args
host, port = addr_and_port.split(':')
self.connectivity.send(message, (host, port))
elif command == 'CreatePermission':
addr_and_port = args[0]
host, port = addr_and_port.split(':')
self.connectivity.permit((host, port))
elif command == 'JoinGame':
addr, login, peer_id = args
self._joins.append(peer_id)
self.connectivity.bind(addr, login, peer_id)
elif command == 'ConnectToPeer':
addr, login, peer_id = args
self._connects.append(peer_id)
self.connectivity.bind(addr, login, peer_id)
else:
self._game_connection.send(command, *args)
def send(self, command_id, args):
logger.info("Outgoing relay message {} {}".format(command_id, args))
self._client.lobby_connection.send({
'command': command_id,
'target': 'game',
'args': args or []
})
@_needs_game_connection
def _peer_bound(self, login, peer_id, port):
logger.info("Bound peer {}/{} to {}".format(login, peer_id, port))
if peer_id in self._connects:
self._game_connection.send('ConnectToPeer',
'127.0.0.1:{}'.format(port), login,
peer_id)
self._connects.remove(peer_id)
elif peer_id in self._joins:
self._game_connection.send('JoinGame', '127.0.0.1:{}'.format(port),
login, peer_id)
self._joins.remove(peer_id)
def _new_game_connection(self):
logger.info("Game connected through GPGNet")
assert not self._game_connection
self._game_connection = GPGNetConnection(
self._game_listener.nextPendingConnection())
self._game_connection.messageReceived.connect(self._on_game_message)
self.state = GameSessionState.RUNNING
@_needs_game_connection
def _on_game_message(self, command, args):
logger.info("Incoming GPGNet: {} {}".format(command, args))
if command == "GameState":
if args[0] == 'Idle':
# autolobby, port, nickname, uid, hasSupcom
self._game_connection.send("CreateLobby", self.init_mode,
self.game_port + 1,
self.me.player.login,
self.me.player.id, 1)
elif args[0] == 'Lobby':
# TODO: Eagerly initialize the game by hosting/joining early
pass
elif command == 'Rehost':
self._rehost = True
elif command == 'GameFull':
self.gameFullSignal.emit()
self.send(command, args)
def _turn_state_changed(self, val):
if val == TURNState.BOUND:
self.ready.emit()
def _launched(self):
logger.info("Game has started")
def _exited(self, status):
self._game_connection = None
self.state = GameSessionState.OFF
logger.info("Game has exited with status code: {}".format(status))
self.send('GameState', ['Ended'])
if self._rehost:
self._client.host_game(title=self.game_name,
mod=self.game_mod,
visibility=self.game_visibility,
mapname=self.game_map,
password=self.game_password,
is_rehost=True)
self._rehost = False
self.game_uid = None
self.game_name = None
self.game_mod = None
self.game_visibility = None
self.game_map = None
self.game_password = None
class Dialog(QDialog):
TotalBytes = 50 * 1024 * 1024
PayloadSize = 65536
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.tcpServer = QTcpServer()
self.tcpClient = QTcpSocket()
self.bytesToWrite = 0
self.bytesWritten = 0
self.bytesReceived = 0
self.clientProgressBar = QProgressBar()
self.clientStatusLabel = QLabel("Client ready")
self.serverProgressBar = QProgressBar()
self.serverStatusLabel = QLabel("Server ready")
self.startButton = QPushButton("&Start")
self.quitButton = QPushButton("&Quit")
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.startButton.clicked.connect(self.start)
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.acceptConnection)
self.tcpClient.connected.connect(self.startTransfer)
self.tcpClient.bytesWritten.connect(self.updateClientProgress)
self.tcpClient.error.connect(self.displayError)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.clientProgressBar)
mainLayout.addWidget(self.clientStatusLabel)
mainLayout.addWidget(self.serverProgressBar)
mainLayout.addWidget(self.serverStatusLabel)
mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Loopback")
def start(self):
self.startButton.setEnabled(False)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.bytesWritten = 0
self.bytesReceived = 0
while not self.tcpServer.isListening() and not self.tcpServer.listen():
ret = QMessageBox.critical(self, "Loopback",
"Unable to start the test: %s." % self.tcpServer.errorString(),
QMessageBox.Retry | QMessageBox.Cancel)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText("Listening")
self.clientStatusLabel.setText("Connecting")
self.tcpClient.connectToHost(QHostAddress(QHostAddress.LocalHost), self.tcpServer.serverPort())
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.updateServerProgress)
self.tcpServerConnection.error.connect(self.displayError)
self.serverStatusLabel.setText("Accepted connection")
self.tcpServer.close()
def startTransfer(self):
self.bytesToWrite = Dialog.TotalBytes - self.tcpClient.write(QByteArray(Dialog.PayloadSize, '@'))
self.clientStatusLabel.setText("Connected")
def updateServerProgress(self):
self.bytesReceived += self.tcpServerConnection.bytesAvailable()
self.tcpServerConnection.readAll()
self.serverProgressBar.setMaximum(Dialog.TotalBytes)
self.serverProgressBar.setValue(self.bytesReceived)
self.serverStatusLabel.setText("Received %dMB" % (self.bytesReceived / (1024 * 1024)))
if self.bytesReceived == Dialog.TotalBytes:
self.tcpServerConnection.close()
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
def updateClientProgress(self, numBytes):
self.bytesWritten += numBytes
if self.bytesToWrite > 0:
self.bytesToWrite -= self.tcpClient.write(QByteArray(
min(self.bytesToWrite, Dialog.PayloadSize), '@'))
self.clientProgressBar.setMaximum(Dialog.TotalBytes)
self.clientProgressBar.setValue(self.bytesWritten)
self.clientStatusLabel.setText("Sent %dMB" % (self.bytesWritten / (1024 * 1024)))
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(self, "Network error",
"The following error occured: %s." % self.tcpClient.errorString())
self.tcpClient.close()
self.tcpServer.close()
self.clientProgressBar.reset()
self.serverProgressBar.reset()
self.clientStatusLabel.setText("Client ready")
self.serverStatusLabel.setText("Server ready")
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
class BaristaServer():
MIN_PORT = 0
MAX_PORT = 65535
DEFAULT_PORT = 4200
def __init__(self, application, ip, port, sessionPath):
self.application = application
self.server = None
self.port = int(port)
self.ip = QHostAddress.Any
if ip is not None:
self.ip = QHostAddress(ip)
self.sessionPath = sessionPath
self.configpath = os.path.join(self.sessionPath, "barista.conf") ####
self.hardware = []
self.trainOnHW = 0
self.transactionList = []
self._loadConfig()
self.checkHardware()
state = self._checkConfig()
self.start()
self.sessionManager = ServerSessionManager(self, self.sessionPath)
def start(self):
self.server = QTcpServer()
self.server.listen(self.ip, self.port)
self.server.newConnection.connect(self._newConnection)
if self.server.isListening():
hostIP = str(self.server.serverAddress().toString())
if hostIP == '0.0.0.0':
hostIP = '<any>'
sys.stdout.write("Hostname: " + socket.gethostname() + "\tIP: " +
hostIP + ":" + str(self.server.serverPort()) +
"\n")
else:
sys.stderr.write(
"Something went wrong. Server is not listening.\n")
logging.error("Something went wrong. Server is not listening.")
exit(1)
def getBaristaStatus(self, pid=""):
hardware = [k["name"] for k in self.hardware]
statusdict = {"trainOnHW": self.trainOnHW, "hardware": hardware}
statusdict["connections"] = len(self.transactionList)
statusdict["config"] = self._checkConfig(False)
statusdict["training"] = len(
self.sessionManager.findSessionIDsWithState(State.RUNNING)) is 0
statusdict["sessioncount"] = len(self.sessionManager.sessions)
statusdict["sessionpath"] = self.sessionPath
if pid is not "":
pidses = {}
sessions = set(self.sessionManager.findSessionIDsByProjectId(pid))
pidses["pid"] = pid
pidses["count"] = len(sessions)
pidses["running"] = len(
set(self.sessionManager.findSessionIDsWithState(State.RUNNING))
& sessions)
pidses["running"] += len(
set(self.sessionManager.findSessionIDsWithState(State.PAUSED))
& sessions)
pidses["waiting"] = len(
set(self.sessionManager.findSessionIDsWithState(State.WAITING))
& sessions)
pidses["finished"] = len(
set(self.sessionManager.findSessionIDsWithState(
State.FINISHED)) & sessions)
statusdict["projectsessions"] = pidses
return statusdict
def _newConnection(self):
transaction = ServerTransaction(self)
self.transactionList.append(transaction)
transaction.socketClosed.connect(
lambda item=transaction: self._deleteConnection(item))
transaction.acceptClient(self.server.nextPendingConnection())
def _deleteConnection(self, transaction):
index = self.transactionList.index(transaction)
del self.transactionList[index]
def _saveConfig(self):
#Save train on hardware
tosave = dict()
tosave["trainOnHW"] = self.trainOnHW
with open(self.configpath, "w") as file:
json.dump(tosave, file, sort_keys=True, indent=4)
def _loadConfig(self):
####
if not os.path.exists(self.configpath):
# TODO Default
pass
else:
with open(self.configpath, "r") as file:
res = json.load(file)
if "trainOnHW" in res:
self.trainOnHW = res["trainOnHW"]
else:
# TODO default
pass
def _checkConfig(self, verbose=True):
state = True
caffe_versions.loadVersions(self.sessionPath)
if caffe_versions.versionCount() == 0:
if verbose:
sys.stderr.write(
"Warning: There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path.\n"
)
logging.warning(
"There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path."
)
if self.trainOnHW >= len(self.hardware):
self.trainOnHW = 0
if verbose:
sys.stderr.write(
"Warning: Currently selected Hardware could not be matched against detected Hardware."
" Set to CPU mode!\n")
logging.warning(
"Currently selected Hardware could not be matched against detected Hardware."
" Set to CPU mode!")
return state
def checkHardware(self, verbose=True, transaction=None):
caffe_versions.loadVersions(self.sessionPath)
if caffe_versions.versionCount() == 0:
if verbose:
sys.stderr.write(
"Warning: Can't check hardware without Caffeversions\n")
logging.warning("Can't check hardware without Caffeversions")
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": False,
"error": "Can't check hardware without Caffeversions"
}
transaction.send(msg)
return
try:
binary = caffe_versions.getDefaultVersion().getBinarypath()
self.hardware = checkHardware(binary, not verbose, transaction)
if verbose:
sys.stdout.write("Finished scanning Hardware. " +
str(len(self.hardware)) + " devices found.\n")
logging.info("Finished scanning Hardware. %s devices found.",
str(len(self.hardware)))
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": True,
"finished": True,
"hardware": self.hardware,
"current": self.trainOnHW
}
transaction.send(msg)
except:
if verbose:
sys.stderr.write("Error: Failed to check hardware!\n")
logging.error("Failed to check hardware!")
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": False,
"error": "Failed to check hardware!"
}
transaction.send(msg)
def setHardware(self, hid):
if hid >= len(self.hardware):
return False
self.trainOnHW = hid
self._saveConfig()
return True
class Server(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.cam = webcam(640, 480, '/dev/video0')
self.cam.activate()
self.statusLabel = QLabel()
self.quitButton = QPushButton("Quit")
self.quitButton.setAutoDefault(False)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(self.quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle('Frame Server')
self.tcpServer = QTcpServer(self)
self.tcpServer.listen()
self.client = None
ipAddress = ''
for address in QNetworkInterface.allAddresses():
if address != QHostAddress.LocalHost and address.toIPv4Address():
ipAddress = address.toString()
break
if len(ipAddress) == 0:
ipAddress = QHostAddress(QHostAddress.LocalHost).toString()
self.statusLabel.setText(
'Address:\t\t{}\nPort:\t\t\t{}'.format(ipAddress, self.tcpServer.serverPort()))
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.clientConnected)
def clientConnected(self):
self.client = self.tcpServer.nextPendingConnection()
self.client.disconnected.connect(self.client.deleteLater)
self.client.disconnected.connect(self.clientDisconnected)
self.client.readyRead.connect(self.sendFrame)
self.client.readyRead.connect(self.client.readAll)
self.client.setReadBufferSize(32)
self.tcpServer.pauseAccepting()
def clientDisconnected(self):
self.client = None
self.tcpServer.resumeAccepting()
def sendFrame(self):
block = QByteArray()
out = QDataStream(block, QIODevice.WriteOnly)
out.setVersion(QDataStream.Qt_5_0)
frame = huffman.encode(self.cam.capture())
out.writeInt32(len(frame))
out.writeRawData(frame)
self.client.write(block)
class Dialog(QDialog):
def __init__(self, parent: QWidget = None) -> None:
super().__init__(parent)
self.tcpServer = QTcpServer()
self.tcpClient = QTcpSocket()
self.tcpServerConnection: QTcpSocket = None
self.bytesToWrite = 0
self.bytesWritten = 0
self.bytesReceived = 0
self.clientProgressBar = QProgressBar()
self.clientStatusLabel = QLabel(self.tr("Client ready"))
self.serverProgressBar = QProgressBar()
self.serverStatusLabel = QLabel(self.tr("Server ready"))
self.startButton = QPushButton(self.tr("&Start"))
self.quitButton = QPushButton(self.tr("&Quit"))
self.buttonBox = QDialogButtonBox()
self.buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.startButton.clicked.connect(self.start)
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.acceptConnection)
self.tcpClient.connected.connect(self.startTransfer)
self.tcpClient.bytesWritten.connect(self.updateClientProgress)
self.tcpClient.error.connect(self.displayError)
mainLayout = QVBoxLayout(self)
mainLayout.addWidget(self.clientProgressBar)
mainLayout.addWidget(self.clientStatusLabel)
mainLayout.addWidget(self.serverProgressBar)
mainLayout.addWidget(self.serverStatusLabel)
mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(self.buttonBox)
@pyqtSlot()
def start(self):
self.startButton.setEnabled(False)
QGuiApplication.setOverrideCursor(Qt.WaitCursor)
self.bytesWritten = 0
self.bytesReceived = 0
while not self.tcpServer.isListening() and not self.tcpServer.listen():
ret = QMessageBox.critical(
self,
self.tr("Loopback"),
self.tr(
"Unable to start the test: %s" % (self.tcpServer.errorString())
),
QMessageBox.Retry | QMessageBox.Cancel,
)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText(self.tr("Listening"))
self.clientStatusLabel.setText(self.tr("Connecting"))
self.tcpClient.connectToHost(
QHostAddress.LocalHost, self.tcpServer.serverPort()
)
@pyqtSlot()
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
if not self.tcpServerConnection:
self.serverStatusLabel.setText(
self.tr("Error: got invalid pending connection!")
)
return
self.tcpServerConnection.readyRead.connect(self.updateServerProgress)
self.tcpServerConnection.error.connect(self.displayError)
self.tcpServerConnection.disconnected.connect(
self.tcpServerConnection.deleteLater
)
self.serverStatusLabel.setText(self.tr("Accepted connection"))
self.tcpServer.close()
@pyqtSlot()
def startTransfer(self):
# called when the TCP client connected to the loopback server
self.bytesToWrite = TOTAL_BYTES - int(
self.tcpClient.write(QByteArray(PAYLOAD_SIZE, "@"))
)
self.clientStatusLabel.setText(self.tr("Connected"))
@pyqtSlot()
def updateServerProgress(self):
self.bytesReceived += int(self.tcpServerConnection.bytesAvailable())
self.tcpServerConnection.readAll()
self.serverProgressBar.setMaximum(TOTAL_BYTES)
self.serverProgressBar.setValue(self.bytesReceived)
self.serverStatusLabel.setText(
self.tr("Received %dMB" % (self.bytesReceived / (1024 * 1024),))
)
if self.bytesReceived == TOTAL_BYTES:
self.tcpServerConnection.close()
self.startButton.setEnabled(True)
QGuiApplication.restoreOverrideCursor()
@pyqtSlot("qint64")
def updateClientProgress(self, numBytes):
self.bytesWritten += int(numBytes)
if self.bytesToWrite > 0 and self.tcpClient.bytesToWrite() <= 4 * PAYLOAD_SIZE:
self.bytesToWrite -= self.tcpClient.write(
QByteArray(min(self.bytesToWrite, PAYLOAD_SIZE), "@")
)
self.clientProgressBar.setMaximum(TOTAL_BYTES)
self.clientProgressBar.setValue(self.bytesWritten)
self.clientStatusLabel.setText(
self.tr("Sent %dMB" % (self.bytesWritten / (1024 * 1024),))
)
@pyqtSlot(QAbstractSocket.SocketError)
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(
self,
self.tr("Network error"),
self.tr(
"The following error occurred: %s." % (self.tcpClient.errorString(),)
),
)
self.tcpClient.close()
self.tcpServer.close()
self.clientProgressBar.reset()
self.serverProgressBar.reset()
self.clientStatusLabel.setText(self.tr("Client ready"))
self.serverStatusLabel.setText(self.tr("Server ready"))
self.startButton.setEnabled(True)
QGuiApplication.restoreOverrideCursor()
