pytodo-qt 0.2.0__py3-none-any.whl

todo/gui/SyncDialog.py

@@ -0,0 +1,103 @@
+"""SyncDialog.py
+
+Simple dialog to collect information needed to perform a sync operation.
+"""
+
+import sys
+
+from PyQt5 import QtGui, QtWidgets
+
+from todo.core import error_on_none_db, settings
+from todo.core.Logger import Logger
+from todo.net.sync_operations import sync_operations
+
+
+logger = Logger(__name__)
+
+
+class SyncDialog(QtWidgets.QDialog):
+    """Synchronize lists with remotes."""
+
+    def __init__(self, operation=None):
+        """Create a simple dialog.
+
+        Get information about a remote host to perform a sync operation with.
+        """
+        logger.log.info("Creating a Sync dialog")
+
+        super().__init__()
+
+        self.operation = operation
+
+        # address
+        address_label = QtWidgets.QLabel("Host Address", self)
+        self.address_field = QtWidgets.QLineEdit(self)
+
+        # port
+        port_label = QtWidgets.QLabel("Port", self)
+        self.port_field = QtWidgets.QLineEdit(self)
+        self.port_field.setText(str(settings.options["port"]))
+        self.port_field.setValidator(QtGui.QIntValidator())
+
+        # add button
+        self.get_button = QtWidgets.QPushButton("Synchronize", self)
+        self.get_button.clicked.connect(self.get_host)
+
+        # create a vertical box layout
+        v_box = QtWidgets.QVBoxLayout()
+        v_box.addWidget(address_label)
+        v_box.addWidget(self.address_field)
+        v_box.addWidget(port_label)
+        v_box.addWidget(self.port_field)
+        v_box.addWidget(self.get_button)
+
+        # set layout and window title
+        self.setLayout(v_box)
+        self.setWindowTitle(f"Sync {operation}")
+        self.setMinimumWidth(350)
+
+        logger.log.info("Sync dialog created")
+
+    @error_on_none_db
+    def get_host(self, *args, **kwargs):
+        """Get host information."""
+        address = self.address_field.text()
+        if address == "":
+            QtWidgets.QMessageBox.information(
+                self, "Empty address", "Address cannot be empty"
+            )
+            return
+
+        # get remote port
+        port = self.port_field.text()
+        if port == "":
+            QtWidgets.QMessageBox.information(
+                self, "Empty port", "Port cannot be empty"
+            )
+            return
+
+        port = int(port)
+
+        logger.log.info("Got host information for sync operation")
+        if self.operation == sync_operations["PULL_REQUEST"].name:
+            # try the pull, inform user of the results
+            result, msg = settings.db.sync_pull((address, port))
+            QtWidgets.QMessageBox.information(self, "Sync Pull", msg)
+            if not result:
+                return
+        elif self.operation == sync_operations["PUSH_REQUEST"].name:
+            # temporarily enable pulling for the push
+            pull_ok = settings.options["pull"]
+            if not pull_ok:
+                settings.options["pull"] = True
+
+            # try the push, inform user of results
+            result, msg = settings.db.sync_push((address, port))
+            QtWidgets.QMessageBox.information(self, "Sync Push", msg)
+            if not pull_ok:
+                settings.options["pull"] = False
+
+            if not result:
+                return
+
+        self.accept()

todo/net/__init__.py

@@ -0,0 +1,20 @@
+""""__init__.py
+
+A small TCP socket reader with a simple progress bar.
+"""
+
+from PyQt5 import QtWidgets, QtCore
+
+
+def recv_all(sock, size):
+    """Read data from a socket until it's finished."""
+    pd = QtWidgets.QProgressDialog("Sync To-Do lists", "Abort sync", 0, size, None)
+    pd.setMinimumWidth(375)
+    pd.setWindowModality(QtCore.Qt.WindowModality.WindowModal)
+    pd.setValue(0)
+    pd.forceShow()
+    data = bytearray()
+    while chunk := sock.recv(1):
+        data.extend(chunk)
+        pd.setValue(len(data))
+    return data

todo/net/sync_operations.py

@@ -0,0 +1,18 @@
+"""sync_operations.py
+
+Network synchronization enums.
+"""
+
+from enum import Enum
+
+
+sync_operations = Enum(
+    value="OPERATION",
+    names=[
+        ("PUSH_REQUEST", 1),
+        ("PULL_REQUEST", 2),
+        ("REJECT", 3),
+        ("ACCEPT", 4),
+        ("NO_DATA", 5),
+    ],
+)

todo/net/tcp_client_lib.py

@@ -0,0 +1,123 @@
+"""tcp_client_lib.py
+
+This module implements the To-Do database network client.
+"""
+
+import json
+import os
+import socket
+import time
+
+from todo.core import settings, json_helpers
+from todo.core.Logger import Logger
+from todo.crypto.AESCipher import AESCipher
+from todo.net.sync_operations import sync_operations
+
+from . import recv_all
+
+
+logger = Logger(__name__)
+
+
+class DataBaseClient:
+    """To-Do database client class."""
+
+    def __init__(self):
+        """Initialize client."""
+        self.buf_size = 4096
+        self.aes_cipher = AESCipher(settings.options["key"])
+
+    def send_request(self, host, sock, request):
+        """Send a request to remote connection."""
+        logger.log.info(f"sending {request} to {host}")
+        encrypted_request = self.aes_cipher.encrypt(request)
+        sock.send(encrypted_request)
+
+    def get_response(self, sock):
+        """Get a response from remote connection."""
+        encrypted_data = sock.recv(self.buf_size)
+        decrypted_data = self.aes_cipher.decrypt(encrypted_data)
+        response = decrypted_data.decode("utf-8")
+        return response
+
+    def process_response(self, host, sock, request, response):
+        """Process remote host's response to a request."""
+        msg = f"{host} responded to {request} with {response}"
+        logger.log.info(msg)
+
+        if response == sync_operations["ACCEPT"].name:
+            if request == sync_operations["PULL_REQUEST"].name:
+                size_header = sock.recv(self.buf_size)
+                decrypted_header = self.aes_cipher.decrypt(size_header)
+                size = int(decrypted_header)
+                logger.log.info("remote lists is %d bytes", size)
+                time.sleep(1)
+                data = recv_all(sock, size)
+                return self.process_data(host, data)
+            elif request == sync_operations["PUSH_REQUEST"].name:
+                return True, msg
+            else:
+                return False, msg
+        else:
+            return False, msg
+
+    def process_data(self, host, data):
+        """Process encrypted data received."""
+        # decrypt and decode received data
+        decrypted_data = self.aes_cipher.decrypt(data)
+        try:
+            deserialized = json.loads(decrypted_data)
+        except OSError as e:
+            logger.log.exception(e)
+            return False, e
+
+        # write data to a temporary file, then read it in
+        tmp = os.path.join(settings.todo_dir, ".todo_lists.tmp")
+        try:
+            with open(tmp, "w", encoding="utf-8") as f:
+                f.write(deserialized)
+            msg = f"Pull from {host} successful."
+            logger.log.info(msg)
+            result, e = json_helpers.read_json_data(tmp)
+            if not result:
+                return False, e
+            os.remove(tmp)
+            return True, msg
+        except IOError as e:
+            msg = f"Unable to write temporary file: {e}"
+            logger.log.exception(msg)
+            return False, msg
+
+    def synchronize(self, host, request):
+        """Synchronize to-do lists with other hosts."""
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.settimeout(30)
+                try:
+                    sock.connect(host)
+                except socket.error as err:
+                    msg = f"Unable to connect to host: {err}"
+                    logger.log.exception(msg)
+                    return False, msg
+                self.send_request(host, sock, request)
+                response = self.get_response(sock)
+                return self.process_response(host, sock, request, response)
+        except OSError as e:
+            msg = f"Unable to connect to host {host}: {e}"
+            logger.log.exception(msg)
+            return False, msg
+
+    def sync_pull(self, host):
+        """Synchronize database with another by pulling it from a host."""
+        logger.log.info("Performing a Sync Pull")
+        return self.synchronize(host, sync_operations["PULL_REQUEST"].name)
+
+    def sync_push(self, host):
+        """Synchronize lists between devices by pushing them to a host.
+
+        To-Do doesn't really support pushing because that is rude.
+        In our terminology, if you do a push, it really means asking
+        the device you want your to-do lists on to pull from you.
+        """
+        logger.log.info("Performing a Sync Push")
+        return self.synchronize(host, sync_operations["PUSH_REQUEST"].name)

todo/net/tcp_server_lib.py

@@ -0,0 +1,139 @@
+"""tcp_server_lib.py
+
+This module implements a threaded tcp socket server and request handler for To-Do.
+"""
+
+import json
+import os
+import socketserver
+import sys
+import time
+
+from PyQt5 import QtWidgets
+from todo.core import error_on_none_db, settings
+from todo.core.Logger import Logger
+from todo.crypto.AESCipher import AESCipher
+from todo.net.sync_operations import sync_operations
+
+
+logger = Logger(__name__)
+
+
+class DataBaseServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
+    """Threaded tcp server."""
+
+    allow_reuse_address = True
+
+
+class TCPRequestHandler(socketserver.StreamRequestHandler):
+    """Socket server request handler."""
+
+    def __init__(self, request, client_address, server):
+        """Initialize request handler."""
+        self.aes_cipher = AESCipher(settings.options["key"])
+        self.buf_size = 4096
+        self.peer_name = None
+        self.host = None
+        self.data = None
+        self.encrypted_header = None
+        self.encrypted_data = None
+        self.decrypted_data = None
+        self.command = None
+        self.encrypted_reply = None
+        super().__init__(request, client_address, server)
+
+    def process_request(self):
+        """Process a request."""
+        self.encrypted_data = self.request.recv(self.buf_size)
+        self.decrypted_data = self.aes_cipher.decrypt(self.encrypted_data)
+        self.command = self.decrypted_data.decode("utf-8")
+
+        if self.command == sync_operations["PULL_REQUEST"].name:
+            self.pull()
+        elif self.command == sync_operations["PUSH_REQUEST"].name:
+            self.push()
+        else:
+            pass
+
+    def pull(self):
+        """Pull to-do lists from remote host."""
+        logger.log.info("received PULL_REQUEST from %s", self.peer_name)
+        if not settings.options["pull"]:
+            logger.log.info("PULL_REQUEST denied")
+            self.encrypted_reply = self.aes_cipher.encrypt(
+                sync_operations["REJECT"].name
+            )
+            self.request.send(self.encrypted_reply)
+            return
+
+        if os.path.exists(settings.lists_fn):
+            self.data = ""
+            with open(settings.lists_fn, encoding="utf-8") as f:
+                for line in f:
+                    self.data += line
+
+        if self.data is not None:
+            logger.log.info("PULL_REQUEST ACCEPTED")
+            self.encrypted_reply = self.aes_cipher.encrypt(
+                sync_operations["ACCEPT"].name
+            )
+            self.request.sendall(self.encrypted_reply)
+            time.sleep(1)
+            self.send_size_header()
+        else:
+            self.encrypted_reply = self.aes_cipher.encrypt(
+                sync_operations["NO_DATA"].name
+            )
+            self.request.send(self.encrypted_reply)
+
+    def send_size_header(self):
+        """Send the size of the to-do lists."""
+        size = sys.getsizeof(self.data)
+        self.encrypted_header = self.aes_cipher.encrypt(str(size))
+        self.request.sendall(self.encrypted_header)
+        time.sleep(1)
+        self.send_data()
+
+    def send_data(self):
+        """Send to-do list data."""
+        try:
+            serialized = json.dumps(self.data)
+        except OSError as e:
+            logger.log.exception(e)
+            return False, e
+        self.encrypted_data = self.aes_cipher.encrypt(serialized)
+        self.request.sendall(self.encrypted_data)
+        return True
+
+    @error_on_none_db
+    def push(self):
+        """Push to-do lists to remote hosts."""
+        logger.log.info("PUSH_REQUEST from %s", self.peer_name)
+        if not settings.options["push"]:
+            msg = f"PUSH_REQUEST from {self.peer_name} denied"
+            self.encrypted_reply = self.aes_cipher.encrypt(
+                sync_operations["REJECT"].name
+            )
+            self.request.send(self.encrypted_reply)
+            QtWidgets.QMessageBox.warning(None, "Push Sync", msg)
+            logger.log.warning(msg)
+            return
+
+        logger.log.info("PUSH_REQUEST accepted")
+        self.encrypted_reply = self.aes_cipher.encrypt(sync_operations["ACCEPT"].name)
+        self.request.send(self.encrypted_reply)
+
+        if self.peer_name is not None:
+            self.host = (self.peer_name[0], settings.options["port"])
+        else:
+            msg = "Not performing push sync, no host peer"
+            QtWidgets.QMessageBox.warning(None, "Push Sync", msg)
+            logger.log.warning(msg)
+            return
+
+        settings.db.sync_pull(self.host)
+
+    def handle(self):
+        """Handle requests."""
+        self.peer_name = self.request.getpeername()
+        self.process_request()