291 lines
8.8 KiB
Python
Executable File
291 lines
8.8 KiB
Python
Executable File
from gevent import monkey
|
|
monkey.patch_all()
|
|
import sys
|
|
import time
|
|
import signal
|
|
import socket
|
|
import traceback
|
|
import logging
|
|
import json
|
|
import gevent
|
|
import gevent.pywsgi
|
|
import gevent.queue
|
|
import flask
|
|
import circularlog
|
|
|
|
|
|
def guess_mimetype(filename):
|
|
if filename.endswith('.js'):
|
|
mimetype = 'text/javascript'
|
|
elif filename.endswith('.css'):
|
|
mimetype = 'text/css'
|
|
elif filename.endswith('.ico'):
|
|
mimetype = 'image/x-icon'
|
|
elif filename.endswith(".png"):
|
|
mimetype = "image/png"
|
|
else:
|
|
mimetype = 'text/html'
|
|
return mimetype
|
|
|
|
|
|
class MyEncoder(json.JSONEncoder):
|
|
def default(self, obj):
|
|
try:
|
|
return super().default(obj)
|
|
except TypeError:
|
|
return int(obj) # try to convert SECoP Enum
|
|
|
|
|
|
# SSE 'protocol' is described here: https://bit.ly/UPFyxY
|
|
def to_json_sse(msg):
|
|
txt = json.dumps(msg, separators=(',', ': '), cls=MyEncoder)
|
|
logging.debug('data: %s', txt)
|
|
return 'data: %s\n\n' % txt
|
|
|
|
|
|
instrument = None
|
|
app = flask.Flask(__name__)
|
|
|
|
update_rider = circularlog.Rider("upd")
|
|
pollinterval = 0.2
|
|
|
|
|
|
@app.route('/update')
|
|
def get_update(path=None):
|
|
# Client Adress: socket.getfqdn(flask.request.remote_addr)
|
|
client = instrument.new_client()
|
|
client.remote_info = circularlog.strtm() + " " + socket.getfqdn(flask.request.remote_addr.split(':')[-1])
|
|
|
|
@flask.stream_with_context
|
|
def generator():
|
|
logging.info('UPDATE %s %s', client.id, socket.getfqdn(flask.request.remote_addr.split(':')[-1]))
|
|
# msg = dict(type='id', id=client.id, title=instrument.title);
|
|
# yield to_json_sse(msg)
|
|
msg = dict(type='id', id=client.id, instrument=instrument.title, device=instrument.device)
|
|
yield to_json_sse(msg)
|
|
try:
|
|
lastmsg = time.time()
|
|
while True:
|
|
if client.info() == "":
|
|
print(time.time()-lastmsg)
|
|
messages = client.poll()
|
|
for msg in messages:
|
|
update_rider.put('-', repr(msg))
|
|
yield to_json_sse(msg)
|
|
if messages:
|
|
lastmsg = time.time()
|
|
else:
|
|
if time.time() > lastmsg + 30:
|
|
if not client.info():
|
|
raise GeneratorExit("no activity")
|
|
logging.info('HEARTBEAT %s (%s)', client.id, "; ".join(client.info()))
|
|
yield to_json_sse(dict(type='heartbeat'))
|
|
lastmsg = time.time()
|
|
else:
|
|
gevent.sleep(pollinterval)
|
|
except GeneratorExit as e:
|
|
logging.info("except clause %r", repr(e))
|
|
logging.info('CLOSED %s', client.id)
|
|
print('CLOSE client')
|
|
instrument.remove(client)
|
|
pass
|
|
except Exception as e:
|
|
logging.info('error')
|
|
logging.error('%s', traceback.format_exc())
|
|
instrument.remove(client)
|
|
# msg = dict(type='error',error=traceback.format_exc())
|
|
# yield to_json_sse(msg)
|
|
|
|
resp = flask.Response(generator(), mimetype='text/event-stream')
|
|
resp.headers['Access-Control-Allow-Origin'] = '*'
|
|
return resp
|
|
|
|
|
|
@app.route('/circular')
|
|
def dump_circular():
|
|
circularlog.log()
|
|
return "log"
|
|
|
|
|
|
@app.route('/clients')
|
|
def show_clients():
|
|
result = ""
|
|
for id in instrument.clients:
|
|
c = instrument.clients[id]
|
|
result += c.remote_info + " " + "; ".join(c.info()) + "<br>"
|
|
return result
|
|
|
|
|
|
@app.route('/export')
|
|
def export():
|
|
args = flask.request.args
|
|
kwargs = dict((k, args.get(k)) for k in args)
|
|
path = flask.request.path
|
|
logging.info('GET %s %s', path, repr(kwargs))
|
|
try:
|
|
id = kwargs.pop('id')
|
|
print('export')
|
|
client = instrument.clients[id]
|
|
bytes = client.w_export(**kwargs)
|
|
return flask.send_file(
|
|
bytes,
|
|
as_attachment=True,
|
|
download_name='export.tsv',
|
|
mimetype='text/tab-separated-values'
|
|
)
|
|
|
|
except Exception as e:
|
|
logging.error('%s', traceback.format_exc())
|
|
circularlog.log()
|
|
msg = dict(type='error', request=path[1:], error=repr(e))
|
|
logging.error('MSG: %r', msg)
|
|
resp = flask.Response(json.dumps(msg), mimetype='application/json')
|
|
resp.headers['Access-Control-Allow-Origin'] = '*'
|
|
return resp
|
|
|
|
|
|
@app.route('/getblock')
|
|
@app.route('/updateblock')
|
|
@app.route('/sendcommand')
|
|
@app.route('/console')
|
|
@app.route('/graph')
|
|
@app.route('/updategraph')
|
|
@app.route('/gettime')
|
|
@app.route('/getvars', methods=["GET", "POST"])
|
|
def reply():
|
|
args = flask.request.values
|
|
kwargs = dict((k, args.get(k)) for k in args)
|
|
path = flask.request.path
|
|
logging.info('GET %s %r', path, kwargs)
|
|
try:
|
|
id = kwargs.pop('id')
|
|
client = instrument.clients[id]
|
|
msg = getattr(client, "w_" + path[1:])(**kwargs)
|
|
except Exception as e:
|
|
logging.error('%s', traceback.format_exc())
|
|
circularlog.log()
|
|
msg = dict(type='error', request=path[1:], error=repr(e))
|
|
jsonmsg = json.dumps(msg)
|
|
if len(jsonmsg) < 120:
|
|
logging.info('REPLY %s %s', path, jsonmsg)
|
|
else:
|
|
logging.info('REPLY %s %s...', path, jsonmsg[:80])
|
|
logging.debug('REPLY %s %r', path, jsonmsg)
|
|
resp = flask.Response(jsonmsg, mimetype='application/json')
|
|
resp.headers['Access-Control-Allow-Origin'] = '*'
|
|
return resp
|
|
|
|
|
|
@app.route('/test/<file>')
|
|
def subdir_test_file(file):
|
|
gevent.sleep(2)
|
|
resp = flask.send_file("client/test/"+file, mimetype=guess_mimetype(file))
|
|
return resp
|
|
|
|
|
|
@app.route('/components/curves_settings_popup/color_selector/<file>')
|
|
@app.route('/components/curves_settings_popup/<file>')
|
|
@app.route('/components/action_entry/<file>')
|
|
@app.route('/components/export_popup/<file>')
|
|
@app.route('/components/dates_popup/<file>')
|
|
@app.route('/components/menu_popup/<file>')
|
|
@app.route('/components/help_popup/<file>')
|
|
@app.route('/components/help_entry/<file>')
|
|
@app.route('/components/control/<file>')
|
|
@app.route('/components/divider/<file>')
|
|
@app.route('/components/states_indicator/dates/<file>')
|
|
@app.route('/res/<file>')
|
|
@app.route('/jsFiles/<file>')
|
|
@app.route('/cssFiles/<file>')
|
|
@app.route('/externalFiles/<file>')
|
|
def subdir_file(file):
|
|
subdir = "/".join(flask.request.path.split("/")[1:-1])
|
|
resp = flask.send_file("client/" + subdir+"/"+file, mimetype=guess_mimetype(file))
|
|
# resp.headers['Content-Security-Policy'] = "sandbox; script-src 'unsafe-inline';"
|
|
return resp
|
|
|
|
|
|
@app.route('/externalFiles/maps/<file>.map')
|
|
def replace_by_empty(file):
|
|
return ""
|
|
|
|
|
|
@app.route('/')
|
|
def main():
|
|
return general_file('SEAWebClient.html')
|
|
|
|
|
|
@app.route('/select')
|
|
def default():
|
|
out = ['''<html><body><table>
|
|
<style>
|
|
th {
|
|
text-align: left;
|
|
}
|
|
</style>
|
|
<tr><th>Instrument</th><th colspan=99>Devices</th></tr>''']
|
|
result = {}
|
|
for stream, tags in instrument.get_stream_tags().items():
|
|
ins = tags.get('instrument', '0')
|
|
result.setdefault(ins, []).append((stream, tags.get('device')))
|
|
bare_streams = result.pop('0', [])
|
|
for ins, streams in result.items():
|
|
out.append(f'<tr><td><a href="/?ins={ins}">{ins}</a></td>')
|
|
out.extend(f'<td>{d or s}</td>' for s, d in streams)
|
|
out.append('</tr>')
|
|
for stream, device in bare_streams:
|
|
out.append(f'<tr><td><a href="/?srv={stream}">{stream}</a></td><td>{device}</td><tr>')
|
|
out.extend(['</table></body?</html>', ''])
|
|
return '\n'.join(out)
|
|
|
|
|
|
@app.route('/<file>')
|
|
def general_file(file):
|
|
subdir = "client/"
|
|
try:
|
|
resp = flask.send_file(subdir+file, mimetype=guess_mimetype(file))
|
|
except FileNotFoundError:
|
|
logging.warning('file %s not found', file)
|
|
return 'file not found'
|
|
# resp.headers['Content-Security-Policy'] = "sandbox; script-src 'unsafe-inline';"
|
|
return resp
|
|
|
|
|
|
def hostport_split(hostport):
|
|
h = hostport.split(':')
|
|
return (h[0], int(h[1]))
|
|
|
|
|
|
# def handle_pdb(sig, frame):
|
|
# import pdb
|
|
# print('PDB')
|
|
# pdb.Pdb().set_trace(frame)
|
|
|
|
|
|
def main(cls, **config):
|
|
global instrument
|
|
if not config:
|
|
for arg in sys.argv[1:]:
|
|
key, _, value = arg.partition('=')
|
|
config[key] = value
|
|
port = int(config['port'])
|
|
inst_name = config['instrument']
|
|
instrument = cls(inst_name, config)
|
|
|
|
# signal.signal(signal.SIGUSR1, handle_pdb)
|
|
|
|
def handle_term(sig, _):
|
|
server.stop()
|
|
server.close()
|
|
|
|
signal.signal(signal.SIGTERM, handle_term)
|
|
|
|
app.debug = True
|
|
|
|
logging.basicConfig(filename='log/%s.log' % inst_name, filemode='w', level=logging.INFO,
|
|
format='%(asctime)s %(levelname)s %(message)s')
|
|
|
|
#server = gevent.wsgi.WSGIServer(('', port), app, keyfile='key.key', certfile='key.crt')
|
|
server = gevent.pywsgi.WSGIServer(('', port), app, log=logging.getLogger('server'))
|
|
server.serve_forever()
|