feat: update logger and improvements

Author: insoIite

config.yml

@@ -1,41 +1,34 @@
 ---
 folders:
   # Folder in which torrent files are download
-  # Example downloding my_file.torrent in src_folder
-  src: ""  # Example: C:\Users\foo\Downloads
+  # Example downloding my_movie.torrent in src_folder
+  src: "c:\should_exists"
   # Folder in which the actual files will be downloaded
   # Example downloading my_move from ftp
-  dest: '' # Example: 'E:\My_files
+  dest: "c:\should_exists"
 
 qbittorrent:
   scheme: https
-  domain: ""   # Example 'qbittorrent.mydomain'
-  user: ""     # qbittorrent user
-  password: "" # qbittorrent password
-  port: 8080   # qbitorrent port
-  clean_older_than: 7 # Clean torrents older than 7 days
+  domain: "my_domain.com"
+  user: "userA"
+  password: "Apasswd"
+  port: 10412
+  clean_older_than: 7
 
-# Either use ftp or sftp depending on your remote.
-# Only one of those 2 dict should be filles
-# If not, ftp will prevail
-ftp: {}
-  #domain: ""      # FTP hostname
-  #port: 21        # FTP port
-  #user: ""        # FTP user
-  #password: ""    # FTP password
-  #tls: true
-  # Remote path on the FTP server
-  #remote_path: "" # Example: "/torrents/qbittorrent/"
+ftp:
+  domain: "my_domain.com"
+  port: 21
+  user: "userA"
+  password: "Apasswd"
+  tls: True,
+  remote_path: "/torrents/qbittorrent/"
+#sftp:
+#  domain: "my_domain.com"
+#  port: 22
+#  user: "userA"
+#  password: "Apasswd"
+#  remote_path: "torrents/qbittorrent/"
 
-sftp:
-  domain: ""      # FTP hostname
-  port: 22        # FTP port
-  user: ""        # FTP user
-  password: ""    # FTP password
-  # Remote path on the FTP server
-  remote_path: "" # Example: "/torrents/qbittorrent/"
-
-# Windows notification
 toaster:
   duration: 5 # seconds
   title: "qbit-watcher"

qbit-watcher.py

@@ -1,7 +1,9 @@
 import os
 import logging
+import logging.handlers
 import sys
 
+from qbit_watcher import MainError
 from qbit_watcher.main import main
 
 
@@ -33,7 +35,7 @@ def create_emergency_logger():
     try:
         main()
     # Catch all wanted worst case scenario
-    except Exception as exn:
+    except (MainError, Exception) as exn:
         logger = create_emergency_logger()
         logger.error(exn)
         sys.exit(1)

qbit_watcher/__init__.py

@@ -0,0 +1,4 @@
+
+class MainError(Exception):
+    """ Main Error
+    """

qbit_watcher/config.py

@@ -1,13 +1,19 @@
 """
 Read config file
 """
+from pathlib import Path
 from qbit_watcher.logger import get_logger
 
 import yaml
 
 LOGGER = get_logger(__name__)
 
 
+class ConfigError(Exception):
+    """ Config Error
+    """
+
+
 class Config:
     def __init__(self, path):
         self.path = path
@@ -26,3 +32,14 @@ def load(self):
             LOGGER.error(fnfe)
             raise
         return conf
+
+    def validate(self):
+        """ Validate config file
+        """
+        conf = self.load()
+        if not Path(conf['folders']['src']).exists():
+            LOGGER.error("Source folder does not exists: %s", conf['folders']['src'])
+            raise ConfigError
+        if not Path(conf['folders']['dest']).exists():
+            LOGGER.error("Dest folder does not exists: %s", conf['folders']['dest'])
+            raise ConfigError

qbit_watcher/logger/__init__.py

@@ -3,4 +3,3 @@
 """
 from .logger import get_logger
 from .exceptions import LogError
-from .json_formatter import QbitJsonFormatter

qbit_watcher/logger/json_formatter.py

@@ -1,33 +1,17 @@
 """
 Logging definition module
-
-opts = {
-    "debug": True,
-    "stream_handler": True,
-    "file_handler": {
-        "path": "/tmp/foo",
-        "name": "foo.log"
-    },
-    'json_formatter': {
-        'enabled': True,
-        'extra_fields': {
-            'foo': 'foo',
-            'bar': 'bar'
-        },
-        'timestamp_fmt': "%Y-%m-%dT%H:%M:%S.%fZ"
-    }
-}
 """
 
 import logging
+import logging.handlers
+import sys
 
-from os import makedirs
 from pathlib import Path
 
 from colorlog import ColoredFormatter
 
+from qbit_watcher.settings import APP_LOGFILE
 from qbit_watcher.logger.exceptions import LogError
-from qbit_watcher.logger.json_formatter import QbitJsonFormatter
 
 
 class LastPartFilter(logging.Filter):
@@ -41,56 +25,39 @@ def filter(self, record):
         return True
 
 
-def get_logger(name, opts=None):
+def get_logger(name):
     """
     Return a new named logger that will inherit the root logger
     """
-    __init_main_logger(opts)
+    __init_main_logger()
     return logging.getLogger('qbit_watcher.' + name)
 
 
-def __init_main_logger(opts):
+def __init_main_logger():
     """
     Init the main logger with its handlers when required
     """
     logger = logging.getLogger('qbit_watcher')
     logger.setLevel(logging.INFO)
-    if not opts:
-        return logger
-    __valid_opts(opts)
-
-    is_debug = opts['debug'] if "debug" in opts else False
-    if is_debug:
-        logger.setLevel(logging.DEBUG)
-
-    stream_handler = opts['stream_handler'] if "stream_handler" in opts else False
-    if stream_handler:
-        json_opts = None
-        if 'json_formatter' in opts:
-            if opts.get('json_formatter', {}).get('enabled') is True:
-                json_opts = opts['json_formatter']
-
-        if logger.handlers:
-            if not __has_handler(logger.handlers, logging.StreamHandler):
-                handler = __create_stream_handler(json_opts=json_opts)
-                logger.addHandler(handler)
-        else:
-            handler = __create_stream_handler(json_opts=json_opts)
-            logger.addHandler(handler)
 
-    file_handler = bool("file_handler" in opts)
-    if file_handler:
-        if logger.handlers:
-            if not __has_handler(logger.handlers, logging.FileHandler):
-                handler = __create_json_file_handler(
-                    opts['file_handler']['path'],
-                    opts['file_handler']['name']
-                )
+    if sys.stdout.isatty() and sys.stderr.isatty():
+        stream_handler = __create_stream_handler()
+        logger.addHandler(stream_handler)
+
+    if logger.handlers:
+        if not __has_handler(logger.handlers, logging.StreamHandler):
+            if sys.stdout.isatty() and sys.stderr.isatty():
+                handler = __create_stream_handler()
                 logger.addHandler(handler)
-        else:
-            handler = __create_stream_handler(json_opts=json_opts)
+        if not __has_handler(logger.handlers, logging.FileHandler):
+            handler = __create_file_handler()
             logger.addHandler(handler)
-
+    else:
+        if sys.stdout.isatty() and sys.stderr.isatty():
+            handler = __create_stream_handler()
+            logger.addHandler(handler)
+        fhandler = __create_file_handler()
+        logger.addHandler(fhandler)
     return logger
 
 
@@ -101,7 +68,7 @@ def __valid_opts(opts):
     if 'file_handler' in opts:
         if not isinstance(opts['file_handler'], dict):
             raise LogError("file_handler must be a dict {path: '/tmp', file: 'file.log'}")
-        if not 'path' in opts['file_handler'] or not 'name' in opts['file_handler']:
+        if 'path' not in opts['file_handler'] or 'name' not in opts['file_handler']:
             raise LogError("file_handler is set in options but 'name' or 'path' are missing")
 
 
@@ -116,42 +83,41 @@ def __has_handler(handlers, handler_type):
     return res
 
 
-def __create_stream_handler(json_opts=None):
+def __create_stream_handler():
     """
     Create a stream logger with default formatter
     """
     stream_handler = logging.StreamHandler()
-    if json_opts:
-        extra = json_opts['extra_fields'] if 'extra_fields' in json_opts else {}
-        ts_fmt = json_opts['timestamp_fmt'] if 'timestamp_fmt' in json_opts else None
-        formatter = QbitJsonFormatter(extra, ts_fmt)
-        stream_handler.setFormatter(formatter)
-    else:
-        last_filter = LastPartFilter()
-        stream_handler.addFilter(last_filter)
-        fmt_name = "  %(log_color)s%(name_last)-8s%(reset)s"
-        fmt_levelname = "%(log_color)s%(levelname)s%(reset)s"
-        fmt_message = "%(log_color)s%(message)s%(reset)s"
-
-        stream_log_fmt = "  %s | %s | %s" % (fmt_name, fmt_levelname, fmt_message)
-        stream_format = ColoredFormatter(stream_log_fmt)
-        stream_handler.setFormatter(stream_format)
-
+    last_filter = LastPartFilter()
+    stream_handler.addFilter(last_filter)
+    fmt_name = "  %(log_color)s%(name_last)-8s%(reset)s"
+    fmt_levelname = "%(log_color)s%(levelname)s%(reset)s"
+    fmt_message = "%(log_color)s%(message)s%(reset)s"
+
+    stream_log_fmt = "  %s | %s | %s" % (fmt_name, fmt_levelname, fmt_message)
+    stream_format = ColoredFormatter(stream_log_fmt)
+    stream_handler.setFormatter(stream_format)
     return stream_handler
 
 
-def __create_json_file_handler(folder_path, fname):
-    """
-    Create a json file logger
+def __create_file_handler():
+    """ Add filehandler
     """
-    path = Path(folder_path)
-    if not path.exists():
-        makedirs(path, exist_ok=True)
-
-    file_handler = logging.FileHandler(path / fname)
-    json_format = logging.Formatter(
-        '{"timestamp": "%(asctime)s", "level": "%(levelname)s", "short_message": "%(message)s"}',
-        datefmt="%s"
+    last_filter = LastPartFilter()
+    fmt_date = "  %(asctime)s"
+    fmt_name = "%(name_last)-8s"
+    fmt_levelname = "%(levelname)s"
+    fmt_message = "%(message)s"
+
+    file_log_fmt = "%s  %s | %s | %s" % (fmt_date, fmt_name, fmt_levelname, fmt_message)
+    if not APP_LOGFILE.parent.exists():
+        Path.mkdir(APP_LOGFILE.parent, exist_ok=True)
+    file_handler = logging.handlers.RotatingFileHandler(
+        APP_LOGFILE,
+        maxBytes=(1048576 * 5),
+        backupCount=7
     )
-    file_handler.setFormatter(json_format)
+
+    file_handler.addFilter(last_filter)
+    file_handler.setFormatter(logging.Formatter(file_log_fmt))
     return file_handler