Make sure to reuse same client secrets between runs.

fix #605

modoboa_installer/config_dict_template.py

@@ -1,5 +1,6 @@
 import random
 import string
+import uuid
 
 from .constants import DEFAULT_BACKUP_DIRECTORY
 
@@ -11,6 +12,10 @@ def make_password(length=16):
             string.ascii_letters + string.digits) for _ in range(length))
 
 
+def make_client_secret():
+    return str(uuid.uuid4())
+
+
 # Validators should return a tuple bool, error message
 def is_email(user_input):
     """Return True in input is a valid email"""
@@ -351,6 +356,10 @@ ConfigDictTemplate = [
                 "option": "move_spam_to_junk",
                 "default": "true",
             },
+            {
+                "option": "oauth2_client_secret",
+                "default": make_client_secret
+            },
         ]
     },
     {
@@ -480,7 +489,11 @@ ConfigDictTemplate = [
             {
                 "option": "venv_path",
                 "default": "%(home_dir)s/env",
-            }
+            },
+            {
+                "option": "oauth2_client_secret",
+                "default": make_client_secret
+            },
         ]
     },
     {

modoboa_installer/scripts/__init__.py

@@ -9,7 +9,8 @@ from .. import utils
 def load_app_script(appname):
     """Load module corresponding to the given appname."""
     try:
-        script = importlib.import_module("modoboa_installer.scripts.{}".format(appname))
+        script = importlib.import_module(
+            "modoboa_installer.scripts.{}".format(appname))
     except ImportError:
         print("Unknown application {}".format(appname))
         sys.exit(1)
@@ -18,9 +19,8 @@ def load_app_script(appname):
 
 def install(appname: str, config, upgrade: bool, archive_path: str):
     """Install an application."""
-    if config.has_option(appname, "enabled") and not config.getboolean(
-        appname, "enabled"
-    ):
+    if (config.has_option(appname, "enabled") and
+            not config.getboolean(appname, "enabled")):
         return
 
     utils.printcolor("Installing {}".format(appname), utils.MAGENTA)
@@ -34,9 +34,8 @@ def install(appname: str, config, upgrade: bool, archive_path: str):
 
 def backup(appname, config, path):
     """Backup an application."""
-    if config.has_option(appname, "enabled") and not config.getboolean(
-        appname, "enabled"
-    ):
+    if (config.has_option(appname, "enabled") and
+            not config.getboolean(appname, "enabled")):
         return
 
     utils.printcolor("Backing up {}".format(appname), utils.MAGENTA)
@@ -50,5 +49,6 @@ def backup(appname, config, path):
 
 def restore_prep(restore):
     """Restore instance"""
-    script = importlib.import_module("modoboa_installer.scripts.restore")
+    script = importlib.import_module(
+        "modoboa_installer.scripts.restore")
     getattr(script, "Restore")(restore)

modoboa_installer/scripts/amavis.py

@@ -10,29 +10,18 @@ from . import backup, install
 
 
 class Amavis(base.Installer):
+
     """Amavis installer."""
 
     appname = "amavis"
     packages = {
         "deb": [
-            "libdbi-perl",
-            "amavisd-new",
-            "arc",
-            "arj",
-            "cabextract",
-            "liblz4-tool",
-            "lrzip",
-            "lzop",
-            "p7zip-full",
-            "rpm2cpio",
+            "libdbi-perl", "amavisd-new", "arc", "arj", "cabextract",
+            "liblz4-tool", "lrzip", "lzop", "p7zip-full", "rpm2cpio",
             "unrar-free",
         ],
         "rpm": [
-            "amavisd-new",
-            "arj",
-            "lz4",
-            "lzop",
-            "p7zip",
+            "amavisd-new", "arj", "lz4", "lzop", "p7zip",
         ],
     }
     with_db = True
@@ -54,10 +43,8 @@ class Amavis(base.Installer):
         """Return appropriate config files."""
         if package.backend.FORMAT == "deb":
             return [
-                "conf.d/05-node_id",
-                "conf.d/15-content_filter_mode",
-                "conf.d/50-user",
-            ]
+                "conf.d/05-node_id", "conf.d/15-content_filter_mode",
+                "conf.d/50-user"]
         return ["amavisd.conf"]
 
     def get_packages(self):
@@ -84,9 +71,9 @@ class Amavis(base.Installer):
             raise NotImplementedError("DB driver not supported")
         packages += ["perl-DBD-{}".format(db_driver)]
         name, version = utils.dist_info()
-        if version.startswith("7"):
+        if version.startswith('7'):
             packages += ["cabextract", "lrzip", "unar", "unzoo"]
-        elif version.startswith("8"):
+        elif version.startswith('8'):
             packages += ["perl-IO-stringy"]
         return packages
 
@@ -98,10 +85,12 @@ class Amavis(base.Installer):
             version = package.backend.get_installed_version("amavis")
             if version is None:
                 raise utils.FatalError("Amavis is not installed")
-        path = self.get_file_path("amavis_{}_{}.sql".format(self.dbengine, version))
+        path = self.get_file_path(
+            "amavis_{}_{}.sql".format(self.dbengine, version))
         if not os.path.exists(path):
             version = ".".join(version.split(".")[:-1]) + ".X"
-            path = self.get_file_path("amavis_{}_{}.sql".format(self.dbengine, version))
+            path = self.get_file_path(
+                "amavis_{}_{}.sql".format(self.dbengine, version))
             if not os.path.exists(path):
                 raise utils.FatalError("Failed to find amavis database schema")
         return path
@@ -118,21 +107,20 @@ class Amavis(base.Installer):
 
     def custom_backup(self, path):
         """Backup custom configuration if any."""
+        if package.backend.FORMAT == "deb":
             amavis_custom = f"{self.config_dir}/conf.d/99-custom"
             if os.path.isfile(amavis_custom):
                 utils.copy_file(amavis_custom, path)
                 utils.success("Amavis custom configuration saved!")
-        backup("spamassassin", self.config, self.base_backup_path)
+        backup("spamassassin", self.config, os.path.dirname(path))
 
     def restore(self):
         """Restore custom config files."""
         if package.backend.FORMAT != "deb":
             return
         amavis_custom_configuration = os.path.join(
-            self.archive_path, "custom/amavis/99-custom"
-        )
+            self.archive_path, "custom/99-custom")
         if os.path.isfile(amavis_custom_configuration):
-            utils.copy_file(
-                amavis_custom_configuration, os.path.join(self.config_dir, "conf.d")
-            )
+            utils.copy_file(amavis_custom_configuration, os.path.join(
+                self.config_dir, "conf.d"))
             utils.success("Custom amavis configuration restored.")

modoboa_installer/scripts/backup.py

@@ -0,0 +1,226 @@
+"""Backup script for pre-installed instance."""
+
+import os
+import pwd
+import shutil
+import stat
+import sys
+import datetime
+
+from .. import database
+from .. import utils
+from ..constants import DEFAULT_BACKUP_DIRECTORY
+
+
+class Backup:
+    """
+    Backup structure ( {optional} ):
+    {{backup_directory}}
+    ||
+    ||--> installer.cfg
+    ||--> custom
+        |--> { (copy of) /etc/amavis/conf.d/99-custom }
+        |--> { (copy of) /etc/postfix/custom_whitelist.cidr }
+        |--> { (copy of) dkim directory }
+            |--> {dkim.pem}...
+        |--> { (copy of) radicale home_dir }
+    ||--> databases
+        |--> modoboa.sql
+        |--> { amavis.sql }
+        |--> { spamassassin.sql }
+    ||--> mails
+        |--> vmails
+    """
+
+    def __init__(self, config, silent_backup, backup_path, nomail):
+        self.config = config
+        self.backup_path = backup_path
+        self.nomail = nomail
+        self.silent_backup = silent_backup
+
+    def validate_path(self, path):
+        """Check basic condition for backup directory."""
+
+        path_exists = os.path.exists(path)
+
+        if path_exists and os.path.isfile(path):
+            utils.error("Error, you provided a file instead of a directory!")
+            return False
+
+        if not path_exists:
+            if not self.silent_backup:
+                create_dir = input(
+                    f"\"{path}\" doesn't exist, would you like to create it? [Y/n]\n").lower()
+
+            if self.silent_backup or (not self.silent_backup and create_dir.startswith("y")):
+                pw = pwd.getpwnam("root")
+                utils.mkdir_safe(path, stat.S_IRWXU |
+                                 stat.S_IRWXG, pw[2], pw[3])
+            else:
+                utils.error("Error, backup directory not present.")
+                return False
+
+        if len(os.listdir(path)) != 0:
+            if not self.silent_backup:
+                delete_dir = input(
+                    "Warning: backup directory is not empty, it will be purged if you continue... [Y/n]\n").lower()
+
+            if self.silent_backup or (not self.silent_backup and delete_dir.startswith("y")):
+                try:
+                    os.remove(os.path.join(path, "installer.cfg"))
+                except FileNotFoundError:
+                    pass
+
+                shutil.rmtree(os.path.join(path, "custom"),
+                              ignore_errors=False)
+                shutil.rmtree(os.path.join(path, "mails"), ignore_errors=False)
+                shutil.rmtree(os.path.join(path, "databases"),
+                              ignore_errors=False)
+            else:
+                utils.error("Error: backup directory not clean.")
+                return False
+
+        self.backup_path = path
+
+        pw = pwd.getpwnam("root")
+        for dir in ["custom/", "databases/"]:
+            utils.mkdir_safe(os.path.join(self.backup_path, dir),
+                             stat.S_IRWXU | stat.S_IRWXG, pw[2], pw[3])
+        return True
+
+    def set_path(self):
+        """Setup backup directory."""
+        if self.silent_backup:
+            if self.backup_path is None:
+                if self.config.has_option("backup", "default_path"):
+                    path = self.config.get("backup", "default_path")
+                else:
+                    path = DEFAULT_BACKUP_DIRECTORY
+                date = datetime.datetime.now().strftime("%m_%d_%Y_%H_%M")
+                path = os.path.join(path, f"backup_{date}")
+                self.validate_path(path)
+            else:
+                if not self.validate_path(self.backup_path):
+                    utils.printcolor(
+                        f"Path provided: {self.backup_path}", utils.BLUE)
+                    sys.exit(1)
+        else:
+            user_value = None
+            while user_value == "" or user_value is None or not self.validate_path(user_value):
+                utils.printcolor(
+                    "Enter backup path (it must be an empty directory)", utils.MAGENTA)
+                utils.printcolor("CTRL+C to cancel", utils.MAGENTA)
+                user_value = utils.user_input("-> ")
+
+    def config_file_backup(self):
+        utils.copy_file("installer.cfg", self.backup_path)
+
+    def mail_backup(self):
+        if self.nomail:
+            utils.printcolor(
+                "Skipping mail backup, no-mail argument provided", utils.MAGENTA)
+            return
+
+        utils.printcolor("Backing up mails", utils.MAGENTA)
+
+        home_path = self.config.get("dovecot", "home_dir")
+
+        if not os.path.exists(home_path) or os.path.isfile(home_path):
+            utils.error("Error backing up Email, provided path "
+                        f" ({home_path}) seems not right...")
+
+        else:
+            dst = os.path.join(self.backup_path, "mails/")
+
+            if os.path.exists(dst):
+                shutil.rmtree(dst)
+
+            shutil.copytree(home_path, dst)
+            utils.printcolor("Mail backup complete!", utils.GREEN)
+
+    def custom_config_backup(self):
+        """
+        Custom config :
+        - DKIM keys: {{keys_storage_dir}}
+        - Radicale collection (calendars, contacts): {{home_dir}}
+        - Amavis : /etc/amavis/conf.d/99-custom
+        - Postwhite : /etc/postwhite.conf
+        Feel free to suggest to add others!
+        """
+        utils.printcolor(
+            "Backing up some custom configuration...", utils.MAGENTA)
+
+        custom_path = os.path.join(
+            self.backup_path, "custom")
+
+        # DKIM Key
+        if (self.config.has_option("opendkim", "enabled") and
+                self.config.getboolean("opendkim", "enabled")):
+            dkim_keys = self.config.get(
+                "opendkim", "keys_storage_dir", fallback="/var/lib/dkim")
+            if os.path.isdir(dkim_keys):
+                shutil.copytree(dkim_keys, os.path.join(custom_path, "dkim"))
+                utils.printcolor(
+                    "DKIM keys saved!", utils.GREEN)
+
+        # Radicale Collections
+        if (self.config.has_option("radicale", "enabled") and
+                self.config.getboolean("radicale", "enabled")):
+            radicale_backup = os.path.join(self.config.get(
+                "radicale", "home_dir", fallback="/srv/radicale"), "collections")
+            if os.path.isdir(radicale_backup):
+                shutil.copytree(radicale_backup, os.path.join(
+                    custom_path, "radicale"))
+                utils.printcolor("Radicale files saved", utils.GREEN)
+
+        # AMAVIS
+        if (self.config.has_option("amavis", "enabled") and
+                self.config.getboolean("amavis", "enabled")):
+            amavis_custom = "/etc/amavis/conf.d/99-custom"
+            if os.path.isfile(amavis_custom):
+                utils.copy_file(amavis_custom, custom_path)
+                utils.printcolor(
+                    "Amavis custom configuration saved!", utils.GREEN)
+
+        # POSTWHITE
+        if (self.config.has_option("postwhite", "enabled") and
+                self.config.getboolean("postwhite", "enabled")):
+            postswhite_custom = "/etc/postwhite.conf"
+            if os.path.isfile(postswhite_custom):
+                utils.copy_file(postswhite_custom, custom_path)
+                utils.printcolor(
+                    "Postwhite configuration saved!", utils.GREEN)
+
+    def database_backup(self):
+        """Backing up databases"""
+
+        utils.printcolor("Backing up databases...", utils.MAGENTA)
+
+        self.database_dump("modoboa")
+        self.database_dump("amavis")
+        self.database_dump("spamassassin")
+
+    def database_dump(self, app_name):
+
+        dump_path = os.path.join(self.backup_path, "databases")
+        backend = database.get_backend(self.config)
+
+        if app_name == "modoboa" or (self.config.has_option(app_name, "enabled") and
+                                     self.config.getboolean(app_name, "enabled")):
+            dbname = self.config.get(app_name, "dbname")
+            dbuser = self.config.get(app_name, "dbuser")
+            dbpasswd = self.config.get(app_name, "dbpassword")
+            backend.dump_database(dbname, dbuser, dbpasswd,
+                                  os.path.join(dump_path, f"{app_name}.sql"))
+
+    def backup_completed(self):
+        utils.printcolor("Backup process done, your backup is available here:"
+                         f"--> {self.backup_path}", utils.GREEN)
+
+    def run(self):
+        self.set_path()
+        self.config_file_backup()
+        self.mail_backup()
+        self.custom_config_backup()
+        self.database_backup()
+        self.backup_completed()

modoboa_installer/scripts/base.py

@@ -31,12 +31,12 @@ class Installer:
             self.app_config = dict(self.config.items(self.appname))
         self.dbengine = self.config.get("database", "engine")
         # Used to install system packages
-        self.db_driver = "pgsql" if self.dbengine == "postgres" else self.dbengine
+        self.db_driver = (
+            "pgsql" if self.dbengine == "postgres" else self.dbengine)
         self.backend = database.get_backend(self.config)
         self.dbhost = self.config.get("database", "host")
         self.dbport = self.config.get(
-            "database", "port", fallback=self.backend.default_port
-        )
+            "database", "port", fallback=self.backend.default_port)
         self._config_dir = None
         if not self.with_db:
             return
@@ -50,19 +50,19 @@ class Installer:
         modoboa_version = python.get_package_version(
             "modoboa",
             self.config.get("modoboa", "venv_path"),
-            sudo_user=self.config.get("modoboa", "user"),
+            sudo_user=self.config.get("modoboa", "user")
             )
         condition = (
-            int(modoboa_version[0]) == 2 and int(modoboa_version[1]) >= 2
-        ) or int(modoboa_version[0]) > 2
+            (int(modoboa_version[0]) == 2 and int(modoboa_version[1]) >= 2) or
+            int(modoboa_version[0]) > 2
+            )
         return condition
 
     @property
     def config_dir(self):
         """Return main configuration directory."""
         if self._config_dir is None and self.config.has_option(
-            self.appname, "config_dir"
-        ):
+                self.appname, "config_dir"):
             self._config_dir = self.config.get(self.appname, "config_dir")
         return self._config_dir
 
@@ -73,11 +73,11 @@ class Installer:
     def get_sql_schema_from_backup(self):
         """Retrieve a dump path from a previous backup."""
         utils.printcolor(
-            f"Trying to restore {self.appname} database from backup.", utils.MAGENTA
+            f"Trying to restore {self.appname} database from backup.",
+            utils.MAGENTA
         )
         database_backup_path = os.path.join(
-            self.archive_path, f"databases/{self.appname}.sql"
-        )
+            self.archive_path, f"databases/{self.appname}.sql")
         if os.path.isfile(database_backup_path):
             utils.success(f"SQL dump found in backup for {self.appname}!")
             return database_backup_path
@@ -86,7 +86,8 @@ class Installer:
     def get_file_path(self, fname):
         """Return the absolute path of this file."""
         return os.path.abspath(
-            os.path.join(os.path.dirname(__file__), "files", self.appname, fname)
+            os.path.join(
+                os.path.dirname(__file__), "files", self.appname, fname)
         )
 
     def setup_database(self):
@@ -101,7 +102,8 @@ class Installer:
         if not schema:
             schema = self.get_sql_schema_path()
         if schema:
-            self.backend.load_sql_file(self.dbname, self.dbuser, self.dbpasswd, schema)
+            self.backend.load_sql_file(
+                self.dbname, self.dbuser, self.dbpasswd, schema)
 
     def setup_user(self):
         """Setup a system user."""
@@ -117,7 +119,8 @@ class Installer:
     def get_template_context(self):
         """Return context used for template rendering."""
         context = {
-            "dbengine": ("Pg" if self.dbengine == "postgres" else self.dbengine),
+            "dbengine": (
+                "Pg" if self.dbengine == "postgres" else self.dbengine),
             "dbhost": self.dbhost,
             "dbport": self.dbport,
         }
@@ -169,11 +172,9 @@ class Installer:
             utils.copy_from_template(src, dst, context)
 
     def backup(self, path):
-        self.base_backup_path = path
         if self.with_db:
             self._dump_database(path)
-        custom_backup_path = os.path.join(path, "custom", self.appname)
-        utils.mkdir_safe(custom_backup_path)
+        custom_backup_path = os.path.join(path, "custom")
         self.custom_backup(custom_backup_path)
 
     def custom_backup(self, path):
@@ -212,7 +213,8 @@ class Installer:
         """Create a new database dump for this app."""
         target_dir = os.path.join(backup_path, "databases")
         target_file = os.path.join(target_dir, f"{self.appname}.sql")
-        self.backend.dump_database(self.dbname, self.dbuser, self.dbpasswd, target_file)
+        self.backend.dump_database(
+            self.dbname, self.dbuser, self.dbpasswd, target_file)
 
     def pre_run(self):
         """Tasks to execute before the installer starts."""

modoboa_installer/scripts/dovecot.py

@@ -43,6 +43,7 @@ class Dovecot(base.Installer):
             "conf.d/10-master.conf",
             "conf.d/10-ssl.conf",
             "conf.d/10-ssl-keys.try",
+            "conf.d/15-mailboxes.conf",
             "conf.d/20-lmtp.conf",
             "conf.d/auth-oauth2.conf.ext",
         ],
@@ -153,7 +154,10 @@ class Dovecot(base.Installer):
             protocols = ""
 
         oauth2_client_id, oauth2_client_secret = utils.create_oauth2_app(
-            "Dovecot", "dovecot", self.config
+            "Dovecot",
+            "dovecot",
+            self.config.get("dovecot", "oauth2_client_secret"),
+            self.config
         )
         hostname = self.config.get("general", "hostname")
         oauth2_introspection_url = (
@@ -269,7 +273,7 @@ class Dovecot(base.Installer):
         dst = os.path.join(path, "mails/")
         if os.path.exists(dst):
             shutil.rmtree(dst)
-        shutil.copytree(home_dir, dst, dirs_exist_ok=True)
+        shutil.copytree(home_dir, dst)
         utils.success("Mail backup complete!")
 
     def restore(self):

modoboa_installer/scripts/files/dovecot/2.4/conf.d/15-mailboxes.conf.tpl

@@ -0,0 +1,90 @@
+##
+## Mailbox definitions
+##
+
+# Each mailbox is specified in a separate mailbox section. The section name
+# specifies the mailbox name. If it has spaces, you can put the name
+# "in quotes". These sections can contain the following mailbox settings:
+#
+# auto:
+#   Indicates whether the mailbox with this name is automatically created
+#   implicitly when it is first accessed. The user can also be automatically
+#   subscribed to the mailbox after creation. The following values are
+#   defined for this setting:
+#
+#     no        - Never created automatically.
+#     create    - Automatically created, but no automatic subscription.
+#     subscribe - Automatically created and subscribed.
+#
+# special_use:
+#   A space-separated list of SPECIAL-USE flags (RFC 6154) to use for the
+#   mailbox. There are no validity checks, so you could specify anything
+#   you want in here, but it's not a good idea to use flags other than the
+#   standard ones specified in the RFC:
+#
+#     \All       - This (virtual) mailbox presents all messages in the
+#                  user's message store.
+#     \Archive   - This mailbox is used to archive messages.
+#     \Drafts    - This mailbox is used to hold draft messages.
+#     \Flagged   - This (virtual) mailbox presents all messages in the
+#                  user's message store marked with the IMAP \Flagged flag.
+#     \Important - This (virtual) mailbox presents all messages in the
+#                  user's message store deemed important to user.
+#     \Junk      - This mailbox is where messages deemed to be junk mail
+#                  are held.
+#     \Sent      - This mailbox is used to hold copies of messages that
+#                  have been sent.
+#     \Trash     - This mailbox is used to hold messages that have been
+#                  deleted.
+#
+# comment:
+#   Defines a default comment or note associated with the mailbox. This
+#   value is accessible through the IMAP METADATA mailbox entries
+#   "/shared/comment" and "/private/comment". Users with sufficient
+#   privileges can override the default value for entries with a custom
+#   value.
+
+# NOTE: Assumes "namespace inbox" has been defined in 10-mail.conf.
+namespace inbox {
+  # These mailboxes are widely used and could perhaps be created automatically:
+  mailbox Drafts {
+    auto = subscribe
+    special_use = \Drafts
+  }
+  mailbox Junk {
+    auto = subscribe
+    special_use = \Junk
+  }
+  mailbox Trash {
+    auto = subscribe
+    special_use = \Trash
+  }
+
+  # For \Sent mailboxes there are two widely used names. We'll mark both of
+  # them as \Sent. User typically deletes one of them if duplicates are created.
+  mailbox Sent {
+    auto = subscribe
+    special_use = \Sent
+  }
+  # mailbox "Sent Messages" {
+  #   special_use = \Sent
+  # }
+
+  # If you have a virtual "All messages" mailbox:
+  #mailbox virtual/All {
+  #  special_use = \All
+  #  comment = All my messages
+  #}
+
+  # If you have a virtual "Flagged" mailbox:
+  #mailbox virtual/Flagged {
+  #  special_use = \Flagged
+  #  comment = All my flagged messages
+  #}
+
+  # If you have a virtual "Important" mailbox:
+  #mailbox virtual/Important {
+  #  special_use = \Important
+  #  comment = All my important messages
+  #}
+}

modoboa_installer/scripts/files/nginx/autoconfig.conf.tpl

@@ -9,6 +9,7 @@ server {
 
     location ~ ^/(mail/config-v1.1.xml|mobileconfig) {
         include uwsgi_params;
+        uwsgi_param UWSGI_SCRIPT instance.wsgi:application;
         uwsgi_pass modoboa;
     }
 }

modoboa_installer/scripts/opendkim.py

@@ -16,7 +16,10 @@ class Opendkim(base.Installer):
     """OpenDKIM installer."""
 
     appname = "opendkim"
-    packages = {"deb": ["opendkim"], "rpm": ["opendkim"]}
+    packages = {
+        "deb": ["opendkim"],
+        "rpm": ["opendkim"]
+    }
     config_files = ["opendkim.conf", "opendkim.hosts"]
 
     def get_packages(self):
@@ -33,34 +36,30 @@ class Opendkim(base.Installer):
         """Make sure config directory exists."""
         user = self.config.get("opendkim", "user")
         pw = pwd.getpwnam(user)
-        targets = [[self.app_config["keys_storage_dir"], pw[2], pw[3]]]
+        targets = [
+            [self.app_config["keys_storage_dir"], pw[2], pw[3]]
+        ]
         for target in targets:
             if not os.path.exists(target[0]):
                 utils.mkdir(
                     target[0],
-                    stat.S_IRWXU
-                    | stat.S_IRGRP
-                    | stat.S_IXGRP
-                    | stat.S_IROTH
-                    | stat.S_IXOTH,
-                    target[1],
-                    target[2],
+                    stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
+                    stat.S_IROTH | stat.S_IXOTH,
+                    target[1], target[2]
                 )
         super().install_config_files()
 
     def get_template_context(self):
         """Additional variables."""
         context = super(Opendkim, self).get_template_context()
-        context.update(
-            {
+        context.update({
             "db_driver": self.db_driver,
             "db_name": self.config.get("modoboa", "dbname"),
             "db_user": self.app_config["dbuser"],
             "db_password": self.app_config["dbpassword"],
             "port": self.app_config["port"],
-                "user": self.app_config["user"],
-            }
-        )
+            "user": self.app_config["user"]
+        })
         return context
 
     def setup_database(self):
@@ -73,14 +72,11 @@ class Opendkim(base.Installer):
         dbuser = self.config.get("modoboa", "dbuser")
         dbpassword = self.config.get("modoboa", "dbpassword")
         self.backend.load_sql_file(
-            dbname,
-            dbuser,
-            dbpassword,
-            self.get_file_path("dkim_view_{}.sql".format(self.dbengine)),
+            dbname, dbuser, dbpassword,
+            self.get_file_path("dkim_view_{}.sql".format(self.dbengine))
         )
         self.backend.grant_right_on_table(
-            dbname, "dkim", self.app_config["dbuser"], "SELECT"
-        )
+            dbname, "dkim", self.app_config["dbuser"], "SELECT")
 
     def post_run(self):
         """Additional tasks.
@@ -94,33 +90,31 @@ class Opendkim(base.Installer):
         else:
             params_file = "/etc/opendkim.conf"
         pattern = r"s/^(SOCKET=.*)/#\1/"
-        utils.exec_cmd("perl -pi -e '{}' {}".format(pattern, params_file))
+        utils.exec_cmd(
+            "perl -pi -e '{}' {}".format(pattern, params_file))
         with open(params_file, "a") as f:
-            f.write(
-                "\n".join(
-                    [
+            f.write('\n'.join([
                 "",
                 'SOCKET="inet:12345@localhost"',
-                    ]
-                )
-            )
+            ]))
 
         # Make sure opendkim is started after postgresql and mysql,
         # respectively.
-        if self.dbengine != "postgres" and package.backend.FORMAT == "deb":
+        if (self.dbengine != "postgres" and package.backend.FORMAT == "deb"):
             dbservice = "mysql.service"
-        elif self.dbengine != "postgres" and package.backend.FORMAT != "deb":
+        elif (self.dbengine != "postgres" and package.backend.FORMAT != "deb"):
             dbservice = "mysqld.service"
         else:
             dbservice = "postgresql.service"
-        pattern = "s/^After=(.*)$/After=$1 {}/".format(dbservice)
+        pattern = (
+            "s/^After=(.*)$/After=$1 {}/".format(dbservice))
         utils.exec_cmd(
-            "perl -pi -e '{}' /lib/systemd/system/opendkim.service".format(pattern)
-        )
+            "perl -pi -e '{}' /lib/systemd/system/opendkim.service".format(pattern))
 
     def restore(self):
         """Restore keys."""
-        dkim_keys_backup = os.path.join(self.archive_path, "custom/opendkim")
+        dkim_keys_backup = os.path.join(
+            self.archive_path, "custom/dkim")
         keys_storage_dir = self.app_config["keys_storage_dir"]
         if os.path.isdir(dkim_keys_backup):
             for file in os.listdir(dkim_keys_backup):
@@ -135,7 +129,6 @@ class Opendkim(base.Installer):
     def custom_backup(self, path):
         """Backup DKIM keys."""
         if os.path.isdir(self.app_config["keys_storage_dir"]):
-            shutil.copytree(
-                self.app_config["keys_storage_dir"], path, dirs_exist_ok=True
-            )
-            utils.printcolor("DKIM keys saved!", utils.GREEN)
+            shutil.copytree(self.app_config["keys_storage_dir"], os.path.join(path, "dkim"))
+            utils.printcolor(
+                "DKIM keys saved!", utils.GREEN)

modoboa_installer/scripts/postwhite.py

@@ -19,7 +19,10 @@ class Postwhite(base.Installer):
         "crontab=/etc/cron.d/postwhite",
     ]
     no_daemon = True
-    packages = {"deb": ["bind9-host", "unzip"], "rpm": ["bind-utils", "unzip"]}
+    packages = {
+        "deb": ["bind9-host", "unzip"],
+        "rpm": ["bind-utils", "unzip"]
+    }
 
     def install_from_archive(self, repository, target_dir):
         """Install from an archive."""
@@ -33,7 +36,8 @@ class Postwhite(base.Installer):
         if os.path.exists(archive_dir):
             shutil.rmtree(archive_dir)
         utils.exec_cmd("unzip master.zip", cwd=target_dir)
-        utils.exec_cmd("mv {name}-master {name}".format(name=app_name), cwd=target_dir)
+        utils.exec_cmd(
+            "mv {name}-master {name}".format(name=app_name), cwd=target_dir)
         os.unlink(target)
         return archive_dir
 
@@ -41,8 +45,10 @@ class Postwhite(base.Installer):
         """Additionnal tasks."""
         install_dir = "/usr/local/bin"
         self.install_from_archive(SPF_TOOLS_REPOSITORY, install_dir)
-        self.postw_dir = self.install_from_archive(POSTWHITE_REPOSITORY, install_dir)
-        utils.copy_file(os.path.join(self.postw_dir, "postwhite.conf"), self.config_dir)
+        self.postw_dir = self.install_from_archive(
+            POSTWHITE_REPOSITORY, install_dir)
+        utils.copy_file(
+            os.path.join(self.postw_dir, "postwhite.conf"), self.config_dir)
         self.postw_bin = os.path.join(self.postw_dir, "postwhite")
         utils.exec_cmd("{} /etc/postwhite.conf".format(self.postw_bin))
 
@@ -51,13 +57,13 @@ class Postwhite(base.Installer):
         postswhite_custom = "/etc/postwhite.conf"
         if os.path.isfile(postswhite_custom):
             utils.copy_file(postswhite_custom, path)
-            utils.printcolor("Postwhite configuration saved!", utils.GREEN)
+            utils.printcolor(
+                "Postwhite configuration saved!", utils.GREEN)
 
     def restore(self):
         """Restore config files."""
         postwhite_backup_configuration = os.path.join(
-            self.archive_path, "custom/postwhite/postwhite.conf"
-        )
+            self.archive_path, "custom/postwhite.conf")
         if os.path.isfile(postwhite_backup_configuration):
             utils.copy_file(postwhite_backup_configuration, self.config_dir)
             utils.success("postwhite.conf restored from backup")

modoboa_installer/scripts/radicale.py

@@ -18,7 +18,10 @@ class Radicale(base.Installer):
     appname = "radicale"
     config_files = ["config"]
     no_daemon = True
-    packages = {"deb": ["supervisor"], "rpm": ["supervisor"]}
+    packages = {
+        "deb": ["supervisor"],
+        "rpm": ["supervisor"]
+    }
     with_user = True
 
     def __init__(self, *args, **kwargs):
@@ -29,25 +32,28 @@ class Radicale(base.Installer):
     def _setup_venv(self):
         """Prepare a dedicated virtualenv."""
         python.setup_virtualenv(self.venv_path, sudo_user=self.user)
-        packages = ["Radicale", "pytz", "radicale-modoboa-auth-oauth2"]
+        packages = [
+            "Radicale", "pytz", "radicale-modoboa-auth-oauth2"
+        ]
         python.install_packages(packages, self.venv_path, sudo_user=self.user)
 
     def get_template_context(self):
         """Additional variables."""
         context = super().get_template_context()
         oauth2_client_id, oauth2_client_secret = utils.create_oauth2_app(
-            "Radicale", "radicale", self.config
+            "Radicale",
+            "radicale",
+            self.config.get("radicale", "oauth2_client_secret"),
+            self.config
         )
         hostname = self.config.get("general", "hostname")
         oauth2_introspection_url = (
             f"https://{oauth2_client_id}:{oauth2_client_secret}"
             f"@{hostname}/api/o/introspect/"
         )
-        context.update(
-            {
+        context.update({
             "oauth2_introspection_url": oauth2_introspection_url,
-            }
-        )
+        })
         return context
 
     def get_config_files(self):
@@ -65,19 +71,16 @@ class Radicale(base.Installer):
         if not os.path.exists(self.config_dir):
             utils.mkdir(
                 self.config_dir,
-                stat.S_IRWXU
-                | stat.S_IRGRP
-                | stat.S_IXGRP
-                | stat.S_IROTH
-                | stat.S_IXOTH,
-                0,
-                0,
+                stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
+                stat.S_IROTH | stat.S_IXOTH,
+                0, 0
             )
         super().install_config_files()
 
     def restore(self):
         """Restore collections."""
-        radicale_backup = os.path.join(self.archive_path, "custom/radicale")
+        radicale_backup = os.path.join(
+            self.archive_path, "custom/radicale")
         if os.path.isdir(radicale_backup):
             restore_target = os.path.join(self.home_dir, "collections")
             if os.path.isdir(restore_target):
@@ -88,17 +91,18 @@ class Radicale(base.Installer):
     def post_run(self):
         """Additional tasks."""
         self._setup_venv()
-        daemon_name = "supervisor" if package.backend.FORMAT == "deb" else "supervisord"
+        daemon_name = (
+            "supervisor" if package.backend.FORMAT == "deb" else "supervisord"
+        )
         system.enable_service(daemon_name)
         utils.exec_cmd("service {} stop".format(daemon_name))
         utils.exec_cmd("service {} start".format(daemon_name))
 
     def custom_backup(self, path):
         """Backup collections."""
-        radicale_backup = os.path.join(
-            self.config.get("radicale", "home_dir", fallback="/srv/radicale"),
-            "collections",
-        )
+        radicale_backup = os.path.join(self.config.get(
+            "radicale", "home_dir", fallback="/srv/radicale"), "collections")
         if os.path.isdir(radicale_backup):
-            shutil.copytree(radicale_backup, path, dirs_exist_ok=True)
+            shutil.copytree(radicale_backup, os.path.join(
+                path, "radicale"))
             utils.printcolor("Radicale files saved", utils.GREEN)

modoboa_installer/scripts/rspamd.py

@@ -16,7 +16,11 @@ class Rspamd(base.Installer):
     """Rspamd installer."""
 
     appname = "rspamd"
-    packages = {"deb": ["rspamd", "redis"]}
+    packages = {
+        "deb": [
+            "rspamd", "redis"
+        ]
+    }
     config_files = [
         "local.d/arc.conf",
         "local.d/dkim_signing.conf",
@@ -35,9 +39,10 @@ class Rspamd(base.Installer):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.generate_password_condition = not self.upgrade or utils.user_input(
-            "Do you want to (re)generate rspamd password ? (y/N)"
-        ).lower().startswith("y")
+        self.generate_password_condition = (
+            not self.upgrade or utils.user_input(
+                "Do you want to (re)generate rspamd password ? (y/N)").lower().startswith("y")
+        )
 
     @property
     def config_dir(self):
@@ -49,20 +54,16 @@ class Rspamd(base.Installer):
         if debian_based_dist:
             utils.mkdir_safe(
                 "/etc/apt/keyrings",
-                stat.S_IRWXU
-                | stat.S_IRGRP
-                | stat.S_IXGRP
-                | stat.S_IROTH
-                | stat.S_IXOTH,
-                0,
-                0,
+                stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
+                stat.S_IROTH | stat.S_IXOTH,
+                0, 0
             )
 
             package.backend.add_custom_repository(
                 "rspamd",
                 "http://rspamd.com/apt-stable/",
                 "https://rspamd.com/apt-stable/gpg.key",
-                codename,
+                codename
             )
             package.backend.update()
 
@@ -72,18 +73,16 @@ class Rspamd(base.Installer):
         """Make sure config directory exists."""
         user = self.config.get(self.appname, "user")
         pw = pwd.getpwnam(user)
-        targets = [[self.app_config["dkim_keys_storage_dir"], pw[2], pw[3]]]
+        targets = [
+            [self.app_config["dkim_keys_storage_dir"], pw[2], pw[3]]
+        ]
         for target in targets:
             if not os.path.exists(target[0]):
                 utils.mkdir(
                     target[0],
-                    stat.S_IRWXU
-                    | stat.S_IRGRP
-                    | stat.S_IXGRP
-                    | stat.S_IROTH
-                    | stat.S_IXOTH,
-                    target[1],
-                    target[2],
+                    stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP |
+                    stat.S_IROTH | stat.S_IXOTH,
+                    target[1], target[2]
                 )
         super().install_config_files()
 
@@ -102,23 +101,16 @@ class Rspamd(base.Installer):
 
     def get_template_context(self):
         _context = super().get_template_context()
-        _context["greylisting_disabled"] = (
-            "" if not self.app_config["greylisting"].lower() == "true" else "#"
-        )
-        _context["whitelist_auth_enabled"] = (
-            "" if self.app_config["whitelist_auth"].lower() == "true" else "#"
-        )
+        _context["greylisting_disabled"] = "" if not self.app_config["greylisting"].lower() == "true" else "#"
+        _context["whitelist_auth_enabled"] = "" if self.app_config["whitelist_auth"].lower() == "true" else "#"
         if self.generate_password_condition:
             code, controller_password = utils.exec_cmd(
-                r"rspamadm pw -p {}".format(self.app_config["password"])
-            )
+                r"rspamadm pw -p {}".format(self.app_config["password"]))
             if code != 0:
-                utils.error(
-                    "Error setting rspamd password. "
+                utils.error("Error setting rspamd password. "
                             "Please make sure it is not 'q1' or 'q2'."
                             "Storing the password in plain. See"
-                    "https://rspamd.com/doc/quickstart.html#setting-the-controller-password"
-                )
+                            "https://rspamd.com/doc/quickstart.html#setting-the-controller-password")
                 _context["controller_password"] = self.app_config["password"]
             else:
                 controller_password = controller_password.decode().replace("\n", "")
@@ -128,59 +120,35 @@ class Rspamd(base.Installer):
     def post_run(self):
         """Additional tasks."""
         user = self.config.get(self.appname, "user")
-        system.add_user_to_group(self.config.get("modoboa", "user"), user)
+        system.add_user_to_group(
+            self.config.get("modoboa", "user"),
+            user
+        )
         if self.config.getboolean("clamav", "enabled"):
             install("clamav", self.config, self.upgrade, self.archive_path)
 
-    def backup(self, path):
-        self._dump_database(path)
-        super().backup(path)
-
-    def _dump_database(self, backup_path: str):
-        """Copy the rrd file containing the redis db for rspamd.
-        Uses the default path on debian 13,
-        it may be somewhere else on other distros..."""
-        rspamd_redis_db = "/var/lib/rspamd/rspamd.rrd"
-        if not os.path.isfile(rspamd_redis_db):
-            return
-        target_dir = os.path.join(backup_path, "databases")
-        target_file = os.path.join(target_dir, "rspamd.rrd")
-        system.stop_service("redis")
-        utils.copy_file(rspamd_redis_db, target_file)
-        system.restart_service("redis")
-
     def custom_backup(self, path):
         """Backup custom configuration if any."""
-        custom_config_dir = os.path.join(self.config_dir, "local.d/")
-        local_files = [
-            os.path.join(custom_config_dir, f)
-            for f in os.listdir(custom_config_dir)
-            if os.path.isfile(os.path.join(custom_config_dir, f))
+        custom_config_dir = os.path.join(self.config_dir,
+                                         "/local.d/")
+        custom_backup_dir = os.path.join(path, "/rspamd/")
+        local_files = [f for f in os.listdir(custom_config_dir)
+                       if os.path.isfile(custom_config_dir, f)
                        ]
-        backup_locald_path = os.path.join(path, "local.d")
-        if local_files:
-            utils.mkdir_safe(backup_locald_path)
         for file in local_files:
-            basename = os.path.basename(file)
-            utils.copy_file(file, os.path.join(backup_locald_path, basename))
-        if local_files:
+            utils.copy_file(file, custom_backup_dir)
+        if len(local_files) != 0:
             utils.success("Rspamd custom configuration saved!")
 
     def restore(self):
         """Restore custom config files."""
-        custom_config_dir = os.path.join(self.config_dir, "/local.d/")
+        custom_config_dir = os.path.join(self.config_dir,
+                                         "/local.d/")
         custom_backup_dir = os.path.join(self.archive_path, "/rspamd/")
         backed_up_files = [
-            f
-            for f in os.listdir(custom_backup_dir)
+            f for f in os.listdir(custom_backup_dir)
             if os.path.isfile(custom_backup_dir, f)
         ]
         for f in backed_up_files:
             utils.copy_file(f, custom_config_dir)
-        rspamd_redis_db = "/var/lib/rspamd"
-        rspamd_redis_db_backup = os.path.join(self.archive_path, "databases/rspamd.rrd")
-        if os.path.isdir(rspamd_redis_db) and os.path.isfile(rspamd_redis_db_backup):
-            system.stop_service("redis")
-            utils.copy_file(rspamd_redis_db_backup, rspamd_redis_db)
-            system.restart_service("redis")
         utils.success("Custom Rspamd configuration restored.")

modoboa_installer/system.py

@@ -16,13 +16,12 @@ def create_user(name, home=None):
     else:
         extra_message = "."
         if home:
-            extra_message = " but please make sure the {} directory exists.".format(
-                home
-            )
+            extra_message = (
+                " but please make sure the {} directory exists.".format(
+                    home))
         utils.printcolor(
-            "User {} already exists, skipping creation{}".format(name, extra_message),
-            utils.YELLOW,
-        )
+            "User {} already exists, skipping creation{}".format(
+                name, extra_message), utils.YELLOW)
         return
     cmd = "useradd -m "
     if home:
@@ -63,8 +62,3 @@ def enable_and_start_service(name):
 def restart_service(name):
     """Restart a service."""
     utils.exec_cmd("service {} restart".format(name))
-
-
-def stop_service(name):
-    """Stop a service."""
-    utils.exec_cmd(f"service {name} stop")

modoboa_installer/utils.py

@@ -13,7 +13,6 @@ import stat
 import string
 import subprocess
 import sys
-import uuid
 
 from . import config_dict_template
 from .compatibility_matrix import APP_INCOMPATIBILITY
@@ -24,6 +23,7 @@ BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
 
 
 class FatalError(Exception):
+
     """A simple exception."""
 
     pass
@@ -76,14 +76,16 @@ def dist_info():
         info = {}
         with open(path) as fp:
             for line in fp.readlines():
-                if line == "\n":
+                if line == '\n':
                     continue
                 key, value = line.split("=")
                 value = value.rstrip('"\n')
                 value = value.strip('"')
                 info[key] = value
         return info["NAME"], info["VERSION_ID"]
-    printcolor("Failed to retrieve information about your system, aborting.", RED)
+    printcolor(
+        "Failed to retrieve information about your system, aborting.",
+        RED)
     sys.exit(1)
 
 
@@ -96,27 +98,14 @@ def is_dist_debian_based() -> (bool, str):
     """Check if current OS is Debian based or not."""
     status, codename = exec_cmd("lsb_release -c -s")
     codename = codename.decode().strip().lower()
-    return (
-        codename
-        in [
-            "bionic",
-            "bookworm",
-            "bullseye",
-            "buster",
-            "focal",
-            "jammy",
-            "jessie",
-            "sid",
-            "stretch",
-            "trusty",
-            "wheezy",
-            "xenial",
-        ],
-        codename,
-    )
+    return codename in [
+        "bionic", "bookworm", "bullseye", "buster",
+        "focal", "jammy", "jessie", "sid", "stretch",
+        "trusty", "wheezy", "xenial"
+    ], codename
 
 
-def mkdir(path, mode=0o777, uid=os.getuid(), gid=os.getgid()):
+def mkdir(path, mode, uid, gid):
     """Create a directory."""
     if not os.path.exists(path):
         os.mkdir(path, mode)
@@ -125,7 +114,7 @@ def mkdir(path, mode=0o777, uid=os.getuid(), gid=os.getgid()):
     os.chown(path, uid, gid)
 
 
-def mkdir_safe(path, mode=0o777, uid=os.getuid(), gid=os.getgid()):
+def mkdir_safe(path, mode, uid, gid):
     """Create a directory. Safe way (-p)"""
     if not os.path.exists(path):
         os.makedirs(os.path.abspath(path), mode)
@@ -135,9 +124,8 @@ def mkdir_safe(path, mode=0o777, uid=os.getuid(), gid=os.getgid()):
 def make_password(length=16):
     """Create a random password."""
     return "".join(
-        random.SystemRandom().choice(string.ascii_letters + string.digits)
-        for _ in range(length)
-    )
+        random.SystemRandom().choice(
+            string.ascii_letters + string.digits) for _ in range(length))
 
 
 @contextlib.contextmanager
@@ -160,7 +148,8 @@ def backup_file(fname):
     """Create a backup of a given file."""
     for f in glob.glob("{}.old.*".format(fname)):
         os.unlink(f)
-    bak_name = "{}.old.{}".format(fname, datetime.datetime.now().isoformat())
+    bak_name = "{}.old.{}".format(
+        fname, datetime.datetime.now().isoformat())
     shutil.copy(fname, bak_name)
 
 
@@ -181,13 +170,17 @@ def copy_from_template(template, dest, context):
     if os.path.isfile(dest):
         backup_file(dest)
     with open(dest, "w") as fp:
-        fp.write("# This file was automatically installed on {}\n".format(now))
+        fp.write(
+            "# This file was automatically installed on {}\n"
+            .format(now))
         fp.write(ConfigFileTemplate(buf).substitute(context))
 
 
-def check_config_file(
-    dest, interactive=False, upgrade=False, backup=False, restore=False
-):
+def check_config_file(dest,
+                      interactive=False,
+                      upgrade=False,
+                      backup=False,
+                      restore=False):
     """Create a new installer config file if needed."""
     is_present = True
     if os.path.exists(dest):
@@ -195,25 +188,22 @@ def check_config_file(
     if upgrade:
         error(
             "You cannot upgrade an existing installation without a "
-            "configuration file."
-        )
+            "configuration file.")
         sys.exit(1)
     elif backup:
         is_present = False
         error(
             "Your configuration file hasn't been found. A new one will be generated. "
-            "Please edit it with correct password for the databases !"
-        )
+            "Please edit it with correct password for the databases !")
     elif restore:
         error(
             "You cannot restore an existing installation without a "
-            f"configuration file. (file : {dest} has not been found..."
-        )
+            f"configuration file. (file : {dest} has not been found...")
         sys.exit(1)
 
     printcolor(
-        "Configuration file {} not found, creating new one.".format(dest), YELLOW
-    )
+        "Configuration file {} not found, creating new one."
+        .format(dest), YELLOW)
     gen_config(dest, interactive)
     return is_present, None
 
@@ -226,7 +216,6 @@ def has_colours(stream):
         return False  # auto color only on TTYs
     try:
         import curses
-
         curses.setupterm()
         return curses.tigetnum("colors") > 2
     except:
@@ -261,9 +250,8 @@ def convert_version_to_int(version):
     numbers = [int(number_string) for number_string in version.split(".")]
     if len(numbers) > len(number_bits):
         raise NotImplementedError(
-            "Versions with more than {0} decimal places are not supported".format(
-                len(number_bits) - 1
-            )
+            "Versions with more than {0} decimal places are not supported"
+            .format(len(number_bits) - 1)
         )
     # add 0s for missing numbers
     numbers.extend([0] * (len(number_bits) - len(numbers)))
@@ -274,9 +262,8 @@ def convert_version_to_int(version):
         max_num = (bits + 1) - 1
         if num >= 1 << max_num:
             raise ValueError(
-                "Number {0} cannot be stored with only {1} bits. Max is {2}".format(
-                    num, bits, max_num
-                )
+                "Number {0} cannot be stored with only {1} bits. Max is {2}"
+                .format(num, bits, max_num)
             )
         number += num << total_bits
         total_bits += bits
@@ -327,9 +314,7 @@ def validate(value, config_entry):
         return True
 
 
-def get_entry_value(
-    entry: dict, interactive: bool, config: configparser.ConfigParser
-) -> string:
+def get_entry_value(entry: dict, interactive: bool, config: configparser.ConfigParser) -> string:
     default_entry = entry["default"]
     if type(default_entry) is type(list()):
         default_value = str(check_if_condition(config, default_entry)).lower()
@@ -339,7 +324,7 @@ def get_entry_value(
         default_value = default_entry
     user_value = None
     if entry.get("customizable") and interactive:
-        while user_value != "" and not validate(user_value, entry):
+        while (user_value != '' and not validate(user_value, entry)):
             question = entry.get("question")
             if entry.get("values"):
                 question += " from the list"
@@ -380,10 +365,14 @@ def load_config_template(interactive):
         config.add_section(section["name"])
         for config_entry in section["values"]:
             if config_entry.get("if") is not None:
-                interactive_section = interactive_section and check_if_condition(
+                interactive_section = (interactive_section and
+                                       check_if_condition(
                                            config, config_entry["if"]
                                            )
-            value = get_entry_value(config_entry, interactive_section, config)
+                                       )
+            value = get_entry_value(config_entry,
+                                    interactive_section,
+                                    config)
             config.set(section["name"], config_entry["option"], value)
     return config
 
@@ -403,11 +392,10 @@ def update_config(path, apply_update=True):
     dropped_sections = list(set(old_sections) - set(new_sections))
     added_sections = list(set(new_sections) - set(old_sections))
     if len(dropped_sections) > 0 and apply_update:
-        printcolor(
-            "Following section(s) will not be ported "
-            "due to being deleted or renamed: " + ", ".join(dropped_sections),
-            RED,
-        )
+        printcolor("Following section(s) will not be ported "
+                   "due to being deleted or renamed: " +
+                   ', '.join(dropped_sections),
+                   RED)
 
     if len(dropped_sections) + len(added_sections) > 0:
         update = True
@@ -420,12 +408,11 @@ def update_config(path, apply_update=True):
             dropped_options = list(set(old_options) - set(new_options))
             added_options = list(set(new_options) - set(old_options))
             if len(dropped_options) > 0 and apply_update:
-                printcolor(
-                    f"Following option(s) from section: {section}, "
+                printcolor(f"Following option(s) from section: {section}, "
                            "will not be ported due to being "
-                    "deleted or renamed: " + ", ".join(dropped_options),
-                    RED,
-                )
+                           "deleted or renamed: " +
+                           ', '.join(dropped_options),
+                           RED)
             if len(dropped_options) + len(added_options) > 0:
                 update = True
 
@@ -478,27 +465,29 @@ def validate_backup_path(path: str, silent_mode: bool):
     """Check if provided backup path is valid or not."""
     path_exists = os.path.exists(path)
     if path_exists and os.path.isfile(path):
-        printcolor("Error, you provided a file instead of a directory!", RED)
+        printcolor(
+            "Error, you provided a file instead of a directory!", RED)
         return None
 
     if not path_exists:
         if not silent_mode:
             create_dir = input(
-                f'"{path}" doesn\'t exist, would you like to create it? [y/N]\n'
+                f"\"{path}\" doesn't exist, would you like to create it? [y/N]\n"
             ).lower()
 
         if silent_mode or (not silent_mode and create_dir.startswith("y")):
             pw = pwd.getpwnam("root")
             mkdir_safe(path, stat.S_IRWXU | stat.S_IRWXG, pw[2], pw[3])
         else:
-            printcolor("Error, backup directory not present.", RED)
+            printcolor(
+                "Error, backup directory not present.", RED
+            )
             return None
 
     if len(os.listdir(path)) != 0:
         if not silent_mode:
             delete_dir = input(
-                "Warning: backup directory is not empty, it will be purged if you continue... [y/N]\n"
-            ).lower()
+                "Warning: backup directory is not empty, it will be purged if you continue... [y/N]\n").lower()
 
         if silent_mode or (not silent_mode and delete_dir.startswith("y")):
             try:
@@ -506,30 +495,32 @@ def validate_backup_path(path: str, silent_mode: bool):
             except FileNotFoundError:
                 pass
 
-            shutil.rmtree(os.path.join(path, "custom"), ignore_errors=False)
+            shutil.rmtree(os.path.join(path, "custom"),
+                          ignore_errors=False)
             shutil.rmtree(os.path.join(path, "mails"), ignore_errors=False)
-            shutil.rmtree(os.path.join(path, "databases"), ignore_errors=False)
+            shutil.rmtree(os.path.join(path, "databases"),
+                          ignore_errors=False)
         else:
-            printcolor("Error: backup directory not clean.", RED)
+            printcolor(
+                "Error: backup directory not clean.", RED
+            )
             return None
 
     backup_path = path
     pw = pwd.getpwnam("root")
     for dir in ["custom/", "databases/"]:
-        mkdir_safe(
-            os.path.join(backup_path, dir), stat.S_IRWXU | stat.S_IRWXG, pw[2], pw[3]
-        )
+        mkdir_safe(os.path.join(backup_path, dir),
+                   stat.S_IRWXU | stat.S_IRWXG, pw[2], pw[3])
     return backup_path
 
 
-def create_oauth2_app(app_name: str, client_id: str, config) -> tuple[str, str]:
+def create_oauth2_app(app_name: str, client_id: str, client_secret: str, config) -> tuple[str, str]:
     """Create a application for Oauth2 authentication."""
     # FIXME: how can we check that application already exists ?
     venv_path = config.get("modoboa", "venv_path")
     python_path = os.path.join(venv_path, "bin", "python")
     instance_path = config.get("modoboa", "instance_path")
     script_path = os.path.join(instance_path, "manage.py")
-    client_secret = str(uuid.uuid4())
     cmd = (
         f"{python_path} {script_path} createapplication "
         f"--name={app_name} --skip-authorization "
@@ -546,9 +537,7 @@ def check_app_compatibility(section, config):
     if section in APP_INCOMPATIBILITY.keys():
         for app in APP_INCOMPATIBILITY[section]:
             if config.getboolean(app, "enabled"):
-                error(
-                    f"{section} cannot be installed if {app} is enabled. "
-                    "Please disable one of them."
-                )
+                error(f"{section} cannot be installed if {app} is enabled. "
+                      "Please disable one of them.")
                 incompatible_app.append(app)
     return len(incompatible_app) == 0

run.py

@@ -26,11 +26,11 @@ PRIMARY_APPS = [
     "uwsgi",
     "nginx",
     "postfix",
-    "dovecot",
+    "dovecot"
 ]
 
 
-def backup_system(config, args, antispam_apps):
+def backup_system(config, args):
     """Launch backup procedure."""
     disclaimers.backup_disclaimer()
     backup_path = None
@@ -52,7 +52,8 @@ def backup_system(config, args, antispam_apps):
         user_value = None
         while not user_value or not backup_path:
             utils.printcolor(
-                "Enter backup path (it must be an empty directory)", utils.MAGENTA
+                "Enter backup path (it must be an empty directory)",
+                utils.MAGENTA
             )
             utils.printcolor("CTRL+C to cancel", utils.MAGENTA)
             user_value = utils.user_input("-> ")
@@ -63,9 +64,7 @@ def backup_system(config, args, antispam_apps):
     # Backup configuration file
     utils.copy_file(args.configfile, backup_path)
     # Backup applications
-    for app in PRIMARY_APPS + antispam_apps:
-        if config.has_option(app, "enabled") and not config.getboolean(app, "enabled"):
-            continue
+    for app in PRIMARY_APPS:
         if app == "dovecot" and args.no_mail:
             utils.printcolor("Skipping mail backup", utils.BLUE)
             continue
@@ -73,97 +72,65 @@ def backup_system(config, args, antispam_apps):
 
 
 def config_file_update_complete(backup_location):
-    utils.printcolor("Update complete. It seems successful.", utils.BLUE)
+    utils.printcolor("Update complete. It seems successful.",
+                     utils.BLUE)
     if backup_location is not None:
-        utils.printcolor(
-            "You will find your old config file " f"here: {backup_location}", utils.BLUE
-        )
+        utils.printcolor("You will find your old config file "
+                         f"here: {backup_location}",
+                         utils.BLUE)
 
 
 def parser_setup(input_args):
     parser = argparse.ArgumentParser()
-    versions = ["latest"] + list(compatibility_matrix.COMPATIBILITY_MATRIX.keys())
+    versions = (
+        ["latest"] + list(compatibility_matrix.COMPATIBILITY_MATRIX.keys())
+        )
+    parser.add_argument("--debug", action="store_true", default=False,
+                        help="Enable debug output")
+    parser.add_argument("--force", action="store_true", default=False,
+                        help="Force installation")
+    parser.add_argument("--configfile", default="installer.cfg",
+                        help="Configuration file to use")
     parser.add_argument(
-        "--debug", action="store_true", default=False, help="Enable debug output"
+        "--version", default="latest", choices=versions,
+        help="Modoboa version to install")
+    parser.add_argument(
+        "--stop-after-configfile-check", action="store_true", default=False,
+        help="Check configuration, generate it if needed and exit")
+    parser.add_argument(
+        "--interactive", action="store_true", default=False,
+        help="Generate configuration file with user interaction")
+    parser.add_argument(
+        "--upgrade", action="store_true", default=False,
+        help="Run the installer in upgrade mode")
+    parser.add_argument(
+        "--beta", action="store_true", default=False,
+        help="Install latest beta release of Modoboa instead of the stable one")
+    parser.add_argument(
+        "--backup-path", type=str, metavar="path",
+        help="To use with --silent-backup, you must provide a valid path")
+    parser.add_argument(
+        "--backup", action="store_true", default=False,
+        help="Backing up interactively previously installed instance"
         )
     parser.add_argument(
-        "--force", action="store_true", default=False, help="Force installation"
-    )
-    parser.add_argument(
-        "--configfile", default="installer.cfg", help="Configuration file to use"
-    )
-    parser.add_argument(
-        "--version",
-        default="latest",
-        choices=versions,
-        help="Modoboa version to install",
-    )
-    parser.add_argument(
-        "--stop-after-configfile-check",
-        action="store_true",
-        default=False,
-        help="Check configuration, generate it if needed and exit",
-    )
-    parser.add_argument(
-        "--interactive",
-        action="store_true",
-        default=False,
-        help="Generate configuration file with user interaction",
-    )
-    parser.add_argument(
-        "--upgrade",
-        action="store_true",
-        default=False,
-        help="Run the installer in upgrade mode",
-    )
-    parser.add_argument(
-        "--beta",
-        action="store_true",
-        default=False,
-        help="Install latest beta release of Modoboa instead of the stable one",
-    )
-    parser.add_argument(
-        "--backup-path",
-        type=str,
-        metavar="path",
-        help="To use with --silent-backup, you must provide a valid path",
-    )
-    parser.add_argument(
-        "--backup",
-        action="store_true",
-        default=False,
-        help="Backing up interactively previously installed instance",
-    )
-    parser.add_argument(
-        "--silent-backup",
-        action="store_true",
-        default=False,
+        "--silent-backup", action="store_true", default=False,
         help="For script usage, do not require user interaction "
         "backup will be saved at ./modoboa_backup/Backup_M_Y_d_H_M "
-        "if --backup-path is not provided",
-    )
+        "if --backup-path is not provided")
     parser.add_argument(
-        "--no-mail",
-        action="store_true",
-        default=False,
-        help="Disable mail backup (save space)",
-    )
+        "--no-mail", action="store_true", default=False,
+        help="Disable mail backup (save space)")
     parser.add_argument(
-        "--restore",
-        type=str,
-        metavar="path",
+        "--restore", type=str, metavar="path",
         help="Restore a previously backup up modoboa instance on a NEW machine. "
-        "You MUST provide backup directory",
+        "You MUST provide backup directory"
         )
     parser.add_argument(
-        "--skip-checks",
-        action="store_true",
-        default=False,
-        help="Skip the checks the installer performs initially",
-    )
-    parser.add_argument(
-        "domain", type=str, help="The main domain of your future mail server"
-    )
+        "--skip-checks", action="store_true", default=False,
+        help="Skip the checks the installer performs initially")
+    parser.add_argument("domain", type=str,
+                        help="The main domain of your future mail server")
     return parser.parse_args(input_args)
 
 
@@ -180,7 +147,9 @@ def main(input_args):
         is_restoring = True
         args.configfile = os.path.join(args.restore, args.configfile)
         if not os.path.exists(args.configfile):
-            utils.error("Installer configuration file not found in backup!")
+            utils.error(
+                "Installer configuration file not found in backup!"
+            )
             sys.exit(1)
 
     utils.success("Welcome to Modoboa installer!\n")
@@ -192,34 +161,26 @@ def main(input_args):
         utils.success("Checks complete\n")
 
     is_config_file_available, outdate_config = utils.check_config_file(
-        args.configfile, args.interactive, args.upgrade, args.backup, is_restoring
-    )
+        args.configfile, args.interactive, args.upgrade, args.backup, is_restoring)
 
     if not is_config_file_available and (
-        args.upgrade or args.backup or args.silent_backup
-    ):
+            args.upgrade or args.backup or args.silent_backup):
         utils.error("No config file found.")
         return
 
     # Check if config is outdated and ask user if it needs to be updated
     if is_config_file_available and outdate_config:
-        answer = utils.user_input(
-            "It seems that your config file is outdated. "
-            "Would you like to update it? (Y/n) "
-        )
+        answer = utils.user_input("It seems that your config file is outdated. "
+                                  "Would you like to update it? (Y/n) ")
         if not answer or answer.lower().startswith("y"):
             config_file_update_complete(utils.update_config(args.configfile))
             if not args.stop_after_configfile_check:
-                answer = utils.user_input(
-                    "Would you like to stop to review the updated config? (Y/n)"
-                )
+                answer = utils.user_input("Would you like to stop to review the updated config? (Y/n)")
                 if not answer or answer.lower().startswith("y"):
                     return
         else:
-            utils.error(
-                "You might encounter unexpected errors ! "
-                "Make sure to update your config before opening an issue!"
-            )
+            utils.error("You might encounter unexpected errors ! "
+                        "Make sure to update your config before opening an issue!")
 
     if args.stop_after_configfile_check:
         return
@@ -240,7 +201,7 @@ def main(input_args):
         antispam_apps = ["rspamd"]
 
     if args.backup or args.silent_backup:
-        backup_system(config, args, antispam_apps)
+        backup_system(config, args)
         return
 
     # Display disclaimer python 3 linux distribution
@@ -255,20 +216,11 @@ def main(input_args):
     # Show concerned components
     components = []
     for section in config.sections():
-        if section in [
-            "general",
-            "antispam",
-            "database",
-            "mysql",
-            "postgres",
-            "certificate",
-            "letsencrypt",
-            "backup",
-        ]:
+        if section in ["general", "antispam", "database", "mysql", "postgres",
+                       "certificate", "letsencrypt", "backup"]:
             continue
-        if config.has_option(section, "enabled") and not config.getboolean(
-            section, "enabled"
-        ):
+        if (config.has_option(section, "enabled") and
+                not config.getboolean(section, "enabled")):
             continue
         incompatible_app_detected = not utils.check_app_compatibility(section, config)
         if incompatible_app_detected:
@@ -281,9 +233,8 @@ def main(input_args):
             return
     config.set("general", "force", str(args.force))
     utils.printcolor(
-        "The process can be long, feel free to take a coffee " "and come back later ;)",
-        utils.BLUE,
-    )
+        "The process can be long, feel free to take a coffee "
+        "and come back later ;)", utils.BLUE)
     utils.success("Starting...")
     package.backend.prepare_system()
     package.backend.install_many(["sudo", "wget"])
@@ -317,8 +268,13 @@ def main(input_args):
         "You like the project and want it to be sustainable?\n"
         "Then don't wait anymore and go sponsor it here:\n"
     )
-    utils.printcolor("https://github.com/sponsors/modoboa\n", utils.YELLOW)
-    utils.success("Thank you for your help :-)\n")
+    utils.printcolor(
+        "https://github.com/sponsors/modoboa\n",
+        utils.YELLOW
+    )
+    utils.success(
+        "Thank you for your help :-)\n"
+    )
 
 
 if __name__ == "__main__":

version.txt

@@ -1 +1 @@
-1d701353d900f4b6e2f7ffba6f6b7a46d304f58b
+36c8352223481a87316367f76cfc8c5772286e7a