def rule_picker(rule_id, formula_list):
triggers = get_formula_triggers(formula_list)
rule_on = False
rule_id_s = '%02d' % rule_id
triggers_dic = {trigger_id: False for trigger_id in triggers}
context = zmq.Context()
socket_rule = context.socket(zmq.PUB)
socket_rule.connect('tcp://localhost:' + str(Port.multi.value))
socket_trigger = context.socket(zmq.SUB)
socket_trigger.connect('tcp://localhost:' + str(Port.proxy.value))
for trigger_id in triggers:
trigger_id_s = '%02d' % trigger_id
socket_trigger.setsockopt(
zmq.SUBSCRIBE, Subscription.trigger.value + trigger_id_s.encode())
while True:
bdata = socket_trigger.recv()[1:]
trigger_id_s = bdata[:2].decode()
trigger_id = int(trigger_id_s)
trigger_val = bdata[2:3] == b'1'
triggers_dic[trigger_id] = trigger_val
rule_expr = get_expr(formula_list, triggers_dic)
rule_val = eval(rule_expr)
if rule_val != rule_on:
logger.info('rule triggered, rule_id:' + rule_id_s + ' rule val:' +
str(rule_val) + ' rule expr:' + rule_expr)
rule_on = rule_val
bin_message = Subscription.rule.value + rule_id_s.encode()
if rule_on:
bin_message += b'1'
else:
bin_message += b'0'
bin_message += bdata[-8:]
logger.debug('bin_message:' + str(bin_message))
socket_rule.send(bin_message)
def trigger(self, data):
if data.size >= self.nsta:
res1 = self.trigger(data[:self.nsta - 1])
res2 = self.trigger(data[self.nsta - 1:])
return np.append(res1, res2)
if self.buf.size > self.nlta:
decrement = self.buf[-self.nlta - 1]
else:
decrement = 0
self.buf = self.buf[-self.nlta:]
self.buf -= decrement
cum_sum = np.cumsum(data**2)
try:
next_sta = self.sta + \
((cum_sum + self.buf[-self.nsta - 1]) - self.buf[-self.nsta:-self.nsta + data.size]) / self.nsta
except Exception as ex:
logger.debug('buf size:' + str(self.buf.size))
raise ex
next_lta = self.lta + (
cum_sum - self.buf[-self.nlta:-self.nlta + data.size]) / self.nlta
self.sta = next_sta[-1]
self.lta = next_lta[-1]
self.buf = np.append(self.buf, cum_sum + self.buf[-1])
#logger.debug('\nsta:' + str(self.sta[-data.size:])) # + '\nlta:' + str(self.lta[-data.size:]))
return next_sta / next_lta
def __init__(self, nsta, nlta):
if nlta <= nsta:
raise Exception('incorrect nlta:' + str(nlta) + ' nsta:' +
str(nsta))
self.nsta = nsta
self.nlta = nlta
# print('nlta:' + str(nlta))
self.lta = .0
self.sta = .0
self.buf = np.require(np.zeros(nlta), dtype='float')
logger.debug('buf size:' + str(self.buf.size))
def do_GET(self):
if self.path == "/":
self.path = "/index.html"
try:
# Check the file extension required and
# set the right mime type
sendReply = False
if self.path.endswith(".html"):
logger.debug('do get, html, self.path:' + self.path)
mimetype = 'text/html'
sendReply = True
if self.path.endswith(".jpg"):
mimetype = 'image/jpg'
sendReply = True
if self.path.endswith(".gif"):
mimetype = 'image/gif'
sendReply = True
if self.path.endswith(".js"):
mimetype = 'application/javascript'
sendReply = True
if self.path.endswith(".css"):
mimetype = 'text/css'
sendReply = True
if sendReply:
# Open the static file requested and send it
if mimetype == 'image/jpg':
f = open(curdir + sep + self.path, 'rb')
else:
f = open(curdir + sep + self.path)
self.send_response(200)
self.send_header('Content-type', mimetype)
self.end_headers()
if mimetype == 'image/jpg':
self.wfile.write(f.read())
else:
self.wfile.write(f.read().encode())
f.close()
return
except IOError:
self.send_error(404, 'File Not Found: %s' % self.path)
def pick(self, starttime, data):
if self.filter:
try:
data = self.filter.bandpass(data)
except Exception as ex:
logger.error(str(ex) + '\ndisable filter')
self.filter = None
trigger_data = self.data_trigger.trigger(data)
if self.init_level >= self.stop_level:
activ_data = trigger_data > self.init_level
deactiv_data = trigger_data < self.stop_level
else:
activ_data = trigger_data < self.init_level
deactiv_data = trigger_data > self.stop_level
date_time = starttime
message_start = Subscription.trigger.value + self.trigger_index_s
while True:
if self.trigger_on:
seek_ar = np.where(deactiv_data)[0]
else:
seek_ar = np.where(activ_data)[0]
#logger.debug(f'trigger off, seek_ar:{seek_ar}')
if seek_ar.size == 0:
break
offset = seek_ar[0]
activ_data = activ_data[offset:]
deactiv_data = deactiv_data[offset:]
date_time += offset / self.sampling_rate
self.trigger_on = not self.trigger_on
if self.trigger_on:
btrig = b'1'
else:
btrig = b'0'
logger.debug('triggered, trigger id:' + str(self.trigger_index_s) +
' ' + str(btrig))
self.socket_trigger.send(
message_start + btrig +
date_time._ns.to_bytes(8, byteorder='big'))
def resend(conn_str, rules, pem, pet):
context = zmq.Context()
socket_sub = context.socket(zmq.SUB)
conn_str_sub = 'tcp://localhost:' + str(Port.proxy.value)
socket_sub.connect(conn_str_sub)
socket_sub.setsockopt(zmq.SUBSCRIBE, Subscription.parameters.value)
socket_sub.setsockopt(zmq.SUBSCRIBE, Subscription.signal.value)
socket_confirm = context.socket(zmq.PUB)
socket_confirm.connect('tcp://localhost:' + str(Port.multi.value))
str_parts = conn_str.split(':')[-2:]
host = ''
port = int(str_parts[-1])
print('port:', port)
logger.debug('create stream_server, host:%s, port %d' % (host, port))
stream_server = None
socket_rule = context.socket(zmq.SUB)
socket_rule.connect(conn_str_sub)
socket_rule.setsockopt(zmq.SUBSCRIBE, Subscription.test.value + b'03')
for rule_index in rules:
rule_index_s = '%02d' % rule_index
socket_rule.setsockopt(zmq.SUBSCRIBE,
Subscription.rule.value + rule_index_s.encode())
trigger = 0
buf = []
pet_time = UTCDateTime(0)
while True:
#logger.debug('resender loop')
try:
bin_data = socket_rule.recv(zmq.NOBLOCK)
test = bin_data[:1] == Subscription.test.value
if test:
logger.debug('test rule event')
trigger_data = b'0'
if buf:
trigger_time, _ = buf[-1]
else:
trigger_time = None
else:
logger.debug('rule event')
trigger_data = bin_data[3:4]
trigger_time = UTCDateTime(
int.from_bytes(bin_data[-8:], byteorder='big') / 10**9)
if test:
if trigger == 0:
logger.info('detrigger test event')
if trigger_time:
pet_time = trigger_time + pet
else:
pet_time = None
else:
logger.debug('trigger_data:' + str(trigger_data))
if trigger_data == b'1':
trigger += 1
if buf:
logger.info('buf item dt:' + str(buf[0][0]))
else:
logger.debug('inner detriggering')
if trigger > 0:
logger.debug('decrement trigger counter')
trigger -= 1
else:
logger.warning('unexpected detriggering')
if trigger == 1 and not test:
logger.info('triggered\ntrigger time:' + str(trigger_time) +
'\npem time:' + str(trigger_time - pem) +
'\ntrigger:' + str(bin_data[1:3]))
if trigger == 0:
logger.info('detriggered , test:' + str(test) +
'\ndetrigger time:' + str(trigger_time) +
'\npet time:' + str(trigger_time + pet) +
'\ntrigger:' + str(bin_data[1:3]))
if not buf:
logger.warning('buf is empty')
logger.debug('trigger:' + str(trigger))
except zmq.ZMQError:
pass
socket_confirm.send(Subscription.confirm.value + b'1')
if not socket_sub.poll(3000):
logger.info('no signal or params data')
continue
raw_data = socket_sub.recv()
#print('raw_data recvd:' + str(raw_data))
subscription = raw_data[0]
if subscription != 1:
logger.debug('subscription:' + str(raw_data[0]))
if raw_data[:1] == Subscription.parameters.value:
logger.debug('parameters received in resender')
#exit(1)
init_packet = json.loads(raw_data[1:].decode())
if stream_server is None:
stream_server = NJSP_STREAMSERVER((host, port), init_packet)
stream_name = list(init_packet['parameters']['streams'].keys())[0]
if stream_name not in \
stream_server.init_packet['parameters']['streams']:
stream_server.init_packet['parameters']['streams'][stream_name] = \
init_packet['parameters']['streams'][stream_name]
stream_server.load_init_packet(stream_server.init_packet)
stream_server.init_data = stream_server.NJSP_PROTOCOL_IDENTIFIER + \
stream_server.encode_hdr_and_json(stream_server.init_packet)
continue
resent_data = raw_data[1:]
custom_header = CustomHeader()
header_size = sizeof(CustomHeader)
BytesIO(resent_data[:header_size]).readinto(custom_header)
#memmove(addressof(custom_header), resent_data[:header_size], header_size)
# logger.debug('custom header received:' + str(custom_header))
dt = UTCDateTime(custom_header.ns / 10**9)
#logger.debug('dt:' + str(dt))
# logger.debug('wait binary data')
bdata = resent_data[header_size:]
json_data = json.loads(bdata.decode())
streams = json_data['streams']
stream_name = list(streams.keys())[0]
data_dic = streams[stream_name]['samples']
for ch in data_dic:
ch_data = data_dic[ch]
data_dic[ch] = base64.decodebytes(ch_data.encode())
# logger.debug('binary data received')
#logger.debug('dt:' + str(UTCDateTime(dt)) + ' bdata len:' + str(len(bdata)))
if not pet_time or trigger:
#logger.debug('pet time is None')
pet_time = dt + pet
if dt < pet_time or trigger:
#logger.debug('dt:' + str(dt) + ', pet time:' + str(pet_time) + ', trigger:' + str(trigger))
# if buf:
# logger.debug('clear buf, trigger:' + str(trigger))
while buf:
logger.debug('send data to output from buf, dt:' +
str(buf[0][0]))
if stream_server:
logger.debug('broadcast_data...')
stream_server.broadcast_data(buf[0][1])
else:
logger.debug('stream_server:' + str(stream_server))
#stream_server.send(buf[0][1])
# logger.debug('buf item dt:' + str(buf[0][0]))
buf = buf[1:]
logger.debug('send regular data, dt' + str(dt))
#logger.debug('send data to output')
if stream_server:
logger.debug('broadcast_data...')
stream_server.broadcast_data(json_data)
else:
logger.debug('stream_server:' + str(stream_server))
else:
#logger.debug('append to buf with dt:' + str(dt))
buf.append((dt, json_data))
if buf:
#logger.debug('buf start:' + str(buf[0][0]))
dt_begin = buf[0][0]
while dt_begin < dt - pem and buf[3:]:
# logger.debug('delete from buf with dt:' + str(buf[0][0]) + '\ncurrent pem:' +
# str(dt-pem) + '\ncurrent buf:' + str(buf[0][0]) + '-' + str(buf[-1][0]))
buf = buf[1:]
dt_begin = buf[0][0]
def do_POST(self):
# logger.debug('inside post')
# logger.debug(self.path)
content_length = int(
self.headers['Content-Length']) # <--- Gets the size of data
post_data = self.rfile.read(
content_length) # <--- Gets the data itself
post_data_str = post_data.decode()
#print(f'{UTCDateTime()} POST {post_data_str}')
if self.path == '/initTrigger':
stations_dic = getSources()
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
self.wfile.write(json.dumps(stations_dic).encode())
if self.path == '/trigger':
# logging.info('json_map:' + str(json_map))
json_dic = json.loads(post_data_str)
session_id = json_dic['sessionId']
# logger.debug('session id:' + str(session_id))
json_triggers = json_dic['triggers']
sockets_trigger = get_sockets_data(session_id)
json_map = post_triggers(json_triggers, sockets_trigger)
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
self.wfile.write(json.dumps(json_map).encode())
if self.path == '/rule':
json_dic = json.loads(post_data_str)
session_id = json_dic['sessionId']
# logger.debug('session id:' + str(session_id))
json_triggers = json_dic['triggers']
sockets_trigger = get_sockets_data(session_id)
json_map = post_triggers(json_triggers, sockets_trigger)
sockets_rule = get_rule_sockets(session_id)
rules_dic = json_dic['rules']
rules_dic = update_rules(rules_dic, sockets_rule)
json_map['rules'] = rules_dic
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
self.wfile.write(json.dumps(json_map).encode())
if self.path == '/initRule':
params_list = getTriggerParams()
logger.debug('params_list:' + str(params_list))
trigger_dic = {
params['ind']: params['name']
for params in params_list
}
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
# print('trigger ids' + str(trigger_ids))
json_dic = {
'triggers': trigger_dic,
'actions': action_names_dic0.copy()
}
actions_dic = getActions()
logger.debug('getActions:' + str(actions_dic))
sms_dic = actions_dic.get('sms', {})
sms_dic = {
sms_id: sms_dic[sms_id]['name']
for sms_id in sms_dic
}
logger.debug('sms_dic:' + str(sms_dic) + ' json_dic:' +
str(json_dic))
json_dic['actions'].update(sms_dic)
logger.debug('actions_dic:' + str(json_dic['actions']))
self.wfile.write(json.dumps(json_dic).encode())
if self.path == '/apply':
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
self.wfile.write(json.dumps({'apply': 1}).encode())
if self.path == '/applyRules':
json_dic = json.loads(post_data_str)
session_id = json_dic['sessionId']
html = json_dic['html']
save_rules(html)
sockets_rule = get_rule_sockets(session_id)
apply_sockets_rule(conn_str_sub, context, sockets_rule)
socket_backend.send(b'AP')
if self.path == '/save':
json_dic = json.loads(post_data_str)
session_id = json_dic['sessionId']
html = json_dic['html']
save_triggers(html)
sockets_trigger = get_sockets_data(session_id)
update_triggers_sockets(conn_str_sub, context, sockets_trigger)
socket_backend.send(b'AP')
if self.path == '/saveSources':
save_sources(post_data_str)
socket_backend.send(b'AP')
if self.path == '/applyActions':
save_actions(post_data_str)
socket_backend.send(b'AP')
if self.path == '/testActions':
test_dic = json.loads(post_data_str)
ids = test_dic['ids']
for action_id in ids:
action_id_s = '%02d' % action_id
bin_message = Subscription.test.value + action_id_s.encode(
)
# if action_id in [1, 2]:
# if test_dic['relay' + str(action_id)]:
# bin_message += b'1'
# else:
# bin_message += b'0'
# else:
# bin_message += b'1'
logger.info('send bin_message:' + str(bin_message))
socket_test.send(bin_message)
# print('actions test:' + str(ids))
if self.path == '/load':
print('load')