def main():
logConfig()
handle = open("./resultChen.csv", "w")
f = open("./top5k.csv")
threads = []
while 1:
line = f.readline().strip()
if not line:
break
lineList = line.split(",") #line: "1,google.com"
if len(threads) < 10:
mt = MyThread(process, (lineList, handle))
mt.start()
time.sleep(1)
threads.append(mt)
for thread in threads:
if thread.isAlive():
continue
else:
threads.remove(thread)
for thread in threads:
thread.join()
f.close()
handle.close()
class MyPixmap(QtGui.QGraphicsPixmapItem):
def __init__(self, parent):
QtGui.QGraphicsPixmapItem.__init__(self)
self.parent = parent
self.currentSide = 0
self.thread = MyThread(self.parent, self.parent.getRandom)
self.thread.finished.connect(self.parent.errorHandler)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.swapCoin)
def mousePressEvent(self, e):
if self.thread.isRunning() and self.timer.isActive():
e.ignore()
else:
self.parent.hint.hide()
self.count = 0 # counter for coin's swaping
self.timer.start(50)
self.thread.start()
e.accept()
def swapCoin(self):
if self.count < 50 or self.thread.isRunning():
self.currentSide = int(not self.currentSide) # 1 turns to 0, 0 to 1
self.setPixmap (self.parent.comboBox.itemData(self.parent.comboBox.currentIndex())[ self.currentSide ])
self.count += 1
else:
self.timer.stop()
if not self.parent.error and self.parent.result:
self.setPixmap (self.parent.comboBox.itemData(self.parent.comboBox.currentIndex())[ int(self.parent.result[0]) ]) # SHOW RESULT!
self.parent.log(error=self.parent.error) # log into journal
def Listen(self):
print("server：开始监听")
self.__server_socket.listen(128)
self.__server_is_listening = True
while self.__server_is_listening:
try:
client_socket, client_addr = self.__server_socket.accept(
) # 设置setblocking(False)后, accept不再阻塞
print("连接成功，客户端ip:{}，port:{}".format(client_addr[0],
client_addr[1]))
# 一旦连接成功，开一个子线程进行通信
client_socket.setblocking(False) # 子线程是非阻塞模式的(需要循环判断监听线程退出)
client_socket.settimeout(5) # 超时值设为5s
self.__running_client_cnt += 1
self.__thread_cnt += 1
self.new_client_signal.emit(
self.__running_client_cnt) # 向ui发信号，更新ui
client_name = "client{}".format(self.__thread_cnt) # 创建子线程
client_thread = MyThread(client_name, self.SubClientThread,
[client_socket, client_name])
client_thread.setDaemon(True) # 子线程配置为守护线程，主线程结束时强制结束
client_thread.start() # 子线程启动
except BlockingIOError:
pass
def main():
argv = sys.argv[1:]
numS = [ int(argv[0][i:i+2], 16) for i in range(0,len(argv[0]),2) ]
numD = [ int(argv[1][i:i+2], 16) for i in range(0,len(argv[1]),2) ]
src = ''
dst = ''
for i in numS:
src += struct.pack('!B', i)
for i in numD:
dst += struct.pack('!B', i)
back = MyThread(thread_func, [])
back.start()
#back.join()
back2 = MyThread(thread_func2, [])
back2.start()
cheat2 = eapauth.EAPAuth(['1','1','eth1'])
cheat2.set_fake(src, dst)
cheat2.send_failure()
while True:
try:
print "ok"
packet = cheat2.client.recv(1600)
print "ok2"
print repr(packet)
#cheat2.send_request_pass()
#packet = cheat2.client.recv(1600)
#print repr(packet)
except:
print "error"
pass
class Controller:
def __init__(self):
self.clock_block = threading.Event()
self.person_detection_block = threading.Event()
self.face_detection_block = threading.Event()
self.pose_detection_block = threading.Event()
self.emotion_detection_block = threading.Event()
self.face_direction_block = threading.Event()
self.face_recognition_block = threading.Event()
self.students = []
self.faces = []
self.poses = []
self.names = []
self.emo = []
self.face_dir = []
self.faceDetector = DetectFace()
self.recognitionFace = RecognitionFace()
def process_frame(self, frame):
# clear all events
self.person_detection_block.clear()
self.face_detection_block.clear()
self.pose_detection_block.clear()
self.emotion_detection_block.clear()
self.face_direction_block.clear()
self.face_recognition_block.clear()
# frame = cv2.imread(framePath, cv2.IMREAD_COLOR)
# init all threads
self.faceDetectorThread = MyThread(
name="faceDetectorThread",
processor=self.faceDetector,
other_events=[self.face_detection_block],
args=frame)
self.faceRecogThread = MyThread(
name="faceRecognitionThread",
other_events=[self.face_recognition_block],
processor=self.recognitionFace,
args=self.faces)
# start all threads
self.faceDetectorThread.start()
self.faceRecogThread.start()
# waiting all events
self.face_detection_block.wait()
self.face_recognition_block.wait()
# take res from threads
self.faces = self.faceDetectorThread.mydata
self.names = self.faceRecogThread.mydata
# return last res
return self.names
def queue_standby_Th(q, judArr, masterArr):
thQueue = MyThread(savedQueue, (q, judArr))
thStandby = MyThread(standby, masterArr)
thQueue.start()
thStandby.start()
thQueue.join()
thStandby.join()
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
fract = self.spinFract.value()
num = self.spinNum.value()
min = self.spinMin.value()
max = self.spinMax.value()
# list with only integers (0, 2, 5, 17...)
intResult = [min]*num if (min == max-1) else self.master.random.integers(num=num, min=min, max=max-1, base='10', col=1, format='plain', rnd='new')
# list with only decimals (100, 225, 50, 4...)
fractResult = self.master.random.integers(num=num, min=0, max=(10**fract)-1, base='10', col=1, format='plain', rnd='new')
# merge 2 lists together (0.100, 2.225, 5.050, 17.004...)
result = ["{0:.{1}f}".format(int(intResult[i]) + (int(fractResult[i]) / 10**fract), fract) for i in range(num)] # 1 and 23 -> 1.00023 if fract is 5
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Floats Generator",
error if error else "Generated: num=%s min=%s max=%s ndigits=%s" % (self.spinNum.value(), self.spinMin.value(), self.spinMax.value(), self.spinFract.value()))
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
result = self.master.random.strings(num = self.spinNum.value(),
len = self.spinLen.value(),
loweralpha = "on" if self.checkLower.isChecked() else "off",
digits = "on" if self.checkDigits.isChecked() else "off",
upperalpha = "on" if self.checkUpper.isChecked() else "off",
unique = "on" if self.checkUnique.isChecked() else "off",
format='plain', rnd='new')
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Strings Generator",
error if error else "Generated: num=%s len=%s" % (self.spinNum.value(),
self.spinLen.value()))
def main():
nfuncs = range(len(funcs))
print '*** SINGLE THREAD'
for i in nfuncs:
print 'starting', funcs[i].__name__, 'at:', ctime()
print funcs[i](n)
print funcs[i].__name__, 'finished at:', ctime()
print '*** MULTIPLE THREAD'
threads = []
for i in nfuncs:
t = MyThread(funcs[i], (n, ), funcs[i].__name__)
threads.append(t)
for t in threads:
t.start()
sleep(0.01)
for t in threads:
t.join()
print t.getResult()
print 'all done'
class Controller:
def __init__(self):
self.person_detection_block = threading.Event()
self.face_detection_block = threading.Event()
self.pose_detection_block = threading.Event()
self.emotion_detection_block = threading.Event()
self.face_direction_block = threading.Event()
self.face_recognition_block = threading.Event()
self.students = []
self.faces = []
self.poses = []
self.names = []
self.emo = []
self.face_dir = []
self.faceDetector = DetectFace()
self.recognitionFace = RecognitionFace()
def process_frame(self, frame):
# frame = cv2.imread(framePath, cv2.IMREAD_COLOR)
self.faceDetectorThread = MyThread(
name="faceDetectorThread",
processor=self.faceDetector,
event=None,
other_events=[self.face_recognition_block],
args=frame)
self.faceRecogThread = MyThread(
name="faceRecognitionThread",
processor=self.recognitionFace,
event=self.face_recognition_block,
other_events=[self.emotion_detection_block],
args=self.faceDetectorThread.mydata)
self.faceDetectorThread.start()
self.faceRecogThread.start()
self.emotion_detection_block.wait()
return self.faceRecogThread.mydata
def Confirm(self):
if self.portNum.text() == '':
self.statusbar.showMessage("配置错误，port禁止为空")
return
if not IsIPV4(self.IPNum.text()):
self.statusbar.showMessage("配置错误，非法的ip地址")
return
port = int(self.portNum.text())
ip = self.IPNum.text()
if self.__TransPorter.IsServer():
self.__port = port
self.__TransPorter.GetMainUI().uploadButton.setEnabled(False)
self.__TransPorter.GetMainUI().downloadButton.setEnabled(False)
server = self.__TransPorter.GetServer()
server.ServerStart(port) # 启动服务器（开始监听）
self.statusbar.showMessage("正在监听port:{}，client连接：0".format(port))
self.__TransPorter.GetMainUI().statusbar.showMessage(
"正在监听port:{}，client连接：0".format(port))
else:
self.__TransPorter.GetMainUI().uploadButton.setEnabled(True)
self.__TransPorter.GetMainUI().downloadButton.setEnabled(True)
client = self.__TransPorter.GetClient()
client.SetDestServer(port, ip) # 设置目标port和ip
client.ClientStart() # 启动客户端
self.statusbar.showMessage("connecting server")
self.__TransPorter.GetMainUI().statusbar.showMessage(
"connecting server")
# 用一个子线程连接服务器，若连接成功，就创建心跳线程，然后结束
connection_thread = MyThread(
'connecting',
self.__TransPorter.GetClient().Connect2Server)
connection_thread.setDaemon(True) # 子线程配置为守护线程，主线程结束时强制结束
connection_thread.start()
self.__TransPorter.SetWroking(True) # 设置工作标志
self.ShowWindow() # 刷新窗口UI
def AddConnection(self,proc,name,pabr=None):
# 创建一个socket连接
new_socket = self.CreatSocket()
if new_socket == None:
return
new_socket.setblocking(False) # 子线程是非阻塞模式的(需要循环判断监听线程退出)
new_socket.settimeout(5) # 超时值设为5s
# 创建一个连接子线程
if pabr == None: # 不关联下载进度页面，这是心跳线程
connection_thread = MyThread(name,proc,[new_socket,name])
else: # 下载线程，关联下载进度页面
connection_thread = MyThread(name,proc,[new_socket,name,pabr])
# 子线程统一加入__sub_thread管理
if not name in self.__sub_thread:
self.__sub_thread[name] = [Frame(),connection_thread,new_socket]
# 注册socket
self.DataSend(new_socket,name,self.__ID.encode('utf-8'))
# 启动连接子线程
connection_thread.setDaemon(True) # 子线程配置为守护线程，主线程结束时强制结束
connection_thread.start()
def run(*args, **kwargs):
try:
t = MyThread(function, args=args, kwargs=kwargs)
t.start()
except:
raise
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.tableResult.setSortingEnabled(False) # disable column sorting (keep the items mixed is the point)
self.listModel = MyModel(1, 1, self.lblInfo)
self.tableCustomList.setModel(self.listModel)
self.tableCustomList.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
self.tableCustomList.horizontalHeader().hide()
self.tableCustomList.setColumnWidth(0, 150)
self.fillPresetsList()
# one groupPanel disables the other
self.groupGenerate.toggled.connect(lambda checked: self.groupLoad.setChecked(not checked))
self.groupLoad.toggled.connect(lambda checked: self.groupGenerate.setChecked(not checked))
self.btnGenerate.clicked.connect(self.generate)
self.comboPresets.activated["int"].connect(self.setPreset)
self.btnLoad.clicked.connect(self.loadList)
self.btnListClear.clicked.connect(lambda: self.listModel.clear())
self.spinCol.valueChanged["int"].connect(self.changeColumn)
self.btnClear.clicked.connect(self.clearTable)
self.btnCopy.clicked.connect(self.copyResult)
self.btnSave.clicked.connect(self.saveResult)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def fillPresetsList(self):
for preset in sorted(PRESETS["Sequences"]):
self.comboPresets.addItem(preset[1:], PRESETS["Sequences"][preset])
def loadList(self):
file = QtGui.QFileDialog.getOpenFileName(
parent=self, caption="Load data from file", directory=QtCore.QDir.currentPath(),
filter="CSV and text files (*.csv *.txt)")
if file:
sep = QtGui.QInputDialog.getText(self, "Type separator", "Type symbol that will be use for split text data", text=",")
if not all(sep): return
data = open(file, 'r').read()
res=[]
for l in data.split('\n'):
res.extend(l.split(sep[0]))
res = list( filter(lambda x: x.lstrip(), res) )
self.listModel.clear()
for row in range(len(res)):
item = QtGui.QStandardItem(res[row])
self.listModel.setItem(row, 0, item)
self.tableCustomList.setColumnWidth(0, 150)
self.log(file=file)
def setPreset(self, index):
self.listModel.clear()
if index == 0: return
# list stored in comboBox itemData
l = self.comboPresets.itemData(index)
for i in range(len(l)):
item = QtGui.QStandardItem(l[i])
self.listModel.setItem(i, 0, item)
self.tableCustomList.setColumnWidth(0, 150)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
if self.groupGenerate.isChecked(): # generate sequence
min = self.spinMin.value()
max = self.spinMax.value()
else: # shuffle existing list
if self.listModel.rowCount() < 2: return
min = 0
max = self.listModel.rowCount()-2
result = self.master.random.sequences(min=min, max=max, col=1, format='plain', rnd='new')
if self.groupLoad.isChecked(): # shuffle custom list
customList = [self.listModel.index(i,0).data() for i in range(max+1)]
result = [customList[int(i)] for i in result]
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
self.makeTable()
def log(self, error=None, file=None):
from time import strftime
from os.path import basename
if file:
msg = "Custom list (%s elem.) was loaded from '%s' for shuffling" % (self.listModel.rowCount()-1, basename(file))
elif self.groupLoad.isChecked():
msg = "Custom list with %s element(s) was shuffled" % (self.listModel.rowCount()-1)
else:
msg = "Sequence was generated: min=%s max=%s" % (self.spinMin.value(), self.spinMax.value())
self.master.logs.addRow(
strftime("%d-%m-%Y"), strftime("%H:%M:%S"), self.master.random.__class__.__name__,
"Sequences Generator/Shuffler", error if error else msg)
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.checkIsSeconds.toggled.connect(self.allowSeconds)
self.checkIsMili.toggled.connect(self.allowMiliseconds)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
# secToTime(64835555, True, True) -> QTime(18, 0, 35, 555)
# secToTime(64835, True, False) -> QTime(18, 0, 35)
# secToTime(1080, False, False) -> QTime(18, 0)
def secToTime(self, units, isSeconds=True, isMilisec=True): # miliseconds to QTime (65482833 -> QTime(18, 11, 22, 833) 18:11:22.833)
hour = min = sec = msec = 0
if isMilisec:
msec = units % 1000
units /= 1000
if isSeconds:
sec = units % 60
units /= 60
min = units % 60
units /= 60
hour = units
return QtCore.QTime(hour, min, sec, msec)
# timeToSec(QTime(18, 0, 35, 555), True, True) -> 64835555
# timeToSec(QTime(18, 0, 35, 555), True, False) -> 64835
# timeToSec(QTime(18, 0, 35, 555), False, False) -> 1080
def timeToSec(self, qTime, isSeconds=True, isMilisec=True): # QTime to miliseconds (QTime(23, 59, 59, 999) -> 86399999)
if isSeconds:
if isMilisec:
return (qTime.hour()*3600 + qTime.minute()*60 + qTime.second())*1000 + qTime.msec()
return qTime.hour()*3600 + qTime.minute()*60 + qTime.second()
return qTime.hour()*60 + qTime.minute()
# formatTime(QTime(18, 0, 35, 555)) -> 18:00:35.555
# formatTime(QTime(18, 0)) -> 18:00
def formatTime(self, qTime):
format = self.timeEditFrom.displayFormat()
return qTime.toString(format)
def allowSeconds(self, isChecked):
self.checkIsMili.setCheckState(QtCore.Qt.Unchecked)
self.checkIsMili.setDisabled(not isChecked)
if isChecked:
self.timeEditFrom.setDisplayFormat("H:mm:ss")
self.timeEditTo.setDisplayFormat("H:mm:ss")
else:
self.timeEditFrom.setDisplayFormat("H:mm")
self.timeEditTo.setDisplayFormat("H:mm")
def allowMiliseconds(self, isChecked):
if isChecked:
self.timeEditFrom.setDisplayFormat("H:mm:ss.zzz")
self.timeEditTo.setDisplayFormat("H:mm:ss.zzz")
else:
self.timeEditFrom.setDisplayFormat("H:mm:ss")
self.timeEditTo.setDisplayFormat("H:mm:ss")
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
num = self.spinNum.value()
isSec = self.checkIsSeconds.isChecked()
isMsec = self.checkIsMili.isChecked()
interval = self.comboTimeInterval.itemData(self.comboTimeInterval.currentIndex())
timeStart = time1 = self.timeToSec( self.timeEditFrom.time(), isSec, isMsec )
timeEnd = time2 = self.timeToSec( self.timeEditTo.time(), isSec, isMsec )
if interval:
if isMsec: coef = interval * 60 * 1000
elif isSec: coef = interval * 60
else: coef = interval
time1 = 0
time2 = (timeEnd-timeStart) // coef
result = self.master.random.integers(num=num, min=time1, max=time2,
base='10', col=1, format='plain', rnd='new') # ['64835555', '573755', '73753'...]
if interval:
result = list( map(lambda x: self.secToTime(timeStart + int(x)*coef, isSec, isMsec), result) ) # [QTime(18, 0, 35, 555), QTime(01, 10, 35, 105)...]
else:
result = list( map(lambda x: self.secToTime(int(x), isSec, isMsec), result) ) # [QTime(18, 0, 35, 555), QTime(01, 10, 35, 105)...]
result = list( map(self.formatTime, result) ) # ['18:00:35.555', '01:10:35.105'...]
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Time Generator",
error if error else "Generated %s clock time(s) between %s and %s with interval %s" % (
self.spinNum.value(),
self.timeEditFrom.textFromDateTime(self.timeEditFrom.dateTime()),
self.timeEditTo.textFromDateTime(self.timeEditTo.dateTime()),
self.comboTimeInterval.currentText())
)
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.daysOfWeek = [0,1,2,3,4]
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.btnGenerate.clicked.connect(self.generate)
self.chkMon.toggled.connect(lambda x: self.updateDaysOfWeek(x, 0))
self.chkTue.toggled.connect(lambda x: self.updateDaysOfWeek(x, 1))
self.chkWed.toggled.connect(lambda x: self.updateDaysOfWeek(x, 2))
self.chkThr.toggled.connect(lambda x: self.updateDaysOfWeek(x, 3))
self.chkFri.toggled.connect(lambda x: self.updateDaysOfWeek(x, 4))
self.chkSut.toggled.connect(lambda x: self.updateDaysOfWeek(x, 5))
self.chkSun.toggled.connect(lambda x: self.updateDaysOfWeek(x, 6))
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def updateDaysOfWeek(self, isChecked, day):
if isChecked: self.daysOfWeek.append(day)
else: self.daysOfWeek.remove(day)
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
assert self.daysOfWeek, "Error: You should choose at least one day of the week"
from datetime import date, timedelta
day = timedelta(days=1)
num = self.spinNum.value()
date1 = currDate = self.dateEdit.date().toPyDate()
date2 = self.dateEdit_2.date().toPyDate()
format = self.comboFormat.itemData(self.comboFormat.currentIndex())
assert date2 > date1, "Error: Second date must be greater than first one"
allDaysList = []
while currDate != date2:
if currDate.weekday() in self.daysOfWeek:
allDaysList.append(currDate)
currDate += day
assert num <= len(allDaysList), "Error: There are only %s acceptable dates, when you need %s" % (len(allDaysList), num)
result = []
if len(allDaysList) == num:
result = allDaysList
else:
while len(result) < num:
result.append(
allDaysList.pop(
int( self.master.random.integers(num=1, min=0, max=len(allDaysList)-1, base='10', col=1, format='plain', rnd='new')[0] )
)
)
result = [d.strftime(format) for d in result]
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Date Generator",
error if error else "Generated %s date(s) between %s and %s" % (
self.spinNum.value(),
self.dateEdit.textFromDateTime(self.dateEdit.dateTime()),
self.dateEdit_2.textFromDateTime(self.dateEdit_2.dateTime()))
)
def thFertilizer(num, delay, arr):
fer = MyThread(fertilizer, (num, delay, arr))
fer.start()
fer.join()
class MyWidget(QtGui.QWidget, Ui_MyWidget, ResultTable):
def __init__(self, parent=None, master=None):
QtGui.QWidget.__init__(self, parent)
self.master = master
self.error = self.result = self.model = None
self.base = "10"
self.column = 1
self.setupUi(self) # set UI (method from Ui_MyWidget)
ResultTable.__init__(self) # set UI for result group widget (result table etc...)
self.fillPresetsList()
self.btnGenerate.clicked.connect(self.generate)
self.radioBin.clicked.connect(lambda: setattr(self, "base", "2")) # in lambda can't use '=' operator
self.radioOct.clicked.connect(lambda: setattr(self, "base", "8"))
self.radioDec.clicked.connect(lambda: setattr(self, "base", "10"))
self.radioHex.clicked.connect(lambda: setattr(self, "base", "16"))
self.comboPresets.activated["int"].connect(self.setPreset)
self.thread = MyThread(self, self.getRandom)
self.thread.finished.connect(self.errorHandler)
def fillPresetsList(self):
for preset in PRESETS["Integers"]:
title = "%s - %s" % (preset, repr(PRESETS["Integers"][preset]))
self.comboPresets.addItem(title, PRESETS["Integers"][preset])
def setPreset(self, index):
if index == 0: return
# tuple stored in comboBox itemData - (a, b) where a-min, b-max
self.spinMin.setValue(self.comboPresets.itemData(index)[0])
self.spinMax.setValue(self.comboPresets.itemData(index)[1])
def generate(self):
self.btnGenerate.setDisabled(True)
self.thread.start()
def getRandom(self):
result = self.master.random.integers(num=self.spinNum.value(),
min=self.spinMin.value(),
max=self.spinMax.value(),
base=self.base,
col=1, format='plain', rnd='new')
if self.checkAdd.isChecked() and type(self.result) is list:
self.result.extend(result)
else:
self.result = result
# print(self.result)
self.makeTable()
def log(self, error=None):
from time import strftime
self.master.logs.addRow(strftime("%d-%m-%Y"),
strftime("%H:%M:%S"),
self.master.random.__class__.__name__,
"Integers Generator",
error if error else "Generated: num=%s min=%s max=%s" % (self.spinNum.value(),
self.spinMin.value(),
self.spinMax.value()))
class Server(QtCore.QObject):
new_client_signal = QtCore.pyqtSignal(int) #每连接一个client，就向ui发一个信号，更新状态栏
# 构造函数
def __init__(self):
super().__init__()
self.SaveSelfIP() # 提取缓存本地ip
self.__running_client_cnt = 0 # 当前连接的客户端数量
self.__thread_cnt = 0 # 线程计数
self.__sub_thread = dict(
) # 每个client线程有一个Frame对象空间,用字典管理。元素构成 (线程名:[Frame对象,thread对象,Lock对象,所属客户端ID])
self.__sub_thread_union = dict(
) # 每一个客户端会和服务器建立多条连接（主连接用来更新UI、心跳连接用来检测断连、数据连接用来传输数据）
# 用一个字典管理同一个client的所有连接。元素构成 (所属客户端ID:[心跳线程名,主线程名,文件线程名...])
self.__sub_thread_heart = [] # 所有心跳线程集中到这。
self.__died_client = [] # 断开的客户端ID暂存在这里，当其所有相关线程关闭后清除此项
# 缓存本机ip地址 (构造一个UDP包但不发送 ，从中提取)
def SaveSelfIP(self):
self.__ip = CheckIp()
# 获取本机IP
def GetIP(self):
return self.__ip
# 启动服务器（创建监听线程和套接字）
def ServerStart(self, port):
# 创建一个监听套接字
print("server：创建了监听套接字")
self.__server_socket = socket.socket(
socket.AF_INET, socket.SOCK_STREAM) # 创建用于监听的socket
self.__server_socket.setblocking(False) # 配置为非阻塞的socket
self.__server_is_listening = False
# 设置并绑定监听的端口
print("server：设置并绑定port:{}".format(port))
self.__server_socket.bind(("", port))
self.__port = port
# 启动监听线程
self.__sub_thread.clear() # 清空子线程记录
self.__listenThread = MyThread("监听线程", self.Listen)
self.__listenThread.setDaemon(True) #设置为守护线程，程序结束时强行结束监听
self.__listenThread.start()
# 关闭服务器（关闭所有子线程和套接字）
def ServerShutDown(self):
print("server：停止监听")
self.__server_is_listening = False # 通过共享内存和子线程线程通信，关闭所有子线程和客户端线程
self.__listenThread.join() # 等待监听线程和所有客户端线程结束
print("server：监听套接字关闭")
self.__server_socket.close()
self.__running_client_cnt = 0
# 用于数据收发的基础方法---------------------------------------------------------------------------
# socket接受
def BytesRecv(self, client_socket, client_name, max_size):
data = None
timeout = 0
ID = self.__sub_thread[client_name][2] # 此线程所属客户端ID
while data == None and self.__server_is_listening and not ID in self.__died_client:
try:
data = client_socket.recv(max_size)
except BlockingIOError: # 非阻塞socket，pass此异常以实现轮询
pass
except ConnectionAbortedError:
if client_name in self.__sub_thread_heart: # 客户端断开，可能出这个异常
self.HeartStop(client_name)
return '连接断开'
except ConnectionResetError: # 客户端断开，可能出这个异常
if client_name in self.__sub_thread_heart:
self.HeartStop(client_name)
return '连接断开'
except socket.timeout:
if client_name in self.__sub_thread_heart: # 只对心跳线程做超时判断
timeout += 5
print(client_name, '连接超时', timeout)
if timeout == 10:
self.HeartStop(client_name)
return '连接断开'
if not self.__server_is_listening or data == b'': # 客户端断开，data返回空串
return '连接断开'
return data
# 线性安全的socket发送
def BytesSend(self, client_socket, data):
client_socket.send(data)
# 准备好接收(获取分片数)
def GetReady2Recv(self, client_socket, client_name):
frame = self.__sub_thread[client_name][0]
# 接受本次通信分片数
data = self.BytesRecv(client_socket, client_name, 256)
if data == '连接断开':
return '连接断开'
frame_num = frame.DecodeFrameNum(client_name, data)
if frame_num == -1:
return 'crc error'
print(client_name, '本次接收分片数', frame_num)
# 返回分片数应答
frame.Reset()
ack_data = '分片{}'.format(frame_num).encode('utf-8')
frame.Code(ack_data)
client_socket.send(ack_data)
return frame_num
def GetReady2Send(self, client_socket, client_name, size, isDownload):
frame = self.__sub_thread[client_name][0]
# 发送本次通信分片数
max_size = frame.GetLoadNum() # 最大负载长字节
n = math.ceil(size / max_size)
print(client_name, '本次发送分片数', n)
frame.Reset()
if isDownload:
n_data = frame.Code(n.to_bytes(length=8, byteorder="big"))
else:
n_data = frame.Code(n.to_bytes(length=1, byteorder="big"))
self.BytesSend(client_socket, n_data)
# 确定客户端已经装备好接受
ack_n = self.BytesRecv(client_socket, client_name,
1024).decode('utf-8')
print(client_name, 'ack:', ack_n)
if ack_n == '连接断开':
return '连接断开'
if ack_n != '分片{}'.format(n):
return '分片通信错误'
print(client_name, "已准备好发送")
return 'OK'
# 接受数据
def DataRecv(self, client_socket, client_name):
frame = self.__sub_thread[client_name][0]
# 先准备好接受(接受分片数)
frame_num = self.GetReady2Recv(client_socket, client_name)
if not type(frame_num) == int:
return frame_num
print(client_name, "准备接收分片", frame_num)
# 开始接受并整合所有数据
i = 0
data = b''
while i < frame_num:
# 限制每次收帧长，可以解决部分粘包问题
data_f = self.BytesRecv(client_socket, client_name, 256)
data, n, errCnt = frame.Decode(client_name, data_f, data)
if errCnt != 0:
print(client_name, '数据接收结束，校验错误')
return 'crc error'
i += n
#print(client_name,"有效数据 ",data)
print(client_name, '数据接收结束，成功')
return data
# 发送数据
def DataSend(self, client_socket, client_name, data):
frame = self.__sub_thread[client_name][0]
# 准备好发送
res = self.GetReady2Send(client_socket, client_name, len(data), False)
if res != 'OK':
return res
# 发送所有分片
max_size = frame.GetLoadNum() # 最大负载长字节
frame.Reset()
while len(data) > max_size:
sub_data = data[0:max_size]
data = data[max_size:]
file_content = frame.Code(sub_data) # 拼数据帧
self.BytesSend(client_socket, file_content) # 发送数据
# 发送最后一个分片
file_content = frame.Code(data) # 拼数据帧
self.BytesSend(client_socket, file_content) # 发送数据
print(client_name, "数据发送完成--------------------\n")
return '发送完成'
# 利用基本收发方法封装的一些方法------------------------------------------------------------------
# 发送path路径下的文件和目录信息
def SendListDir(self, client_socket, client_name, path):
print(client_name, "请求目录", path)
try:
items = os.listdir(path) # 获取路径下所有文件名
except PermissionError:
print("无访问权限")
self.DataSend(client_socket, client_name, '无访问权限'.encode('utf-8'))
return
# 分离文件和文件夹
floders = []
files = []
sizes = []
for item in items:
file_path = os.path.join(path, item)
if os.path.isdir(file_path):
floders.append(item)
else:
size = str(round(os.stat(file_path).st_size / 1024))
files.append(item)
sizes.append(size)
floder_str = '/'.join(floders)
files_str = '/'.join(files)
size_str = '/'.join(sizes)
list_str = floder_str + '<>' + files_str + '<>' + size_str
self.DataSend(client_socket, client_name, list_str.encode('utf-8'))
def DownloadFile(self, client_socket, client_name, file_path):
# 计算分片数
frame = self.__sub_thread[client_name][0]
max_size = frame.GetLoadNum() # 最大负载长字节
size = os.stat(file_path).st_size
frame_num = math.ceil(size / max_size)
# 准备好发送数据
res = self.GetReady2Send(client_socket, client_name, size, True)
if res != 'OK':
return res
# 发送文件数据
print(client_name, '开始发送文件')
with open(file_path, "rb") as f: # 直接以二进制读入，传输时不用encode和decode了
frame.Reset()
for i in range(frame_num):
data = f.read(max_size) # 最多读最大负载长字节
file_content = frame.Code(data) # 获取帧的字节流数据
print(client_name, len(file_content))
client_socket.send(file_content)
# 关闭传输socket
print(client_name, '文件发送完毕')
client_socket.close()
def UploadFile(self, client_socket, client_name):
frame = self.__sub_thread[client_name][0]
frame.Reset()
# 接收文件名
file_name = self.DataRecv(client_socket, client_name)
if not type(file_name) == bytes:
return file_name
file_name = file_name.decode('utf-8')
print(client_name, '上传请求', file_name)
# 接收并应答分片数
frame_num = self.GetReady2Recv(client_socket, client_name) # 分片数
if not type(frame_num) == int:
return frame_num
# 接受文件数据
i = 0
errCnt = 0
desktop_path = GetDesktopPath()
with open(desktop_path + "\\[upload]" + file_name, "wb") as f:
while i < frame_num:
# 限制每次收帧长，可以自动进行粘包处理
data_f = self.BytesRecv(client_socket, client_name, 256)
if data_f == '连接断开'.encode('utf-8'):
return
data, n, err = frame.Decode(client_name, data_f)
errCnt += err
f.write(data)
i += n
# 关闭传输socket
print(client_name, '错误帧数:', errCnt)
client_socket.close()
# 接受数据后的处理--------------------------------------------------------------------------------
# 客户端子线程（非阻塞socket）：接收客户端的各种请求
def SubClientThread(self, client_socket, client_name):
print(client_name + "：线程启动")
# 给此线程一个Frame对象，用来构成帧
if not client_name in self.__sub_thread:
self.__sub_thread[client_name] = [
Frame(), threading.currentThread(), ''
] #字典可自动添加
# 轮询处理客户端的命令
while self.__server_is_listening:
# 先检查此线程对应的客户端是不是已经断开连接,如果断开了,关闭连接
thread_id = self.__sub_thread[client_name][2]
if thread_id in self.__died_client:
break
data = self.DataRecv(client_socket, client_name)
if type(data) == bytes:
data = data.decode('utf-8')
print(client_name, "接收数据", data, '-----------------------------\n')
if data == '连接断开':
break
# client主线程发起注册
elif data == 'login new client':
self.Login(client_socket, client_name)
# client子线程注册
elif data in self.__sub_thread_union:
self.__sub_thread[client_name][2] = data
if not client_name in self.__sub_thread_union[data]:
self.__sub_thread_union[data].append(client_name)
# 发送桌面
elif data == "获取桌面":
desktop_path = GetDesktopPath()
if self.DataSend(client_socket, client_name,
desktop_path.encode('utf-8')) == '连接断开':
self.StopSubThread(client_socket, client_name)
print(client_name, "通信结束")
break
# client心跳
elif data[:5] == 'heart':
ID = data[6:]
if not client_name in self.__sub_thread_union[ID]:
self.__sub_thread_union[ID].append(client_name)
if not client_name in self.__sub_thread_heart:
self.__sub_thread_heart.append(client_name)
# 上传
elif data == 'upload':
self.UploadFile(client_socket, client_name)
break
# 判断为目录则刷新
elif os.path.isdir(data):
self.SendListDir(client_socket, client_name, data)
# 判断为文件则下载
elif os.path.isfile(data):
self.DownloadFile(client_socket, client_name, data)
break
else:
pass
self.StopSubThread(client_socket, client_name)
print(client_name, "通信结束")
# 线程控制相关--------------------------------------------------------------------------------
# 结束子线程
def StopSubThread(self, client_socket, client_name):
# 从客户端线程集中清除此线程
thread_id = self.__sub_thread[client_name][2]
self.__sub_thread_union[thread_id].remove(client_name)
# 如果这是断开的客户端的线程，且此断开客户端线程集已清空，把这个客户端ID移除
if thread_id in self.__died_client and not self.__sub_thread_union[
thread_id]:
del self.__sub_thread_union[thread_id]
self.__died_client.remove(thread_id)
# 从全体线程集中清除此线程记录
del self.__sub_thread[client_name]
client_socket.close()
self.__running_client_cnt -= 1
self.new_client_signal.emit(self.__running_client_cnt) # 向ui发信号，更新ui
# 心跳线程断开后的处理
def HeartStop(self, heart_name):
self.__sub_thread_heart.remove(heart_name) # 从心跳列表中移除此线程
ID = self.__sub_thread[heart_name][2] # 获取心跳超时的客户端ID
self.__died_client.append(ID) # 此心跳对应的客户端ID加入死亡client列表
# 监听线程中启动监听socket，允许被动连接
def Listen(self):
print("server：开始监听")
self.__server_socket.listen(128)
self.__server_is_listening = True
while self.__server_is_listening:
try:
client_socket, client_addr = self.__server_socket.accept(
) # 设置setblocking(False)后, accept不再阻塞
print("连接成功，客户端ip:{}，port:{}".format(client_addr[0],
client_addr[1]))
# 一旦连接成功，开一个子线程进行通信
client_socket.setblocking(False) # 子线程是非阻塞模式的(需要循环判断监听线程退出)
client_socket.settimeout(5) # 超时值设为5s
self.__running_client_cnt += 1
self.__thread_cnt += 1
self.new_client_signal.emit(
self.__running_client_cnt) # 向ui发信号，更新ui
client_name = "client{}".format(self.__thread_cnt) # 创建子线程
client_thread = MyThread(client_name, self.SubClientThread,
[client_socket, client_name])
client_thread.setDaemon(True) # 子线程配置为守护线程，主线程结束时强制结束
client_thread.start() # 子线程启动
except BlockingIOError:
pass
# 新连接注册
def Login(self, client_socket, client_name):
print('注册新client')
# 生成一个唯一的key
key = ''.join(random.sample('abcdefghijklmnopqrstuvwxyz', 10))
while key in self.__sub_thread_union:
key = ''.join(random.sample('abcdefghijklmnopqrstuvwxyz', 10))
# 主线程加入字典
self.__sub_thread_union[key] = [client_name]
self.__sub_thread[client_name][2] = key
# 返回key
self.DataSend(client_socket, client_name, key.encode('utf-8'))
def showQuota(self):
thread = MyThread(self, lambda: self.sb.label2.setText("Your quota (random bits for today): %s" % self.random.quota(format='plain')[0]))
thread.finished.connect(self.errorHandler)
thread.start()
