Revize be89639f

Feature/8921 preferences dialog

aswi2021vochomurka/service/mqtt/mqtt_subscriber.py

@@ -7 +7 @@
 
 
 class MQTTSubscriber(Subscriber):
+    client: mqtt.Client = None
 
     # The callback for when the client receives a CONNACK response from the server.
     def on_connect(self, client, userdata, flags, rc, properties=None):
@@ -40 +41 @@
     def start(self):
         super().start()
         client = mqtt.Client()
+        self.client = client
         client.on_connect = self.on_connect
         client.on_message = self.on_message
         client.on_disconnect = self.on_disconnect
@@ -47 +49 @@
 
         if not self.params.anonymous:
             logging.info('Using credentials, username=' + self.params.username + ', password=' + self.params.password)
-            client.tls_set()
             client.username_pw_set(self.params.username, self.params.password)
 
         try:
@@ -63 +64 @@
             return
 
         client.loop_forever()
+
+    def stop(self):
+        super().stop()
+        if self.client is not None:
+            logging.info("Disconnecting from broker")
+            client = self.client
+            self.client = None
+            client.disconnect()

aswi2021vochomurka/service/subscriber.py

@@ -1 +1 @@
 import time
+from typing import Dict
 
 from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.schedulers.base import STATE_STOPPED
 
 from aswi2021vochomurka.model.Message import Message
 from aswi2021vochomurka.service.file_manager import FileManager
 from aswi2021vochomurka.service.subscriber_callback import SubscriberCallback
 from aswi2021vochomurka.service.subscriber_params import SubscriberParams
-from typing import Dict
 
 
 class Subscriber:
     callback: SubscriberCallback
     params: SubscriberParams
 
-    scheduler = BackgroundScheduler()
+    scheduler: BackgroundScheduler
     files: Dict[str, FileManager] = {}
 
     def __init__(self, callback: SubscriberCallback, params: SubscriberParams):
@@ -22 +23 @@
 
     def start(self):
         # start scheduler to check closed topics
+        self.scheduler = BackgroundScheduler()
         self.scheduler.add_job(self.check_closed_topics, 'interval', seconds=self.params.closeLimit)
         self.scheduler.start()
 
     def stop(self):
-        self.scheduler.shutdown()
+        if self.scheduler.state != STATE_STOPPED:
+            self.scheduler.shutdown()
         self.close_files()
 
     def close_files(self):
         for topic in self.files:
             self.files.get(topic).close()
-        self.files = {}
+        self.files.clear()
 
     def check_closed_topics(self):
         t = time.time()

aswi2021vochomurka/view/main_view.py

@@ -2 +2 @@
 
 import matplotlib.pyplot as plt
 from PyQt5 import QtCore
-from PyQt5.QtCore import QSize, QThread, QObject, pyqtSignal
-from PyQt5.QtWidgets import QDialog, QPushButton, QVBoxLayout
-from PyQt5.QtWidgets import QHBoxLayout, QGridLayout, QScrollArea, QWidget
+from PyQt5 import QtGui
+from PyQt5.QtCore import QSize, QThread, QObject, pyqtSignal, QSettings
+from PyQt5.QtWidgets import QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QScrollArea, QGridLayout
+from PyQt5.QtWidgets import QMenuBar, QAction, QPushButton
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 
 from aswi2021vochomurka.model.Message import Message
@@ -13 +14 @@
 from aswi2021vochomurka.service.subscriber_callback import SubscriberCallback
 from aswi2021vochomurka.service.subscriber_params import SubscriberParams, ConnectionParams
 from aswi2021vochomurka.view.logger_view import LoggerView
+from aswi2021vochomurka.view.settings import SettingsDialog, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_KEEPALIVE, \
+    DEFAULT_ANONYMOUS, DEFAULT_USERNAME, DEFAULT_TIMEOUT, DEFAULT_TOPICS
 
 
 class Worker(QObject, SubscriberCallback):
@@ -21 +24 @@
     error = pyqtSignal(Exception)
     newMessage = pyqtSignal(Message)
     subscriber: Subscriber = None
+    params: SubscriberParams
 
-    params = SubscriberParams(
-        ["/home/1", "/home/2", "/home/3", "/home/4", "/home/5", "/home/6", "/home/7", "/home/8"],
-        10,
-        ConnectionParams("localhost", 1883, 60),
-        True
-    )
+    def __init__(self, params: SubscriberParams) -> None:
+        super().__init__()
+        self.params = params
 
     def start(self):
         self.subscriber = MQTTSubscriber(self, self.params)
         self.subscriber.start()
 
+    def stop(self):
+        self.subscriber.stop()
+
     def onConnected(self):
         self.connected.emit()
 
@@ -40 +44 @@
         self.disconnected.emit()
 
     def onError(self):
-        self.error.emit()
+        pass
 
     def onMessage(self, message: Message):
         self.newMessage.emit(message)
@@ -50 +54 @@
         pass
 
 
-class MainView(QDialog):
+class MainView(QMainWindow):
     worker: Worker = None
     workerThread: QThread = None
 
@@ -70 +74 @@
 
         # self.setMinimumSize(QSize(440, 240))
         self.setMinimumSize(QSize(1200, 800))
-        self.setWindowTitle("MQTT demo")
-
-        # Add logger text field
-        logger = LoggerView(self)
-        formatter = logging.Formatter('%(asctime)s %(message)s', '%H:%M')
-        logger.setFormatter(formatter)
-        logger.setLevel(logging.INFO)
-        logging.getLogger('').addHandler(logger)
+        self.setWindowTitle("MQTT client")
 
+        logger = self._createLoggerView()
         layout = QVBoxLayout()
         layout.addWidget(logger.widget)
         # layout.addWidget(self.toolbar)
 
-        self.setLayout(layout)
+        widget = QWidget()
+        widget.setLayout(layout)
+        self.setCentralWidget(widget)
+        self._createMenuBar()
 
         scrollArea = QScrollArea(self)
         scrollArea.setWidgetResizable(True)
@@ -94 +95 @@
 
         self.init_subscriber()
 
+    def _createLoggerView(self):
+        logger = LoggerView(self)
+        formatter = logging.Formatter('%(asctime)s %(message)s', '%H:%M')
+        logger.setFormatter(formatter)
+        logger.setLevel(logging.INFO)
+        logging.getLogger('').addHandler(logger)
+        return logger
+
+    def _createMenuBar(self):
+        menuBar = QMenuBar(self)
+        settingsAction = QAction("&Settings", self)
+        settingsAction.triggered.connect(self.settings)
+        menuBar.addAction(settingsAction)
+        self.setMenuBar(menuBar)
+
     def plot(self, message: Message):
         if message.topic in self.dataDict:
             self.dataDict[message.topic].append(message.value)
@@ -130 +146 @@
 
             self.chartsNum += 1
 
+    def closeEvent(self, a0: QtGui.QCloseEvent) -> None:
+        self.worker.stop()
+
+    def settings(self):
+        dialog = SettingsDialog()
+        if dialog.exec_():
+            self.reconnect()
+
+    def disconnect(self):
+        self.worker.stop()
+        self.workerThread.quit()
+        self.workerThread.wait()
+
+    def reconnect(self):
+        self.disconnect()
+        self.worker.params = self.getConfigParams()
+        self.workerThread.start()
+
     def init_subscriber(self):
         self.workerThread = QThread()
-        self.worker = Worker()
+        self.worker = Worker(self.getConfigParams())
         self.worker.moveToThread(self.workerThread)
         self.workerThread.started.connect(self.worker.start)
         self.worker.newMessage.connect(
@@ -140 +174 @@
         )
         self.worker.window = self
         self.workerThread.start()
+
+    def getConfigParams(self) -> SubscriberParams:
+        settings = QSettings("Vochomurka", "MQTTClient")
+
+        connection = ConnectionParams(
+            settings.value("connection_host", DEFAULT_HOST, str),
+            settings.value("connection_port", DEFAULT_PORT, int),
+            settings.value("connection_keepalive", DEFAULT_KEEPALIVE, int)
+        )
+
+        params = SubscriberParams(
+            settings.value("topics_items", DEFAULT_TOPICS),
+            settings.value("topics_timeout", DEFAULT_TIMEOUT),
+            connection,
+            settings.value("connection_anonymous", DEFAULT_ANONYMOUS, bool),
+            settings.value("connection_username", DEFAULT_USERNAME, str),
+            settings.value("connection_password", DEFAULT_USERNAME, str),
+        )
+
+        return params

aswi2021vochomurka/view/settings.py

@@ +1 @@
+from PyQt5 import QtCore
+from PyQt5.QtCore import QSettings, QSize
+from PyQt5.QtWidgets import QDialog, QVBoxLayout, QDialogButtonBox, QGroupBox, QFormLayout, QLabel, QLineEdit, QSpinBox, \
+    QCheckBox, QPushButton, QListWidget, QListWidgetItem
+
+DEFAULT_HOST = "localhost"
+DEFAULT_PORT = 1883
+DEFAULT_KEEPALIVE = 60
+DEFAULT_ANONYMOUS = True
+DEFAULT_USERNAME = ""
+DEFAULT_PASSWORD = ""
+DEFAULT_TOPICS = ["/home/1", "/home/2"]
+DEFAULT_TIMEOUT = 60
+
+
+class SettingsDialog(QDialog):
+    topics = DEFAULT_TOPICS
+
+    def __init__(self):
+        super(SettingsDialog, self).__init__(None,
+                                             QtCore.Qt.WindowCloseButtonHint | QtCore.Qt.WindowSystemMenuHint | QtCore.Qt.WindowTitleHint)
+        self.settings = QSettings("Vochomurka", "MQTTClient")
+        self.setWindowTitle("Settings")
+        self.setMinimumSize(QSize(600, 500))
+
+        connectionGroupBox = QGroupBox("Connection")
+        connectionLayout = QFormLayout()
+        self.hostInput = QLineEdit(self.settings.value("connection_host", DEFAULT_HOST, str))
+        connectionLayout.addRow(QLabel("Host:"), self.hostInput)
+        self.portInput = QSpinBox()
+        self.portInput.setMaximum(65535)
+        self.portInput.setValue(self.settings.value("connection_port", DEFAULT_PORT, int))
+        connectionLayout.addRow(QLabel("Port:"), self.portInput)
+        self.keepaliveInput = QSpinBox()
+        self.keepaliveInput.setMaximum(1000)
+        self.keepaliveInput.setValue(self.settings.value("connection_keepalive", DEFAULT_KEEPALIVE, int))
+        connectionLayout.addRow(QLabel("Keepalive(s):"), self.keepaliveInput)
+        self.anonymousInput = QCheckBox()
+        self.anonymousInput.setChecked(self.settings.value("connection_anonymous", DEFAULT_ANONYMOUS, bool))
+        self.anonymousInput.stateChanged.connect(self.anonymousChanged)
+        connectionLayout.addRow(QLabel("Anonymous:"), self.anonymousInput)
+        self.usernameInput = QLineEdit(self.settings.value("connection_username", DEFAULT_USERNAME, str))
+        connectionLayout.addRow(QLabel("Username:"), self.usernameInput)
+        self.passwordInput = QLineEdit(self.settings.value("connection_password", DEFAULT_PASSWORD, str))
+        connectionLayout.addRow(QLabel("Password:"), self.passwordInput)
+        self.anonymousChanged()
+        connectionGroupBox.setLayout(connectionLayout)
+
+        topicsGroupBox = QGroupBox("Topics")
+        topicsLayout = QFormLayout()
+
+        self.topics = self.settings.value("topics_items", DEFAULT_TOPICS, list)
+        self.topicsListWidget = QListWidget()
+        for topic in self.topics:
+            item = QListWidgetItem()
+            item.setText(topic)
+            item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)
+            self.topicsListWidget.addItem(item)
+
+        topicsLayout.addRow(self.topicsListWidget)
+        add = QPushButton("Add")
+        add.setFixedWidth(60)
+        add.clicked.connect(self.addTopic)
+        remove = QPushButton("Remove")
+        remove.setFixedWidth(60)
+        remove.clicked.connect(self.removeTopic)
+        topicsLayout.addRow(add, remove)
+
+        self.timeoutInput = QSpinBox()
+        self.timeoutInput.setMaximum(1000)
+        self.timeoutInput.setToolTip("Unsubscribe topic and close file when there is not new message after this "
+                                     "timeout (in seconds) expires")
+        timeoutLabel = QLabel("Topic timeout(s):")
+        timeoutLabel.setToolTip("Unsubscribe topic and close file when there is not new message after this "
+                                "timeout (in seconds) expires")
+        self.timeoutInput.setValue(self.settings.value("topics_timeout", DEFAULT_TIMEOUT, int))
+        topicsLayout.addRow(timeoutLabel, self.timeoutInput)
+
+        topicsGroupBox.setLayout(topicsLayout)
+
+        buttonBox = QDialogButtonBox()
+        buttonBox.addButton("Save and Reconnect", QDialogButtonBox.AcceptRole)
+        buttonBox.addButton("Cancel", QDialogButtonBox.RejectRole)
+        buttonBox.accepted.connect(self.accept)
+        buttonBox.rejected.connect(self.reject)
+
+        mainLayout = QVBoxLayout()
+        mainLayout.addWidget(connectionGroupBox)
+        mainLayout.addWidget(topicsGroupBox)
+        mainLayout.addWidget(buttonBox)
+        self.setLayout(mainLayout)
+
+    def addTopic(self):
+        item = QListWidgetItem()
+        item.setText("/topic")
+        item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable)
+        self.topicsListWidget.addItem(item)
+
+    def removeTopic(self):
+        for item in self.topicsListWidget.selectedItems():
+            self.topicsListWidget.takeItem(self.topicsListWidget.row(item))
+
+    def anonymousChanged(self):
+        self.usernameInput.setEnabled(not self.anonymousInput.isChecked())
+        self.passwordInput.setEnabled(not self.anonymousInput.isChecked())
+
+    def accept(self) -> None:
+        super().accept()
+        self.topics = []
+        for index in range(self.topicsListWidget.count()):
+            self.topics.append(self.topicsListWidget.item(index).text())
+
+        self.settings.setValue("topics_items", self.topics)
+        self.settings.setValue("topics_timeout", self.timeoutInput.value())
+        self.settings.setValue("connection_host", self.hostInput.text())
+        self.settings.setValue("connection_port", self.portInput.value())
+        self.settings.setValue("connection_keepalive", self.keepaliveInput.value())
+        self.settings.setValue("connection_anonymous", self.anonymousInput.isChecked())
+        self.settings.setValue("connection_username", self.usernameInput.text())
+        self.settings.setValue("connection_password", self.passwordInput.text())