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
