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