def main():
try:
while True:
test()
time.sleep(0.5)
except(KeyboardInterrupt):
print('main thread(%f):stop'%_interval_timer())
print('main thread(%f):stopped'%_interval_timer())
def test1(log):
import time
tt1=TThread(seq=1,log=log)
try:
while True:
log.debug('main _thread(%f):start',_interval_timer())
tt1.running_start()
time.sleep(0.4)
tt1.running_stop()
tt1.join(1)
time.sleep(1)
except(KeyboardInterrupt):
log.debug('main _thread(%f):stop timer',_interval_timer())
tt1.running_stop()
tt1.join(1)
#tt2.stop()
#tt3.stop()
log.debug('main _thread(%f):stopped',_interval_timer())
def test2(workingLine,log):
log.info('test for all start (%f)',_interval_timer())
workingLine=WorkQueue(name="test_worker",log=log)
workingLine.wq_start()
import time
seq=0
while seq < 10:
seq += 1
log.info("Add a work : %d"%seq)
workingLine.QueueWork(MyWork(seq=seq,name="testwork"))
workingLine.wq_pause() # restart .........
log.info('main thread(%f):paused',_interval_timer())
time.sleep(5)
workingLine.wq_resume() # restart .........
log.info('main thread(%f):resumed',_interval_timer())
while seq < 100:
seq += 1
log.info("Add a work : %d"%seq)
workingLine.QueueWork(MyWork(seq=seq,name="testwork"))
time.sleep(1)
def item_get_top_n(self, item, size, track_type, retry_on_exception=True):
re_dict={}
try:
bt=_interval_timer()
sql = r"select * from track_data where tracktype_id=%d and name = '%s' order by tracktime desc limit %d"\
% (track_type,item,size)
n = self._cursor.execute(sql)
for i in range(n):
db_data = self._cursor.fetchone()
db_item = TrackData.GetInstance(db_data)
re_dict[db_item] = db_item #???
interval = _interval_timer()-bt
self.log.debug("interval:item_get_top_n(%s,%d) %f" % (item,len(re_dict),interval) )
except OperationalError as e:
self._handle_exception(e)
if retry_on_exception:
self.item_get_top_n(item,size,track_type,False)
except Exception as e:
self.log.exception(e)
finally:
return re_dict
def do(self,worker=None):
self.times += 1
if self._work_param:
for i in range(10):
c = self._work_param.cursor()
if not c:
self.log.debug("failed on get cursor")
else:
self.log.debug("get cursor succed")
else:
self.log.debug("conn is None")
self.log.info("[%04d][%03d] working .... %f",self.seq,self.times,_interval_timer() )
def test1(workingLine,log):
log.info('test for process of work buffer is full (%f)',_interval_timer())
workingLine=WorkQueue(name="test_worker",log=log)
workingLine.wq_start()
seq=0
while seq < 1000:
for i in range(20):
seq += 1
log.info("Add a work : %d",seq)
wr=MyRedoableWork(seq=seq,period=10,name="testwork")
workingLine.QueueWork(wr)
time.sleep(1)
def test3(workingLine,log):
log.info('test for priority work start (%f)',_interval_timer())
# test for priority work
workingLine=WorkQueue(priority_support=True,name="test_worker",log=log)
workingLine.wq_start()
seq=1000
while seq > 0:
for i in range(20):
seq -= 1
log.info("Add a work : %d",seq)
wr=MyPriorityWork(seq=seq,log=log,name="testwork")
workingLine.QueueWork(wr)
time.sleep(1)
def run(self):
while self.IsRunning:
try:
tb = _interval_timer()
if not self.works.empty() and not self.IsPaused:
work = self.works.get(block=True,timeout=0.5)
work._do(worker=self) # working ...
#if __debug__: self.log.debug("[%s] work(%s) func out"%(self.getName(),work._work_name))
if self._redoable_support and not work._done:
if self.doneWorks.full():
self.doneWorks.get() # drop top when buffer is full
self.log.warn("[%s] Work buffer is full,drop top work.", self.getName())
#if __debug__: self.log.warn("[%s] add a redo work."%work._work_name )
self.doneWorks.put(work)
else:
te = _interval_timer()
sleep_interval= 0.05 - te + tb
if sleep_interval > 0:
time.sleep(sleep_interval)
except Exception as e:
self.log.exception(e)
time.sleep(0.5)
def test_workqueue(log):
wq = WorkQueue(name = "work_queue", redoable_support = True, log = log)
try:
seq = 0
wq.Start()
for i in range(10):
tgw = TestWork(seq=seq)
wq.QueueWork(work=tgw)
seq += 1
while True:
log.info("wq is running ................")
time.sleep(1)
log.info('main thread(%f):stop', _interval_timer())
wq.Stop()
log.info('main thread(%f):stopped', _interval_timer())
except(KeyboardInterrupt):
log.info('main thread(%f): User canceled by Ctrl-c', _interval_timer())
finally:
log.info('main thread(%f):stop', _interval_timer())
wq.Stop()
log.info('main thread(%f):stopped', _interval_timer())
def _get_item_list_by_sql(self,sql, retry_on_exception=True):
try:
bt=_interval_timer()
n = self._cursor.execute(sql)
res = self._cursor.fetchall()
res_dict = {}
for each in res:
if len(each) > 2:
ts = TrackStatus(each)
res_dict[ts.shipment_name] = ts
else:
self.log.error( "result:%d" % len(each) )
interval = _interval_timer()-bt
self.log.debug("interval:_get_item_list_by_sql %f" % interval)
return res_dict
except OperationalError as e:
self._handle_exception(e)
if retry_on_exception:
self._get_item_list_by_sql(sql,False)
except Exception as e:
self.log.exception(e)
finally:
pass
def test2(log):
import time
tt1=TThread(seq=1,log=log)
#tt2=TThread(2)
#tt3=TThread(3)
log.debug('main _thread(%f):start',_interval_timer())
tt1.running_start()
#tt2.start()
#tt3.start()
try:
while True:
if not tt1.IsPaused:
tt1.running_pause()
else:
tt1.running_resume()
time.sleep(2)
except(KeyboardInterrupt):
log.debug('main _thread(%f):stop timer',_interval_timer())
tt1.running_stop()
#tt2.stop()
#tt3.stop()
log.debug('main _thread(%f):stopped',_interval_timer())
# init log
log = util.initlog("./log/"+ os.path.split(__file__)[1]+".log")
# init db conn
dbpool = PooledDB.PooledDB(
MySQLdb,11,22,11,22,False,host='localhost',user='******',passwd='123',db='tracking', charset='utf8' )
conn = dbpool.connection()
# init dbworkshop
dbws = dbworkshop.DBWorkshop(dbpool=dbpool,minsize=2,log=log)
display_str="""test Begin[%s]"""
log.info(display_str%(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time()))))
try:
# 开始工作 ===============================================================
dbws.StartWork()
dhl_test(dbws,conn,log)
# 工作完成 ===============================================================
while True:
time.sleep(3)
log.info('main thread(%s):stopped'%
time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time())))
except(KeyboardInterrupt):
print('main thread(%f): User canceled by Ctrl-c'%_interval_timer())
finally:
print('main thread(%f):stop'%_interval_timer())
if dbws.IsAlive:
dbws.StopWork(timeout=30)
log.info('main thread(%s):stopped'%
time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(time.time())))
def test3(ws):
# test stop work function
ws.StartWork()
time.sleep(1)
ws.QueueWork(TWork(seq=1,period=3,name="dbworkshop_tester"))
while True:
time.sleep(1)
if __name__ == '__main__':
import vavava.util
dbpool = PooledDB(
MySQLdb,20,50,20,400,False,
host='localhost',user='******',passwd='123',db='tracking',
charset='utf8'
)
log = vavava.util.initlog("./log/test_dbworkshop.log")
ws = DBWorkshop(dbpool=dbpool,log=log)
try:
test3(ws)
#test2(ws)
except(KeyboardInterrupt):
log.info('main thread(%f): User canceled by Ctrl-c',_interval_timer())
finally:
log.info('main thread(%f):stop',_interval_timer())
ws.StopWork()
log.info('main thread(%f):stopped',_interval_timer())
def do(self,worker):
import time
self.log.info("[%05d] Hello DB, am %s !!!!!!! %f", self.seq,worker.getName(), _interval_timer())
log.info("Add a work : %d"%seq)
workingLine.QueueWork(MyWork(seq=seq,name="testwork"))
time.sleep(1)
def test3(workingLine,log):
log.info('test for priority work start (%f)',_interval_timer())
# test for priority work
workingLine=WorkQueue(priority_support=True,name="test_worker",log=log)
workingLine.wq_start()
seq=1000
while seq > 0:
for i in range(20):
seq -= 1
log.info("Add a work : %d",seq)
wr=MyPriorityWork(seq=seq,log=log,name="testwork")
workingLine.QueueWork(wr)
time.sleep(1)
if __name__ == '__main__':
import vavava.util
log = vavava.util.initlog("./log/test_workqueue.log")
workingLine = WorkQueue()
try:
test1(workingLine,log)
except(KeyboardInterrupt):
log.info('main thread(%f):stop',_interval_timer())
workingLine.wq_stop(timeout=5,flush=True)
log.info('main thread(%f):stopped',_interval_timer())
