def _get_push_data(self):
"""
1、从队列获取package；
2、分析包并触发相应处理程序；
3、发送package。
:return:
"""
print('start send data')
while self.isrunning:
try:
if not self.q_rsl.empty():
transfer_package = self.q_rsl.get()
data_dict = transfer_package.to_dict()
# print('get push data--', data_dict)
self._analyze_pkg(package=data_dict)
# data_send = bytes('{}'.format(data_dict), encoding='utf-8')
# print('File: "' + __file__ + '", Line ' + str(sys._getframe().f_lineno) + ' , in ' + sys._getframe().f_code.co_name)
# print(data_send)
# if self.sock:
# self.sock.send(data_send)
else:
time.sleep(1)
except (OSError, BrokenPipeError):
continue
except Exception as e:
print(e)
mylogger.error(e)
continue
def _operate_equipment(self, transfer_package):
"""
异步访问硬件
:param transfer_package:
:return:
"""
try:
target = transfer_package.target
task = transfer_package.data['func']
args = transfer_package.data['args']
# get the queue of equipment
self.lock.acquire()
qt = self.terminal_active[target]['queuetask']
qr = self.terminal_active[target]['queuersl']
subevent = self.terminal_active[target]['subevent']
self.lock.release()
subevent.clear()
qt.put((task, args))
subevent.wait()
if not qr.empty():
pkg = qr.get()
self.queue_rsl.put(pkg)
else:
print(target, ' qr is empty!')
except Exception as e:
print('except------', e)
mylogger.error(e)
def _save_data2db(self):
"""
1、先查询用户是否有借出，有则清除并更新格子重量；
2、更改对应EPC的在库状态，更新用户的借还历史；
3、同时检测是否放置错误的重力格子或者RFID格子；
:return:
"""
try:
print('_save_data2db')
print('\033[1;33m', 'all gravity--', self.gravity_goods)
print('all RFID--', self.rfid_goods, '\033[0m')
history_list = History_inbound_outbound.by_user_need_return(self.user_id)
# print('history_list--', history_list)
history_gravity = [h for h in history_list if h.monitor_way == 1]
history_rfid = [h for h in history_list if h.monitor_way == 2]
if self.manage_mode == 1:
self._save_gravity_data(history=history_gravity)
self._save_rfid_data(rfid_history=history_rfid)
with self.lock:
self.rfid_goods.clear()
self.gravity_goods.clear()
return True
except Exception as e:
mylogger.error(e)
return False
def delete_equipment(self, ip: str, port: int, isserver: bool):
"""
1、加入设备服务器列表或设备客户端列表；
2、尝试连接设备；
:param ip:
:param port:
:param type_new:
:param isserver:
:return:
"""
addr = (ip, port)
try:
if isserver:
self.lock.acquire()
del self.servers[addr]
self.lock.release()
else:
self.lock.acquire()
del self.clients[addr]
self.lock.release()
return True
except Exception as e:
print('gateway server is failed to delete_equipment():%s' % e)
mylogger.error(
'gateway server is failed to delete_equipment():%s' % e)
return False
def _handle_cmd(self):
try:
if not self.queue_task.empty():
# get transfer package type 'TransferPackage' from queue
transfer_package = self.queue_task.get()
target = transfer_package.target
task = transfer_package.data['func']
args = transfer_package.data['args']
print('\033[1;33m CMD: ', task, ' ', args, '\033[0m')
# cmd for the equipment running async
if transfer_package.msg_type == 0:
thd = threading.Thread(target=self._operate_equipment,
args=(transfer_package, ))
thd.setDaemon(True)
thd.start()
# cmd for gateway server
elif transfer_package.msg_type == 1:
rsl = methodcaller(task, *args)(self)
if rsl is True:
transfer_package.code = SUCCESS
transfer_package.msg_type = 4
else:
transfer_package.code = ERR_EQUIPMENT_RESP
transfer_package.msg_type = 4
self.queue_rsl.put(transfer_package)
else:
pass
else:
pass
except KeyboardInterrupt:
with self.lock:
self.isrunning = False
except Exception as e:
print('excetp', e)
mylogger.error(e)
def main():
mydb = MyDB()
myserver = None
mycontroler = None
thd_timer = None
# task_controler与gateway_server交互的全局队列
q_task = Queue(50)
q_rsl = Queue(50)
try:
rsl = get_all_equipments()
servers_registered = dict() # {addr: (type, storeroom_id, uuid)}
clients_registered = dict()
for r_id, s_c in rsl.items():
temp_servers = {
k: (v[0], r_id, v[1])
for k, v in s_c['servers'].items()
}
servers_registered.update(temp_servers)
temp_clients = {
k: (v[0], r_id, v[1])
for k, v in s_c['clients'].items()
}
clients_registered.update(temp_clients)
myserver = GatewayServer(port=8809,
servers_registered=servers_registered,
clients_registered=clients_registered,
queue_task=q_task,
queue_rsl=q_rsl)
mycontroler = TaskControler(queue_task=q_task, queue_rsl=q_rsl)
myserver.daemon = True
mycontroler.daemon = True
myserver.start()
progress['gateway_server'] = myserver
mycontroler.start()
progress['task_controler'] = mycontroler
thd_timer = threading.Timer(interval=60,
function=ontime_progress_monitor,
args=([q_task, q_rsl]))
thd_timer.start()
thd_timer.join()
except KeyboardInterrupt:
mydb.close()
myserver.stop()
mycontroler.stop()
thd_timer.cancel()
while mycontroler.is_alive() or myserver.is_alive():
time.sleep(1)
print('thread--mycontroler/myserver is still alive')
except Exception as e:
print('exception from main', e)
mylogger.error('exception from main: %s' % e)
def run(self):
"""
1、主动连接所有已注册服务端；
2、监听等待连接所有已注册客户端；
3、打开注册子线程；
4、打开创建与监测子线程；
5、打开交互接口。
:return:
"""
try:
# connect all servers
if self.servers is not None:
print("Start to connect to registered servers!!!!")
for k, v in self.servers.items():
self._connect_server(addr=k,
ttype=v[0],
storeroom_id=v[1],
uuid=v[2])
else:
mylogger.info(
'There is None registered server for connecting!')
# monitor and reconn servers
thread_reconn_server = threading.Thread(
target=self._reconnect_offline_server)
thread_reconn_server.daemon = True
thread_reconn_server.start()
# listen all access clients
thread_monitor_client = threading.Thread(
target=self._monitor_access)
thread_monitor_client.daemon = True
thread_monitor_client.start()
# monitor status subthread on time
t = threading.Timer(interval=1, function=self.time_thread)
t.daemon = True
t.start()
# wait for cmd
while True:
with self.lock:
status = self.isrunning
if status:
self._handle_cmd()
else:
break
except Exception as e:
print('gateway_server: ', e)
mylogger.error(e)
def call_cpp(self, func_name, *args):
# print(func_name)
for so_lib in self.so_list:
try:
lib = cdll.LoadLibrary(so_lib)
try:
value = eval("lib.%s" % func_name)(*args)
# mylogger.info("调用的库：" + so_lib)
# mylogger.info("执行成功,返回值：" + str(value))
return value
except:
continue
except:
continue
# logging.info("库文件载入失败：" + so_lib )
mylogger.error("没有找到接口！")
return False
def _check_data_update(self):
start = time.time()
try:
with self.lock:
print('CM_R2000FH old EPCs: ', self.data_buff)
print('CM_R2000FH new EPCs: ', self.current_epcs)
if self.current_epcs is not None:
print(
time.asctime(), 'CM_R2000RH(%s, %d) exception:' %
(self.addr[0], self.addr[1]), self.current_epcs)
diff_epcs = list(
set(epc[0] for epc in self.current_epcs)
^ set(epc[0] for epc in self.data_buff))
print('CM_R2000FH diff_epcs--', diff_epcs)
if diff_epcs:
is_increase = True if len(self.current_epcs) > len(
self.data_buff) else False
diff = [
epc_ant for epc_ant in self.current_epcs
if epc_ant[0] in diff_epcs
] if is_increase else [
epc_ant for epc_ant in self.data_buff
if epc_ant[0] in diff_epcs
]
data = {'epcs': diff, 'is_increase': is_increase}
# pkg = TransferPackage(code=EQUIPMENT_DATA_UPDATE, eq_type=4, data=data, source=self.addr,
# msg_type=3, storeroom_id=self.storeroom_id, eq_id=self.uuid)
# self.queue_push_data.put(pkg)
self.data_buff.clear()
self.data_buff = [epc_ant for epc_ant in self.current_epcs]
self.current_epcs.clear()
except Exception as e:
print('CM_R2000RH(%s, %d) exception: %s' %
(self.addr[0], self.addr[1], e))
mylogger.error('CM_R2000RH(%s, %d) exception: %s' %
(self.addr[0], self.addr[1], e))
end = time.time()
start_end = end - start
interval = round((self.update_interval - start_end), 2)
thread_ontime = threading.Timer(interval=interval,
function=self._check_data_update)
thread_ontime.daemon = True
thread_ontime.start()
def main():
mydb = MyDB()
myserver = None
mycontroler = None
# task_controler与gateway_server交互的全局队列
q_task = Queue(50)
q_rsl = Queue(50)
try:
rsl = get_all_equipments()
servers_registered = dict() # {addr: (type, storeroom_id, uuid)}
clients_registered = dict()
for r_id, s_c in rsl.items():
temp_servers = {
k: (v[0], r_id, v[1])
for k, v in s_c['servers'].items()
}
servers_registered.update(temp_servers)
temp_clients = {
k: (v[0], r_id, v[1])
for k, v in s_c['clients'].items()
}
clients_registered.update(temp_clients)
myserver = GatewayServer(port=8809,
servers_registered=servers_registered,
clients_registered=clients_registered,
queue_task=q_task,
queue_rsl=q_rsl)
mycontroler = TaskControler(queue_task=q_task, queue_rsl=q_rsl)
myserver.start()
mycontroler.start()
mycontroler.join()
# while True:
# pass
except KeyboardInterrupt:
# mydb.close()
# myserver.stop()
mycontroler.stop()
while mycontroler.is_alive():
time.sleep(1)
print('thread is still alive')
except Exception as e:
print(e)
mylogger.error(e)
def _create_socket(self, addr: tuple):
##############################
# create every socket connected to equipment
##############################
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(1)
failed_count = 0
while True:
try:
s.connect(addr)
print('success to conn client: ', addr)
break
except socket.error:
failed_count += 1
print("fail to connect to server %d times" % failed_count)
if failed_count == 10:
print('Fail to connect Client: ', addr)
mylogger.error('Fail conn to: ' + str(addr))
return None
return s
def run(self):
cursec = 0
current_data = {}
while self.isrunning:
try:
if not self.queuetask.empty():
task, args = self.queuetask.get()
rsl = methodcaller(task, *args)(self)
if rsl is not None:
pkg = TransferPackage(code=200,
eq_type=1,
data={'rsl': rsl},
source=self.addr,
msg_type=4)
self.queuersl.put(pkg)
self.event.set()
else:
time.sleep(30)
localtime = time.localtime(time.time())
if localtime.tm_sec != cursec:
cursec = localtime.tm_sec
rsl = cursec
allg = {}
if rsl is not None and rsl % 10 == 0:
allg[str(rsl)] = rsl
if allg != current_data:
current_data.update(allg)
pkg = TransferPackage(code=206,
eq_type=1,
data=allg,
source=self.addr,
msg_type=3)
self.queue_push_data.put(pkg)
# print(time.asctime(), 'G--getAllInfo: ', allg)
else:
pass
except Exception as e:
print(e)
mylogger.error(e)
print('网络断开啦，子线程%s要关闭了！' % threading.current_thread().name)
def ontime_progress_monitor(q_task, q_rsl):
print('*********times out progress monitor**********')
if not progress['gateway_server'].is_alive():
print('progress gateway_server is not alive')
mylogger.error('progress gateway_server is not alive')
rsl = get_all_equipments()
servers_registered = dict() # {addr: (type, storeroom_id, uuid)}
clients_registered = dict()
for r_id, s_c in rsl.items():
temp_servers = {
k: (v[0], r_id, v[1])
for k, v in s_c['servers'].items()
}
servers_registered.update(temp_servers)
temp_clients = {
k: (v[0], r_id, v[1])
for k, v in s_c['clients'].items()
}
clients_registered.update(temp_clients)
myserver_demo = GatewayServer(port=8809,
servers_registered=servers_registered,
clients_registered=clients_registered,
queue_task=q_task,
queue_rsl=q_rsl)
myserver_demo.daemon = True
myserver_demo.start()
progress['gateway_server'] = myserver_demo
mylogger.info('progress gateway_server is start again')
if not progress['task_controler'].is_alive():
print('progress task_controler is not alive')
mylogger.error('progress task_controler is not alive')
mycontroler_demo = TaskControler(queue_task=q_task, queue_rsl=q_rsl)
mycontroler_demo.daemon = True
mycontroler_demo.start()
progress['task_controler'] = mycontroler_demo
mylogger.info('progress task_controler is start again')
thd_timer1 = threading.Timer(interval=60,
function=ontime_progress_monitor,
args=([q_task, q_rsl]))
thd_timer1.start()
def run(self):
try:
print('PID--task_controler:', os.getpid())
mylogger.info('PID--task_controler: %d' % os.getpid())
thread_conn = threading.Thread(target=self._monitorconn)
thread_send = threading.Thread(target=self._get_push_data)
thread_conn.daemon = True
thread_send.daemon = True
thread_conn.start()
thread_send.start()
print('start task')
thread_conn.join()
print('stop task controler')
mylogger.error('task controler was stop')
except KeyboardInterrupt:
# while self.sock is not None:
# print(self.server_sock)
# self.server_sock.shutdown(socket.SHUT_RDWR)
# self.server_sock.close()
# time.sleep(2)
print('self.sock', self.sock)
except Exception as e:
print('task_controler was stop by exception: ', e)
mylogger.error('task_controler was stop by exception:' + e)
print('\033[1;33m', 'task_controler was stop', '\033[0m')
mylogger.error('task_controler was stop')
def add_new_equipment(self, ip: str, port: int, type_new: str,
isserver: bool, storeroom_id: str, uuid: str):
"""
1、加入设备服务器列表或设备客户端列表；
2、尝试连接设备；
:param ip:
:param port:
:param type_new:
:param isserver:
:return:
"""
addr = (ip, port)
try:
if isserver:
self.lock.acquire()
self.servers[addr] = (type_new, storeroom_id, uuid)
self.lock.release()
self._connect_server(addr=addr,
ttype=type_new,
storeroom_id=storeroom_id,
uuid=uuid)
if addr in self.server_active.keys():
return True
else:
return False
else:
self.lock.acquire()
self.clients[addr] = (type_new, storeroom_id, uuid)
self.lock.release()
time.sleep(1)
if addr in self.client_active:
return True
else:
return False
except Exception as e:
print('gateway server is failed to add_new_equipment():%s' % e)
mylogger.error(
'gateway server is failed to add_new_equipment():%s' % e)
return False
def run(self):
num = 0
cursec = 0
while self.isrunning:
try:
if not self.queuetask.empty():
task, args = self.queuetask.get()
rsl = methodcaller(task, *args)(self)
if rsl is not None:
pkg = TransferPackage(code=200,
eq_type=1,
data={'rsl': rsl},
source=self.addr,
msg_type=6)
self.queuersl.put(pkg)
self.event.set()
else:
localtime = time.localtime(time.time())
if localtime.tm_sec != cursec:
cursec = localtime.tm_sec
num = num + 1 if num < 1000 else 0
for i in self.alladdrs:
rsl = self.showNum(num, i)
activate = True if num % 2 == 0 else False
self.onLed(activate=activate, pos='up', addr=i)
self.onLed(activate=not activate,
pos='down',
addr=i)
# if rsl:
# print('L(%s)--showNum: %i' % (i, num))
else:
pass
except Exception as e:
print(e)
mylogger.error(e)
print('网络断开啦，子线程%s要关闭了！' % threading.current_thread().name)
def run(self):
"""
1、主动连接所有已注册服务端；
2、监听等待连接所有已注册客户端；
3、打开注册子线程；
4、打开创建与监测子线程；
5、打开交互接口。
:return:
"""
try:
print('PID--gateway_server:', os.getpid())
mylogger.info('PID--gateway_server: %d' % os.getpid())
# connect all servers
if self.servers is not None:
print("Start to connect to registered servers!!!!")
for k, v in self.servers.items():
self._connect_server(addr=k,
ttype=v[0],
storeroom_id=v[1],
uuid=v[2])
else:
mylogger.info(
'There is None registered server for connecting!')
# monitor and reconn servers
thread_reconn_server = threading.Thread(
target=self._reconnect_offline_server)
thread_reconn_server.daemon = True
thread_reconn_server.start()
# listen all access clients
thread_monitor_client = threading.Thread(
target=self._monitor_access)
thread_monitor_client.daemon = True
thread_monitor_client.start()
# monitor status subthread on time
self.check_interval = conpar.read_yaml_file(
'configuration')['gateway_server_check_interval']
t = threading.Timer(interval=self.check_interval,
function=self._thread_ontime)
t.daemon = True
t.start()
# wait for cmd
print('gateway server was start')
while self.isrunning:
self._handle_cmd()
time.sleep(1)
print('gateway server was stop')
mylogger.error('gateway server was stop')
except Exception as e:
print('gateway server was stop by exception: ', e)
mylogger.error('gateway server was stop by exception:' + e)
print('\033[1;33m', 'gateway_server was stop', '\033[0m')
mylogger.error('gateway_server was stop')
def print_error(self, msg=""):
error_info = self.call_cpp("NET_DVR_GetLastError")
mylogger.error(msg + str(error_info))
def _analyze_pkg(self, package: dict):
"""
1、门禁事件：
查询是否存在该门禁的处理线程，存活的就放入pkg，否则创建开始新线程；
2、数据更新事件：
根据设备pkg中storeroom的ID号放入相应的线程；
3、其他推送到web的响应事件；
:param package:
:return:
"""
try:
print('analyze pkg: ', package)
# if self.sock:
# data_send = bytes('{}'.format(package), encoding='utf-8')
# self.sock.send(data_send)
storeroom_id = package['storeroom_id']
if package['msg_type'] == 3 and package['equipment_type'] in (3, 5):
print('111')
# 门禁的数据更新pkg处理
if storeroom_id in self.storeroom_thread.keys() and self.storeroom_thread[storeroom_id]['thread'].isAlive():
self.storeroom_thread[storeroom_id]['queue'].put(package)
else:
print('\033[1;33m', package['data']['user'] + 'enter to storeroom--' + storeroom_id + ' by entrance--' + str(package['source']), '\033[0m')
addr = package['source']
eq_id = package['equipment_id']
user_code = package['data']['user']
queue_storeroom = Queue(50)
thread_store_mag = StoreroomManager(entrance_addr=addr, entrance_id=eq_id, user_code=user_code,
queue_storeroom=queue_storeroom, q_send=self.q_rsl, q_task=self.q_task)
thread_store_mag.daemon = True
thread_store_mag.start()
self.storeroom_thread[storeroom_id] = {'thread': thread_store_mag, 'queue': queue_storeroom}
elif package['msg_type'] == 3:
print('222')
# 其他设备的数据更新pkg处理. 判断是否为重力，并更新DB的实时总重量；若有人在库，则放入库房处理程序；
if package['equipment_type'] == 1:
self._update_db_data(package=package)
if storeroom_id in self.storeroom_thread.keys() and self.storeroom_thread[storeroom_id]['thread'].isAlive():
self.storeroom_thread[storeroom_id]['queue'].put(package)
else:
print('someone has not login but did something')
path_cur = os.path.abspath(os.path.dirname(__file__))
playsound(path_cur + '/../util/a_o.mp3')
elif package['msg_type'] == 2 and package['code'] == 301:
print('333')
# web确定按钮pkg
if storeroom_id in self.storeroom_thread.keys() and self.storeroom_thread[storeroom_id]['thread'].isAlive():
self.storeroom_thread[storeroom_id]['queue'].put(package)
# 等待线程结束信号并返回web
else:
# 此借还线程不存在，返回web信息不成功
package['code'] = TASK_HANDLE_ERR
package['msg_type'] = 4
package['data'] = {'msg': 'the thread of storeroom is not alive'}
if self.sock:
# data_send = bytes('{}'.format(package), encoding='utf-8')
print(type(package))
data_send = json.dumps(package).encode()
length = len(data_send)
# 定制包头 i为4个字节，所以接收方为四个字节，这个大小并不是输入的大小，而是封装固定的大小
data_length = struct.pack('i', length) # 使用struct，直接将int转为二进制型数据传输，对方使用struct解包
self.sock.send(data_length)
self.sock.send(data_send)
elif package['msg_type'] == 4 and package['source'] is None:
print('444')
# web response
print('web response--', package)
else:
print('555')
if self.sock:
# data_send = bytes('{}'.format(package), encoding='utf-8')
print(type(package))
data_send = json.dumps(package).encode()
length = len(data_send)
# 定制包头 i为4个字节，所以接收方为四个字节，这个大小并不是输入的大小，而是封装固定的大小
data_length = struct.pack('i', length) # 使用struct，直接将int转为二进制型数据传输，对方使用struct解包
self.sock.send(data_length)
self.sock.send(data_send)
print('\033[1;34m', 'send to web pkg--', data_send, '\033[0m')
mylogger.info('send web pkg--%s' % str(data_send, encoding='utf-8'))
except Exception as e:
mylogger.error(e)
