class MainApp(QCoreApplication): def __init__(self, argv): super().__init__(argv) self.server = QTcpServer(self) self.server.setMaxPendingConnections(1) self.server.newConnection.connect(self.onNewConnection) self.server.listen(QHostAddress.Any, 6666) self.client = QTcpSocket(self) self.cap = cv2.VideoCapture(0) @pyqtSlot() def onNewConnection(self): self.client = self.server.nextPendingConnection() self.client.disconnected.connect(self.onClientDisconnected) self.client.readyRead.connect(self.onClientReadyRead) print('connected') @pyqtSlot() def onClientDisconnected(self): print('disconnected') @pyqtSlot() def onClientReadyRead(self): while self.client.canReadLine(): line = self.client.readLine()[:-1] if 'get' == line: ret, frame = self.cap.read() data = cv2.imencode('.jpg', frame)[1] self.client.writeData((str(len(data)) + '\n').encode()) self.client.writeData(data)
class cServer(QTcpSocket): finished = QtCore.pyqtSignal() newData = QtCore.pyqtSignal(str) running = False def __init__(self): super().__init__() self.tcpServer = QTcpServer(self) PORT = 9999 address = QHostAddress('127.0.0.1') self.tcpServer.listen(address, PORT) self.tcpServer.newConnection.connect(self.dealCommunication) print("[SERVER] Listening on port-", PORT, "...") def dealCommunication(self): print("[SERVER] Client is connecting...") client = self.tcpServer.nextPendingConnection() msg = str(client.readAll(),encoding='utf-8') self.newData.emit(msg) def run(self): self.running = True while self.running: QtCore.QCoreApplication.processEvents() print("[SERVER] Terminated!") def stop(self): self.running = False self.finished.emit()
class TcpServer(): def __init__(self): self.tcp_server = QTcpServer() self.tcp_server.listen(QHostAddress(SERVER_ADDRESS), SERVER_PORT) self.tcp_server.newConnection.connect(self.connect_client) self.clients = [] def connect_client(self): client_socket = self.tcp_server.nextPendingConnection() self.clients.append(client_socket) client_socket.readyRead.connect(self.read_data) def read_data(self): for client_id, client_socket in enumerate(self.clients): if client_socket.bytesAvailable() > 0: stream = QDataStream(client_socket) stream.setVersion(QDataStream.Qt_5_9) stream.readUInt32() client_data = stream.readQString() self.return_data_to_clients(client_id, client_data) def return_data_to_clients(self, client_id, data): for client_socket in self.clients: return_data_string = 'Client {} sent: {}'.format(client_id, data) data_byte_array = QByteArray() stream = QDataStream(data_byte_array, QIODevice.WriteOnly) stream.setVersion(QDataStream.Qt_5_9) stream.writeUInt32(0) stream.writeQString(return_data_string) client_socket.write(data_byte_array)
def __init__(self, sock_type='TCP Client', ip='127.0.0.1', port=2007): '''打开网络设备,建立连接 ## sock_type: - 'TCP Client' - 'TCP Server' - 'UDP' ''' self.sock_type = sock_type # self.ip = ip self.port = port if sock_type == 'TCP Client': tcp_client = QTcpSocket() tcp_client.connectToHost(ip, port) self.sock = tcp_client elif sock_type == 'TCP Server': tcp_server = QTcpServer() tcp_server.listen(QHostAddress(ip), port) self.sock = tcp_server elif sock_type == 'UDP': udp = QUdpSocket() udp.bind(QHostAddress(ip), port) self.sock = udp else: print('Unkonw sock_type=%r' % sock_type)
class Server: def __init__(self): self.server = None def start(self): self.server = QTcpServer(None) self.server.listen(QHostAddress.Any, 8000) self.server.newConnection.connect(self.newConnection) def newConnection(self): print('new') self.currClientConnection = self.server.nextPendingConnection() self.readStream = QDataStream(self.server)
class TcpServer(QWidget, Ui_Form): def __init__(self): super(TcpServer, self).__init__() self.ui = Ui_Form() self.ui.setupUi(self) self.tcpServer = QTcpServer(self) #指定父对象自动回收空间 监听套接字 self.tcpSocket = QTcpSocket(self) #通信套接字 self.tcpServer.listen(QHostAddress.Any, 8888) #any默认绑定当前网卡的所有IP self.tcpServer.newConnection.connect(self.handleNewConnection) self.ui.sendButton.clicked.connect(self.sendMessage) self.ui.closeButton.clicked.connect(self.closeConnect) def handleNewConnection(self): self.tcpSocket = self.tcpServer.nextPendingConnection() #取出建立好链接的套接字 #获取对方IP和端口 ip = self.tcpSocket.peerAddress().toString() #获取对方的IP地址 port = self.tcpSocket.peerPort() #获取对方的端口号 self.ui.showText.setText("[{IP}:{Port}]".format(IP=ip, Port=port)) self.tcpSocket.readyRead.connect(self.showMessage) def sendMessage(self): # message = self.ui.sendEdit.toPlainText() # 获取编辑区内容 # self.request = QByteArray() #由于write函数的参数是QByteArray, bytes, bytearray所以在这里通过QByteArray来传递参数 # stream = QDataStream(self.request, QIODevice.WriteOnly) #创建数据流,和QByteArray关联,并且以只写的方式 # stream.setVersion(QDataStream.Qt_5_10) #设置数据流所对应的PyQt5版本 # stream.writeQString(message) #向数据流中写入数据,亦即向request中写入数据 # self.tcpSocket.write(self.request) # self.ui.sendEdit.clear() #每次数据发送后,将当前的输入text区域清空 message = self.ui.sendEdit.toPlainText() message = message.encode('utf-8') #encode()转换为bytes类型 self.tcpSocket.write(message) self.ui.sendEdit.clear() def showMessage(self): # stream = QDataStream(self.tcpSocket) #发送数据是以QByteArray数据类型发送过来的,所以接收数据也应该以此接收 # stream.setVersion(QDataStream.Qt_5_10) #发送和接收数据以相同的编码形式传输 # message = stream.readQString() #写入使用writeString, 对应读取使用readQString # self.ui.showText.append(message) message = QByteArray() message = self.tcpSocket.readAll() message = str(message, 'utf-8') self.ui.showText.setText(message) def closeConnect(self): self.tcpSocket.disconnectFromHost() self.tcpSocket.close()
class Server(QDialog): def __init__(self): super().__init__() self.tcpServer = None self.signals = ServerSignals() self.clientConnection = None def sessionOpened(self): self.tcpServer = QTcpServer(self) PORT = 65432 address = QHostAddress('127.0.0.1') if not self.tcpServer.listen(address, PORT): print("cant listen!") self.close() return self.tcpServer.newConnection.connect(self.dealCommunication) @pyqtSlot() def dealCommunication(self): # Get a QTcpSocket from the QTcpServer self.clientConnection = self.tcpServer.nextPendingConnection() # wait until the connection is ready to read self.clientConnection.waitForReadyRead() # read incomming data instr = self.clientConnection.readAll() # raise signal with message tomaingui = str(instr, encoding='utf-8') self.signals.msg.emit(tomaingui) # def sendtoclient(self, msg): # # OLD Might be deleted in next version # # # instantiate a QByteArray # block = QByteArray() # out = QDataStream(block, QIODevice.ReadWrite) # out.setVersion(QDataStream.Qt_5_0) # # # this is the message we will send it could come from a widget. # message = msg + '\n' # # message = msg # message = bytes(message, encoding='utf-8') # # now use the QDataStream and write the byte array to it. # out.writeString(message) # out.device().seek(0) # out.writeUInt16(block.size() - 2) # # # get the connection ready for clean up # self.clientConnection.disconnected.connect(self.clientConnection.deleteLater) # # now send the QByteArray. # self.clientConnection.write(block) # # now disconnect connection. # self.clientConnection.disconnectFromHost() def sendeasy(self, msg): message = msg + '\n' out = bytes(message, 'utf-8') self.clientConnection.write(out) self.clientConnection.disconnectFromHost()
class Server(QObject): def __init__(self, parent: QObject = None): super().__init__(parent) self.m_server = QTcpServer() self.m_server.newConnection.connect(self.handleNewConnection) @pyqtSlot() def run(self): if not self.m_server.listen(QHostAddress.LocalHost, 5555): print( f"Could not start the server -> http/proxy authentication dialog will not work. Error:{self.m_server.errorString()}" ) @pyqtSlot() def handleNewConnection(self): socket = self.m_server.nextPendingConnection() socket.disconnected.connect(socket.deleteLater) socket.readyRead.connect(self.handleReadReady) @pyqtSlot() def handleReadReady(self): socket = self.sender() assert socket msg = socket.readAll() if msg.contains(b"OPEN_AUTH"): socket.write(b"HTTP/1.1 401 Unauthorized\nWWW-Authenticate: " b'Basic realm="Very Restricted Area"\r\n\r\n') if msg.contains(b"OPEN_PROXY"): socket.write( b"HTTP/1.1 407 Proxy Auth Required\nProxy-Authenticate: " b'Basic realm="Proxy requires authentication"\r\n\r\n')
class QTServerThread(QWidget): server = None players = [] def __init__(self, _parent): super().__init__(_parent) self.setLayout(QHBoxLayout()) self.server = QTcpServer(self) if self.server.listen(port=4223) is False: print("Error starting the server!") return self.server.newConnection.connect(self.handleNewConnection) def getIDFromSocket(self, socket): ipadd = socket.peerAddress().toString() splited = ipadd.split(".") return int(splited[len(splited)-1]) @pyqtSlot() def handleNewConnection(self): newSock = self.server.nextPendingConnection() if(newSock is not None): newID = self.getIDFromSocket(newSock) for player in self.players: if self.getIDFromSocket(player.client.sock) == newID: player.client.attachSock(newSock) return newPlayer = GPlayer(newSock, newID) self.players.append(newPlayer) self.layout().addWidget(newPlayer)
class Server(QWidget): def __init__(self, model, prediction, vocabulary): super(Server, self).__init__() self.model = model self.prediction = prediction self.vocabulary = vocabulary self.resize(500, 450) # 1 self.browser = QTextBrowser(self) self.v_layout = QVBoxLayout() self.v_layout.addWidget(self.browser) self.setLayout(self.v_layout) # 2 self.server = QTcpServer(self) if not self.server.listen(QHostAddress.LocalHost, 8080): self.browser.append(self.server.errorString()) self.server.newConnection.connect(self.new_socket_slot) def new_socket_slot(self): sock = self.server.nextPendingConnection() peer_address = sock.peerAddress().toString() peer_port = sock.peerPort() news = 'Connected with address {}, port{}'.format( peer_address, str(peer_port)) self.browser.append(news) sock.readyRead.connect(lambda: self.read_data_slot(sock)) sock.disconnected.connect(lambda: self.disconnected_slot(sock)) # 3 def read_data_slot(self, sock): while sock.bytesAvailable(): datagram = sock.read(sock.bytesAvailable()) message = datagram.decode() answer = self.get_answer(message).encode() sock.write(bytes(answer)) def get_answer(self, message): sentence = pre_dosegment(message) sentence = ' '.join(sentence) prediction1 = self.model.test(str(sentence), self.vocabulary) query = match_question(prediction1, str(message)) answer = self.prediction.run(query, prediction1) return answer # 4 def disconnected_slot(self, sock): peer_address = sock.peerAddress().toString() peer_port = sock.peerPort() news = 'Disconnected with address {}, port {}'.format( peer_address, str(peer_port)) self.browser.append(news) sock.close()
class CameraListener(QThread): """ 网络线程,监听并接收摄像头拍摄的图片 """ tcpserver = 0 tcpsocket = 0 def __init__(self, parent=None): super(QThread, self).__init__(parent) self.tcpserver = QTcpServer() self.tcpserver.listen(QHostAddress.Any, 8888) def onClientConnection(self): self.tcpsocket = self.tcpserver.nextPendingConnection() self.start() def run(self): self.tcpsocket.readData()
class APIService(object): def __init__(self): self.local_server = QTcpServer() self.local_server.newConnection.connect(self._handle_connection) increment = 0 while (available := self.local_server.listen(port=DEFAULT_LOCAL_PORT + increment)) is False: increment += 1 self.fetch_worker_proc = multiprocessing.Process( target=entrypoint, args=(DEFAULT_LOCAL_PORT + increment, )) self.fetch_worker_proc.start() self.worker_socket = None self.next_event_id = 0 # event id to (api_event, callback) map self.callback_map = {} # Used for queueing up requests that had been sent before the connection with the # other process was established self.request_queue = [] self._phase = 0 self._size_of_request_size = None self._request_size = None
class ServerThread(QThread): def __init__(self, ip, port, console): super().__init__() self.ip = ip self.port = port self.tcpServer = QTcpServer() self.clientList = [] address = QHostAddress(self.ip) if not self.tcpServer.listen(address, self.port): print("cant listen!") self.tcpServer.close() return self.tcpServer.newConnection.connect(self.addConnection) self.receviedDataSignal = pyqtSignal(str) # This generate error Attribue No attribute connect ! # self.receviedDataSignal.connect(console.receivePacket) def run(self): self.tcpServer.moveToThread(self.thread()) while True: for conn in self.clientList: self.echoConnection(conn) self.closeAllTCPClient() def addConnection(self): connectionToAdd = self.tcpServer.nextPendingConnection() self.clientList.append(connectionToAdd) def echoConnection(self, clientConnection): readData = self.readFromTCPSocket(clientConnection) print("[HOST] Received from ", clientConnection.localAddress().toString(), clientConnection.localPort()) print(readData) # Add write to our console # self.receviedDataSignal.emit(readData) def readFromTCPSocket(self, tcpSocket): tcpSocket.waitForReadyRead() data = tcpSocket.readAll() return data def closeAllTCPClient(self): for conn in self.clientList: conn.disconnectFromHost() def readNewConnection(self): conn = self.tcpServer.nextPendingConnection() self.echoConnection(conn)
class Server(QDialog): def __init__(self): super().__init__() self.tcpServer = None self.Label1 = QLabel(self) def sessionOpened(self): self.tcpServer = QTcpServer(self) PORT = 8000 address = QHostAddress('127.0.0.1') if not self.tcpServer.listen(address, PORT): print("cant listen!") self.close() return self.tcpServer.newConnection.connect(self.dealCommunication) def dealCommunication(self): # Get a QTcpSocket from the QTcpServer clientConnection = self.tcpServer.nextPendingConnection() # instantiate a QByteArray block = QByteArray() # QDataStream class provides serialization of binary data to a QIODevice out = QDataStream(block, QIODevice.ReadWrite) # We are using PyQt5 so set the QDataStream version accordingly. out.setVersion(QDataStream.Qt_5_0) out.writeUInt16(0) # this is the message we will send it could come from a widget. message = "Goodbye!" # get a byte array of the message encoded appropriately. message = bytes(message, encoding='ascii') # now use the QDataStream and write the byte array to it. out.writeString(message) out.device().seek(0) out.writeUInt16(block.size() - 2) # wait until the connection is ready to read clientConnection.waitForReadyRead() # read incomming data instr = clientConnection.readAll() # in this case we print to the terminal could update text of a widget if we wanted. print(str(instr, encoding='ascii')) self.Label1.setText(str(instr, encoding='ascii')) # get the connection ready for clean up clientConnection.disconnected.connect(clientConnection.deleteLater) # now send the QByteArray. clientConnection.write(block) # now disconnect connection. clientConnection.disconnectFromHost()
class DataReceive(QObject): def __init__(self, parent=None): super(DataReceive, self).__init__(parent) self.tcpServer = QTcpServer(self) if self.tcpServer.listen(QHostAddress("127.0.0.1"), 8890): self.tcpServer.newConnection.connect(self.sendMessage) self.tcpServerConnection = None print('init done') self.index = 0 self.data_size = 0 self.message = None self.image = None def sendMessage(self): print('send') self.data_size = 0 self.tcpServerConnection = self.tcpServer.nextPendingConnection() self.tcpServerConnection.readyRead.connect(self.readData) def readData(self): in_data = QDataStream(self.client) in_data.setVersion(QDataStream.Qt_4_0) if self.data_size == 0: tmp = self.client.bytesAvailable() if tmp < SIZEOF_UINT32: return self.data_size = in_data.readUInt32() print(self.data_size) if self.client.bytesAvailable() < self.data_size: return self.message = self.client.read(self.data_size) self.list.append(self.message) print(self.index) self.index = self.index + 1 if self.index == 10: try: with open("message.pkl", "wb") as fp: pickle.dump(self.list, fp, pickle.HIGHEST_PROTOCOL) self.client.close() except: print("what")
class TcpServer(QObject): def __init__(self): super(TcpServer, self).__init__() self.server = QTcpServer() self.server.newConnection.connect(self.incomingConnection) @pyqtSlot() def incomingConnection(self): self.client = TcpClient(self.server.nextPendingConnection()) self.client.parse_data = self.parse_data def start(self): if self.server.listen(QHostAddress.Any, 8888): print "Tcp server started" else: print "Error starting Tcp server" def parse_data(self, data): print 'Server: ', str(data).strip() def moveToThread(self, target_thread): self.server.moveToThread(target_thread) super(TcpServer, self).moveToThread(target_thread)
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(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 TcpS(QDialog, Ui_TcpServer): """ 文件传输服务器 """ sendFileName = pyqtSignal(str) def __init__(self, parent=None): """ 一些初始设置 """ super(TcpS, self).__init__(parent) self.setupUi(self) self.payloadSize = 64 * 1024 # 读取数据64KB self.totalBytes = 0 # 总大小 self.bytesWritten = 0 # 保存的数据 self.bytesToWrite = 0 # 每次减少连接写的数据量大小 self.theFileName = "" # 文件名(不含路径) self.fileName = "" # 文件全名 self.localFile = QFile() self.outBlock = QByteArray() # QByteArray()的对象,即字节数组 self.time = QTime() self.initServer() def initServer(self): """ 网络设置初始化 """ self.tcpPort = 7788 # 指定了TCP端口为7788 self.tcpServer = QTcpServer(self) self.clientConnection = QTcpSocket(self) # 创建一个Tcp服务器和一个Tcp套接字 self.tcpServer.newConnection.connect(self.sendMessage) # 当有新的连接来的时候发出newConnection信号,我们连接到sendMessage()函数。 self.serverStatuslabel.setText("请选择要传送的文件") self.progressBar.reset() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.tcpServer.close() # 显示我们开始创建的对话框,打开按钮是可用的,发送按钮是不可用的,进度条复位,先关闭服务器。 def refused(self): """ 对端拒绝接收文件,主程序会调用服务器的refused()函数,关闭服务器。 """ self.tcpServer.close() self.serverStatuslabel.setText("对方拒绝接收") def closeEvent(self, event): """ 关闭事件 """ self.on_serverCloseBtn_clicked() # 产生关闭事件,直接调用关闭窗口按钮函数。 def sendMessage(self): """ 发送文件 """ self.serverSendBtn.setEnabled(False) # 发送按钮不可用 self.clientConnection = self.tcpServer.nextPendingConnection() # self.clientConnection作为连接的QTcpSocket对象返回下一个挂起的连接。 self.clientConnection.bytesWritten.connect(self.updateClientProgress) # 当连接中每次将数据有效载荷写入设备的当前写通道时,都会发出此信号。在此有效负载中写入的数据量为字节数。 self.serverStatuslabel.setText("开始传送文件 {} !".format(self.theFileName)) self.localFile = QFile(self.fileName) if not (self.localFile.open(QFile.ReadOnly)): errorMsg = "无法读取文件 {}:\n {}".format(self.fileName, self.localFile.errorString()) QMessageBox.warning(self, "应用程序", errorMsg) return # 尝试打开文件,要是存在问题就报错。 self.serverCloseBtn.setText("取消") self.totalBytes = self.localFile.size() # 记录一下需要传输的文件大小。单位:字节 sendOut = QDataStream(self.outBlock, QIODevice.WriteOnly) # 这里的self.outBlock是QByteArray()的对象,即字节数组;QIODevice的模式为WriteOnly sendOut.setVersion(QDataStream.Qt_5_4) # 设定QDataStream的版本为Qt_5_4 self.time.start() # 开始计时 currentFile = self.fileName.split("/")[-1] # 传输的文件名 sendOut.writeInt64(0) sendOut.writeInt64(0) sendOut.writeQString(currentFile) self.totalBytes += self.outBlock.size() # 在sendOut中写入文件名以及文件名和文件的大小,大小都是以字节为单位的。 sendOut.device().seek(0) sendOut.writeInt64(self.totalBytes) sendOut.writeInt64(self.outBlock.size() - 2) # QIODevice读写位置移动到0。然后分别写入总的大小和文件名大小。 self.bytesToWrite = self.totalBytes - self.clientConnection.write( self.outBlock) # 待传输文件的大小。 self.outBlock.resize(0) # outBlock清零。 def updateClientProgress(self, numBytes): """ 发送进度显示 """ qApp.processEvents() # 长时间工作用,以免窗口假死 self.bytesWritten += numBytes if self.bytesWritten > 0: self.block = self.localFile.read( min(self.bytesToWrite, self.payloadSize)) self.bytesToWrite -= self.clientConnection.write(self.block) else: self.localFile.close() # 当我们待写入的字节数大于0时,我们每次读取的数据都是小于等于self.payloadSize的,这个self.payloadSize我们定义是64KB。 # self.bytesToWrite每次减少连接写的数据量大小。 # 要是待写入的字节数小于等于0,则关闭文件。 byteSent = self.bytesWritten / (1024 * 1024) # 已经写了多少文件 useTime = self.time.elapsed() / 1000 # 传输用了多长时间 speed = self.bytesWritten / useTime / (1024 * 1024) # 传输速度 total = self.totalBytes / (1024 * 1024) # 总大小 left = (total - byteSent) / speed # 表示剩余时间 if byteSent < 0.01: byteSent = self.bytesWritten / 1024 speed = self.bytesWritten / useTime / 1024 total = self.totalBytes / 1024 if left > 0: sendInfo = "已发送 {0:.2f}KB({1:.2f}KB/s)\n共{2:.2f}KB 已用时:{3:.1f}秒\n 估计剩余时间:{4:.1f}秒".format( byteSent, speed, total, useTime, left) else: sendInfo = "已发送 {0:.2f}KB({1:.2f}KB/s)\n共{2:.2f}KB 用时:{3:.1f}秒\n".format( byteSent, speed, total, useTime) else: if left > 0: sendInfo = "已发送 {0:.2f}MB({1:.2f}MB/s)\n共{2:.2f}MB 已用时:{3:.1f}秒\n 估计剩余时间:{4:.1f}秒".format( byteSent, speed, total, useTime, left) else: sendInfo = "已发送 {0:.2f}MB({1:.2f}MB/s)\n共{2:.2f}MB 用时:{3:.1f}秒\n".format( byteSent, speed, total, useTime) self.progressBar.setMaximum(total) self.progressBar.setValue(byteSent) if self.bytesWritten == self.totalBytes: self.serverCloseBtn.setText("关闭") # 进度条显示的方式,以及当传输的字节数等于总的字节数的时候,按钮就显示关闭。 self.serverStatuslabel.setText(sendInfo) @pyqtSlot() def on_serverOpenBtn_clicked(self): """ 打开文件准备发送 """ self.fileName = QFileDialog.getOpenFileName(self, '打开文件', './')[0] if self.fileName: self.theFileName = self.fileName.split("/")[-1] self.serverStatuslabel.setText("要传送的文件为:{}".format( self.theFileName)) self.serverSendBtn.setEnabled(True) self.serverOpenBtn.setEnabled(False) @pyqtSlot() def on_serverSendBtn_clicked(self): """ 发送文件,等待接收 """ if not (self.tcpServer.listen(QHostAddress.Any, self.tcpPort)): errorMsg = self.tcpServer.errorString() QMessageBox.warning(self, "错误", "发送失败:\n {}".format(errorMsg)) self.TcpServer.close() return self.serverStatuslabel.setText("等待对方接收... ...") self.serverSendBtn.setEnabled(False) self.sendFileName.emit(self.theFileName) @pyqtSlot() def on_serverCloseBtn_clicked(self): """ 取消或者关闭 """ if self.tcpServer.isListening(): self.tcpServer.close() if self.localFile.isOpen(): self.localFile.close() self.clientConnection.abort() if self.serverCloseBtn.text() == "取消": self.serverCloseBtn.setText("关闭") else: self.close() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.progressBar.reset() self.totalBytes = 0 self.bytesWritten = 0 self.bytesToWrite = 0 self.serverStatuslabel.setText("请选择要传送的文件")
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 MyRenderArea(QWidget): def __init__(self, parent=None): super().__init__(parent) self.setFocusPolicy(Qt.StrongFocus) self.main = parent self.background_tex = QImage("Ground.png") self.ups = 60 self.uc = 0 self.gamesecond = 0 self.players_tex = [ QImage("panzer_0.png"), QImage("panzer_1.png"), QImage("panzer_2.png") ] self.explosion_sprites = [ QImage("000" + str(i) + ".png") for i in range(1, 10) ] + [QImage("00" + str(i) + ".png") for i in range(10, 51)] self.players = [ Player(self.ups, (0.5, 0.5)), Player(self.ups, (0.7, 0.7)) ] self.controls = [False, False, False, False, False] self.controls2 = [False, False, False, False, False] self.inputs = [self.controls, self.controls2] self.timer = QTimer() # Wir richten einen Server ein, zu dem Clients einen Kommunikationskanal # öffnen können. self.tcpServer = QTcpServer(self) # Der Server akzeptiert jeden Client, der auf der angegebenen Port-Nummer # sendet. self.tcpServer.listen(QHostAddress.Any, 40890) # self.tcpServer.listen(QHostAddress('127.0.0.1'), 40890) # Falls beim Server eine Verbindungsanfrage von einem Client eingeht, # soll die eigene Memberfunktion connectToClient aufgerufen werden. self.tcpServer.newConnection.connect(self.connectToClient) # Falls ein Fehler beim Server auftritt, kann dieser mit # self.tcpServer.errorString() abgefragt werden. # Memberfunktion für eine Verbindungsanfrage eines Clients def timer_funktion(self): self.writeData() self.update() def connectToClient(self): # Über die Membervariable tcpSocket kann der Kommunikationskanal zum # Senden und Empfangen von Nachrichten angesprochen werden. self.tcpSocket = self.tcpServer.nextPendingConnection() # In der Statuszeile geben wir aus, dass sich ein Client mit dem Server # verbunden hat. self.main.statusBar().showMessage('Client connected') self.connected = True # Falls neue Daten zum Lesen vom Client eingetroffen sind, soll die # Memberfunktion readData aufgerufen werden. self.tcpSocket.readyRead.connect(self.readData) self.timer.timeout.connect(self.timer_funktion) self.timer.start(round(1000 / self.ups)) def readData(self): instr = QDataStream(self.tcpSocket) data = instr.readQString() #print(data) controls = [False, False, False, False, False] for i in range(len(data)): if data[i] == "1": self.controls2[i] = True else: self.controls2[i] = False def encode_game(self): data = "" player_index = 0 #Format: pNUMMER#USED#POSX#POSY#ROT for player in self.players: pos = player.get_position() data += "p" + str(player_index) + "#" + "0" + "#" + str( pos[0]) + "#" + str(pos[1]) + "#" + str(player.get_rotation()) return data def writeData(self): block = QByteArray() out = QDataStream(block, QIODevice.ReadWrite) controls = "" data = self.encode_game() out.writeQString(data) print(data) self.tcpSocket.write(block) def keyPressEvent(self, e): if e.key() == Qt.Key_W or e.key() == Qt.Key_Up: self.controls[0] = True if e.key() == Qt.Key_S or e.key() == Qt.Key_Down: self.controls[1] = True if e.key() == Qt.Key_A or e.key() == Qt.Key_Left: self.controls[2] = True if e.key() == Qt.Key_D or e.key() == Qt.Key_Right: self.controls[3] = True def keyReleaseEvent(self, e): if e.key() == Qt.Key_W or e.key() == Qt.Key_Up: self.controls[0] = False if e.key() == Qt.Key_S or e.key() == Qt.Key_Down: self.controls[1] = False if e.key() == Qt.Key_A or e.key() == Qt.Key_Left: self.controls[2] = False if e.key() == Qt.Key_D or e.key() == Qt.Key_Right: self.controls[3] = False def spawnPlayer(self): self.players.append(Player((0.5, 0.5))) def resizeEvent(self, e): # (ox,oy) steht für die linke obere Ecke des quadratischen Spielfeldes und dient als # Ursprung des Koordinatensystems. if self.width() > self.height(): self.len = self.height() self.ox = (self.width() - self.height()) / 2 self.oy = 0 else: self.len = self.width() self.ox = 0 self.oy = (self.height() - self.width()) / 2 self.tex_scale = self.len / self.background_tex.width() def draw_players(self): painter = QPainter(self) index = 0 for player in self.players: painter.save() tex = self.players_tex[index] trans = QTransform() (x, y) = player.get_position() size = tex.width() * self.tex_scale trans.translate(self.ox + x * self.len, (self.oy + y * self.len)) trans.rotate(-player.get_rotation() / 2) trans.translate(0 - size / 2, 0 - size / 2) painter.setTransform(trans) painter.drawImage(0, 0, tex.scaled(size, size)) self.draw_explosion(self.ox + x * self.len, (self.oy + y * self.len)) painter.restore() index += 1 def draw_explosion(self, x, y): painter = QPainter(self) frame = int(self.gamesecond * 50) size = self.explosion_sprites[0].width() * self.tex_scale painter.drawImage(x - size / 2, y - size / 2, self.explosion_sprites[frame].scaled(size, size)) def move_players(self): index = 0 for player in self.players: player.move(self.inputs[index]) index += 1 def paintEvent(self, e): painter = QPainter(self) painter.setBrush(QColor('black')) painter.setPen(Qt.NoPen) painter.drawRect(0, 0, self.width(), self.height()) painter.drawImage(self.ox, self.oy, self.background_tex.scaled(self.len, self.len)) self.move_players() self.draw_players() self.uc += 1 if self.uc == self.ups: self.uc = 0 self.gamesecond = self.uc / self.ups
class TestTransact(XWidget, Ui_Form): def __init__(self): super(TestTransact, self).__init__() self.setupUi(self) try: self._init_device_config() self._init_terminal_operation() self._init_online_parameters() except Exception as e: print("here exception") self.exception(e) # ********************************************** Init **************************************************** def _init_device_config(self): self.deviceconfig = DeviceConfig() self.deviceconfig.print_signal.connect(self.print_signal) self.layout_DeviceConfig.addWidget(self.deviceconfig) def _init_terminal_operation(self): self.port = 12345 self.serveropened = False self._onPushButton_Openserver_Clicked() def _init_online_parameters(self): self.comboBox_AuthorizationResponseCode.addItems(['00:Approve', '51:Decline']) self._issuerdata = [''] try: with open('script/transact/issuerdata', 'r') as fd: for line in fd.readlines(): line = line.replace('\n', '').replace('\r', '') self._issuerdata.append(line) fd.close() except Exception as e: self.exception(e) self.comboBox_IssuerAppData.addItems(self._issuerdata) def showEvent(self, QShowEvent): try: if self.config.get('comboBox_AuthorizationResponseCode'): self.comboBox_AuthorizationResponseCode.setCurrentText(self.config['comboBox_AuthorizationResponseCode']) if self.config.get('comboBox_IssuerAppData'): self.comboBox_IssuerAppData.setCurrentText(self.config['comboBox_IssuerAppData']) except Exception as e: self.exception(e) super().showEvent(QShowEvent) def hideEvent(self, QHideEvent): try: self.config['comboBox_AuthorizationResponseCode'] = self.comboBox_AuthorizationResponseCode.currentText() self.config['comboBox_IssuerAppData'] = self.comboBox_IssuerAppData.currentText() except Exception as e: self.exception(e) super().hideEvent(QHideEvent) # ********************************************** Slot **************************************************** def _onPushButton_Openserver_Clicked(self): print("start socker at ",self.port) if self.serveropened is False: #start init qtcpserver self.tcpServer = QTcpServer(self) address = QHostAddress('0.0.0.0') if not self.tcpServer.listen(address, self.port): print("cant listen!") self.close() return self.tcpServer.newConnection.connect(self.dealCommunication) self.fillActivateIps() def dealCommunication(self): # Get a QTcpSocket from the QTcpServer print("start handle") self.print_signal.emit("info", "connected") self.tcpSocket = self.tcpServer.nextPendingConnection() #first read self.tcpSocket.readyRead.connect(self.showMessage) self.tcpSocket.disconnected.connect(self.showDisconnect) def showMessage(self): print ("start read show message") self.tcpSocket.readAll() #construct return data here origstr = self.comboBox_IssuerAppData.currentText() lenofstr = int(len(origstr) / 2) origstr2 = self.comboBox_AuthorizationResponseCode.currentText() finalstr = "8A02{:02}{:02}91{:02X}{}".format(int(origstr2[0]) + 30, int(origstr2[1])+30, lenofstr, origstr) print("return:", finalstr) self.tcpSocket.write(finalstr.encode("utf-8")) def showDisconnect(self): self.print_signal.emit("info", "disconnected") def fillActivateIps(self): print("start fill") for interface in QNetworkInterface.allInterfaces(): iflags = interface.flags() if (iflags & QNetworkInterface.IsRunning) and not (iflags & QNetworkInterface.IsLoopBack) : for addrentry in interface.addressEntries(): # print("append ",addrentry.ip().toString(),addrentry.ip().protocol()) if addrentry.ip().protocol() == QAbstractSocket.IPv4Protocol: self.plainTextEdit_iplist.appendPlainText("{}:{}".format(addrentry.ip().toString(), self.port))
class Server(QWidget): def __init__(self, parent=None): super(Server, self).__init__(parent) self.users = [] self.step_index = 0 self.active_user = -1 self.active_socket = None import random self.nodes_list = range(8) random.shuffle(self.nodes_list) print self.nodes_list self.setWindowTitle("The Standard Model Game Server") self.sockets = [] mainLayout = QVBoxLayout() self.register_started = False self.b_register_user = Button("Start Register") self.b_register_user.clicked.connect(self.register_user_change_status) self.game_started = False self.b_start = Button("Start") self.b_start.clicked.connect(self.start_game) mainLayout.addWidget(self.b_register_user) mainLayout.addWidget(self.b_start) self.setLayout(mainLayout) self.server = QTcpServer() self.server.listen(QHostAddress.Any, 8088) self.server.newConnection.connect(self.registing) self.timer = QTimer(self) # self.register_timer.timeout.connect(self.registing) self.timer.setInterval(1) self.timer.start() # self.timer.timeout.connect(self.checkout) def start_game(self): if (len(self.users) == 0): show_message("No User Registed", "", 2) return self.game_started = True for user_index, user in enumerate(self.users): self.step_index += 1 step = Step() step.user = user_index step.index = self.step_index step.action = "setup user" step.command = [ user.username, user.avatar, self.nodes_list[user_index] ] self.broad_cast(step) step = Step() step.action = "start game" self.process(step) self.get_initial_funding() step = Step() step.action = "next turn" self.process(step) def get_initial_funding(self): pass def register_user_change_status(self): if self.register_started: self.register_started = False # self.register_timer.stop() self.b_register_user.setText("Start Register") else: self.register_started = True # self.register_timer.start() self.b_register_user.setText("Stop Register") def register_user(self, socket): if socket in self.sockets: return self.sockets.append(socket) socket.waitForReadyRead() message = socket.readLine().data().decode().split("@") index = len(self.sockets) user = User(message[0], int(message[1]), index, None) socket.readyRead.connect(lambda: self.checkout(socket)) self.users.append(user) print("Register User") def registing(self): if self.register_started: socket = self.server.nextPendingConnection() # address = socket.peerAddress() self.register_user(socket) def checkout(self, socket): #for socket in self.sockets: # socket.write(steps[-1].to_string()) print("checkout") print(self.active_user) print(self.active_socket) print(socket) if self.active_socket is socket: print("is") message = socket.readLine().data().decode() step = Step() step.from_string(message) self.process(step) """ if self.game_started: for socket in self.sockets: if socket.readyRead(): message = str(socket.readLine().data()) for socket in self.sockets: self.send_step(socket, step) """ # socket = self.server.nextPendingConnection() # socket.write("hello\n") # socket.flush() # socket.disconnect() def change_to_next_user(self): self.active_user += 1 if self.active_user == len(self.sockets): self.active_user = 0 self.active_socket = self.sockets[self.active_user] def broad_cast(self, step): print("broading cast") for user_index, socket in enumerate(self.sockets): if step.action == "setup user": step.work_user = user_index qmessage = QByteArray() qmessage.append(step.to_string()) socket.write(qmessage) def process(self, step): if step.action == "start game": print("Start game") self.step_index += 1 step.index = self.step_index self.broad_cast(step) if step.action == "next turn": self.change_to_next_user() self.step_index += 1 # step = Step() step.from_string( "%d@get funding@%d@%d@%d\n" % (self.active_user, self.step_index, self.active_user, 1000)) self.broad_cast(step) if step.action == "buy node": self.step_index += 1 step.index = self.step_index self.broad_cast(step)
class TcpS(QDialog, Ui_TcpServer): """ Class documentation goes here. """ sendFileName = pyqtSignal(str) def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget @type QWidget """ super(TcpS, self).__init__(parent) self.setupUi(self) self.payloadSize = 64 * 1024 self.totalBytes = 0 self.bytesWritten = 0 self.bytesToWrite = 0 self.theFileName = "" self.fileName = "" self.localFile = QFile() self.outBlock = QByteArray() self.time = QTime() self.initServer() def initServer(self): """ 网络设置初始化 """ self.tcpPort = 7788 self.tcpServer = QTcpServer(self) self.clientConnection = QTcpSocket(self) self.tcpServer.newConnection.connect(self.sendMessage) self.serverStatuslabel.setText("请选择要传送的文件") self.progressBar.reset() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.tcpServer.close() def refused(self): """ 对端拒绝接收文件 """ self.tcpServer.close() self.serverStatuslabel.setText("对方拒绝接收") def closeEvent(self, event): """ 关闭事件 """ self.on_serverCloseBtn_clicked() def sendMessage(self): """ 发送文件 """ self.serverSendBtn.setEnabled(False) self.clientConnection = self.tcpServer.nextPendingConnection() self.clientConnection.bytesWritten.connect(self.updateClientProgress) self.serverStatuslabel.setText("开始传送文件 {} !".format(self.theFileName)) self.localFile = QFile(self.fileName) if not (self.localFile.open(QFile.ReadOnly)): errorMsg = "无法读取文件 {}:\n {}".format(self.fileName, self.localFile.errorString()) QMessageBox.warning(self, "应用程序", errorMsg) return self.serverCloseBtn.setText("取消") self.totalBytes = self.localFile.size() #单位:字节 sendOut = QDataStream(self.outBlock, QIODevice.WriteOnly) sendOut.setVersion(QDataStream.Qt_5_4) self.time.start() currentFile = self.fileName.split("/")[-1] sendOut.writeInt64(0) sendOut.writeInt64(0) sendOut.writeQString(currentFile) self.totalBytes += self.outBlock.size() sendOut.device().seek(0) sendOut.writeInt64(self.totalBytes) sendOut.writeInt64(self.outBlock.size() - 2) self.bytesToWrite = self.totalBytes - self.clientConnection.write( self.outBlock) self.outBlock.resize(0) def updateClientProgress(self, numBytes): """ 发送进度显示 """ qApp.processEvents() self.bytesWritten += numBytes if self.bytesWritten > 0: self.block = self.localFile.read( min(self.bytesToWrite, self.payloadSize)) self.bytesToWrite -= self.clientConnection.write(self.block) else: self.localFile.close() byteSent = self.bytesWritten / (1024 * 1024) useTime = self.time.elapsed() / 1000 speed = self.bytesWritten / useTime / (1024 * 1024) total = self.totalBytes / (1024 * 1024) left = (total - byteSent) / speed if byteSent < 0.01: byteSent = self.bytesWritten / 1024 speed = self.bytesWritten / useTime / 1024 total = self.totalBytes / 1024 if left > 0: sendInfo = "已发送 {0:.2f}KB({1:.2f}KB/s)\n共{2:.2f}KB 已用时:{3:.1f}秒\n 估计剩余时间:{4:.1f}秒".format( byteSent, speed, total, useTime, left) else: sendInfo = "已发送 {0:.2f}KB({1:.2f}KB/s)\n共{2:.2f}KB 用时:{3:.1f}秒\n".format( byteSent, speed, total, useTime) else: if left > 0: sendInfo = "已发送 {0:.2f}MB({1:.2f}MB/s)\n共{2:.2f}MB 已用时:{3:.1f}秒\n 估计剩余时间:{4:.1f}秒".format( byteSent, speed, total, useTime, left) else: sendInfo = "已发送 {0:.2f}MB({1:.2f}MB/s)\n共{2:.2f}MB 用时:{3:.1f}秒\n".format( byteSent, speed, total, useTime) self.progressBar.setMaximum(total) self.progressBar.setValue(byteSent) if self.bytesWritten == self.totalBytes: self.serverCloseBtn.setText("关闭") self.serverStatuslabel.setText(sendInfo) @pyqtSlot() def on_serverOpenBtn_clicked(self): """ 打开文件 """ self.fileName = QFileDialog.getOpenFileName(self, '打开文件', './')[0] if self.fileName: self.theFileName = self.fileName.split("/")[-1] self.serverStatuslabel.setText("要传送的文件为:{}".format( self.theFileName)) self.serverSendBtn.setEnabled(True) self.serverOpenBtn.setEnabled(False) @pyqtSlot() def on_serverSendBtn_clicked(self): """ 发送文件 """ if not (self.tcpServer.listen(QHostAddress.Any, self.tcpPort)): errorMsg = self.tcpServer.errorString() QMessageBox.warning(self, "错误", "发送失败:\n {}".format(errorMsg)) self.TcpServer.close() return self.serverStatuslabel.setText("等待对方接收... ...") self.serverSendBtn.setEnabled(False) self.sendFileName.emit(self.theFileName) @pyqtSlot() def on_serverCloseBtn_clicked(self): """ 取消或者关闭 """ if self.tcpServer.isListening(): self.tcpServer.close() if self.localFile.isOpen(): self.localFile.close() self.clientConnection.abort() if self.serverCloseBtn.text() == "取消": self.serverCloseBtn.setText("关闭") else: self.close() self.serverOpenBtn.setEnabled(True) self.serverSendBtn.setEnabled(False) self.progressBar.reset() self.totalBytes = 0 self.bytesWritten = 0 self.bytesToWrite = 0 self.serverStatuslabel.setText("请选择要传送的文件")
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 Server(QDialog): def __init__(self): super().__init__() playbtn = QPushButton('Send', self) playbtn.resize(50, 32) playbtn.move(10, 10) playbtn.clicked.connect(self.send_msg) self.label1 = QLabel("") self.label = QLabel("Received Messages from Clients appear here") self.label.setWordWrap(1) self.textbox = QLineEdit(self) self.textbox.move(10, 50) self.textbox.resize(600, 32) self.setWindowTitle("Server") self.resize(600, 300) layout = QVBoxLayout() layout.addWidget(self.label1) layout.addWidget(self.label) layout.addWidget(self.textbox) layout.addWidget(playbtn) self.setLayout(layout) self.tcpServer = None self.clientConnections = [] self.blockSize = 0 self.ip, _ = self.getIP() def sessionOpened(self): self.tcpServer = QTcpServer(self) PORT = 8000 address = QHostAddress( self.ip) # e.g. use your server ip 192.144.178.26 if not self.tcpServer.listen(address, PORT): print("cant listen!") self.close() return self.tcpServer.newConnection.connect(self.serverInputCommunication) def send_msg(self): block = QByteArray() # QDataStream class provides serialization of binary data to a QIODevice out = QDataStream(block, QIODevice.ReadWrite) # We are using PyQt5 so set the QDataStream version accordingly. out.setVersion(QDataStream.Qt_5_0) out.writeUInt16(0) text_box_msg = self.textbox.text() to = "" msg = "" if "@" not in text_box_msg: print( "TO whom should I send a message? use e.g. @all Hello all or @Max Hello max" ) return else: to, msg = text_box_msg.split(' ', 1)[0], text_box_msg.split(' ', 1)[1] to = to.replace("@", "") # get a byte array of the message encoded appropriately. message = bytes(msg, encoding='ascii') # now use the QDataStream and write the byte array to it. out.writeString(message) out.device().seek(0) out.writeUInt16(block.size() - 2) aaa = True if to == "all": for conn in self.clientConnections: conn["conn"].write(block) else: for conn in self.clientConnections: if conn["name"] == to: conn["conn"].write(block) aaa = False if aaa: print("Sry I server could not send message to", to) def cl1Input(self): for conn in self.clientConnections: #conn.waitForReadyRead() # read incomming data instr = conn["conn"].readAll() # in this case we print to the terminal could update text of a widget if we wanted. in_msg = str(instr, encoding='ascii') try: name, message = in_msg.split(",")[0], in_msg.split(",")[1] if not "name" in conn: conn["name"] = name except: print(in_msg, conn["idx"]) name = None if name is not None: self.label.setText(self.label.text() + "\n" + name + "\t" + message) def getIP(self): hostname = socket.gethostname() s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("8.8.8.8", 80)) ip_address = s.getsockname()[0] print(ip_address, hostname, "<<localhost") self.label1.setText("This PC:" + hostname + " " + str(ip_address)) return ip_address, hostname def serverInputCommunication(self): print("serverInputCommunication") self.clientConnections.append({ "conn": self.tcpServer.nextPendingConnection(), "idx": len(self.clientConnections) }) self.clientConnections[len(self.clientConnections) - 1]["conn"].readyRead.connect(self.cl1Input)
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 CodeExecutor: """ This class is responsible for executing code (when starting Tribler in debug mode). The protocol to execute code is as follows. First, a client that wants to execute some code opens a connection with the TCP server and sends the string: <code in base64 format> <task_id>\n This code will be executed and the result will be sent to the client in the following format: result <result> <task_id>\n. If Tribler crashes, the server sends the following result: crash <stack trace in base64 format> Note that the socket uses the newline as separator. """ def __init__(self, port, shell_variables=None): self.logger = logging.getLogger(self.__class__.__name__) self.tcp_server = QTcpServer() self.sockets = [] self.stack_trace = None if not self.tcp_server.listen(port=port): self.logger.error("Unable to start code execution socket! Error: %s", self.tcp_server.errorString()) else: connect(self.tcp_server.newConnection, self._on_new_connection) self.shell = Console(locals=shell_variables or {}, logger=self.logger) def _on_new_connection(self): self.logger.info("CodeExecutor has new connection") while self.tcp_server.hasPendingConnections(): socket = self.tcp_server.nextPendingConnection() connect(socket.readyRead, self._on_socket_read_ready) connect(socket.disconnected, self._on_socket_disconnect(socket)) self.sockets.append(socket) # If Tribler has crashed, notify the other side immediately if self.stack_trace: self.on_crash(self.stack_trace) def run_code(self, code, task_id): self.logger.info(f"Run code for task {task_id}") self.logger.debug(f"Code for execution:\n{code}") try: self.shell.runcode(code) except SystemExit: pass if self.shell.last_traceback: self.on_crash(self.shell.last_traceback) return self.logger.info("Code execution with task %s finished:", task_id) return_value = b64encode(self.shell.locals.get('return_value', '').encode('utf-8')) for socket in self.sockets: socket.write(b"result %s %s\n" % (return_value, task_id)) def on_crash(self, exception_text): self.logger.error(f"Crash in CodeExecutor:\n{exception_text}") self.stack_trace = exception_text for socket in self.sockets: socket.write(b"crash %s\n" % b64encode(exception_text.encode('utf-8'))) def _on_socket_read_ready(self): data = bytes(self.sockets[0].readAll()) parts = data.split(b" ") if len(parts) != 2: return try: code = b64decode(parts[0]).decode('utf8') task_id = parts[1].replace(b'\n', b'') self.run_code(code, task_id) except binascii.Error: self.logger.error("Invalid base64 code string received!") def _on_socket_disconnect(self, socket): def on_socket_disconnect_handler(): self.sockets.remove(socket) return on_socket_disconnect_handler
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 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 TeacherSessionManager(SessionManager): def __init__(self, gui): SessionManager.__init__(self, gui) self.session_type = SessionType.TEACHER self.gui = gui self.session_ticker = Ticker(self.tickSessionOnce, parent=gui) self.simulation_paused_at = None # pause time if session is paused; None otherwise self.server = QTcpServer(gui) self.student_socket = None self.server.newConnection.connect(self.studentConnects) self.aircraft_list = [] # ControlledAircraft list self.current_local_weather = None # initialised by the teaching console on sessionStarted self.noACK_traffic_count = 0 def start(self): self.aircraft_list.clear() self.simulation_paused_at = None self.session_ticker.start_stopOnZero(teacher_ticker_interval) self.server.listen(port=settings.teaching_service_port) print('Teaching server ready on port %d' % settings.teaching_service_port) signals.specialTool.connect(self.createNewTraffic) signals.kbdPTT.connect(self.sendPTT) signals.sessionStarted.emit() def stop(self): if self.isRunning(): self.session_ticker.stop() if self.studentConnected(): self.shutdownStudentConnection() signals.specialTool.disconnect(self.createNewTraffic) signals.kbdPTT.disconnect(self.sendPTT) self.server.close() self.aircraft_list.clear() signals.sessionEnded.emit() def studentConnected(self): return self.student_socket != None def isRunning(self): return self.session_ticker.isActive( ) or self.simulation_paused_at != None def myCallsign(self): return teacher_callsign def getAircraft(self): return self.aircraft_list[:] def getWeather(self, station): return self.current_local_weather if station == settings.primary_METAR_station else None def postRadioChatMsg(self, msg): raise ValueError( 'Public radio chat panel reserved for monitoring read-backs in teacher sessions. ' 'Use the ATC text chat system to communicate with the student.') def postAtcChatMsg(self, msg): if self.studentConnected(): if msg.isPrivate(): payload = '%s\n%s' % (msg.sender(), msg.txtOnly()) self.student.sendMessage( TeachingMsg(TeachingMsg.ATC_TEXT_CHAT, data=payload)) else: raise ValueError( 'Only private messaging is enabled in tutoring sessions.') else: raise ValueError('No student connected.') ## CONNECTION MANAGEMENT def studentConnects(self): new_connection = self.server.nextPendingConnection() if new_connection: peer_address = new_connection.peerAddress().toString() print('Contacted by %s' % peer_address) if self.studentConnected(): new_connection.disconnectFromHost() print('Client rejected. Student already connected.') else: self.student_socket = new_connection self.student_socket.disconnected.connect( self.studentDisconnects) self.student_socket.disconnected.connect( self.student_socket.deleteLater) self.student = TeachingSessionWire(self.student_socket) self.student.messageArrived.connect(self.receiveMsgFromStudent) env.ATCs.updateATC(student_callsign, None, None, None) self.noACK_traffic_count = 0 self.sendWeather() self.sendATCs() self.tickSessionOnce() if self.simulation_paused_at != None: self.student.sendMessage( TeachingMsg(TeachingMsg.SIM_PAUSED)) QMessageBox.information( self.gui, 'Student connection', 'Student accepted from %s' % peer_address) else: print('WARNING: Connection attempt failed.') def studentDisconnects(self): self.shutdownStudentConnection() QMessageBox.information(self.gui, 'Student disconnection', 'Your student has disconnected.') def shutdownStudentConnection(self): self.student_socket.disconnected.disconnect(self.studentDisconnects) env.cpdlc.endAllDataLinks() env.ATCs.removeATC(student_callsign) self.student.messageArrived.disconnect(self.receiveMsgFromStudent) self.student_socket.disconnectFromHost() self.student_socket = None ## TEACHER MANAGEMENT def instructAircraftByCallsign(self, callsign, instr): try: acft = next(acft for acft in self.aircraft_list if acft.identifier == callsign) except StopIteration: print('ERROR: Teacher aircraft not found: %s' % callsign) return try: acft.instruct([instr]) acft.readBack([instr]) except Instruction.Error as err: QMessageBox.critical(self.gui, 'Instruction error', speech_str2txt(str(err))) def createNewTraffic(self, spawn_coords, spawn_hdg): dialog = CreateTrafficDialog(spawn_coords, spawn_hdg, parent=self.gui) dialog.exec() if dialog.result() > 0: params = dialog.acftInitParams() params.XPDR_mode = new_traffic_XPDR_mode acft = ControlledAircraft(dialog.acftCallsign(), dialog.acftType(), params, None) acft.spawned = False acft.frozen = dialog.startFrozen() acft.tickOnce() self.aircraft_list.append(acft) if dialog.createStrip(): strip = Strip() strip.writeDetail(FPL.CALLSIGN, acft.identifier) strip.writeDetail(FPL.ACFT_TYPE, acft.aircraft_type) strip.writeDetail(FPL.WTC, wake_turb_cat(acft.aircraft_type)) strip.linkAircraft(acft) signals.receiveStrip.emit(strip) selection.selectAircraft(acft) def killAircraft(self, acft): if env.cpdlc.isConnected(acft.identifier): env.cpdlc.endDataLink(acft.identifier) pop_all(self.aircraft_list, lambda a: a is acft) if acft.spawned and self.studentConnected(): self.student.sendMessage( TeachingMsg(TeachingMsg.ACFT_KILLED, data=acft.identifier)) signals.aircraftKilled.emit(acft) def sendATCs(self): if self.studentConnected(): msg = TeachingMsg(TeachingMsg.SX_LIST) for atc in env.ATCs.knownATCs( lambda atc: atc.callsign != student_callsign): try: frq = env.ATCs.getATC( atc ).frequency # instance of CommFrequency class, or None except KeyError: frq = None msg.appendData(atc if frq == None else '%s\t%s' % (atc, frq)) msg.appendData('\n') self.student.sendMessage(msg) def setWeather(self, weather): # assumed at primary location and newer self.current_local_weather = weather signals.newWeather.emit(settings.primary_METAR_station, self.current_local_weather) self.sendWeather() def sendWeather(self): if self.studentConnected() and self.current_local_weather != None: self.student.sendMessage( TeachingMsg(TeachingMsg.WEATHER, data=self.current_local_weather.METAR())) def sendPTT(self, ignore_button, on_off): if selection.acft != None and selection.acft.spawned: if on_off: env.rdf.receiveSignal( selection.acft.identifier, lambda acft=selection.acft: acft.coords()) else: env.rdf.dieSignal(selection.acft.identifier) if self.studentConnected(): str_data = '%d %s' % (on_off, selection.acft.identifier) self.student.sendMessage( TeachingMsg(TeachingMsg.PTT, data=str_data)) def requestCpdlcConnection( self, callsign): # NOTE: student must confirm data link if self.studentConnected(): self.student.sendMessage( TeachingMsg(TeachingMsg.CPDLC, data=('%s\n1' % callsign))) def transferCpdlcAuthority( self, acft_callsign, atc_callsign ): # for teacher, ATC here is who to transfer *from* to student if self.studentConnected(): self.student.sendMessage(TeachingMsg(TeachingMsg.CPDLC, \ data=('%s\n%s%s' % (acft_callsign, CPDLC_transfer_cmd_prefix, atc_callsign)))) # NOTE: student must confirm data link def disconnectCpdlc(self, callsign): env.cpdlc.endDataLink(callsign) if self.studentConnected(): self.student.sendMessage( TeachingMsg(TeachingMsg.CPDLC, data=('%s\n0' % callsign))) def sendCpdlcMsg(self, callsign, msg): link = env.cpdlc.currentDataLink(callsign) if link == None: return if msg.type() == CpdlcMessage.ACK and link.msgCount() > 0: last_msg = link.lastMsg() if not last_msg.isFromMe() and last_msg.type() == CpdlcMessage.INSTR \ and yesNo_question(self.gui, 'ACK after received INSTR', last_msg.contents(), 'Execute instruction?'): try: instr = Instruction.fromEncodedStr(last_msg.contents()) self.instructAircraftByCallsign(callsign, instr) except ValueError: # raised by Instruction.fromEncodedStr if not yesNo_question(self.gui, 'CPDLC comm error', \ 'Unable to decode instruction.', 'Send ACK and perform manually?'): return # cancel sending any message except Instruction.Error as err: # raised by TeacherSessionManager.instructAircraftByCallsign if not yesNo_question(self.gui, 'CPDLC instruction error', \ 'Unable to perform instruction: %s' % err, 'Send ACK anyway?'): return # cancel sending any message else: # no problem executing instruction selection.writeStripAssignment(instr) if self.studentConnected() and link != None: link.appendMessage(msg) self.student.sendMessage( TeachingMsg( TeachingMsg.CPDLC, data=('%s\n%s%s' % (callsign, CPDLC_message_cmd_prefix, msg.text())))) def pauseSession(self): self.session_ticker.stop() self.simulation_paused_at = now() signals.sessionPaused.emit() if self.studentConnected(): self.student.sendMessage(TeachingMsg(TeachingMsg.SIM_PAUSED)) def resumeSession(self): pause_delay = now() - self.simulation_paused_at for acft in self.aircraft_list: acft.moveHistoryTimesForward(pause_delay) self.simulation_paused_at = None self.session_ticker.start_stopOnZero(teacher_ticker_interval) signals.sessionResumed.emit() if self.studentConnected(): self.student.sendMessage(TeachingMsg(TeachingMsg.SIM_RESUMED)) ## MESSAGES FROM STUDENT def receiveMsgFromStudent(self, msg): #DEBUG if msg.type != TeachingMsg.TRAFFIC: #DEBUG print('=== TEACHERS RECEIVES ===\n%s\n=== End ===' % msg.data) if msg.type == TeachingMsg.ATC_TEXT_CHAT: lines = msg.strData().split('\n') if len(lines) == 2: signals.incomingAtcTextMsg.emit( ChatMessage(student_callsign, lines[1], recipient=lines[0], private=True)) else: print( 'ERROR: Invalid format in received ATC text chat from student.' ) elif msg.type == TeachingMsg.STRIP_EXCHANGE: line_sep = msg.strData().split('\n', maxsplit=1) toATC = line_sep[0] strip = Strip.fromEncodedDetails( '' if len(line_sep) < 2 else line_sep[1]) strip.writeDetail(received_from_detail, student_callsign) if toATC != teacher_callsign: strip.writeDetail(sent_to_detail, toATC) signals.receiveStrip.emit(strip) elif msg.type == TeachingMsg.WEATHER: # requesting weather information if msg.strData() == settings.primary_METAR_station: self.sendWeather() elif msg.type == TeachingMsg.TRAFFIC: # acknowledging a traffic message if self.noACK_traffic_count > 0: self.noACK_traffic_count -= 1 else: print('ERROR: Student acknowledging unsent traffic?!') elif msg.type == TeachingMsg.CPDLC: # Msg format in 2 lines, first being ACFT callsign, second is either of the following: # - connect/disconnect: "0" or "1" # - data authority transfer: CPDLC_transfer_cmd_prefix + ATC callsign transferring to/from # - other: CPDLC_message_cmd_prefix + encoded message string try: acft_callsign, line2 = msg.strData().split('\n', maxsplit=1) if line2 == '0': # ACFT disconnected by student if env.cpdlc.isConnected(acft_callsign): env.cpdlc.endDataLink(acft_callsign) else: # student is rejecting a connection (unable CPDLC) QMessageBox.warning( self.gui, 'CPDLC connection failed', 'Student is not accepting CPDLC connections.') elif line2 == '1': # student confirming ACFT log-on env.cpdlc.beginDataLink(acft_callsign, student_callsign) elif line2.startswith( CPDLC_transfer_cmd_prefix ): # student transferring or confirming transfer atc = line2[len(CPDLC_transfer_cmd_prefix):] if env.cpdlc.isConnected( acft_callsign ): # student initiating transfer to next ATC env.cpdlc.endDataLink(acft_callsign, transferTo=atc) else: # student confirming proposed transfer env.cpdlc.beginDataLink(acft_callsign, student_callsign, transferFrom=atc) elif line2.startswith(CPDLC_message_cmd_prefix ): # student ATC sent a message encoded_msg = line2[len(CPDLC_message_cmd_prefix):] link = env.cpdlc.currentDataLink(acft_callsign) if link == None: print( 'Ignored CPDLC message sent to %s while not connected.' % acft_callsign) else: link.appendMessage( CpdlcMessage.fromText(False, encoded_msg)) else: print('Error decoding CPDLC command from student:', line2) except (IndexError, ValueError): print('Error decoding CPDLC message value from student') else: print('ERROR: Unhandled message type from student: %s' % msg.type) ## TICK def tickSessionOnce(self): pop_all(self.aircraft_list, lambda a: not env.pointInRadarRange(a.params.position)) send_traffic_this_tick = self.studentConnected( ) and self.noACK_traffic_count < max_noACK_traffic for acft in self.aircraft_list: acft.tickOnce() fgms_packet = acft.fgmsLivePositionPacket() send_packet_to_views(fgms_packet) if send_traffic_this_tick and acft.spawned: self.student.sendMessage( TeachingMsg(TeachingMsg.TRAFFIC, data=fgms_packet)) self.noACK_traffic_count += 1 ## STRIP EXCHANGE def stripDroppedOnATC(self, strip, sendto): if sendto == student_callsign: items = [teacher_callsign] + env.ATCs.knownATCs( lambda atc: atc.callsign != student_callsign) sender, ok = QInputDialog.getItem(self.gui, 'Send strip to student', 'Hand over strip from:', items, editable=False) if ok and self.studentConnected(): msg_data = sender + '\n' + strip.encodeDetails( handover_details) self.student.sendMessage( TeachingMsg(TeachingMsg.STRIP_EXCHANGE, data=msg_data)) else: raise HandoverBlocked('Cancelled by teacher.', silent=True) else: raise HandoverBlocked('Strips can only be sent to the student!') ## SNAPSHOTTING def situationSnapshot(self): return [acft.statusSnapshot() for acft in self.aircraft_list] def restoreSituation(self, situation_snapshot): while self.aircraft_list != []: self.killAircraft(self.aircraft_list[0]) for acft_snapshot in situation_snapshot: self.aircraft_list.append( ControlledAircraft.fromStatusSnapshot(acft_snapshot)) self.tickSessionOnce()
class Window(QWidget, Ui_FormFrameworkTools): def __init__(self, *args, **kwargs): super(Window, self).__init__(*args, **kwargs) self.setupUi(self) # 初始化server self._server = QTcpServer(self) self._server.newConnection.connect(self.onNewConnection) self._server.listen(QHostAddress.LocalHost, 49496) self._getPsPath() self._initCodeEdit() # 设置默认代码和参数 self.argsEdit.setPlainText('testColor("{}")'.format( os.path.abspath('Resources/GM6C6860.jpg').replace('\\', '/'))) self.codeEdit.setText(self._formatArgs(Template)) def _formatArgs(self, code): code = code.replace( '#1#', os.path.abspath('Resources/ProgressBar.jsx').replace('\\', '/')) code = code.replace( '#2#', os.path.abspath('Resources/Core.jsx').replace('\\', '/')) code = code.replace( '#3#', os.path.abspath('Resources/test.jsx').replace('\\', '/')) return code def _initCodeEdit(self): # 初始化编辑器的工作 self.codeEdit.setUtf8(True) self.codeEdit.linesChanged.connect(self.onLinesChanged) # 行改变 # 代码高亮 self.codeEdit.setLexer(QsciLexerJavaScript(self)) # 自动折叠 self.codeEdit.setMarginType(3, QsciScintilla.SymbolMargin) self.codeEdit.setMarginLineNumbers(3, False) self.codeEdit.setMarginWidth(3, 15) self.codeEdit.setMarginSensitivity(3, True) # 显示行号 #self.codeEdit.setMarginType(0, QsciScintilla.NumberMargin) self.codeEdit.setMarginLineNumbers(0, True) self.onLinesChanged() # 代码提示 sciApi = QsciAPIs(self.codeEdit.lexer()) sciApi.prepare() self.codeEdit.setAutoCompletionSource(QsciScintilla.AcsAll) # 设置源 self.codeEdit.setAutoCompletionCaseSensitivity(True) # 设置自动补全大小写敏感 self.codeEdit.setAutoCompletionThreshold(1) # 设置每输入一个字符就会出现自动补全的提示 # 设置字体 self.codeEdit.setFont(QFont('Consolas', 16)) self.codeEdit.setMarginsFont(self.codeEdit.font()) # 设置编码 self.codeEdit.SendScintilla(QsciScintilla.SCI_SETCODEPAGE, QsciScintilla.SC_CP_UTF8) self.codeEdit.setBraceMatching(QsciScintilla.StrictBraceMatch) # 设置当前行高亮 self.codeEdit.setCaretLineVisible(True) self.codeEdit.setCaretLineBackgroundColor(Qt.lightGray) self.codeEdit.setCaretForegroundColor(Qt.white) # tab # table relative self.codeEdit.setIndentationsUseTabs(True) self.codeEdit.setIndentationWidth(4) self.codeEdit.setTabIndents(True) self.codeEdit.setAutoIndent(True) self.codeEdit.setBackspaceUnindents(True) self.codeEdit.setTabWidth(4) # indentation guides self.codeEdit.setIndentationGuides(True) # folding margin self.codeEdit.setFolding(QsciScintilla.PlainFoldStyle) self.codeEdit.setMarginWidth(2, 12) # 自动换行 self.codeEdit.setWrapMode(QsciScintilla.WrapWord) def onLinesChanged(self): # 动态设置左边的边距 self.codeEdit.setMarginWidth( 0, self.codeEdit.fontMetrics().width(str(self.codeEdit.lines())) + 5) def _getPsPath(self): # 获取ps的路径 settings = QSettings('FrameworkTools', 'Settings') psPath = settings.value('path', '') if not psPath: # 如果没有找到自己保存的路径则去找系统安装的路径 settings = QSettings( 'HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Photoshop.exe', QSettings.NativeFormat) psPath = settings.value('.', '') self.pathEdit.setText(psPath) def onNewConnection(self): # 当有新的连接来时 while self._server.hasPendingConnections(): socket = self._server.nextPendingConnection() socket.readyRead.connect(self.onReadyRead) if socket.bytesAvailable() > 0: # 如果已有数据发送过来 self.doRecv(socket) def onReadyRead(self): # 准备接收数据 socket = self.sender() if socket.bytesAvailable() > 0: self.doRecv(socket) def doRecv(self, socket): # 接收数据 try: data = socket.readAll().data().decode() # 对数据解密 data = xxtea.decryptFromBase64(data, '0123456789abcdef') method, args = data.split('|') self.resultEdit.append('被调用函数: {}, 参数: {}'.format(method, args)) try: args = eval(args) except Exception as e: args = [] # 动态执行函数 if hasattr(self, method): getattr(self, method)(socket, *args) except Exception as e: self.resultEdit.append(str(e)) def getCode(self, socket): # 传递参数的函数 args = self.argsEdit.toPlainText().strip() args = xxtea.encryptToBase64(args, '0123456789abcdef') + '\n' print('发送加密数据: ', args) socket.write(args.encode()) socket.flush() def showError(self, _, message): # 显示错误消息 if message: QMessageBox.critical(self, '错误', message) @pyqtSlot() def on_selectButton_clicked(self): # 手动选择路径 path, _ = QFileDialog.getOpenFileName(self, '选择Ps路径', '', 'Photoshop.exe') if path: self.pathEdit.setText(path) settings = QSettings('FrameworkTools', 'Settings') settings.setValue('path', path) settings.sync() @pyqtSlot() def on_runButton_clicked(self): # 运行按钮 code = self.codeEdit.text().strip() if not code: return if not code.startswith('#target'): code = '#target photoshop\n' + code path = tempfile.mktemp('.jsx') open(path, 'wb').write(code.encode('utf-8')) subprocess.call([self.pathEdit.text().strip(), path]) def closeEvent(self, event): if self._server.isListening(): self._server.close() self._server.deleteLater() super(Window, self).closeEvent(event)
class ReceiverEngine(QObject): newDataPacket = pyqtSignal(str, str) def __init__(self, parent=None, port=NetSettings.nodeDataPort): super().__init__(parent) self.__incomingConnections = dict( ) # QMap<QTcpSocket*, _IncomingConnection> self.__incomingConnectionsAddress = str() self.__incomingConnectionsPort = int() self.__server = None self.__signChecker = SignChecker() self.__serverPort = port def __del__(self): pass # self.stop() @pyqtSlot() def setMaxPendingConnections(self, numConnections: int): if not self.__server: return self.__server.setMapPendingConnections(numConnections) def isListening(self): if not self.__server: return False # SHOULD BE PROTECTED WITH MUTEX return self.__server.isListening() @pyqtSlot(str) def runReceiver(self, hostAddress: str): if not self.__server: self.__server = QTcpServer(self) self.__server.acceptError.connect(self.__error) if not self.__server.listen( QHostAddress(hostAddress), self.__serverPort) and not self.isListening(): print("RECEIVER NOT STARTED", self.__server.errorString()) else: self.__server.newConnection.connect(self.__newConnection) self.__incomingConnectionsAddress = hostAddress self.__incomingConnectionsPort = self.__serverPort print("RECEIVER STARTED") @pyqtSlot() def stop(self): if not self.__server: return if self.isListening(): for socket in self.__incomingConnections.keys(): socket.readyRead.disconnect() socket.disconnected.disconnect() socket.close() self.__incomingConnections.clear() @pyqtSlot() def __newConnection(self): socket = self.__server.nextPendingConnection() print("NEW CONN", socket.peerAddress().toString(), socket.peerPort()) socket.setSocketOption(QAbstractSocket.LowDelayOption, 1) socket.setSocketOption(QAbstractSocket.KeepAliveOption, 0) # socket.setProperty("port", socket.peerPort()) # socket.setProperty("address", socket.peerAddress().toString()) incomingConnection = _IncomingConnection() incomingConnection.socketDescriptor = socket.socketDescriptor() incomingConnection.socket = socket # incomingConnection.socket.setReadBufferSize(1024) incomingConnection.socket.readyRead.connect(self.__readData) incomingConnection.socket.disconnected.connect(self.__disconnected) incomingConnection.buffer = QByteArray() incomingConnection.address = socket.peerAddress().toString() incomingConnection.port = socket.peerPort() self.__incomingConnections[socket] = incomingConnection @pyqtSlot() def __readData(self): socket = self.sender() # print("READ", socket.peerAddress().toString(), socket.peerPort()) # print("read data from", socket.objectName()) incomingConnection = self.__incomingConnections.get(socket, None) if incomingConnection: bytesAvailable = socket.bytesAvailable() # if self.__serverPort != NetSettings.nodeCommandPort: # print(bytesAvailable, "READING FROM SOCKET", socket.peerPort()) if bytesAvailable: incomingConnection.buffer.append(socket.read(bytesAvailable)) while incomingConnection.receivingPacketSize == 0 and incomingConnection.buffer.size() >= 4 \ or incomingConnection.receivingPacketSize > 0 and incomingConnection.buffer.size() >= incomingConnection.receivingPacketSize: if incomingConnection.receivingPacketSize == 0 and incomingConnection.buffer.size( ) >= 4: incomingConnection.receivingPacketSize = self.__bytesToInt( incomingConnection.buffer.left(4)) incomingConnection.buffer.remove(0, 4) if incomingConnection.receivingPacketSize > 0 and incomingConnection.buffer.size( ) >= incomingConnection.receivingPacketSize: packet = bytes( incomingConnection.buffer.left( incomingConnection.receivingPacketSize) ).decode() # if self.__signChecker.checkTran(packet): self.newDataPacket.emit(incomingConnection.address, packet) incomingConnection.buffer.remove( 0, incomingConnection.receivingPacketSize) incomingConnection.receivingPacketSize = 0 else: print("Address disconnected already ") # raise Exception("ERROR WITH ADDRESS") @pyqtSlot() def __disconnected(self): socket = self.sender() print("disconnected from ", socket.objectName()) self.__incomingConnections.pop(socket, None) @pyqtSlot() def __error(self): server = self.sender() print("ERROR", server.errorString()) def __bytesToInt(self, data: QByteArray): temp = int().from_bytes(data, byteorder="little") return temp
class Server(QMainWindow): def __init__(self): super().__init__() self.ui = Ui_MainWindow() self.ui.setupUi(self) self.E, self.D, self.N = get_EDN() self.socket = QTcpServer() self.des = DesOperate() self.key = [] self.client = [] self.ui.bind.clicked.connect(self.bind) self.ui.send.clicked.connect(self.sendMessage) self.show() def bind(self): self.bindport = int(self.ui.port.text()) self.socket.listen(QHostAddress.LocalHost,self.bindport) self.socket.newConnection.connect(self.newconnect) self.ui.log.append("正在监听端口 %d" % self.bindport) def on_socket_receive(self): index = 0 for index in range(len(self.client)): rxData = str(self.client[index].readAll(), 'utf-8') if rxData != "": if self.key[index] is None: self.key[index] = decodeRSA(rxData, self.D, self.N) self.ui.log.append("通过RSA获取到第%d个客户端密钥" % index) return self.ui.log.append("收到第%d个客户端消息" % index) self.ui.log.append("密文:%s" % rxData) solvedata = self.des.decry(rxData, self.key[index]) self.ui.log.append("原文:%s" % solvedata) def sendMessage(self): string = self.ui.sendMessage.toPlainText() clientid = int(self.ui.clientid.text()) if len(self.client) <= clientid: QMessageBox.information(self, "提示", "用户%d未建立连接" % clientid) return self.ui.log.append("发送原文:%s" % string) string = self.des.encry(string, self.key[clientid]) self.ui.log.append("加密密文:%s" % string) self.client[clientid].write(string.encode()) self.ui.sendMessage.setPlainText("") def newconnect(self): self.key.append(None) self.client.append(self.socket.nextPendingConnection()) self.ui.log.append("连接成功") self.client[-1].readyRead.connect(self.on_socket_receive) self.client[-1].disconnected.connect(self.on_socket_disconnected) sendmessage = str(self.E) + '_' + str(self.N) self.ui.log.append("发送公钥成功!") self.client[-1].write(sendmessage.encode()) def on_socket_disconnected(self): self.ui.log.append("连接断开!")
class CodeExecutor(object): """ This class is responsible for executing code (when starting Tribler in debug mode). The protocol to execute code is as follows. First, a client that wants to execute some code opens a connection with the TCP server and sends the string: <code in base64 format> <task_id>\n This code will be executed and the result will be sent to the client in the following format: result <result> <task_id>\n. If Tribler crashes, the server sends the following result: crash <stack trace in base64 format> Note that the socket uses the newline as separator. """ def __init__(self, port, shell_variables={}): self.logger = logging.getLogger(self.__class__.__name__) self.tcp_server = QTcpServer() self.sockets = [] self.stack_trace = None if not self.tcp_server.listen(port=port): self.logger.error("Unable to start code execution socket! Error: %s", self.tcp_server.errorString()) else: self.tcp_server.newConnection.connect(self._on_new_connection) self.shell = Console(locals=shell_variables) def _on_new_connection(self): while self.tcp_server.hasPendingConnections(): socket = self.tcp_server.nextPendingConnection() socket.readyRead.connect(self._on_socket_read_ready) socket.disconnected.connect(lambda dc_socket=socket: self._on_socket_disconnect(dc_socket)) self.sockets.append(socket) # If Tribler has crashed, notify the other side immediately if self.stack_trace: self.on_crash(self.stack_trace) def run_code(self, code, task_id): self.shell.runcode(code) stdout = self.shell.stdout.read() stderr = self.shell.stderr.read() self.logger.info("Code execution with task %s finished:", task_id) self.logger.info("Stdout of task %s: %s", task_id, stdout) if 'Traceback' in stderr and 'SystemExit' not in stderr: self.logger.error("Executed code with failure: %s", b64encode(code)) # Determine the return value if 'return_value' not in self.shell.console.locals: return_value = ''.encode('base64') else: return_value = str(self.shell.console.locals['return_value']).encode('base64') for socket in self.sockets: socket.write("result %s %s\n" % (return_value, task_id)) def on_crash(self, exception_text): self.stack_trace = exception_text for socket in self.sockets: socket.write("crash %s\n" % exception_text.encode('base64')) def _on_socket_read_ready(self): data = str(self.sockets[0].readAll()) parts = data.split(" ") if len(parts) != 2: return try: code = parts[0].decode('base64') task_id = parts[1].replace('\n', '') self.run_code(code, task_id) except binascii.Error: self.logger.error("Invalid base64 code string received!") def _on_socket_disconnect(self, socket): self.sockets.remove(socket)
def isAvailable(port): server = QTcpServer() result = server.listen(QHostAddress("127.0.0.1"), port) server.close() return result