def __init__(self, name='default-task', logger=None):
self.tasks = {}
self.lock = threading.RLock()
if logger:
self.LOG = logger
else:
self.LOG = MyLogger(name + '.log', clevel=logging.DEBUG)
self.need_stop = False
def start_sim():
for sim_name in List_sim:
Sim = None
if sim_name == 'air':
for i in range(0, 3):
Log = MyLogger(join('log', '%s%s.log' % (sim_name, i)),
clevel=logging.CRITICAL,
rlevel=logging.WARN)
Sim = Air
sim = Sim(logger=Log,
mac=''.join(random.sample(mac_sample_str, 12)),
time_delay=500)
sim.run_forever()
device_online_list.append(sim)
elif sim_name == 'hanger':
Log = MyLogger(join('log', '%s.log' % (sim_name)),
clevel=logging.CRITICAL,
rlevel=logging.WARN)
Sim = Hanger
sim = Sim(logger=Log,
mac=''.join(random.sample(mac_sample_str, 12)),
time_delay=500)
sim.run_forever()
device_online_list.append(sim)
elif sim_name == 'waterfilter':
Log = MyLogger(join('log', '%s.log' % (sim_name)),
clevel=logging.CRITICAL,
rlevel=logging.WARN)
Sim = Waterfilter
sim = Sim(logger=Log,
mac=''.join(random.sample(mac_sample_str, 12)),
time_delay=500)
sim.run_forever()
device_online_list.append(sim)
elif sim_name == 'airfilter':
Log = MyLogger(join('log', '%s.log' % (sim_name)),
clevel=logging.CRITICAL,
rlevel=logging.WARN)
Sim = AirFilter
sim = Sim(logger=Log,
mac=''.join(random.sample(mac_sample_str, 12)),
time_delay=500)
sim.run_forever()
device_online_list.append(sim)
elif sim_name == 'washer':
Log = MyLogger(join('log', '%s.log' % (sim_name)),
clevel=logging.CRITICAL,
rlevel=logging.WARN)
Sim = Washer
sim = Sim(logger=Log,
mac=''.join(random.sample(mac_sample_str, 12)),
time_delay=500)
sim.run_forever()
device_online_list.append(sim)
def sys_init():
# sys log init
global LOG
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace(
'py', 'log'), clevel=logging.DEBUG, renable=False)
global cprint
cprint = cprint(os.path.abspath(sys.argv[0]).replace('py', 'log'))
# cmd arg init
global arg_handle
arg_handle = ArgHandle()
arg_handle.run()
LOG.info("Let's go!!!")
def sys_init():
global LOG
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace('py', 'log'), clevel=logging.INFO,
rlevel=logging.WARN)
global cprint
cprint = cprint(__name__)
global arg_handle
arg_handle = ArgHandle()
arg_handle.run()
global thread_list
thread_list = []
LOG.info("Let's go!!!")
def _init_(self, name, log_dir):
self.name = name
self.log_dir = log_dir
self.log_dir += os.path.sep + datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + \
'-' + self.name + os.path.sep
self.log_dir = common_APIs.dirit(self.log_dir)
try:
os.mkdir(self.log_dir)
except Exception as er:
print('Can not create log dir: %s\n[[%s]]' % (
self.log_dir, str(er)))
sys.exit()
# create the log obj
self.LOG = MyLogger(self.log_dir + 'output.log', cenable=True)
def start_sims():
if not os.path.exists(log_path):
os.mkdir(log_path)
if del_log_before_start:
del_all_files(log_path)
addr_len = 0
if bind_self:
addr_list = get_connected_ipv4_list()
addr_len = len(addr_list)
mac_mid = "Air" # Ascii of "Air_"
mac_head = ("%s%s" % (mac_prefix[0:1], mac_mid))
for i in range(0, sim_num):
#mac_tmp = mac_prefix + sim_type+"mac"+str(i)
mac_tmp = ("%s%02x" % (mac_head, i))
log = MyLogger(join(log_path, '%s-%s.log' % (sim_type, mac_tmp)),
clevel=eval(cl_level),
flevel=eval(fl_level))
log.warn("device mac:%s" % (mac_tmp, ))
sim = eval(sim_type)
if bind_self and addr_len > 0:
if force_dev_num and i >= addr_len:
log.error("devices should not more than net cards number!")
break
addr_index = i % (addr_len)
sim_temp = sim(logger=log,
mac=mac_tmp,
addr=rout_addr,
self_addr=(addr_list[addr_index], int(start_port)))
else:
log.error("no any net card is connected!")
sys.exit(-666)
#sim_temp = sim(logger=log, mac=mac_tmp)
#sim_temp.sdk_obj.heartbeat_interval = heartbeat_interval
sim_temp.run_forever()
device_online_list.append(sim_temp)
if start_one_by_one:
log.warn("press any key to start next devices")
raw_input()
def replay(record_list, rLOG):
global testresults
testresults = {}
global testcases
testcases = {}
global newwhitelist
newwhitelist = {}
global testnum
testnum = 0
global failnum
failnum = 0
global LOG
LOG = rLOG
global log_dir
log_dir = config.result_dir + datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + os.path.sep
try:
os.mkdir(log_dir)
except Exception as er:
LOG.error('Can not create log dir: %s\n[[%s]]' % (log_dir, str(er)))
# sys.exit()
temp_LOG = LOG
for record in record_list:
LOG = temp_LOG
LOG.yinfo('To replay module: %s...' % record)
global sub_log_dir
sub_log_dir = log_dir + PurePosixPath(record).stem + os.path.sep
global fitters
fitters = import_module('fitters.' + PurePosixPath(record).stem + '_fitter')
try:
os.mkdir(sub_log_dir)
except Exception as er:
LOG.error('Can not create log dir: %s\n[[%s]]' % (sub_log_dir, str(er)))
# sys.exit()
LOG = MyLogger(sub_log_dir + '%s.log' % PurePosixPath(record).stem, clevel=logging.DEBUG)
report(_replayone(record))
class Task():
def __init__(self, name='default-task', logger=None):
self.tasks = {}
self.lock = threading.RLock()
if logger:
self.LOG = logger
else:
self.LOG = MyLogger(name + '.log', clevel=logging.DEBUG)
self.need_stop = False
def stop(self):
self.need_stop = True
self.LOG.warn('Thread %s stoped!' % (__name__))
def add_task(self, name, func, run_times=1, interval=5, *argv):
self.lock.acquire()
if name and func and int(run_times) >= 1 and int(interval) >= 1:
pass
else:
self.LOG.error("Invalid task: %s, run_times: %d, internal: %d" %
(name, int(run_times), int(interval)))
self.LOG.info("To add task: %s, run_times: %d, internal: %d" %
(name, int(run_times), int(interval)))
self.tasks[name] = {
'func': func,
'run_times': int(run_times),
'interval': int(interval),
'now_seconds': 0,
'argv': argv,
'state': 'active',
'name': name
}
self.lock.release()
def del_task(self, name):
self.lock.acquire()
self.LOG.warn("To delete task:%s" % (name))
if name in self.tasks:
del self.tasks[name]
self.lock.release()
def show_tasks(self):
if self.tasks:
for task in self.tasks:
self.LOG.info(task + ":")
for item in sorted(self.tasks[task]):
self.LOG.yinfo(" " + item.ljust(20) + ':' +
str(self.tasks[task][item]).rjust(20))
else:
self.LOG.warn("No task...")
def task_proc(self):
while self.need_stop == False:
if len(self.tasks) == 0:
self.LOG.debug("No task!\n")
'''
for task in self.tasks:
if self.tasks[task]['state'] == 'inactive':
self.del_task(task)
'''
try:
self.lock.acquire()
for task in self.tasks:
if self.tasks[task]['state'] != 'active':
continue
self.tasks[task]['now_seconds'] += 1
if self.tasks[task]['now_seconds'] >= self.tasks[task][
'interval']:
if callable(self.tasks[task]['func']):
# self.LOG.info("It is time to run %s: " % (
# task) + self.tasks[task]['func'].__name__ + str(self.tasks[task]['argv']))
self.tasks[task]['func'](
*(self.tasks[task]['argv']))
elif callable(eval(self.tasks[task]['func'])):
# self.LOG.info("It is time to run %s: " % (
# task) + self.tasks[task]['func'] + str(self.tasks[task]['argv']))
eval(self.tasks[task]['func'] + '(*' +
str(self.tasks[task]['argv']) + ')')
else:
self.LOG.error(
"Uncallable task: %s, will disable it!")
self.tasks[task]['state'] = 'inactive'
self.tasks[task]['now_seconds'] = 0
self.tasks[task]['run_times'] -= 1
if self.tasks[task]['run_times'] == 0:
self.LOG.info("stop task:%s" % (task))
self.tasks[task]['state'] = 'inactive'
else:
pass
self.lock.release()
time.sleep(0.1)
except RuntimeError:
pass
else:
self.LOG.error('Close connection failed!')
def send_data(self, data):
return self.connection.send_once(data)
def recv_data(self):
datas = self.connection.recv_once()
return datas
# 空调遥控器模拟程序入口
if __name__ == '__main__':
# sys log init
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace('py', 'log'),
clevel=logging.INFO,
renable=False)
cprint = cprint(os.path.abspath(sys.argv[0]).replace('py', 'log'))
# cmd arg init
arg_handle = ArgHandle()
arg_handle.run()
# sys init
sys_init()
# multi thread
global thread_list
thread_list = []
# 系统初始化函数，在所有模块开始前调用
def sys_init():
LOG.info("Let's go!!!")
# 系统清理函数，系统退出前调用
def sys_cleanup():
LOG.info("Goodbye!!!")
# 主程序入口
if __name__ == '__main__':
# sys log init
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace('py', 'log'),
clevel=logging.DEBUG,
rlevel=logging.WARN)
cprint = cprint(__name__)
# sys init
sys_init()
# cmd arg init
arg_handle = ArgHandle()
arg_handle.run()
# multi thread
global thread_list
thread_list = []
# create serial objs
def sys_join():
for th in thread_ids:
th.join()
def sys_init():
LOG.info("Let's go!!!")
def sys_cleanup():
LOG.info("Goodbye!!!")
if __name__ == '__main__':
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace('py', 'log'),
clevel=logging.INFO,
rlevel=logging.WARN)
cprint = cprint(__name__)
sys_init()
arg_handle = ArgHandle()
arg_handle.run()
global thread_list
thread_list = []
device_type = arg_handle.get_args('device_type')
device_cls = chr(ord(device_type.lower()[0]) -
32) + device_type.lower()[1:]
Sim = eval(device_cls)
class TestCase(object):
__metaclass__ = ABCMeta
def _init_(self, name, log_dir):
self.name = name
self.log_dir = log_dir
self.log_dir += os.path.sep + datetime.datetime.now().strftime('%Y%m%d_%H%M%S') + \
'-' + self.name + os.path.sep
self.log_dir = common_APIs.dirit(self.log_dir)
try:
os.mkdir(self.log_dir)
except Exception as er:
print('Can not create log dir: %s\n[[%s]]' % (
self.log_dir, str(er)))
sys.exit()
# create the log obj
self.LOG = MyLogger(self.log_dir + 'output.log',
cenable=True, with_print=True)
def setup(self):
pass
def teardown(self):
pass
#@istest
#@with_setup(setup, teardown)
def test(self):
self.common_init()
result = 0
try:
result = self.run()
# except Exception as e:
# traceback.print_exc()
# self.LOG.critical(str(e))
# assert False
finally:
self.common_cleanup()
@abstractmethod
def run(self):
pass
def common_init(self):
pass
def common_cleanup(self):
pass
def case_pass(self, success_info='pass'):
self.LOG.info(success_info)
assert True
return True
def case_fail(self, error_info='fail'):
self.LOG.error(error_info)
assert False
return False
def do_setup(self, config_data):
self.LOG.info('call do_setup')
if 'setup' in config_data:
self.LOG.info('Maybe have data')
setup_list = config_data['setup']
for i in setup_list:
for k in i:
self.LOG.info(k)
def do_run(self, config_data):
self.LOG.info('call core')
def do_teardown(self, config_data):
self.LOG.info('call do_teardown')
def sys_join():
for th in thread_ids:
th.join()
def sys_init():
LOG.info("Let's go!!!")
def sys_cleanup():
LOG.info("Goodbye!!!")
if __name__ == '__main__':
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace('py', 'log').replace(
'exe', 'log'),
clevel=logging.INFO,
rlevel=logging.WARN)
cprint = cprint(__name__)
sys_init()
arg_handle = ArgHandle()
arg_handle.run()
global thread_list
thread_list = []
sims = {}
log_level = logging.DEBUG
zigbee_obj = ZIGBEE('COM' + arg_handle.get_args('serial_port'),
by Kobe Gong. 2018-1-3
"""
import asyncio
import functools
import logging
import os
import re
import struct
import sys
import threading
import time
from basic.log_tool import MyLogger
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace(
'py', 'log'), clevel=logging.DEBUG, renable=False)
def xxoo(func):
@functools.wraps(func)
def tmp(self, *args, **kwargs):
LOG.debug(func.__name__ + ' is called!')
return func(self, *args, **kwargs)
return tmp
class AsyncBase():
@xxoo
def __init__(self, logger=None):
self.LOG = logger
self.loop = asyncio.new_event_loop()
self.set_connection_state(False)
else:
self.LOG.error('Close connection failed!')
def send_data(self, data):
return self.connection.send_once(data)
def recv_data(self):
datas = self.connection.recv_once()
return datas
# 空调模拟程序入口
if __name__ == '__main__':
# sys log init
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace('py', 'log'), clevel=logging.DEBUG,
rlevel=logging.WARN)
cprint = cprint(os.path.abspath(sys.argv[0]).replace('py', 'log'))
# cmd arg init
arg_handle = ArgHandle()
arg_handle.run()
# sys init
sys_init()
# multi thread
global thread_list
thread_list = []
# create clients
clients = []
enable_flog = True
monitor_s = arg_handle.get_args('monitor_s')
disp_sleep_s = arg_handle.get_args('disp_sleep_s')
cmd_index = arg_handle.get_args('cmd_index')
if arg_handle.get_args('device_count') > 1:
log_level = logging.INFO
# enable_flog = False
sims = []
ttt = asyncio.ensure_future(GenRealTimeReport(sims, monitor_s, cmd_index))
start = time.time()
for i in range(arg_handle.get_args('device_count')):
dev_LOG = MyLogger('.\\log_folder\\dev_sim_%d_%d.log' %
(cmd_index, arg_handle.get_args('xx') + i),
clevel=log_level,
flevel=log_level,
fenable=enable_flog,
cenable=False)
self_addr = None
self_ip = None
if ipv4_list:
id = i % len(ipv4_list)
# self_addr = (ipv4_list[id], random.randint(
# arg_handle.get_args('server_port'), 65535))
self_addr = (ipv4_list[id], 0)
dev_LOG.warn('self addr is: %s' % (str(self_addr)))
if self_addr:
self_ip = self_addr[0]
device_timeout = arg_handle.get_args('dto')
if not device_timeout == None:
sys.exit()
if __name__ == '__main__':
sys_init()
loop = asyncio.get_event_loop()
if arg_handle.get_args('device_count') > 1:
log_level = logging.WARN
else:
log_level = logging.INFO
sims = []
for i in range(arg_handle.get_args('device_count')):
dev_LOG = MyLogger('dev_sim_%d.log' % (arg_handle.get_args('xx') + i),
clevel=log_level,
flevel=log_level,
fenable=False)
coro = loop.create_connection(
lambda: Door(config_file=arg_handle.get_args('config_file'),
logger=dev_LOG,
N=arg_handle.get_args('xx') + i,
tt=arg_handle.get_args('tt'),
encrypt_flag=arg_handle.get_args('encrypt')),
arg_handle.get_args('server_IP'),
arg_handle.get_args('server_port'))
transport, protocol = loop.run_until_complete(coro)
asyncio.ensure_future(protocol.run_forever())
sims.append(protocol)
loop.run_forever()
return (r.status_code, r.json(), r.headers)
except json.decoder.JSONDecodeError:
return (r.status_code, r.text, r.headers)
except:
return (400, {}, {})
if __name__ == "__main__":
global LOG
global cprint
global arg_handle
cprint = cprint()
arg_handle = ArgHandle()
arg_handle.run()
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace(
'py', 'log'), clevel=logging.DEBUG, fenable=False)
picpath = "pics"
if not os.path.exists(picpath):
LOG.error('no pics dir!!!')
sys.exit()
msg = {
"name": "小狗狗test",
"userType": "1",
"sex": "1",
"idenType": "111",
"birth": "",
"idenNum": "211223198708080088",
"nation": "1",
"origin": "阿富汗",
"phone": "18888888888",
print("file:%s is removed" % (file, ))
if __name__ == '__main__':
delallLog()
sys_init()
global ipv4_list
if arg_handle.get_args('device_count') > 1:
log_level = logging.DEBUG
else:
log_level = logging.DEBUG
sims = []
for i in range(arg_handle.get_args('device_count')):
dev_LOG = MyLogger('dev_sim_%d.log' % (i),
clevel=log_level,
flevel=log_level,
fenable=True)
if ipv4_list:
id = i % len(ipv4_list)
#self_addr = (ipv4_list[id], random.randint(
#arg_handle.get_args('server_port'), 65535))
self_addr = (ipv4_list[id], 0)
dev_LOG.warn('self addr is: %s' % (str(self_addr)))
else:
self_addr = None
sim = Dev(logger=dev_LOG,
config_file=arg_handle.get_args('config_file'),
server_addr=(arg_handle.get_args('server_IP'),
arg_handle.get_args('server_port')),
def sys_join():
for th in thread_ids:
th.join()
def sys_init():
LOG.info("Let's go!!!")
def sys_cleanup():
LOG.info("Goodbye!!!")
if __name__ == '__main__':
LOG = MyLogger(os.path.abspath(sys.argv[0]).replace('py', 'log'), clevel=logging.INFO,
rlevel=logging.WARN)
cprint = cprint(__name__)
sys_init()
arg_handle = ArgHandle()
arg_handle.run()
global thread_list
thread_list = []
sims = {}
if arg_handle.get_args('device_count') > 1:
log_level = logging.WARN
else:
log_level = logging.INFO
