def create_task(self, task_id, image_data_id, image_data_url,\
image_data_md5, iot_dev_list_md5, iot_dev_list_url, start_time, end_time):
epd_task = EpdTask(self.task_url)
# 0-none 1-sleep 2-ready 3-run 4-finish 5-suspend
if self.__taskId == 0 or (self.__taskStatus in ('', '0', '4', '5')):
# 下载任务
os.system("wget %s -O %s.tmp" %
(image_data_url, epd_task.data_url))
os.system("wget %s -O %s.tmp" %
(iot_dev_list_url, epd_task.execute_url))
ret = self.check_task_integrity(image_data_md5, iot_dev_list_md5)
if not ret:
return False
# 保存任务状态
epd_task.set_item('task_id', str(task_id))
epd_task.set_item('image_data_id', str(image_data_id))
epd_task.set_item('image_data_url', image_data_url)
epd_task.set_item('start_time', start_time)
epd_task.set_item('end_time', end_time)
epd_task.set_item('task_status', '1')
epd_task.save()
# 保存待更新列表
os.system("mv %s.tmp %s" % (epd_task.data_url, epd_task.data_url))
os.system("mv %s.tmp %s" %
(epd_task.execute_url, epd_task.execute_url))
self.__taskId = self.get_task_id()
self.__taskStatus = self.get_task_status() # 更新任务状态
self.set_task_monitor()
return True
else:
LOG.info("task status not allowed, status:%s", self.__taskStatus)
return False
def send_service(self, service_name, data, need_resp=False):
path = ""
for service in self.services:
if service_name == service[0]:
path = service[1]
break
if path:
try:
self.__client = socket(family=AF_UNIX)
self.__client.connect(path)
content = json.dumps(data)
self.__client.send(content.encode('utf-8'))
if need_resp:
resp = self.__client.recv(1024 * 1024)
if not resp:
raise Exception()
resp = resp.decode('utf-8')
LOG.info(resp)
content = json.loads(resp, encoding='utf-8')
except Exception as e:
LOG.error(e.__repr__())
content = {'status': 500, 'msg': e.__repr__()}
finally:
self.__client.close()
return content
def post(self, cmd):
try:
request = self.request.body.decode('utf-8')
request = json.loads(request)
body = request["d"]
if cmd == 'group':
pass
elif cmd == 'white_list':
ret = gw.create_whitelist(body['url'], body['md5'])
if ret:
LOG.info("white list create success")
resp_status = "ok"
resp_data = {"result": "ok"}
elif cmd == 'check_code':
gw.set_auth_key(body['check_code'])
resp_status = "ok"
resp_data = {"result": "ok"}
except EpdException as e:
LOG.error(e.__repr__())
resp_status = "err",
resp_data = {"msg": e.message}
finally:
upload = uplink.Upload()
resp = {
"id": request['id'],
"from": request['from'],
"status": resp_status,
"command": request['command'],
"d": resp_data
}
upload.send(resp, topic="dma/cmd/resp")
def func(self, request):
LOG.info('%s heart beat', request['device_id'])
if gw.is_in_whitelist(request['device_id']):
LOG.info("%s is in white list", request['device_id'])
status = "ok"
else:
status = "error"
send_data = {"status": status}
return send_data
def func(self, request):
LOG.info('%s heart beat', request['device_id'])
if gw.is_in_executelist(request['device_id'], request['data_id']):
LOG.info("%s is in execute list", request['device_id'])
status = "ok"
else:
status = "error"
send_data = {"status": status}
return send_data
# dl.send_service('serial', send_data)
self.upload(request)
def func(self, request):
device_id = request['device_id']
LOG.info("%s register", device_id)
ret = gw.is_in_whitelist(device_id)
send_data = {}
if ret:
LOG.info("%s is in white list", device_id)
send_data['status'] = 'ok'
send_data['key'] = int(gw.get_auth_key())
else:
send_data['status'] = 'error'
return send_data
def create_whitelist(self, url, md5):
LOG.info("download white list file")
os.system("wget -c %s -O %s.tmp" % (url, self.white_list_url))
ret = self.check_whitelist_integrity(md5)
if not ret:
return False
else:
LOG.info("store white list file")
os.system("mv %s.tmp %s" %
(self.white_list_url, self.white_list_url))
self.__whiteListMD5 = self.get_whitelist()
return True
def send(self, url, data):
try:
data = json.dumps(data).encode('utf-8')
LOG.info(data)
request = urllib.request.Request(url,
data=data,
headers={'token': token})
resp = urllib.request.urlopen(request)
content = resp.read().decode('utf-8')
LOG.info("result:" + content)
content = json.loads(content)
return content
except Exception as e:
LOG.error(e.__str__())
def post(self, cmd):
body = self.request.body.decode('utf-8')
body = json.loads(body)
src = "local" if body['from'] == 'local' else 'remote'
radio_number = body.get('radio_number')
if cmd == 'update':
LOG.info('%s setup radio parameters', src)
data = {"cmd": "update", "radio": radio_number}
elif cmd == 'restart':
LOG.info('%s restart radio', src)
data = {"cmd": "restart", "radio": radio_number}
ret = dl.send_service("serial", data, need_resp=True) # 向串口发送消息
if ret['status'] != 'ok':
gw.set_try_data('serial', data)
def handle(self):
try:
data = self.request.recv(1024)
data = data.decode('utf-8')
data = json.loads(data, encoding='utf-8')
LOG.info("downlink recv: %s", data)
HandleClass = self.route(data)
handler = HandleClass()
send_data = handler.func(data)
if isinstance(send_data, dict):
content = json.dumps(send_data)
LOG.info("downlink send: %s", content)
self.wfile.write(content.encode('utf-8'))
except Exception as e:
LOG.error('%s exception: data: %s', e.__str__(), str(data))
def check_task_integrity(self, image_data_md5, iot_dev_list_md5):
hash_obj = hashlib.md5()
with open("%s.tmp" % self.data_url, "rb") as datafile:
hash_obj.update(datafile.read())
hash_code = hash_obj.hexdigest()
if image_data_md5 != hash_code:
LOG.info("image data md5 check failed")
return False
hash_obj = hashlib.md5()
with open("%s.tmp" % self.execute_url, "rb") as devfile:
hash_obj.update(devfile.read())
hash_code = hash_obj.hexdigest()
if iot_dev_list_md5 != hash_code:
LOG.info("iot dev list md5 check failed")
return False
return True
def send(self, payload, topic='pc_test', wait_event=None, need_wait=False, cache=False):
if cache:
url = r'http://127.0.0.1:7788/mqtt/publish/offlinecache'
else:
url = r'http://127.0.0.1:7788/mqtt/publish'
data = {}
data['topic'] = topic
data['payload'] = payload
try:
params = json.dumps(data).encode('utf-8')
LOG.info(params)
request = urllib.request.Request(url, data=params, headers={'token':token})
resp = urllib.request.urlopen(request)
content = resp.read().decode('utf-8')
LOG.info("result:"+content)
except Exception as e:
LOG.error(e.__str__())
def post(self, cmd):
try:
request = self.request.body.decode('utf-8')
request = json.loads(request)
body = request["d"]
if cmd == 'group':
raise Exception("%s cmd not found" % cmd)
elif cmd == 'white_list':
ret = gw.create_whitelist(body['url'], body['md5'])
if ret:
LOG.info("white list create success")
resp_status = "ok"
resp_data = {"result": "ok"}
else:
raise Exception("white list create failed")
elif cmd == 'check_code':
gw.set_auth_key(body['check_code'])
resp_status = "ok"
resp_data = {"result": "ok"}
elif cmd == 'interval':
gw.set_interval_time(body['interval'])
resp_status = "ok"
resp_data = {"result": "ok"}
else:
raise Exception("%s cmd not found" % cmd)
except Exception as e:
LOG.error(e.__repr__())
resp_status = "err",
resp_data = {"msg": e.__str__()}
finally:
upload = uplink.Upload()
url = r'http://127.0.0.1:7788/mqtt/publish/offlinecache'
resp = {
"id": request.get('id'),
"from": request.get('from'),
"status": resp_status,
"command": request.get('command'),
"d": resp_data
}
data = {'topic': "dma/cmd/resp", 'payload': resp}
upload.send(url, data)
def set_task_monitor(self):
try:
task_status = self.get_task_status()
if task_status == '0':
return
start_time, end_time = self.get_task_time()
end_time = mktime(strptime(end_time, "%Y-%m-%d %H:%M:%S"))
cur_time = time()
task_id = self.get_task_id()
if task_status != '4' and (cur_time >
end_time + 60): # 结束1分钟之后没有收到结束信号就主动结束
LOG.info("task %s execute timeout", task_id)
self.set_task_status(task_id, '4')
self.report_task_status()
elif task_status == '4':
pass
else:
timer = threading.Timer(60, self.set_task_monitor)
timer.start()
except:
pass
def func(self, request):
try:
send_data = dict()
upload_data = None
device_id = request['device_id']
firmware = request.get('firmware', None)
data_id = request.get('data_id', "0")
interval = request.get('interval', None)
if firmware:
# 注册上报
LOG.info("%s register", device_id)
upload_data = {
"d": [{
"nid": device_id,
"d": {
"firmware": firmware
}
}]
}
topic = 'dma/report/periph/reg'
elif data_id:
# 心跳上报
# 准备上报数据
upload_data = {
"d": [{
"nid": device_id,
"d": {
"image_data_id": int(data_id),
"interval": request['interval'],
"battery": request['battery']
}
}]
}
topic = 'dma/report/periph'
ts = gw.get_task_status()
LOG.info("task status: %s", ts)
if ts in ('0', '4', '5'): # 没有任务或任务已结束
data = {
'nid': device_id,
'image_data_id': int(data_id),
# 'image_data_id': int(gw.get_data_id()),
'sn': gw.get_gw_id()
}
LOG.info("start query")
host, port = gw.get_server_url()
resp = self.query_task(
'http://{}/iotgw/api/v1/tasks/gwtasks/assign'.format(
host), data)
LOG.info("get response")
if resp:
# 应答成功，保存任务状态，下发时间，下载任务
if resp['status'] != 'ok':
raise Exception("get task error")
data = resp['data']
ret = gw.create_task(data['task_id'], data['image_data_id'], data['image_data_url'], \
data['image_data_md5'], data['iot_dev_list_md5'], data['iot_dev_list_url'], \
data['scheduled_start_time'], data['scheduled_end_time'])
if ret:
start_time, end_time = gw.get_task_time()
send_data['task_id'] = gw.get_task_id()
send_data['data_id'] = gw.get_data_id()
send_data['start_time'] = start_time
send_data['end_time'] = end_time
# 向serial发送任务开始命令
task_start = {
"cmd": "task",
"method": "create",
"task_id": send_data['task_id'],
"data_id": int(send_data['data_id']),
"start_time": send_data['start_time'],
"end_time": send_data['end_time']
}
ret = dl.send_service('serial',
task_start,
need_resp=True)
if ret['status'] != 'ok':
gw.set_try_data('serial', task_start)
# 添加待执行表
gw.create_pending_list()
gw.add_pending_list(device_id)
else:
# 创建失败上报
pass
else:
raise Exception("server no response")
elif ts in ('1', '2'):
ret = gw.is_in_executelist(device_id, data_id)
if ret:
start_time, end_time = gw.get_task_time()
send_data['task_id'] = gw.get_task_id()
send_data['data_id'] = int(gw.get_data_id())
send_data['start_time'] = start_time
send_data['end_time'] = end_time
gw.add_pending_list(device_id)
else:
# 其他情况处理
pass
# 更新唤醒周期
send_data['status'] = 'ok'
interval_time = gw.get_interval_time()
if interval_time != request['interval']:
send_data['interval'] = interval_time
else:
raise Exception("request param invalid")
except Exception as e:
send_data['status'] = 'error'
LOG.error(e.__repr__())
finally:
if upload_data:
self.upload(topic, upload_data)
return send_data
def post(self, cmd):
try:
request = self.request.body.decode('utf-8')
request = json.loads(request)
body = request['d']
if cmd == 'create':
ret = gw.create_task(body['task_id'], body['image_data_id'], body['image_data_url'], \
body['image_data_md5'], body['iot_dev_list_md5'], body['iot_dev_list_url'], \
body['start_time'], body['end_time'])
if ret:
data = {
"cmd": "task",
"method": "create",
"task_id": body['task_id'],
"data_id": body['image_data_id'],
"start_time": body['start_time'],
"end_time": body['end_time']
}
ret = dl.send_service('serial', data, need_resp=True)
if ret['status'] != 'ok':
gw.set_try_data('serial', data)
# raise HTTPError(200)
status = 'ok'
msg = "task_id %s create success" % body['task_id']
else:
# 不可创建任务
LOG.info("task could not create")
status = 'failed'
msg = "task_id %s create not allowed" % body['task_id']
# 上传命令处理结果
upload = uplink.Upload()
resp = {
"id": request['id'],
"from": request['from'],
"status": status,
"command": request['command'],
"d": {
"code": "task_status",
"msg": msg
}
}
# gw.get_task_status()
upload.send(resp, topic='dma/cmd/resp')
elif cmd == 'cancel':
# cancel task
data = {
"cmd": "task",
"method": "cancel",
"task_id": body['task_id']
}
ret = dl.send_service('serial', data, need_resp=True)
if ret['status'] != 'ok': # 向模块发出取消命令
gw.set_try_data('serial', data)
ret = gw.cancel_task(body['task_id'])
if ret:
status = 'ok'
result = {'result': 'ok'}
else:
status = 'err'
result = {'code': 'cancel_failed', 'msg': 'task not found'}
# 上传处理结果
upload = uplink.Upload()
resp = {
"id": request['id'],
"from": request['from'],
"status": status,
"command": request['command'],
"d": result
}
upload.send(resp, topic='dma/cmd/resp')
elif cmd == 'confirm':
# confirm task
data = {
"table_name":"sql",
"sql_cmd":"update `task` set (`start_time`='%s', `end_time`='%s', `status`=2) where `task_id`='%s';" % \
(body['start_time'], body['end_time'], body['task_id'])
}
dl.send_service('database', data)
else:
raise HTTPError(404)
except Exception as e:
self.write(e.__str__())
LOG.error("%s" % e.__str__())
#!/usr/bin/env python3
# from downlink import dl
# from task import task
import sys
import os
from epd_log import epdlog as LOG
version = '1.0.0'
if __name__ == "__main__":
with open('/etc/gateway/gwapp.version', 'w') as vfp:
vfp.write(version)
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
LOG.info('epd service start...')
from uplink import Uplink
uplinkHandler = Uplink()
uplinkHandler.begin()
uplinkHandler.end()
def begin(self):
LOG.info("sever host:%s port:%d", self.__host, self.__port)
self.listen(self.__port, self.__host)
tornado.ioloop.IOLoop.current(instance=False).start()
def stop_service(self):
LOG.info("downlink service stop")
self.server_close()
self.__thread.join()
def start_service(self):
LOG.info("downlink service start")
self.serve_forever()
def end(self):
LOG.info("server stop")
