[update] update Dockerfile

- mojor update of Dockerfile
- reverted location of simulate_fail.json file for simulating errors, e.g. to test sending e-mails

Dockerfile

@@ -1,11 +1,38 @@
 FROM python:3
 
-WORKDIR /usr/src/app
+# metadata
+LABEL maintainer="Kasper D. Fischer <kasper.fischer@rub.de>"
+LABEL version="0.2-docker"
+LABEL description="Docker image for the survBot application"
 
-COPY requirements.txt ./
-RUN pip install --no-cache-dir -r requirements.txt
+# install required system packages
 RUN apt update && apt install -y bind9-host iputils-ping
 
-COPY . .
+# create user and group
+RUN groupadd -r survBot && useradd -r -g survBot survBot
 
+# change working directory
+WORKDIR /usr/src/app
+
+# install required python packages
+RUN --mount=type=bind,source=requirements.txt,target=/tmp/requirements.txt \
+    pip install --no-cache-dir --requirement /tmp/requirements.txt
+
+# switch to user survBot
+USER survBot
+
+# copy application files
+COPY survBot.py utils.py write_utils.py LICENSE README.md ./
+
+# copy configuration files
+VOLUME /usr/src/app/conf
+COPY parameters.yaml mailing_list.yaml simulate_fail.json conf/
+RUN ln -s conf/simulate_fail.json simulate_fail.json
+
+# copy www files
+VOLUME /usr/src/app/www
+COPY logo.png stylesheets/desktop.css stylesheets/mobile.css www/
+RUN ln -s www/index.html survBot_out.html
+
+# run the application
 CMD [ "python", "./survBot.py", "-html", "www", "-parfile", "conf/parameters.yaml" ]

survBot.py

@@ -704,7 +704,7 @@ class StationQC(object):
             return 'active'
         return False
 
-    def _simulated_error_check(self, key, fname='conf/simulate_fail.json'):
+    def _simulated_error_check(self, key, fname='simulate_fail.json'):
         if not os.path.isfile(fname):
             return
         with open(fname) as fid:

survBotGUI.py

@@ -0,0 +1,441 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+GUI overlay for the main survBot to show quality control of different stations specified in parameters.yaml file.
+"""
+
+__version__ = '0.1'
+__author__ = 'Marcel Paffrath'
+
+import os
+import sys
+import traceback
+
+import logging
+
+try:
+    from PySide2 import QtGui, QtCore, QtWidgets
+except ImportError:
+    try:
+        from PySide6 import QtGui, QtCore, QtWidgets
+    except ImportError:
+        try:
+            from PyQt5 import QtGui, QtCore, QtWidgets
+        except ImportError:
+            raise ImportError('Could import neither of PySide2, PySide6 or PyQt5')
+
+from matplotlib.figure import Figure
+
+if QtGui.__package__ in ['PySide2', 'PyQt5', 'PySide6']:
+    from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+    from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT
+else:
+    raise Exception('Not implemented')
+
+from obspy import UTCDateTime
+
+from survBot import SurveillanceBot
+from write_utils import *
+from utils import get_bg_color, modify_stream_for_plot, set_axis_yticks, set_axis_color, plot_axis_thresholds
+
+try:
+    from rest_api.utils import get_station_iccid
+    from rest_api.rest_api_utils import get_last_messages, send_message, get_default_params
+    sms_funcs = True
+except ImportError:
+    logging.warning('Could not load rest_api utils, SMS functionality disabled.')
+    sms_funcs = False
+
+deg_str = '\N{DEGREE SIGN}C'
+
+
+class Thread(QtCore.QThread):
+    """
+    A simple thread that runs outside of the main event loop. Executes the function "runnable" and prevents
+    freezing of the GUI. Run method is executed outside main event loop when called with thread.start().
+    """
+    update = QtCore.Signal()
+
+    def __init__(self, parent, runnable):
+        super(Thread, self).__init__(parent=parent)
+        self.setParent(parent)
+        self.runnable = runnable
+        self.is_active = True
+
+    def run(self):
+        """ Try to run self.runnable and emit update signal, or print Exception if failed. """
+        try:
+            t0 = UTCDateTime()
+            self.runnable()
+            self.update.emit()
+        except Exception as e:
+            self.is_active = False
+            logging.error(e)
+            logging.debug(traceback.format_exc())
+        finally:
+            logging.info(f'Time for Thread execution: {UTCDateTime() - t0}')
+
+
+class MainWindow(QtWidgets.QMainWindow):
+    def __init__(self, parameters='parameters.yaml'):
+        """
+        Main window of survBot GUI.
+        :param parameters: Parameters dictionary file (yaml format)
+        """
+        super(MainWindow, self).__init__()
+
+        # init some attributes
+        self.last_mouse_loc = None
+        self.status_message = ''
+        self.starttime = UTCDateTime()
+
+        # setup main layout of the GUI
+        self.main_layout = QtWidgets.QVBoxLayout()
+        self.centralWidget = QtWidgets.QWidget()
+        self.centralWidget.setLayout(self.main_layout)
+        self.setCentralWidget(self.centralWidget)
+
+        # init new survBot instance, set parameters and refresh
+        self.survBot = SurveillanceBot(parameter_path=parameters)
+        self.parameters = self.survBot.parameters
+        self.refresh_period = self.parameters.get('interval')
+        self.dt_thresh = [int(val) for val in self.parameters.get('dt_thresh')]
+
+        # create thread that is used to update
+        self.thread = Thread(parent=self, runnable=self.survBot.execute_qc)
+        self.thread.update.connect(self.fill_table)
+
+        self.init_table()
+        self.init_buttons()
+
+        # These filters were used to track current mouse position if an event (i.e. mouseclick) is triggered
+        self.table.installEventFilter(self)
+        self.installEventFilter(self)
+
+        # initiate clear_on_refresh flag and set status bar text
+        self.clear_on_refresh = False
+        self.fill_status_bar()
+
+        # start thread that executes qc at first initiation, then activate timer for further thread activation
+        self.thread.start()
+        self.run_refresh_timer()
+
+    def init_table(self):
+        self.table = QtWidgets.QTableWidget()
+        keys = self.survBot.keys
+        station_list = self.survBot.station_list
+
+        self.table.setColumnCount(len(keys))
+        self.table.setRowCount(len(station_list))
+        self.table.setHorizontalHeaderLabels(keys)
+
+        for index, nwst_id in enumerate(station_list):
+            item = QtWidgets.QTableWidgetItem()
+            item.setText(str(nwst_id.rstrip('.')))
+            item.setData(QtCore.Qt.UserRole, nwst_id)
+            self.table.setVerticalHeaderItem(index, item)
+
+        self.main_layout.addWidget(self.table)
+
+        self.table.itemDoubleClicked.connect(self.plot_stream)
+        self.table.setEditTriggers(QtWidgets.QTableWidget.NoEditTriggers)
+
+        if sms_funcs:
+            self.table.verticalHeader().sectionClicked.connect(self.sms_context_menu)
+
+        self.set_stretch()
+
+    def init_buttons(self):
+        if self.parameters.get('track_changes'):
+            button_text = 'Clear track and refresh'
+        else:
+            button_text = 'Refresh'
+        self.clear_button = QtWidgets.QPushButton(button_text)
+        self.clear_button.setToolTip('Reset track changes and refresh table')
+        self.clear_button.clicked.connect(self.refresh)
+        self.main_layout.addWidget(self.clear_button)
+
+    def refresh(self):
+        self.set_clear_on_refresh()
+        self.run_refresh_timer()
+        self.thread.start()
+
+    def run_refresh_timer(self):
+        self.timer = QtCore.QTimer()
+        self.timer.timeout.connect(self.thread.start)
+        self.timer.start(int(self.refresh_period * 1e3))
+
+    def eventFilter(self, object, event):
+        """
+        An event filter that stores last mouse position if an event is raised by the table. All events are passed
+        to the parent class of the Mainwindow afterwards.
+        """
+        if hasattr(event, 'pos'):
+            self.last_mouse_loc = event.pos()
+        return super(QtWidgets.QMainWindow, self).eventFilter(object, event)
+
+    def sms_context_menu(self, row_ind):
+        """ Open a context menu when left-clicking vertical header item """
+        header_item = self.table.verticalHeaderItem(row_ind)
+        if not header_item:
+           return
+        nwst_id = header_item.data(QtCore.Qt.UserRole)
+
+        context_menu = QtWidgets.QMenu()
+        read_sms = context_menu.addAction('Get last SMS')
+        send_sms = context_menu.addAction('Send SMS')
+        action = context_menu.exec_(self.mapToGlobal(self.last_mouse_loc))
+        if action == read_sms:
+           self.read_sms(nwst_id)
+        elif action == send_sms:
+           self.send_sms(nwst_id)
+
+    def read_sms(self, nwst_id):
+        """ Read recent SMS over rest_api using whereversim portal """
+        station = nwst_id.split('.')[1]
+        iccid = get_station_iccid(station)
+        if not iccid:
+            logging.info(f'Could not find iccid for station: {nwst_id}')
+            return
+        sms_widget = ReadSMSWidget(parent=self, iccid=iccid)
+        sms_widget.setWindowTitle(f'Recent SMS of station: {nwst_id}')
+        if sms_widget.data:
+            sms_widget.show()
+        else:
+            self.notification('No recent messages found.')
+
+    def send_sms(self, nwst_id):
+        """ Send SMS over rest_api using whereversim portal """
+        station = nwst_id.split('.')[1]
+        iccid = get_station_iccid(station)
+
+        sms_widget = SendSMSWidget(parent=self, iccid=iccid)
+        sms_widget.setWindowTitle(f'Send SMS to station: {nwst_id}')
+        sms_widget.show()
+
+    def set_clear_on_refresh(self):
+        self.clear_on_refresh = True
+
+    def fill_status_bar(self):
+        """ Set status bar text """
+        self.status_message = self.survBot.status_message
+        status_bar = self.statusBar()
+        status_bar.showMessage(self.status_message)
+
+    def fill_table(self):
+        """ Fills the table with most recent information. Executed after execute_qc thread is done or on refresh. """
+
+        # fill status bar first with new time
+        self.fill_status_bar()
+
+        for col_ind, check_key in enumerate(self.survBot.keys):
+            for row_ind, nwst_id in enumerate(self.survBot.station_list):
+                status_dict = self.survBot.analysis_results.get(nwst_id)
+                status = status_dict.get(check_key)
+                message, detailed_message = status.get_status_str()
+
+                dt_thresh = [timedelta(seconds=sec) for sec in self.dt_thresh]
+                bg_color = get_bg_color(check_key, status, dt_thresh)
+                if check_key == 'temp':
+                    if not type(message) in [str]:
+                        message = str(message) + deg_str
+
+                # Continue if nothing changed
+                text = str(message)
+                cur_item = self.table.item(row_ind, col_ind)
+                if cur_item and text == cur_item.text():
+                    if not self.parameters.get('track_changes') or self.clear_on_refresh:
+                        # set item to default color/font and continue
+                        self.set_font(cur_item)
+                        self.set_fg_color(cur_item)
+                    continue
+
+                # Create new data item
+                item = QtWidgets.QTableWidgetItem()
+                item.setText(str(message))
+                item.setTextAlignment(QtCore.Qt.AlignCenter)
+                item.setData(QtCore.Qt.UserRole, (nwst_id, check_key))
+
+                # if text changed (known from above) set highlight color/font else (new init) set to default
+                cur_item = self.table.item(row_ind, col_ind)
+                if cur_item and check_key != 'last active':
+                    self.set_fg_color(item, (0, 0, 0, 255))
+                    self.set_font_bold(item)
+                else:
+                    self.set_fg_color(item)
+                    self.set_font(item)
+
+                # set item tooltip
+                if detailed_message:
+                    item.setToolTip(str(detailed_message))
+
+                # set bg color corresponding to current text (OK/WARN/ERROR etc.)
+                self.set_bg_color(item, bg_color)
+
+                # insert new item
+                self.table.setItem(row_ind, col_ind, item)
+
+        # table filling/refreshing done, set clear_on_refresh to False
+        self.clear_on_refresh = False
+
+    def set_font_bold(self, item):
+        """ Set item font bold """
+        f = item.font()
+        f.setWeight(QtGui.QFont.Bold)
+        item.setFont(f)
+
+    def set_font(self, item):
+        """ Set item font normal """
+        f = item.font()
+        f.setWeight(QtGui.QFont.Normal)
+        item.setFont(f)
+
+    def set_bg_color(self, item, color):
+        """ Set background color of item, color is RGBA tuple """
+        color = QtGui.QColor(*color)
+        item.setBackground(color)
+
+    def set_fg_color(self, item, color=(20, 20, 20, 255)):
+        """ Set foreground (font) color of item, color is RGBA tuple """
+        color = QtGui.QColor(*color)
+        item.setForeground(color)
+
+    def set_stretch(self):
+        hheader = self.table.horizontalHeader()
+        for index in range(hheader.count()):
+            hheader.setSectionResizeMode(index, QtWidgets.QHeaderView.Stretch)
+        vheader = self.table.verticalHeader()
+        for index in range(vheader.count()):
+            vheader.setSectionResizeMode(index, QtWidgets.QHeaderView.Stretch)
+
+    def plot_stream(self, item):
+        nwst_id, check = item.data(QtCore.Qt.UserRole)
+        st = self.survBot.data.get(nwst_id)
+        if st:
+            self.plot_widget = PlotWidget(self)
+            self.plot_widget.setWindowTitle(nwst_id)
+            st = modify_stream_for_plot(st, parameters=self.parameters)
+            st.plot(equal_scale=False, method='full', block=False, fig=self.plot_widget.canvas.fig)
+            # set_axis_ylabels(fig=self.plot_widget.canvas.fig, parameters=self.parameters)
+            set_axis_yticks(fig=self.plot_widget.canvas.fig, parameters=self.parameters)
+            set_axis_color(fig=self.plot_widget.canvas.fig)
+            plot_axis_thresholds(fig=self.plot_widget.canvas.fig, parameters=self.parameters)
+            self.plot_widget.show()
+
+    def notification(self, text):
+        mbox = QtWidgets.QMessageBox()
+        mbox.setWindowTitle('Notification')
+        #mbox.setDetailedText()
+        mbox.setText(text)
+        mbox.exec_()
+
+    def closeEvent(self, event):
+        self.thread.exit()
+        event.accept()
+
+
+class PlotCanvas(FigureCanvas):
+    def __init__(self, parent=None, width=10, height=8, dpi=100):
+        self.fig = Figure(figsize=(width, height), dpi=dpi)
+        FigureCanvas.__init__(self, self.fig)
+        self.setParent(parent)
+        FigureCanvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
+        FigureCanvas.updateGeometry(self)
+
+
+class PlotWidget(QtWidgets.QDialog):
+    def __init__(self, *args, **kwargs):
+        QtWidgets.QDialog.__init__(self, *args, **kwargs)
+        self.setLayout(QtWidgets.QVBoxLayout())
+        self.canvas = PlotCanvas(self, width=10, height=8)
+        self.toolbar = NavigationToolbar2QT(self.canvas, self)
+        self.layout().addWidget(self.toolbar)
+        self.layout().addWidget(self.canvas)
+
+
+class ReadSMSWidget(QtWidgets.QDialog):
+    def __init__(self, iccid, *args, **kwargs):
+        QtWidgets.QDialog.__init__(self, *args, **kwargs)
+        self.setLayout(QtWidgets.QVBoxLayout())
+        self.table = QtWidgets.QTableWidget()
+        self.layout().addWidget(self.table)
+        self.resize(1280, 400)
+
+        self.iccid = iccid
+        self.data = self.print_sms_table()
+        self.set_stretch()
+
+    def print_sms_table(self, n=5, ntextbreak=40):
+        messages = []
+        params = get_default_params(self.iccid)
+        for message in get_last_messages(params, n, only_delivered=False):
+            messages.append(message)
+        if not messages:
+            return
+        # pull dates to front
+        keys = ['dateSent', 'dateModified', 'dateReceived']
+        for item in messages[0].keys():
+            if not item in keys:
+                keys.append(item)
+        self.table.setRowCount(n)
+        self.table.setColumnCount(len(keys))
+        self.table.setHorizontalHeaderLabels(keys)
+        for row_index, message in enumerate(messages):
+            for col_index, key in enumerate(keys):
+                text = message.get(key)
+                if type(text) == str and len(text) > ntextbreak:
+                    textlist = list(text)
+                    for index in range(ntextbreak, len(text), ntextbreak):
+                        textlist.insert(index, '\n')
+                    text = ''.join(textlist)
+                item = QtWidgets.QTableWidgetItem()
+                item.setText(str(text))
+                self.table.setItem(row_index, col_index, item)
+        return True
+
+    def set_stretch(self):
+        hheader = self.table.horizontalHeader()
+        nheader = hheader.count()
+        for index in range(nheader):
+            if index < nheader - 1:
+                hheader.setSectionResizeMode(index, QtWidgets.QHeaderView.ResizeToContents)
+            else:
+                hheader.setSectionResizeMode(index, QtWidgets.QHeaderView.Stretch)
+        vheader = self.table.verticalHeader()
+        for index in range(vheader.count()):
+            vheader.setSectionResizeMode(index, QtWidgets.QHeaderView.Stretch)
+
+
+
+class SendSMSWidget(QtWidgets.QDialog):
+    def __init__(self, iccid, *args, **kwargs):
+        QtWidgets.QDialog.__init__(self, *args, **kwargs)
+        self.main_layout = QtWidgets.QVBoxLayout()
+        self.setLayout(self.main_layout)
+        self.resize(400, 100)
+
+        self.line_edit = QtWidgets.QLineEdit()
+        self.main_layout.addWidget(self.line_edit)
+
+        self.iccid = iccid
+
+        self.buttonBox = QtWidgets.QDialogButtonBox(QtWidgets.QDialogButtonBox.Ok |
+                                                    QtWidgets.QDialogButtonBox.Close)
+        self.main_layout.addWidget(self.buttonBox)
+        self.buttonBox.accepted.connect(self.send_sms)
+        self.buttonBox.rejected.connect(self.reject)
+
+    def send_sms(self):
+        text = self.line_edit.text()
+        params = get_default_params(self.iccid)
+        send_message(params, text)
+        self.close()
+
+
+if __name__ == '__main__':
+    program_path = sys.path[0]
+    parameters = os.path.join(program_path, 'parameters.yaml')
+    app = QtWidgets.QApplication([])
+    window = MainWindow(parameters=parameters)
+    window.showMaximized()
+    sys.exit(app.exec_())