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()