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 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(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 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 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 TcpServer(QObject):
'''
TCP/IP server class.
Usage:
import sys
import tcp
from PyQt4.QtCore import QCoreApplication
from PyQt4.QtNetwork import QHostAddress
def main():
application = QCoreApplication(sys.argv)
tcpServer = tcp.TcpServer()
def onConnected(descriptor):
print("Client [%s] connected. Now total: %s" % (descriptor, len(tcpServer.descriptors())))
tcpServer.write(descriptor, "Hello dude")
def onDisconnected(descriptor):
print("Client [%s] disconnected. Now total: %s" % (descriptor, len(tcpServer.descriptors())))
def onError(descriptor, error):
print("Error [%s]: ", descriptor, error)
def onRead(descriptor, data):
print("Read from [%s] %s byte(s): %s" % (descriptor, len(data), data))
tcpServer.onConnected = onConnected
tcpServer.onDisconnected = onDisconnected
tcpServer.onError = onError
tcpServer.onRead = onRead
tcpServer.listen(QHostAddress.Any, 9000)
sys.exit(application.exec_())
if __name__ == "__main__":
main()
'''
def __init__(self, parent=None):
QObject.__init__(self, parent)
self.__server = QTcpServer(parent)
self.__clients = dict() # All active clients
# Callbacks
self.__on_connected = None
self.__on_disconnected = None
self.__on_error = None
self.__on_read = None
# Signals and slots connections
self.__server.newConnection.connect(self.__onNewConnection)
# Slots
@pyqtSlot()
def __onNewConnection(self):
'''
The slot is called every time a client connects to the server. The client's socket(QTcpSocket) <socket> and
descriptor(int) <descriptor> are defined. The socket is appended to the dictionary of connected
clients(key=client's descriptor, value=client's socket). Then, socket's descriptor is passed to
__onConnected method.
:return: None
'''
socket = self.__server.nextPendingConnection()
socket.disconnected.connect(self.__onDisconnected)
socket.error.connect(self.__onError)
socket.readyRead.connect(self.__onReadyRead)
descriptor = id(socket)
self.__clients[descriptor] = socket
self.__onConnected(descriptor)
@pyqtSlot()
def __onConnected(self, descriptor):
'''
The method is called by __onNewConnection every time a client connects to the server. If __on_connected callback
is set, it is executed with socket's descriptor(int) <descriptor> argument.
:param descriptor(int): a newly connected client's socket descriptor, the socket itself is in self.__clients
dictionary(key=client's descriptor, value=client's socket);
:return: None
'''
if self.__on_connected:
self.__on_connected(descriptor)
@pyqtSlot()
def __onDisconnected(self):
'''
The slot is called when the connected client disconnects from the server. The client's socket(QTcpSocket)
<socket> and its descriptor(int) <descriptor> are defined, and then the descriptor is passed to
__on_disconnected callback.
:return: None
'''
if self.__on_disconnected:
socket = self.sender()
descriptor = id(socket)
self.__clients.pop(descriptor, None)
self.__on_disconnected(descriptor)
@pyqtSlot()
def __onError(self, socketError):
'''
The slot is called when an error(PyQt4.QtNetwork.SocketError) <socketError> occurs. The socket's descriptor(int)
<descriptor> with error code(int) <errorCode> and description(str) <errorDescription> are defined and passed
to __on_error callback.
:param error(QAbstractSocket.SocketError): socket error;
:return: None
'''
if self.__on_error:
socket = self.__server.sender()
descriptor = id(socket)
errorCode = int(socketError)
errorDescription = str(self.__server.errorString())
error = (errorCode, errorDescription)
self.__on_error(descriptor, error)
@pyqtSlot()
def __onReadyRead(self):
'''
The slot is called when new data is available for reading from the client. The client's socket descriptor(int)
<descriptor> is defined, and all available data(str) <data> is read. Then, the socket descriptor and the data
are passed to __on_read callback.
:return: None
'''
if self.__on_read:
socket = self.sender()
descriptor = id(socket)
data = socket.readAll().data()
self.__on_read(descriptor, data)
# Setters
def __connected(self, callback):
self.__on_connected = callback
def __disconnected(self, callback):
self.__on_disconnected = callback
def __error(self, callback):
self.__on_error = callback
def __read(self, callback):
self.__on_read = callback
# Methods
def isListening(self):
'''
Return True if the server is currently listening for incoming connections, otherwise returns False.
:return: bool
'''
return self.__server.isListening()
def listen(self, address=None, port=0):
'''
Tell the server to listen for incoming connections on address(QHostAddress) <address> and port(int) <port>. If
port is 0, a port is chosen automatically. If address is QHostAddress.Any, the server will listen on all network
interfaces.
:param address(QHosAddress): address to listen to;
:param port(int): the port to listen to;
:return: bool, return True on success, otherwise return False
'''
self.__server.listen(address, port)
def socket(self, descriptor):
'''
Return socket(QTcpSocket) with the given descriptor(int) <descriptor> or None if it is not found.
:param descriptor(int): socket descriptor;
:return: socket(QTcpSocket) or None
'''
return self.__clients.get(descriptor, None)
def descriptors(self):
'''
Return all sockets' descriptors available.
:return list of int
'''
return sorted(self.__clients.keys())
def write(self, descriptor, data):
'''
Write data(str) <data> to the client's socket with the given descriptor(int) <descriptor>.
:param descriptor(int): client's socket descriptor;
:param data(str), data to be written;
:return: int, the number of bytes that were actually written, or -1 if an error occurred
'''
socket = self.socket(descriptor)
if socket:
return socket.write(data)
else:
return -1
def disconnect(self, descriptor):
'''
Disconnect the client socket with the given descriptor(int) <descriptor>.
:param descriptor(int): client's socket descriptor;
:return: None
'''
socket = self.socket(descriptor)
if socket:
socket.close()
def close(self):
'''
Close the server.
:return: None
'''
for socket in self.__clients.values():
socket.close()
self.__server.close()
# Properties
onConnected = property(fset=__connected)
onDisconnected = property(fset=__disconnected)
onError = property(fset=__error)
onRead = property(fset=__read)
class Dialog(QDialog):
TotalBytes = 50 * 1024 * 1024
PayloadSize = 65536
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.tcpServer = QTcpServer()
self.tcpClient = QTcpSocket()
self.bytesToWrite = 0
self.bytesWritten = 0
self.bytesReceived = 0
self.clientProgressBar = QProgressBar()
self.clientStatusLabel = QLabel("Client ready")
self.serverProgressBar = QProgressBar()
self.serverStatusLabel = QLabel("Server ready")
self.startButton = QPushButton("&Start")
self.quitButton = QPushButton("&Quit")
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.startButton.clicked.connect(self.start)
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.acceptConnection)
self.tcpClient.connected.connect(self.startTransfer)
self.tcpClient.bytesWritten.connect(self.updateClientProgress)
self.tcpClient.error.connect(self.displayError)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.clientProgressBar)
mainLayout.addWidget(self.clientStatusLabel)
mainLayout.addWidget(self.serverProgressBar)
mainLayout.addWidget(self.serverStatusLabel)
mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Loopback")
def start(self):
self.startButton.setEnabled(False)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.bytesWritten = 0
self.bytesReceived = 0
while not self.tcpServer.isListening() and not self.tcpServer.listen():
ret = QMessageBox.critical(self, "Loopback",
"Unable to start the test: %s." % self.tcpServer.errorString(),
QMessageBox.Retry | QMessageBox.Cancel)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText("Listening")
self.clientStatusLabel.setText("Connecting")
self.tcpClient.connectToHost(QHostAddress(QHostAddress.LocalHost), self.tcpServer.serverPort())
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.updateServerProgress)
self.tcpServerConnection.error.connect(self.displayError)
self.serverStatusLabel.setText("Accepted connection")
self.tcpServer.close()
def startTransfer(self):
self.bytesToWrite = Dialog.TotalBytes - self.tcpClient.write(QByteArray(Dialog.PayloadSize, '@'))
self.clientStatusLabel.setText("Connected")
def updateServerProgress(self):
self.bytesReceived += self.tcpServerConnection.bytesAvailable()
self.tcpServerConnection.readAll()
self.serverProgressBar.setMaximum(Dialog.TotalBytes)
self.serverProgressBar.setValue(self.bytesReceived)
self.serverStatusLabel.setText("Received %dMB" % (self.bytesReceived / (1024 * 1024)))
if self.bytesReceived == Dialog.TotalBytes:
self.tcpServerConnection.close()
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
def updateClientProgress(self, numBytes):
self.bytesWritten += numBytes
if self.bytesToWrite > 0:
self.bytesToWrite -= self.tcpClient.write(QByteArray(
min(self.bytesToWrite, Dialog.PayloadSize), '@'))
self.clientProgressBar.setMaximum(Dialog.TotalBytes)
self.clientProgressBar.setValue(self.bytesWritten)
self.clientStatusLabel.setText("Sent %dMB" % (self.bytesWritten / (1024 * 1024)))
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(self, "Network error",
"The following error occured: %s." % self.tcpClient.errorString())
self.tcpClient.close()
self.tcpServer.close()
self.clientProgressBar.reset()
self.serverProgressBar.reset()
self.clientStatusLabel.setText("Client ready")
self.serverStatusLabel.setText("Server ready")
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
class BaristaServer():
MIN_PORT = 0
MAX_PORT = 65535
DEFAULT_PORT = 4200
def __init__(self, application, ip, port, sessionPath):
self.application = application
self.server = None
self.port = int(port)
self.ip = QHostAddress.Any
if ip is not None:
self.ip = QHostAddress(ip)
self.sessionPath = sessionPath
self.configpath = os.path.join(self.sessionPath, "barista.conf") ####
self.hardware = []
self.trainOnHW = 0
self.transactionList = []
self._loadConfig()
self.checkHardware()
state = self._checkConfig()
self.start()
self.sessionManager = ServerSessionManager(self, self.sessionPath)
def start(self):
self.server = QTcpServer()
self.server.listen(self.ip, self.port)
self.server.newConnection.connect(self._newConnection)
if self.server.isListening():
hostIP = str(self.server.serverAddress().toString())
if hostIP == '0.0.0.0':
hostIP = '<any>'
sys.stdout.write("Hostname: " + socket.gethostname() + "\tIP: " +
hostIP + ":" + str(self.server.serverPort()) +
"\n")
else:
sys.stderr.write(
"Something went wrong. Server is not listening.\n")
logging.error("Something went wrong. Server is not listening.")
exit(1)
def getBaristaStatus(self, pid=""):
hardware = [k["name"] for k in self.hardware]
statusdict = {"trainOnHW": self.trainOnHW, "hardware": hardware}
statusdict["connections"] = len(self.transactionList)
statusdict["config"] = self._checkConfig(False)
statusdict["training"] = len(
self.sessionManager.findSessionIDsWithState(State.RUNNING)) is 0
statusdict["sessioncount"] = len(self.sessionManager.sessions)
statusdict["sessionpath"] = self.sessionPath
if pid is not "":
pidses = {}
sessions = set(self.sessionManager.findSessionIDsByProjectId(pid))
pidses["pid"] = pid
pidses["count"] = len(sessions)
pidses["running"] = len(
set(self.sessionManager.findSessionIDsWithState(State.RUNNING))
& sessions)
pidses["running"] += len(
set(self.sessionManager.findSessionIDsWithState(State.PAUSED))
& sessions)
pidses["waiting"] = len(
set(self.sessionManager.findSessionIDsWithState(State.WAITING))
& sessions)
pidses["finished"] = len(
set(self.sessionManager.findSessionIDsWithState(
State.FINISHED)) & sessions)
statusdict["projectsessions"] = pidses
return statusdict
def _newConnection(self):
transaction = ServerTransaction(self)
self.transactionList.append(transaction)
transaction.socketClosed.connect(
lambda item=transaction: self._deleteConnection(item))
transaction.acceptClient(self.server.nextPendingConnection())
def _deleteConnection(self, transaction):
index = self.transactionList.index(transaction)
del self.transactionList[index]
def _saveConfig(self):
#Save train on hardware
tosave = dict()
tosave["trainOnHW"] = self.trainOnHW
with open(self.configpath, "w") as file:
json.dump(tosave, file, sort_keys=True, indent=4)
def _loadConfig(self):
####
if not os.path.exists(self.configpath):
# TODO Default
pass
else:
with open(self.configpath, "r") as file:
res = json.load(file)
if "trainOnHW" in res:
self.trainOnHW = res["trainOnHW"]
else:
# TODO default
pass
def _checkConfig(self, verbose=True):
state = True
caffe_versions.loadVersions(self.sessionPath)
if caffe_versions.versionCount() == 0:
if verbose:
sys.stderr.write(
"Warning: There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path.\n"
)
logging.warning(
"There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path."
)
if self.trainOnHW >= len(self.hardware):
self.trainOnHW = 0
if verbose:
sys.stderr.write(
"Warning: Currently selected Hardware could not be matched against detected Hardware."
" Set to CPU mode!\n")
logging.warning(
"Currently selected Hardware could not be matched against detected Hardware."
" Set to CPU mode!")
return state
def checkHardware(self, verbose=True, transaction=None):
caffe_versions.loadVersions(self.sessionPath)
if caffe_versions.versionCount() == 0:
if verbose:
sys.stderr.write(
"Warning: Can't check hardware without Caffeversions\n")
logging.warning("Can't check hardware without Caffeversions")
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": False,
"error": "Can't check hardware without Caffeversions"
}
transaction.send(msg)
return
try:
binary = caffe_versions.getDefaultVersion().getBinarypath()
self.hardware = checkHardware(binary, not verbose, transaction)
if verbose:
sys.stdout.write("Finished scanning Hardware. " +
str(len(self.hardware)) + " devices found.\n")
logging.info("Finished scanning Hardware. %s devices found.",
str(len(self.hardware)))
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": True,
"finished": True,
"hardware": self.hardware,
"current": self.trainOnHW
}
transaction.send(msg)
except:
if verbose:
sys.stderr.write("Error: Failed to check hardware!\n")
logging.error("Failed to check hardware!")
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": False,
"error": "Failed to check hardware!"
}
transaction.send(msg)
def setHardware(self, hid):
if hid >= len(self.hardware):
return False
self.trainOnHW = hid
self._saveConfig()
return True
class Dialog(QDialog):
def __init__(self, parent: QWidget = None) -> None:
super().__init__(parent)
self.tcpServer = QTcpServer()
self.tcpClient = QTcpSocket()
self.tcpServerConnection: QTcpSocket = None
self.bytesToWrite = 0
self.bytesWritten = 0
self.bytesReceived = 0
self.clientProgressBar = QProgressBar()
self.clientStatusLabel = QLabel(self.tr("Client ready"))
self.serverProgressBar = QProgressBar()
self.serverStatusLabel = QLabel(self.tr("Server ready"))
self.startButton = QPushButton(self.tr("&Start"))
self.quitButton = QPushButton(self.tr("&Quit"))
self.buttonBox = QDialogButtonBox()
self.buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.startButton.clicked.connect(self.start)
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.acceptConnection)
self.tcpClient.connected.connect(self.startTransfer)
self.tcpClient.bytesWritten.connect(self.updateClientProgress)
self.tcpClient.error.connect(self.displayError)
mainLayout = QVBoxLayout(self)
mainLayout.addWidget(self.clientProgressBar)
mainLayout.addWidget(self.clientStatusLabel)
mainLayout.addWidget(self.serverProgressBar)
mainLayout.addWidget(self.serverStatusLabel)
mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(self.buttonBox)
@pyqtSlot()
def start(self):
self.startButton.setEnabled(False)
QGuiApplication.setOverrideCursor(Qt.WaitCursor)
self.bytesWritten = 0
self.bytesReceived = 0
while not self.tcpServer.isListening() and not self.tcpServer.listen():
ret = QMessageBox.critical(
self,
self.tr("Loopback"),
self.tr(
"Unable to start the test: %s" % (self.tcpServer.errorString())
),
QMessageBox.Retry | QMessageBox.Cancel,
)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText(self.tr("Listening"))
self.clientStatusLabel.setText(self.tr("Connecting"))
self.tcpClient.connectToHost(
QHostAddress.LocalHost, self.tcpServer.serverPort()
)
@pyqtSlot()
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
if not self.tcpServerConnection:
self.serverStatusLabel.setText(
self.tr("Error: got invalid pending connection!")
)
return
self.tcpServerConnection.readyRead.connect(self.updateServerProgress)
self.tcpServerConnection.error.connect(self.displayError)
self.tcpServerConnection.disconnected.connect(
self.tcpServerConnection.deleteLater
)
self.serverStatusLabel.setText(self.tr("Accepted connection"))
self.tcpServer.close()
@pyqtSlot()
def startTransfer(self):
# called when the TCP client connected to the loopback server
self.bytesToWrite = TOTAL_BYTES - int(
self.tcpClient.write(QByteArray(PAYLOAD_SIZE, "@"))
)
self.clientStatusLabel.setText(self.tr("Connected"))
@pyqtSlot()
def updateServerProgress(self):
self.bytesReceived += int(self.tcpServerConnection.bytesAvailable())
self.tcpServerConnection.readAll()
self.serverProgressBar.setMaximum(TOTAL_BYTES)
self.serverProgressBar.setValue(self.bytesReceived)
self.serverStatusLabel.setText(
self.tr("Received %dMB" % (self.bytesReceived / (1024 * 1024),))
)
if self.bytesReceived == TOTAL_BYTES:
self.tcpServerConnection.close()
self.startButton.setEnabled(True)
QGuiApplication.restoreOverrideCursor()
@pyqtSlot("qint64")
def updateClientProgress(self, numBytes):
self.bytesWritten += int(numBytes)
if self.bytesToWrite > 0 and self.tcpClient.bytesToWrite() <= 4 * PAYLOAD_SIZE:
self.bytesToWrite -= self.tcpClient.write(
QByteArray(min(self.bytesToWrite, PAYLOAD_SIZE), "@")
)
self.clientProgressBar.setMaximum(TOTAL_BYTES)
self.clientProgressBar.setValue(self.bytesWritten)
self.clientStatusLabel.setText(
self.tr("Sent %dMB" % (self.bytesWritten / (1024 * 1024),))
)
@pyqtSlot(QAbstractSocket.SocketError)
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(
self,
self.tr("Network error"),
self.tr(
"The following error occurred: %s." % (self.tcpClient.errorString(),)
),
)
self.tcpClient.close()
self.tcpServer.close()
self.clientProgressBar.reset()
self.serverProgressBar.reset()
self.clientStatusLabel.setText(self.tr("Client ready"))
self.serverStatusLabel.setText(self.tr("Server ready"))
self.startButton.setEnabled(True)
QGuiApplication.restoreOverrideCursor()
class ListenPipe(QObject):
sig_data_arrived = pyqtSignal(QByteArray)
sig_listening_state = pyqtSignal(bool)
def __init__(self, parent=None):
super(ListenPipe, self).__init__(parent=parent)
self.tcpServer = QTcpServer()
self.socketClients = []
self.tcpServer.newConnection.connect(self.on_newconnection)
@pyqtSlot()
def start_listen(self):
print('start_listen:%s %s' % (appsetting.listen_ip, appsetting.listen_port))
self.tcpServer.close()
for socketClient in self.socketClients:
socketClient.close()
socketClient.deleteLater()
if appsetting.listen_enable != '0':
self.tcpServer.listen(QHostAddress(appsetting.listen_ip), int(appsetting.listen_port))
self.sig_listening_state.emit(self.tcpServer.isListening())
@pyqtSlot()
def on_newconnection(self):
print('on_newconnection')
socketClient = self.tcpServer.nextPendingConnection()
socketClient.readyRead.connect(self.on_readyRead)
socketClient.connected.connect(self.on_connected)
socketClient.disconnected.connect(self.on_disconnected)
socketClient.error.connect(self.on_error)
self.socketClients.append(socketClient)
print('self.socketClients size=%d' % len(self.socketClients))
@pyqtSlot()
def on_readyRead(self):
print("%s on_readyRead" % self.__class__.__name__)
socketClient = self.sender()
data = socketClient.readAll()
#print(data)
self.sig_data_arrived.emit(data)
@pyqtSlot(QByteArray)
def on_data_arrived(self, data):
print("%s on_data_arrived" % self.__class__.__name__)
for socketClient in self.socketClients:
socketClient.write(data)
@pyqtSlot()
def on_connected(self):
print('on_connected')
@pyqtSlot()
def on_disconnected(self):
print('on_disconnected')
socketClient = self.sender()
self.socketClients.remove(socketClient)
socketClient.deleteLater()
print('self.socketClients size=%d' % len(self.socketClients))
@pyqtSlot()
def on_error(self):
socketClient = self.sender()
print('%s on_error:%s' % (self.__class__.__name__, socketClient.errorString()))
