retain "config.mail_domain" as the domain part of @ email addresses, so for ipv4 relays "[1.2.3.4]" and introduce config.ipv4_relay and config.mail_domain_bare helpers.

.github/workflows/ci-no-dns.yaml

@@ -9,8 +9,6 @@ on:
   pull_request:
     branches: [ "main" ]
 
-permissions: {}
-
 # Newest push wins: Prevents multiple runs from clashing and wasting runner efforts
 concurrency:
   group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
@@ -20,21 +18,18 @@ concurrency:
 jobs:
   no-dns:
     name: LXC deploy and test
-    uses: chatmail/cmlxc/.github/workflows/lxc-test.yml@main
+    uses: chatmail/cmlxc/.github/workflows/lxc-test.yml@d39fe34c39cee6d760c3479325e8dc82b66a8928
     with:
-      cmlxc_version: main
       cmlxc_commands: |
         cmlxc init 
         # single cmdeploy relay test
-        cmlxc -v deploy-cmdeploy --source ./repo --type ipv4 cm0
-        cmlxc -v test-cmdeploy cm0
+        cmlxc -v deploy-cmdeploy --source ./repo --ipv4-only --no-dns cm0
+        cmlxc -v test-cmdeploy --no-dns cm0
 
-        # cross cmdeploy relay test (two ipv4 relays)
-        cmlxc -v deploy-cmdeploy --source ./repo --ipv4-only --type ipv4 cm1
-        cmlxc -v test-cmdeploy cm0 cm1
+        # cross cmdeploy relay test
+        cmlxc -v deploy-cmdeploy --source ./repo cm1
+        cmlxc -v test-cmdeploy --no-dns cm0 cm1
 
         # cross cmdeploy/madmail relay tests
         cmlxc -v deploy-madmail mad0
-        cmlxc -v test-cmdeploy cm0 mad0
-        cmlxc -v test-mini mad0 cm0
-        cmlxc -v test-mini cm0 mad0
+        cmlxc -v test-cmdeploy --no-dns cm0 mad0

.github/workflows/ci.yaml

@@ -29,7 +29,7 @@ jobs:
           ref: ${{ github.event.pull_request.head.sha }}
           persist-credentials: false
       - name: download filtermail
-        run: curl -L https://github.com/chatmail/filtermail/releases/download/v0.7.4/filtermail-x86_64 -o /usr/local/bin/filtermail && chmod +x /usr/local/bin/filtermail
+        run: curl -L https://github.com/chatmail/filtermail/releases/download/v0.6.4/filtermail-x86_64 -o /usr/local/bin/filtermail && chmod +x /usr/local/bin/filtermail
       - name: run chatmaild tests 
         working-directory: chatmaild
         run: pipx run tox
@@ -57,9 +57,8 @@ jobs:
 
   lxc-test:
     name: LXC deploy and test
-    uses: chatmail/cmlxc/.github/workflows/lxc-test.yml@main
+    uses: chatmail/cmlxc/.github/workflows/lxc-test.yml@d39fe34c39cee6d760c3479325e8dc82b66a8928
     with:
-      cmlxc_version: main
       cmlxc_commands: |
         cmlxc init 
         # single cmdeploy relay test
@@ -76,4 +75,3 @@ jobs:
         cmlxc -v test-cmdeploy cm0 mad0
         cmlxc -v test-mini cm0 mad0
         cmlxc -v test-mini mad0 cm0
-

.github/workflows/docker-dispatch.yaml

@@ -9,7 +9,6 @@ name: Trigger Docker build
 on:
   push:
     branches: [main]
-    tags: ['[0-9]+.[0-9]+.[0-9]+']
   workflow_dispatch:
 
 permissions: {}

.github/workflows/docs-preview.yaml

@@ -51,7 +51,7 @@ jobs:
           mkdir -p "$HOME/.ssh"
           echo "${{ secrets.CHATMAIL_STAGING_SSHKEY }}" > "$HOME/.ssh/key"
           chmod 600 "$HOME/.ssh/key"
-          rsync -rILvh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/doc/build/ "${{ secrets.USERNAME }}@chatmail.at:${STEPS_PREPARE_OUTPUTS_PRID}/"
+          rsync -rILvh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/doc/build/ "${{ secrets.USERNAME }}@chatmail.at:/var/www/html/staging.chatmail.at/doc/relay/${STEPS_PREPARE_OUTPUTS_PRID}/"
         env:
           STEPS_PREPARE_OUTPUTS_PRID: ${{ steps.prepare.outputs.prid }}
 

.github/workflows/docs.yaml

@@ -47,5 +47,5 @@ jobs:
           mkdir -p "$HOME/.ssh"
           echo "${{ secrets.CHATMAIL_STAGING_SSHKEY }}" > "$HOME/.ssh/key"
           chmod 600 "$HOME/.ssh/key"
-          rsync -rILvh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/doc/build/ "${{ secrets.USERNAME }}@chatmail.at:"
+          rsync -rILvh -e "ssh -i $HOME/.ssh/key -o StrictHostKeyChecking=no" $GITHUB_WORKSPACE/doc/build/ "${{ secrets.USERNAME }}@chatmail.at:/var/www/html/chatmail.at/doc/relay/"
 

CHANGELOG.md

@@ -1,101 +1,4 @@
-# Changelog for chatmail deployment
-
-## [1.12.0] - 2026-07-31
-
-### Breaking Changes
-
-- [**breaking**] Introduce configurable system limits to reject new address creation and limit imap/smtp connections.
-  Dovecot default connection limit lowered from 50k to 10k,
-  Postfix default connection limit lowered from 5k to 1k,
-  larger relays need to adjust their settings.
-
-### Features
-
-- Reduce maximal_queue_lifetime from 5d to 2d
-- Disable negative cache in unbound (#992)
-- *(mtail)* Add incoming_mailer_daemon_mail_count
-- *(postfix)* Disable processing of MIME headers
-- *(dovecot)* Advertise privacy_mail as admin contact, drop server comment
-
-### Bug Fixes
-
-- Set relay restrictions per smtpd service with default reject
-- Reduce maxproc for filtermail-transport LMTP client to 500
-- Core 2.50.0 does not have delete_server_after config anymore.
-- Check if all required ports are available for filtermail (#983)
-- Always deploy unbound.conf.d/chatmail.conf (#993)
-- Expire empty directories (#994)
-- Crypt-r dependency was declared for wrong Python version
-- Always overwrite /etc/resolv.conf, even if it is a symbolic link
-- Pass kwargs to files.put()
-- List Iroh proxy endpoints used by 0.35 and 1.0, drop stale /relay/probe from earlier versions
-- Fix port discovery when ss -tulpn shows dovecot before stats
-
-### Documentation
-
-- Add scripts/initenv.sh to upgrade instructions
-- Update overview diagrams (#995)
-- *(overview)* Remove mermaid styles from 'Accepting and delivering mail' (#1009)
-- *(README.md)* Clarify security enforcement (#1011)
-
-### Miscellaneous Tasks
-
-- *(ci)* Auto-trigger docker build on release tag push
-- *(acmetool)* Update let's encrypt ToS link to 1.8
-- *(ci)* Update doc staging upload path
-- *(ci)* Fix docs upload path
-
-### Refactor
-
-- *(postfix)* Remove unused "filter" lmtp service
-- Install dns-root-data instead of using unbound-anchor
-- *(deps)* Remove domain-validator dependency
-
-### Testing
-
-- Set socket security for IMAP and SMTP to "TLS" in "dclogin"
-
-## [1.11.0] - 2026-05-15
-
-### Breaking Changes
-
-- [**breaking**] Drop passthrough_sender and passthrough_recipients chatmail.ini options to eliminate one more source of unencrypted messages
-
-### Features
-
-- Use filtermail for delivery to remote MTAs
-- Expose metadata "maxsmtprecipients" value
-- Support setup without domain, with only an IPv4 address (#963)
-- *(doc/docker)* Introduce docker images in documentation
-- DKIM-sign bounce messages (mainly "user does not exist")
-- *(config)* Load default values from Config(), not chatmail.ini.f (#853)
-- Make turn_socket_path configurable, and cleanup tests and turnserver code.
-- Warn about any unused chatmail.ini parameter at the end of "cmdeploy run"
-
-### Bug Fixes
-
-- Make www tests work with editable instead of just plain installs
-- Use path with no leading slash for mxdeliv
-- Increase filtermail-transport concurrency limit
-- Fix #972 by increasing file descriptors for filtermail
-- *(mtail)* Correct boot ordering and deploy restart logic
-- *(cmdeploy)* Stop and disable unbound-resolvconf
-- *(nginx)* Properly redirect www to mail_domain
-- *(dns)* Query correct NS if MNAME server is hidden (#954)
-- Legacy token metadata storage used list type, but if no new setmetadata happened, the user would not be notified at all.
-- *(logging)* Log all http requests to syslog
-
-### Documentation
-
-- Document how to upgrade to new version (#965)
-
-### Other
-
-- *(deps)* Upgrade to filtermail v0.6.4
-
-### Refactor
-
-- Introduce automated change-tracking across deployers
+# Changelog for chatmail deployment 
 
 ## 1.10.0 2026-04-30
 

README.md

@@ -1,24 +1,19 @@
 
 # Chatmail relays for end-to-end encrypted email
 
-Chatmail relay servers are interoperable Mail Transport Agents (MTAs) designed for:
+Chatmail relay servers are interoperable Mail Transport Agents (MTAs) designed for: 
 
 -  **Zero State:** no private data or metadata collected, messages are auto-deleted, low disk usage
 
 -  **Instant/Realtime:** sub-second message delivery, realtime P2P
    streaming, privacy-preserving Push Notifications for Apple, Google, and Huawei;
 
--  **Security Enforcement**: Only connections with strict TLS are accepted;
-   all messages must be correctly signed with DKIM and OpenPGP-encrypted with minimized metadata.
-   There are experimental exceptions for no-DNS relays,
-   which are allowed use self-signed TLS certificates
-   and which do not need to DKIM-sign their messages.
-   Unencrypted messages are allowed in neither case.
+-  **Security Enforcement**: only strict TLS, DKIM and OpenPGP with minimized metadata accepted
 
 -  **Reliable Federation and Decentralization:** No spam or IP reputation checks, federating
    depends on established IETF standards and protocols.
 
-This repository contains everything needed to setup a ready-to-use chatmail relay on an ssh-reachable host.
+This repository contains everything needed to setup a ready-to-use chatmail relay on an ssh-reachable host. 
 For getting started and more information please refer to the web version of this repositories' documentation at
 
 [https://chatmail.at/doc/relay](https://chatmail.at/doc/relay)

RELEASE.md

@@ -1,13 +1,15 @@
 # Releasing a new version of chatmail relay
 
-For example, to release version 1.13.0 of chatmail relay, do the following steps.
+For example, to release version 1.9.0 of chatmail relay, do the following steps.
 
-1. Update the changelog: `git cliff --unreleased --tag 1.13.0 --prepend CHANGELOG.md` or `git cliff -u -t 1.13.0 -p CHANGELOG.md`.
+1. Update the changelog: `git cliff --unreleased --tag 1.9.0 --prepend CHANGELOG.md` or `git cliff -u -t 1.9.0 -p CHANGELOG.md`.
 
 2. Open the changelog in the editor, edit it if required.
 
 3. Commit the changes to the changelog with a commit message `chore(release): prepare for 1.9.0`.
 
-4. Open a PR with the new commit, merge it to main after review.
+3. Tag the release: `git tag --annotate 1.9.0`.
 
-5. In the web interface, create a GitHub release, tell it to create a new tag.
+4. Push the release tag: `git push origin 1.9.0`.
+
+5. Create a GitHub release: `gh release create 1.9.0`.

chatmaild/pyproject.toml

@@ -8,9 +8,9 @@ version = "0.3"
 dependencies = [
   "iniconfig",
   "filelock",
-  "psutil",
   "requests",
-  "crypt-r >= 3.13.1 ; python_version >= '3.13'",
+  "crypt-r >= 3.13.1 ; python_version >= '3.11'",
+  "domain-validator",
 ]
 
 [tool.setuptools]
@@ -26,6 +26,7 @@ chatmail-expire = "chatmaild.expire:daily_expire_main"
 chatmail-quota-expire = "chatmaild.expire:quota_expire_main"
 chatmail-fsreport = "chatmaild.fsreport:main"
 lastlogin = "chatmaild.lastlogin:main"
+turnserver = "chatmaild.turnserver:main"
 
 [project.entry-points.pytest11]
 "chatmaild.testplugin" = "chatmaild.tests.plugin"

chatmaild/src/chatmaild/config.py

@@ -2,6 +2,7 @@ import ipaddress
 from pathlib import Path
 
 import iniconfig
+from domain_validator import DomainValidator
 
 from chatmaild.user import User
 
@@ -9,14 +10,18 @@ from chatmaild.user import User
 def read_config(inipath):
     assert Path(inipath).exists(), inipath
     cfg = iniconfig.IniConfig(inipath)
-    return Config(inipath, params=cfg.sections["params"])
+    params = cfg.sections["params"]
+    default_config_content = get_default_config_content(params["mail_domain"])
+    df_params = iniconfig.IniConfig("ini", data=default_config_content)["params"]
+    new_params = dict(df_params.items())
+    new_params.update(params)
+    return Config(inipath, params=new_params)
 
 
 class Config:
     def __init__(self, inipath, params):
         self._inipath = inipath
-        params = dict(params)
-        raw_domain = params.pop("mail_domain")
+        raw_domain = params["mail_domain"]
         self.mail_domain_bare = raw_domain
 
         if is_valid_ipv4(raw_domain):
@@ -24,73 +29,60 @@ class Config:
             self.mail_domain = f"[{raw_domain}]"
             self.postfix_myhostname = ipaddress.IPv4Address(raw_domain).reverse_pointer
         else:
+            DomainValidator().validate_domain_re(raw_domain)
             self.ipv4_relay = None
             self.mail_domain = raw_domain
             self.postfix_myhostname = raw_domain
 
-        self.max_user_send_per_minute = int(params.pop("max_user_send_per_minute", 60))
-        self.max_user_send_burst_size = int(params.pop("max_user_send_burst_size", 10))
-        self.max_mailbox_size = params.pop("max_mailbox_size", "500M")
-        self.max_message_size = int(params.pop("max_message_size", 31457280))
-        self.delete_mails_after = params.pop("delete_mails_after", "20")
-        self.delete_large_after = params.pop("delete_large_after", "7")
-        self.delete_inactive_users_after = int(
-            params.pop("delete_inactive_users_after", 90)
-        )
-        self.username_min_length = int(params.pop("username_min_length", 9))
-        self.username_max_length = int(params.pop("username_max_length", 9))
-        self.password_min_length = int(params.pop("password_min_length", 9))
-        self.www_folder = params.pop("www_folder", "")
-        self.filtermail_smtp_port = int(params.pop("filtermail_smtp_port", "10080"))
+        self.max_user_send_per_minute = int(params.get("max_user_send_per_minute", 60))
+        self.max_user_send_burst_size = int(params.get("max_user_send_burst_size", 10))
+        self.max_mailbox_size = params["max_mailbox_size"]
+        self.max_message_size = int(params.get("max_message_size", "31457280"))
+        self.delete_mails_after = params["delete_mails_after"]
+        self.delete_large_after = params["delete_large_after"]
+        self.delete_inactive_users_after = int(params["delete_inactive_users_after"])
+        self.username_min_length = int(params["username_min_length"])
+        self.username_max_length = int(params["username_max_length"])
+        self.password_min_length = int(params["password_min_length"])
+        self.passthrough_senders = params["passthrough_senders"].split()
+        self.passthrough_recipients = params["passthrough_recipients"].split()
+        self.www_folder = params.get("www_folder", "")
+        self.filtermail_smtp_port = int(params.get("filtermail_smtp_port", "10080"))
         self.filtermail_smtp_port_incoming = int(
-            params.pop("filtermail_smtp_port_incoming", "10081")
+            params.get("filtermail_smtp_port_incoming", "10081")
         )
         self.filtermail_http_port_incoming = int(
-            params.pop("filtermail_http_port_incoming", "10082")
+            params.get("filtermail_http_port_incoming", "10082")
         )
         self.filtermail_lmtp_port_transport = int(
-            params.pop("filtermail_lmtp_port_transport", "10083")
+            params.get("filtermail_lmtp_port_transport", "10083")
         )
-        self.postfix_reinject_port = int(params.pop("postfix_reinject_port", "10025"))
+        self.postfix_reinject_port = int(params.get("postfix_reinject_port", "10025"))
         self.postfix_reinject_port_incoming = int(
-            params.pop("postfix_reinject_port_incoming", "10026")
+            params.get("postfix_reinject_port_incoming", "10026")
         )
-        self.mtail_address = params.pop("mtail_address", None)
-        self.disable_ipv6 = params.pop("disable_ipv6", "false").lower() == "true"
-        self.acme_email = params.pop("acme_email", "")
-        self.imap_rawlog = params.pop("imap_rawlog", "false").lower() == "true"
-        self.imap_compress = params.pop("imap_compress", "false").lower() == "true"
-        self.turn_socket_path = params.pop(
-            "turn_socket_path", "/run/chatmail-turn/turn.socket"
-        )
-        iroh_relay = params.pop("iroh_relay", None)
-        if iroh_relay is None:
+        self.mtail_address = params.get("mtail_address")
+        self.disable_ipv6 = params.get("disable_ipv6", "false").lower() == "true"
+        self.acme_email = params.get("acme_email", "")
+        self.imap_rawlog = params.get("imap_rawlog", "false").lower() == "true"
+        self.imap_compress = params.get("imap_compress", "false").lower() == "true"
+        if "iroh_relay" not in params:
             self.iroh_relay = "https://" + raw_domain
             self.enable_iroh_relay = True
         else:
-            self.iroh_relay = iroh_relay.strip()
+            self.iroh_relay = params["iroh_relay"].strip()
             self.enable_iroh_relay = False
-        self.privacy_postal = params.pop("privacy_postal", None)
-        self.privacy_mail = params.pop("privacy_mail", None)
-        self.privacy_pdo = params.pop("privacy_pdo", None)
-        self.privacy_supervisor = params.pop("privacy_supervisor", None)
-
-        self.max_load_1m = float(params.pop("max_load_1m", 5))
-        self.min_available_memory_mb = parse_size_mb(
-            params.pop("min_available_memory", "200M")
-        )
-        self.min_free_disk_space_mb = parse_size_mb(
-            params.pop("min_free_disk_space", "1G")
-        )
-        self.max_imap_connections = int(params.pop("max_imap_connections", 10000))
-        self.max_smtp_connections = int(params.pop("max_smtp_connections", 1000))
+        self.privacy_postal = params.get("privacy_postal")
+        self.privacy_mail = params.get("privacy_mail")
+        self.privacy_pdo = params.get("privacy_pdo")
+        self.privacy_supervisor = params.get("privacy_supervisor")
 
         # TLS certificate management.
         # If tls_external_cert_and_key is set, use externally managed certs.
         # Otherwise derived from the domain name:
         # - Domains starting with "_" use self-signed certificates
         # - All other domains use ACME.
-        external = params.pop("tls_external_cert_and_key", "").strip()
+        external = params.get("tls_external_cert_and_key", "").strip()
 
         if external:
             parts = external.split()
@@ -111,12 +103,11 @@ class Config:
             self.tls_key_path = f"/var/lib/acme/live/{raw_domain}/privkey"
 
         # deprecated option
-        mbdir = params.pop("mailboxes_dir", f"/home/vmail/mail/{raw_domain}")
+        mbdir = params.get("mailboxes_dir", f"/home/vmail/mail/{raw_domain}")
         self.mailboxes_dir = Path(mbdir.strip())
 
         # old unused option (except for first migration from sqlite to maildir store)
-        self.passdb_path = Path(params.pop("passdb_path", "/home/vmail/passdb.sqlite"))
-        self._unused_keys = list(params)
+        self.passdb_path = Path(params.get("passdb_path", "/home/vmail/passdb.sqlite"))
 
     @property
     def max_mailbox_size_mb(self):
@@ -173,7 +164,31 @@ def get_default_config_content(mail_domain, **overrides):
     for name, value in extra.items():
         new_line = f"{name} = {value}"
         new_lines.append(new_line)
-    return "\n".join(new_lines)
+
+    content = "\n".join(new_lines)
+
+    # apply testrun privacy overrides
+
+    if mail_domain.endswith(".testrun.org"):
+        override_inipath = inidir.joinpath("override-testrun.ini")
+        privacy = iniconfig.IniConfig(override_inipath)["privacy"]
+        lines = []
+        for line in content.split("\n"):
+            for key, value in privacy.items():
+                value_lines = value.format(mail_domain=mail_domain).strip().split("\n")
+                if not line.startswith(f"{key} =") or not value_lines:
+                    continue
+                if len(value_lines) == 1:
+                    lines.append(f"{key} = {value}")
+                else:
+                    lines.append(f"{key} =")
+                    for vl in value_lines:
+                        lines.append(f"    {vl}")
+                break
+            else:
+                lines.append(line)
+        content = "\n".join(lines)
+    return content
 
 
 def is_valid_ipv4(address: str) -> bool:
@@ -183,3 +198,18 @@ def is_valid_ipv4(address: str) -> bool:
         return True
     except ValueError:
         return False
+
+
+
+def format_arpa_address(address: str) -> str:
+    if is_valid_ipv4(address):
+        return ipaddress.IPv4Address(address).reverse_pointer
+    DomainValidator().validate_domain_re(address)
+    return address
+
+
+def format_mail_domain(raw_domain: str) -> str:
+    if is_valid_ipv4(raw_domain):
+        return f"[{raw_domain}]"
+    DomainValidator().validate_domain_re(raw_domain)
+    return raw_domain

chatmaild/src/chatmaild/doveauth.py

@@ -14,7 +14,6 @@ except ImportError:
 from .config import Config, read_config
 from .dictproxy import DictProxy
 from .migrate_db import migrate_from_db_to_maildir
-from .syslimits import has_sufficient_resources
 
 NOCREATE_FILE = "/etc/chatmail-nocreate"
 VALID_LOCALPART_RE = re.compile(r"^[a-z0-9._-]+$")
@@ -148,8 +147,6 @@ class AuthDictProxy(DictProxy):
             return userdata
         if not is_allowed_to_create(self.config, addr, cleartext_password):
             return
-        if not has_sufficient_resources(self.config):
-            return
 
         lock = filelock.FileLock(str(user.password_path) + ".lock", timeout=5)
         with lock:

chatmaild/src/chatmaild/expire.py

@@ -168,16 +168,6 @@ class Expiry:
         if mbox.last_login and mbox.last_login < cutoff_without_login:
             self.remove_mailbox(mbox.basedir)
             return
-        elif mbox.last_login is None:
-            try:
-                if not self.dry:
-                    os.rmdir(mbox.basedir)
-                    self.del_mboxes += 1
-            except OSError:
-                print_info(
-                    f"Skipped deleting {mbox.basedir}, doesn't have last_login but isn't empty"
-                )
-            return
 
         mboxname = os.path.basename(mbox.basedir)
         if self.verbose:

chatmaild/src/chatmaild/ini/chatmail.ini.f

@@ -12,62 +12,42 @@ mail_domain = {mail_domain}
 #
 
 # email sending rate per user and minute
-#max_user_send_per_minute = 60
+max_user_send_per_minute = 60
 
 # per-user max burst size for sending rate limiting (GCRA bucket capacity)
-#max_user_send_burst_size = 10
+max_user_send_burst_size = 10
 
 # maximum mailbox size of a chatmail address
-# (Oldest messages will be removed automatically, so mailboxes never run full)
-#max_mailbox_size = 500M
+# Oldest messages will be removed automatically, so mailboxes never run full.
+max_mailbox_size = 500M
 
 # maximum message size for an e-mail in bytes
-#max_message_size = 31457280
+max_message_size = 31457280
 
 # days after which mails are unconditionally deleted
-#delete_mails_after = 20
+delete_mails_after = 20
 
 # days after which large messages (>200k) are unconditionally deleted
-#delete_large_after = 7
+delete_large_after = 7
 
 # days after which users without a successful login are deleted (database and mails)
-#delete_inactive_users_after = 90
+delete_inactive_users_after = 90
 
 # minimum length a username must have
-#username_min_length = 9
+username_min_length = 9
 
 # maximum length a username can have
-#username_max_length = 9
+username_max_length = 9
 
 # minimum length a password must have
-#password_min_length = 9
+password_min_length = 9
 
-#
-# System resource limits
-#
+# list of chatmail addresses which can send outbound un-encrypted mail
+passthrough_senders =
 
-# The following three limits refuse creation of new addresses
-# while existing addresses keep working.
-# Rejections are logged by the doveauth service.
-
-# Maximum 1-minute load average, as reported by "uptime";
-# it counts processes waiting for disk I/O as well as for CPU.
-#max_load_1m = 5
-
-# Minimum memory available without swapping.
-#min_available_memory = 200M
-
-# Minimum free disk space on the file system holding the mailboxes.
-#min_free_disk_space = 1G
-
-# Maximum number of concurrent IMAP connections
-# (the Dovecot imap process limit).
-#max_imap_connections = 10000
-
-# Maximum number of concurrent SMTP connections
-# on each of the submission and smtps ports (the Postfix process limit).
-# A single client IP may use up to a fifth of this.
-#max_smtp_connections = 1000
+# list of e-mail recipients for which to accept outbound un-encrypted mails
+# (space-separated, item may start with "@" to whitelist whole recipient domains)
+passthrough_recipients =
 
 # Use externally managed TLS certificates instead of built-in acmetool.
 # Paths refer to files on the deployment server (not the build machine).
@@ -83,11 +63,19 @@ mail_domain = {mail_domain}
 # Deployment Details
 #
 
+# SMTP outgoing filtermail and reinjection 
+filtermail_smtp_port = 10080
+postfix_reinject_port = 10025
+
+# SMTP incoming filtermail and reinjection 
+filtermail_smtp_port_incoming = 10081
+postfix_reinject_port_incoming = 10026
+
 # if set to "True" IPv6 is disabled
-#disable_ipv6 = False
+disable_ipv6 = False
 
 # Your email adress, which will be used in acmetool to manage Let's Encrypt SSL certificates
-#acme_email =
+acme_email = 
 
 # Defaults to https://iroh.{{mail_domain}} and running `iroh-relay` on the chatmail
 # service.
@@ -120,13 +108,13 @@ mail_domain = {mail_domain}
 # in per-maildir ".in/.out" files. 
 # Note that you need to manually cleanup these files
 # so use this option with caution on production servers. 
-#imap_rawlog = false
+imap_rawlog = false 
 
 # set to true if you want to enable the IMAP COMPRESS Extension,
 # which allows IMAP connections to be efficiently compressed.
 # WARNING: Enabling this makes it impossible to hibernate IMAP
 # processes which will result in much higher memory/RAM usage.
-#imap_compress = false
+imap_compress = false
 
 
 #

chatmaild/src/chatmaild/ini/override-testrun.ini

@@ -0,0 +1,16 @@
+
+[privacy]
+
+passthrough_recipients = privacy@testrun.org echo@{mail_domain}
+
+privacy_postal =
+    Merlinux GmbH, Represented by the managing director H. Krekel,
+    Reichgrafen Str. 20, 79102 Freiburg, Germany
+
+privacy_mail = privacy@testrun.org
+privacy_pdo =
+    Prof. Dr. Fabian Schmieder, lexICT UG (limited), Ostfeldstr. 49, 30559 Hannover.
+    You can contact him at *delta-privacy@merlinux.eu* (Keyword: DPO)
+privacy_supervisor =
+    State Commissioner for Data Protection and Freedom of Information of
+    Baden-Württemberg in 70173 Stuttgart, Germany.

chatmaild/src/chatmaild/metadata.py

@@ -1,5 +1,4 @@
 import logging
-import socket
 import sys
 import time
 from contextlib import contextmanager
@@ -8,14 +7,7 @@ from .config import read_config
 from .dictproxy import DictProxy
 from .filedict import FileDict
 from .notifier import Notifier
-
-
-def turn_credentials(turn_socket_path):
-    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client_socket:
-        client_socket.settimeout(5)
-        client_socket.connect(turn_socket_path)
-        with client_socket.makefile("rb") as file:
-            return file.readline().decode("utf-8").strip()
+from .turnserver import turn_credentials
 
 
 def _is_valid_token_timestamp(timestamp, now):
@@ -78,53 +70,44 @@ class Metadata:
                 # Some tokens have expired, remove them.
                 with self._modify_tokens(addr) as _tokens:
                     pass
-        elif isinstance(tokens, list):
-            with self._modify_tokens(addr) as tokens:
-                token_list = list(tokens.keys())
         else:
             token_list = []
         return token_list
 
 
 class MetadataDictProxy(DictProxy):
-    def __init__(
-        self,
-        notifier,
-        metadata,
-        iroh_relay=None,
-        turn_hostname=None,
-        turn_socket_path=None,
-    ):
+    def __init__(self, notifier, metadata, iroh_relay=None, turn_hostname=None):
         super().__init__()
         self.notifier = notifier
         self.metadata = metadata
         self.iroh_relay = iroh_relay
         self.turn_hostname = turn_hostname
-        self.turn_socket_path = turn_socket_path
 
     def handle_lookup(self, parts):
         # Lpriv/43f5f508a7ea0366dff30200c15250e3/devicetoken\tlkj123poi@c2.testrun.org
-        match parts[0].split("/", 2):
-            case ["priv", _, keyname] if keyname == self.metadata.DEVICETOKEN_KEY:
-                addr = parts[1]
+        keyparts = parts[0].split("/", 2)
+        if keyparts[0] == "priv":
+            keyname = keyparts[2]
+            addr = parts[1]
+            if keyname == self.metadata.DEVICETOKEN_KEY:
                 res = " ".join(self.metadata.get_tokens_for_addr(addr))
                 return f"O{res}\n"
-            case ["shared", _, keyname]:
-                prefix = "vendor/vendor.dovecot/pvt/server/vendor/deltachat/"
-                if keyname.startswith(prefix):
-                    match keyname[len(prefix) :]:
-                        case "irohrelay" if self.iroh_relay:
-                            return f"O{self.iroh_relay}\n"
-                        case "turn":
-                            try:
-                                res = turn_credentials(self.turn_socket_path)
-                            except Exception:
-                                logging.exception("failed to get TURN credentials")
-                                return "N\n"
-                            return f"O{self.turn_hostname}:3478:{res}\n"
-                        case "maxsmtprecipients":
-                            # postfix default  (see "postconf smtpd_recipient_limit")
-                            return "O1000\n"
+        elif keyparts[0] == "shared":
+            keyname = keyparts[2]
+            if (
+                keyname == "vendor/vendor.dovecot/pvt/server/vendor/deltachat/irohrelay"
+                and self.iroh_relay
+            ):
+                # Handle `GETMETADATA "" /shared/vendor/deltachat/irohrelay`
+                return f"O{self.iroh_relay}\n"
+            elif keyname == "vendor/vendor.dovecot/pvt/server/vendor/deltachat/turn":
+                try:
+                    res = turn_credentials()
+                except Exception:
+                    logging.exception("failed to get TURN credentials")
+                    return "N\n"
+                port = 3478
+                return f"O{self.turn_hostname}:{port}:{res}\n"
 
         logging.warning(f"lookup ignored: {parts!r}")
         return "N\n"
@@ -134,13 +117,12 @@ class MetadataDictProxy(DictProxy):
         # https://github.com/dovecot/core/blob/main/src/lib-storage/mailbox-attribute.h
         keyname = parts[1].split("/")
         value = parts[2] if len(parts) > 2 else ""
-        match keyname:
-            case ["priv", _, key] if key == self.metadata.DEVICETOKEN_KEY:
-                self.metadata.add_token_to_addr(addr, value)
-                return True
-            case ["priv", _, "messagenew"]:
-                self.notifier.new_message_for_addr(addr, self.metadata)
-                return True
+        if keyname[0] == "priv" and keyname[2] == self.metadata.DEVICETOKEN_KEY:
+            self.metadata.add_token_to_addr(addr, value)
+            return True
+        elif keyname[0] == "priv" and keyname[2] == "messagenew":
+            self.notifier.new_message_for_addr(addr, self.metadata)
+            return True
 
         return False
 
@@ -151,7 +133,6 @@ def main():
     config = read_config(config_path)
     iroh_relay = config.iroh_relay
     mail_domain = config.mail_domain
-    socket_path = config.turn_socket_path
 
     vmail_dir = config.mailboxes_dir
     if not vmail_dir.exists():
@@ -169,7 +150,6 @@ def main():
         metadata=metadata,
         iroh_relay=iroh_relay,
         turn_hostname=mail_domain,
-        turn_socket_path=socket_path,
     )
 
     dictproxy.serve_forever_from_socket(socket)

chatmaild/src/chatmaild/syslimits.py

@@ -1,32 +0,0 @@
-"""Detect whether the system is at its limits."""
-
-import logging
-
-import psutil
-
-MB = 1024 * 1024
-
-
-def read_value(getter):
-    try:
-        return getter()
-    except Exception as e:
-        logging.warning("ignoring unreadable system limit: %s", e)
-        return None
-
-
-def has_sufficient_resources(config):
-    """Return False if load, memory or disk exceeds a configured limit."""
-    load = read_value(lambda: psutil.getloadavg()[0])
-    mem = read_value(lambda: psutil.virtual_memory().available // MB)
-    disk = read_value(lambda: psutil.disk_usage(str(config.mailboxes_dir)).free // MB)
-    if load is not None and load > config.max_load_1m:
-        msg = f"load avg {load:.2f} > {config.max_load_1m:.2f}"
-    elif mem is not None and mem < config.min_available_memory_mb:
-        msg = f"available memory {mem}MB < {config.min_available_memory_mb}MB"
-    elif disk is not None and disk < config.min_free_disk_space_mb:
-        msg = f"free disk {disk}MB < {config.min_free_disk_space_mb}MB"
-    else:
-        return True
-    logging.warning("registration rejected: %s", msg)
-    return False

chatmaild/src/chatmaild/tests/plugin.py

@@ -20,10 +20,6 @@ def make_config(tmp_path):
         basedir.mkdir(parents=True, exist_ok=True)
         overrides = settings.copy() if settings else {}
         overrides["mailboxes_dir"] = str(basedir)
-        # permissive resource limits so tests never depend on host load/memory/disk
-        overrides.setdefault("max_load_1m", "99999")
-        overrides.setdefault("min_available_memory", "0")
-        overrides.setdefault("min_free_disk_space", "0")
         write_initial_config(inipath, mail_domain, overrides=overrides)
         return read_config(inipath)
 

chatmaild/src/chatmaild/tests/test_config.py

@@ -1,6 +1,10 @@
+from contextlib import nullcontext as does_not_raise
+
 import pytest
 
 from chatmaild.config import (
+    format_arpa_address,
+    format_mail_domain,
     is_valid_ipv4,
     parse_size_mb,
     read_config,
@@ -13,12 +17,7 @@ def test_read_config_basic(example_config):
     assert not example_config.privacy_pdo and not example_config.privacy_postal
 
     inipath = example_config._inipath
-    inipath.write_text(
-        inipath.read_text().replace(
-            "#max_user_send_per_minute = 60",
-            "max_user_send_per_minute = 37",
-        )
-    )
+    inipath.write_text(inipath.read_text().replace("60", "37"))
     example_config = read_config(inipath)
     assert example_config.max_user_send_per_minute == 37
     assert example_config.mail_domain == "chat.example.org"
@@ -36,23 +35,26 @@ def test_read_config_basic_using_defaults(tmp_path, maildomain):
     example_config = read_config(inipath)
     assert example_config.max_user_send_per_minute == 60
     assert example_config.filtermail_smtp_port_incoming == 10081
-    assert example_config.filtermail_smtp_port == 10080
-    assert example_config.postfix_reinject_port == 10025
-    assert example_config.max_user_send_per_minute == 60
-    assert example_config.max_mailbox_size == "500M"
-    assert example_config.delete_mails_after == "20"
-    assert example_config.delete_large_after == "7"
-    assert example_config.username_min_length == 9
-    assert example_config.username_max_length == 9
-    assert example_config.password_min_length == 9
-    assert example_config.max_imap_connections == 10000
-    assert example_config.max_smtp_connections == 1000
-    assert example_config._unused_keys == []
 
 
-def test_config_unused_keys(make_config):
-    config = make_config("chat.example.org", {"passthrough_senders": "x@y.org"})
-    assert config._unused_keys == ["passthrough_senders"]
+def test_read_config_testrun(make_config):
+    config = make_config("something.testrun.org")
+    assert config.mail_domain == "something.testrun.org"
+    assert len(config.privacy_postal.split("\n")) > 1
+    assert len(config.privacy_supervisor.split("\n")) > 1
+    assert len(config.privacy_pdo.split("\n")) > 1
+    assert config.privacy_mail == "privacy@testrun.org"
+    assert config.filtermail_smtp_port == 10080
+    assert config.postfix_reinject_port == 10025
+    assert config.max_user_send_per_minute == 60
+    assert config.max_mailbox_size == "500M"
+    assert config.delete_mails_after == "20"
+    assert config.delete_large_after == "7"
+    assert config.username_min_length == 9
+    assert config.username_max_length == 9
+    assert config.password_min_length == 9
+    assert "privacy@testrun.org" in config.passthrough_recipients
+    assert config.passthrough_senders == []
 
 
 def test_config_userstate_paths(make_config, tmp_path):
@@ -161,3 +163,31 @@ def test_max_mailbox_size_mb(make_config):
 )
 def test_is_valid_ipv4(input, result):
     assert result == is_valid_ipv4(input)
+
+
+@pytest.mark.parametrize(
+    ["input", "result", "exception"],
+    [
+        ("example.org", "example.org", does_not_raise()),
+        ("1.3.3.7", "7.3.3.1.in-addr.arpa", does_not_raise()),
+        ("fe::1", None, pytest.raises(ValueError)),
+        ("12394142", None, pytest.raises(ValueError)),
+    ],
+)
+def test_format_arpa_address(input, result, exception):
+    with exception:
+        assert result == format_arpa_address(input)
+
+
+@pytest.mark.parametrize(
+    ["input", "result", "exception"],
+    [
+        ("example.org", "example.org", does_not_raise()),
+        ("1.3.3.7", "[1.3.3.7]", does_not_raise()),
+        ("fe::1", None, pytest.raises(ValueError)),
+        ("12394142", None, pytest.raises(ValueError)),
+    ],
+)
+def test_format_mail_domain(input, result, exception):
+    with exception:
+        assert result == format_mail_domain(input)

chatmaild/src/chatmaild/tests/test_doveauth.py

@@ -202,17 +202,3 @@ def test_50_concurrent_lookups_different_accounts(gencreds, dictproxy):
         res = results.get()
         if res is not None:
             pytest.fail(f"concurrent lookup failed\n{res}")
-
-
-def test_insufficient_resources_block_creation_not_existing_logins(
-    dictproxy, gencreds, monkeypatch
-):
-    addr, password = gencreds()
-    assert dictproxy.lookup_passdb(addr, password)
-
-    monkeypatch.setattr(
-        chatmaild.doveauth, "has_sufficient_resources", lambda config: False
-    )
-    newaddr, newpassword = gencreds()
-    assert not dictproxy.lookup_passdb(newaddr, newpassword)
-    assert dictproxy.lookup_passdb(addr, password)

chatmaild/src/chatmaild/tests/test_expire.py

@@ -1,7 +1,6 @@
 import itertools
 import os
 import random
-import shutil
 import time
 from datetime import datetime
 from fnmatch import fnmatch
@@ -10,7 +9,6 @@ from pathlib import Path
 import pytest
 
 from chatmaild.expire import (
-    Expiry,
     FileEntry,
     MailboxStat,
     expire_to_target,
@@ -106,32 +104,6 @@ def test_stats_mailbox(mbox1):
     assert mbox3.last_login is None
 
 
-def test_mbox_without_password(mbox1, example_config, capsys):
-    password = Path(mbox1.basedir).joinpath("password")
-    os.remove(password)
-    mbox_rescan = MailboxStat(mbox1.basedir)
-    assert mbox_rescan.last_login is None
-
-    exp = Expiry(
-        example_config, dry=False, now=datetime.now().timestamp(), verbose=False
-    )
-    exp.process_mailbox_stat(mbox_rescan)
-    out, err = capsys.readouterr()
-    assert "doesn't have last_login but isn't empty" in err
-    assert os.path.isdir(mbox_rescan.basedir)
-
-    for entry in os.scandir(mbox_rescan.basedir):
-        if os.path.isdir(entry):
-            shutil.rmtree(entry)
-        else:
-            os.remove(entry)
-
-    exp.process_mailbox_stat(mbox_rescan)
-    out, err = capsys.readouterr()
-    assert "doesn't have last_login but isn't empty" not in err
-    assert not os.path.isdir(mbox_rescan.basedir)
-
-
 def test_report_no_mailboxes(example_config):
     args = (str(example_config._inipath),)
     report_main(args)

chatmaild/src/chatmaild/tests/test_metadata.py

@@ -324,7 +324,7 @@ def test_turn_credentials_exception_returns_N(notifier, metadata, monkeypatch):
         turn_hostname="turn.example.org",
     )
 
-    def mock_turn_credentials(turn_socket_path):
+    def mock_turn_credentials():
         raise ConnectionRefusedError("socket not available")
 
     monkeypatch.setattr(chatmaild.metadata, "turn_credentials", mock_turn_credentials)
@@ -348,9 +348,7 @@ def test_turn_credentials_success(notifier, metadata, monkeypatch):
         turn_hostname="turn.example.org",
     )
 
-    monkeypatch.setattr(
-        chatmaild.metadata, "turn_credentials", lambda path: "user:pass"
-    )
+    monkeypatch.setattr(chatmaild.metadata, "turn_credentials", lambda: "user:pass")
 
     transactions = {}
     res = dictproxy.handle_dovecot_request(
@@ -362,39 +360,15 @@ def test_turn_credentials_success(notifier, metadata, monkeypatch):
 
 
 def test_iroh_relay(dictproxy):
-    key = b"Lshared/0123/vendor/vendor.dovecot/pvt/server/vendor/deltachat/irohrelay\tuser@example.org"
-    rfile, wfile = io.BytesIO(b"H\n" + key), io.BytesIO()
+    rfile = io.BytesIO(
+        b"\n".join(
+            [
+                b"H",
+                b"Lshared/0123/vendor/vendor.dovecot/pvt/server/vendor/deltachat/irohrelay\tuser@example.org",
+            ]
+        )
+    )
+    wfile = io.BytesIO()
     dictproxy.iroh_relay = "https://example.org/"
     dictproxy.loop_forever(rfile, wfile)
     assert wfile.getvalue() == b"Ohttps://example.org/\n"
-
-
-def test_legacy_token_migration(metadata, testaddr):
-    with metadata.get_metadata_dict(testaddr).modify() as data:
-        data[metadata.DEVICETOKEN_KEY] = ["oldtoken1", "oldtoken2"]
-
-    assert metadata.get_tokens_for_addr(testaddr) == ["oldtoken1", "oldtoken2"]
-    mdict = metadata.get_metadata_dict(testaddr).read()
-    tokens = mdict[metadata.DEVICETOKEN_KEY]
-    assert isinstance(tokens, dict)
-    assert "oldtoken1" in tokens and "oldtoken2" in tokens
-
-
-@pytest.mark.parametrize(
-    "suffix, expected",
-    [
-        (b"vendor/deltachat/maxsmtprecipients", b"O1000\n"),
-        (b"wrong/prefix/key", b"N\n"),
-        (b"vendor/deltachat/unknown", b"N\n"),
-    ],
-    ids=["maxsmtprecipients", "prefix_mismatch", "unknown_name"],
-)
-def test_shared_lookup(dictproxy, suffix, expected):
-    key = (
-        b"Lshared/0123/vendor/vendor.dovecot/pvt/server/"
-        + suffix
-        + b"\tuser@example.org"
-    )
-    rfile, wfile = io.BytesIO(b"H\n" + key), io.BytesIO()
-    dictproxy.loop_forever(rfile, wfile)
-    assert wfile.getvalue() == expected

chatmaild/src/chatmaild/tests/test_migrate_db.py

@@ -48,8 +48,6 @@ def test_migration(tmp_path, example_config, caplog):
     assert passdb_path.stat().st_size > 10000
 
     example_config.passdb_path = passdb_path
-    # ensure logging.info records are captured regardless of global configuration
-    caplog.set_level("INFO")
 
     assert not caplog.records
 

chatmaild/src/chatmaild/tests/test_syslimits.py

@@ -1,45 +0,0 @@
-import shutil
-
-import psutil
-
-from chatmaild.syslimits import has_sufficient_resources
-
-PERMISSIVE = {
-    "max_load_1m": "99999",
-    "min_available_memory": "0",
-    "min_free_disk_space": "0",
-}
-
-
-def test_rejects_constrained_system(make_config, caplog):
-    assert has_sufficient_resources(make_config("chat.example.org", PERMISSIVE))
-    for settings in (
-        {"max_load_1m": "-1.0"},
-        {"min_available_memory": "99999999G"},
-        {"min_free_disk_space": "99999999G"},
-    ):
-        config = make_config("chat.example.org", PERMISSIVE | settings)
-        caplog.clear()
-        assert not has_sufficient_resources(config), settings
-        assert "registration rejected" in caplog.text
-
-
-def test_unreadable_disk_does_not_reject(make_config, caplog):
-    config = make_config(
-        "chat.example.org", PERMISSIVE | {"min_free_disk_space": "99999999G"}
-    )
-    shutil.rmtree(config.mailboxes_dir)
-    assert has_sufficient_resources(config)
-    assert "ignoring" in caplog.text
-
-
-def test_one_unreadable_value_keeps_other_checks(make_config, monkeypatch, caplog):
-    def raise_error(*args):
-        raise psutil.Error("dud")
-
-    monkeypatch.setattr(psutil, "getloadavg", raise_error)
-    config = make_config(
-        "chat.example.org", PERMISSIVE | {"min_free_disk_space": "99999999G"}
-    )
-    assert not has_sufficient_resources(config)
-    assert "ignoring" in caplog.text

chatmaild/src/chatmaild/tests/test_turn.py

@@ -1,46 +0,0 @@
-import socket
-import threading
-
-import pytest
-
-from chatmaild.metadata import turn_credentials
-
-
-@pytest.fixture
-def turn_socket(tmp_path):
-    sock_path = str(tmp_path / "turn.socket")
-    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-    server.bind(sock_path)
-    server.listen(1)
-    yield sock_path, server
-    server.close()
-
-
-def test_turn_credentials_timeout(turn_socket):
-    sock_path, server = turn_socket
-    with pytest.raises(socket.timeout):
-        # Inside turn_credentials the kernel listen backlog (1)
-        # completes connect() without accept()
-        # so the client blocks on readline() until the 5s timeout fires.
-        turn_credentials(sock_path)
-
-
-def test_turn_credentials_connection_refused_on_not_existing_socket(tmp_path):
-    missing = str(tmp_path / "nonexistent.socket")
-    with pytest.raises((ConnectionRefusedError, FileNotFoundError)):
-        turn_credentials(missing)
-
-
-def test_turn_credentials_socket_success(turn_socket):
-    sock_path, server = turn_socket
-
-    def respond():
-        conn, _ = server.accept()
-        conn.sendall(b"testuser:testpass\n")
-        conn.close()
-
-    t = threading.Thread(target=respond, daemon=True)
-    t.start()
-
-    result = turn_credentials(sock_path)
-    assert result == "testuser:testpass"

chatmaild/src/chatmaild/tests/test_turnserver.py

@@ -0,0 +1,73 @@
+import socket
+import threading
+import time
+from unittest.mock import patch
+
+import pytest
+
+from chatmaild.turnserver import turn_credentials
+
+SOCKET_PATH = "/run/chatmail-turn/turn.socket"
+
+
+@pytest.fixture
+def turn_socket(tmp_path):
+    """Create a real Unix socket server at a temp path."""
+    sock_path = str(tmp_path / "turn.socket")
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    server.bind(sock_path)
+    server.listen(1)
+    yield sock_path, server
+    server.close()
+
+
+def _call_turn_credentials(sock_path):
+    """Call turn_credentials but connect to sock_path instead of hardcoded path."""
+    original_connect = socket.socket.connect
+
+    def patched_connect(self, address):
+        if address == SOCKET_PATH:
+            address = sock_path
+        return original_connect(self, address)
+
+    with patch.object(socket.socket, "connect", patched_connect):
+        return turn_credentials()
+
+
+def test_turn_credentials_timeout(turn_socket):
+    """Server accepts but never responds — must raise socket.timeout."""
+    sock_path, server = turn_socket
+
+    def accept_and_hang():
+        conn, _ = server.accept()
+        time.sleep(30)
+        conn.close()
+
+    t = threading.Thread(target=accept_and_hang, daemon=True)
+    t.start()
+
+    with pytest.raises(socket.timeout):
+        _call_turn_credentials(sock_path)
+
+
+def test_turn_credentials_connection_refused(tmp_path):
+    """Socket file doesn't exist — must raise ConnectionRefusedError or FileNotFoundError."""
+    missing = str(tmp_path / "nonexistent.socket")
+    with pytest.raises((ConnectionRefusedError, FileNotFoundError)):
+        _call_turn_credentials(missing)
+
+
+def test_turn_credentials_success(turn_socket):
+    """Server responds with credentials — must return stripped string."""
+    sock_path, server = turn_socket
+
+    def respond():
+        conn, _ = server.accept()
+        conn.sendall(b"testuser:testpass\n")
+        conn.close()
+
+    t = threading.Thread(target=respond, daemon=True)
+    t.start()
+
+    result = _call_turn_credentials(sock_path)
+    assert result == "testuser:testpass"

chatmaild/src/chatmaild/turnserver.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+import socket
+
+
+def turn_credentials() -> str:
+    with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as client_socket:
+        client_socket.settimeout(5)
+        client_socket.connect("/run/chatmail-turn/turn.socket")
+        with client_socket.makefile("rb") as file:
+            return file.readline().decode("utf-8").strip()

cmdeploy/src/cmdeploy/acmetool/__init__.py

@@ -1,4 +1,6 @@
-from pyinfra.operations import apt, server
+import importlib.resources
+
+from pyinfra.operations import apt, files, server, systemd
 
 from ..basedeploy import Deployer
 
@@ -7,6 +9,9 @@ class AcmetoolDeployer(Deployer):
     def __init__(self, email, domains):
         self.domains = domains
         self.email = email
+        self.need_restart_redirector = False
+        self.need_restart_reconcile_service = False
+        self.need_restart_reconcile_timer = False
 
     def install(self):
         apt.packages(
@@ -14,41 +19,121 @@ class AcmetoolDeployer(Deployer):
             packages=["acmetool"],
         )
 
-        self.remove_file("/etc/cron.d/acmetool")
+        files.file(
+            name="Remove old acmetool cronjob, it is replaced with systemd timer.",
+            path="/etc/cron.d/acmetool",
+            present=False,
+        )
 
-        self.put_executable("acmetool/acmetool.hook", "/etc/acme/hooks/nginx")
-        self.remove_file("/usr/lib/acme/hooks/nginx")
+        files.put(
+            name="Install acmetool hook.",
+            src=importlib.resources.files(__package__)
+            .joinpath("acmetool.hook")
+            .open("rb"),
+            dest="/etc/acme/hooks/nginx",
+            user="root",
+            group="root",
+            mode="755",
+        )
+        files.file(
+            name="Remove acmetool hook from the wrong location where it was previously installed.",
+            path="/usr/lib/acme/hooks/nginx",
+            present=False,
+        )
 
     def configure(self):
-        self.put_template(
-            "acmetool/response-file.yaml.j2",
-            "/var/lib/acme/conf/responses",
+        files.template(
+            src=importlib.resources.files(__package__).joinpath(
+                "response-file.yaml.j2"
+            ),
+            dest="/var/lib/acme/conf/responses",
+            user="root",
+            group="root",
+            mode="644",
             email=self.email,
         )
 
-        self.put_template(
-            "acmetool/target.yaml.j2",
-            "/var/lib/acme/conf/target",
+        files.template(
+            src=importlib.resources.files(__package__).joinpath("target.yaml.j2"),
+            dest="/var/lib/acme/conf/target",
+            user="root",
+            group="root",
+            mode="644",
         )
 
         server.shell(
             name=f"Remove old acmetool desired files for {self.domains[0]}",
             commands=[f"rm -f /var/lib/acme/desired/{self.domains[0]}-*"],
         )
-        self.put_template(
-            "acmetool/desired.yaml.j2",
-            f"/var/lib/acme/desired/{self.domains[0]}",
+        files.template(
+            src=importlib.resources.files(__package__).joinpath("desired.yaml.j2"),
+            dest=f"/var/lib/acme/desired/{self.domains[0]}",  # 0 is mailhost TLD
+            user="root",
+            group="root",
+            mode="644",
             domains=self.domains,
         )
 
-        self.ensure_systemd_unit("acmetool/acmetool-redirector.service")
-        self.ensure_systemd_unit("acmetool/acmetool-reconcile.service")
-        self.ensure_systemd_unit("acmetool/acmetool-reconcile.timer")
+        service_file = files.put(
+            src=importlib.resources.files(__package__).joinpath(
+                "acmetool-redirector.service"
+            ),
+            dest="/etc/systemd/system/acmetool-redirector.service",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        self.need_restart_redirector = service_file.changed
+
+        reconcile_service_file = files.put(
+            src=importlib.resources.files(__package__).joinpath(
+                "acmetool-reconcile.service"
+            ),
+            dest="/etc/systemd/system/acmetool-reconcile.service",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        self.need_restart_reconcile_service = reconcile_service_file.changed
+
+        reconcile_timer_file = files.put(
+            src=importlib.resources.files(__package__).joinpath(
+                "acmetool-reconcile.timer"
+            ),
+            dest="/etc/systemd/system/acmetool-reconcile.timer",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        self.need_restart_reconcile_timer = reconcile_timer_file.changed
 
     def activate(self):
-        self.ensure_service("acmetool-redirector.service")
-        self.ensure_service("acmetool-reconcile.service", running=False, enabled=False)
-        self.ensure_service("acmetool-reconcile.timer")
+        systemd.service(
+            name="Setup acmetool-redirector service",
+            service="acmetool-redirector.service",
+            running=True,
+            enabled=True,
+            restarted=self.need_restart_redirector,
+        )
+        self.need_restart_redirector = False
+
+        systemd.service(
+            name="Setup acmetool-reconcile service",
+            service="acmetool-reconcile.service",
+            running=False,
+            enabled=False,
+            daemon_reload=self.need_restart_reconcile_service,
+        )
+        self.need_restart_reconcile_service = False
+
+        systemd.service(
+            name="Setup acmetool-reconcile timer",
+            service="acmetool-reconcile.timer",
+            running=True,
+            enabled=True,
+            daemon_reload=self.need_restart_reconcile_timer,
+        )
+        self.need_restart_reconcile_timer = False
 
         server.shell(
             name=f"Reconcile certificates for: {', '.join(self.domains)}",

cmdeploy/src/cmdeploy/acmetool/response-file.yaml.j2

@@ -1,2 +1,2 @@
 "acme-enter-email": "{{ email }}"
-"acme-agreement:https://letsencrypt.org/documents/LE-SA-v1.8-July-06-2026.pdf": true
+"acme-agreement:https://letsencrypt.org/documents/LE-SA-v1.6-August-18-2025.pdf": true

cmdeploy/src/cmdeploy/basedeploy.py

@@ -4,7 +4,6 @@ import os
 from contextlib import contextmanager
 
 from pyinfra import host
-from pyinfra.facts.files import Sha256File
 from pyinfra.facts.server import Command
 from pyinfra.operations import files, server, systemd
 
@@ -51,10 +50,11 @@ def get_resource(arg, pkg=__package__):
     return importlib.resources.files(pkg).joinpath(arg)
 
 
-def configure_remote_units(deployer, mail_domain, units) -> None:
+def configure_remote_units(mail_domain, units) -> None:
     remote_base_dir = "/usr/local/lib/chatmaild"
     remote_venv_dir = f"{remote_base_dir}/venv"
     remote_chatmail_inipath = f"{remote_base_dir}/chatmail.ini"
+    root_owned = dict(user="root", group="root", mode="644")
 
     # install systemd units
     for fn in units:
@@ -70,13 +70,15 @@ def configure_remote_units(deployer, mail_domain, units) -> None:
         source_path = get_resource(f"service/{basename}.f")
         content = source_path.read_text().format(**params).encode()
 
-        deployer.put_file(
+        files.put(
+            name=f"Upload {basename}",
             src=io.BytesIO(content),
             dest=f"/etc/systemd/system/{basename}",
+            **root_owned,
         )
 
 
-def activate_remote_units(deployer, units) -> None:
+def activate_remote_units(units) -> None:
     # activate systemd units
     for fn in units:
         basename = fn if "." in fn else f"{fn}.service"
@@ -86,8 +88,14 @@ def activate_remote_units(deployer, units) -> None:
             enabled = False
         else:
             enabled = True
-
-        deployer.ensure_service(basename, running=enabled, enabled=enabled)
+        systemd.service(
+            name=f"Setup {basename}",
+            service=basename,
+            running=enabled,
+            enabled=enabled,
+            restarted=enabled,
+            daemon_reload=True,
+        )
 
 
 class Deployment:
@@ -133,7 +141,6 @@ class Deployment:
 
 class Deployer:
     need_restart = False
-    daemon_reload = False
 
     def install(self):
         pass
@@ -143,114 +150,3 @@ class Deployer:
 
     def activate(self):
         pass
-
-    def ensure_service(self, service, running=True, enabled=True):
-        if running:
-            verb = "Start and enable"
-        else:
-            verb = "Stop"
-        systemd.service(
-            name=f"{verb} {service}",
-            service=service,
-            running=running,
-            enabled=enabled,
-            restarted=self.need_restart if running else False,
-            daemon_reload=self.daemon_reload,
-        )
-        self.daemon_reload = False
-
-    def ensure_systemd_unit(self, src, **kwargs):
-        dest_name = src.split("/")[-1].replace(".j2", "")
-        dest = f"/etc/systemd/system/{dest_name}"
-        if src.endswith(".j2"):
-            return self.put_template(src, dest, **kwargs)
-        return self.put_file(src, dest)
-
-    def put_file(self, src, dest, mode="644", **kwargs):
-        if isinstance(src, str):
-            src = get_resource(src)
-        res = files.put(
-            name=f"Upload {dest}",
-            src=src,
-            dest=dest,
-            user="root",
-            group="root",
-            mode=mode,
-            **kwargs,
-        )
-
-        return self._update_restart_signals(dest, res)
-
-    def put_executable(self, src, dest):
-        return self.put_file(src, dest, mode="755")
-
-    def put_template(self, src, dest, owner="root", **kwargs):
-        if isinstance(src, str):
-            src = get_resource(src)
-        res = files.template(
-            name=f"Upload {dest}",
-            src=src,
-            dest=dest,
-            user=owner,
-            group=owner,
-            mode="644",
-            **kwargs,
-        )
-
-        return self._update_restart_signals(dest, res)
-
-    def remove_file(self, dest):
-        res = files.file(name=f"Remove {dest}", path=dest, present=False)
-        return self._update_restart_signals(dest, res)
-
-    def ensure_line(self, path, line, **kwargs):
-        name = kwargs.pop("name", f"Ensure line in {path}")
-        res = files.line(name=name, path=path, line=line, **kwargs)
-        return self._update_restart_signals(path, res)
-
-    def ensure_directory(self, path, owner="root", mode="755", **kwargs):
-        name = kwargs.pop("name", f"Ensure directory {path}")
-        res = files.directory(
-            name=name,
-            path=path,
-            user=owner,
-            group=owner,
-            mode=mode,
-            present=True,
-            **kwargs,
-        )
-        return self._update_restart_signals(path, res)
-
-    def remove_directory(self, path, **kwargs):
-        name = kwargs.pop("name", f"Remove directory {path}")
-        res = files.directory(name=name, path=path, present=False, **kwargs)
-        return self._update_restart_signals(path, res)
-
-    def download_executable(self, url, dest, sha256sum, extract=None):
-        existing = host.get_fact(Sha256File, dest)
-        if existing == sha256sum:
-            return
-
-        tmp = f"{dest}.new"
-        if extract:
-            dl_cmd = f"curl -fSL {url} | {extract} >{tmp}"
-        else:
-            dl_cmd = f"curl -fSL {url} -o {tmp}"
-
-        server.shell(
-            name=f"Download {dest}",
-            commands=[
-                f"({dl_cmd}"
-                f" && echo '{sha256sum}  {tmp}' | sha256sum -c"
-                f" && mv {tmp} {dest})",
-                f"chmod 755 {dest}",
-            ],
-        )
-        self.need_restart = True
-
-    def _update_restart_signals(self, path, res):
-        if res.changed:
-            self.need_restart = True
-            if str(path).startswith("/etc/systemd/system/"):
-                self.daemon_reload = True
-        return res

cmdeploy/src/cmdeploy/cmdeploy.py

@@ -84,15 +84,6 @@ def run_cmd_options(parser):
     add_ssh_host_option(parser)
 
 
-def _warn_unused_settings(unused_keys, out):
-    if unused_keys:
-        names = ", ".join(unused_keys)
-        out.red(
-            f"WARNING: chatmail.ini contains settings that have no effect: {names}\n"
-            "Please remove them from chatmail.ini."
-        )
-
-
 def run_cmd(args, out):
     """Deploy chatmail services on the remote server."""
 
@@ -134,7 +125,6 @@ def run_cmd(args, out):
             out.green("Deploy completed.")
         else:
             out.green("Deploy completed, call `cmdeploy dns` next.")
-        _warn_unused_settings(args.config._unused_keys, out)
         return 0
     except subprocess.CalledProcessError:
         out.red("Deploy failed")

cmdeploy/src/cmdeploy/deployers.py

@@ -12,6 +12,7 @@ from chatmaild.config import read_config
 from pyinfra import facts, host, logger
 from pyinfra.api import FactBase
 from pyinfra.facts import hardware
+from pyinfra.facts.files import Sha256File
 from pyinfra.facts.systemd import SystemdEnabled
 from pyinfra.operations import apt, files, pip, server, systemd
 
@@ -24,6 +25,7 @@ from .basedeploy import (
     activate_remote_units,
     blocked_service_startup,
     configure_remote_units,
+    get_resource,
     has_systemd,
     is_in_container,
 )
@@ -80,22 +82,25 @@ def remove_legacy_artifacts():
         )
 
 
-def _install_remote_venv_with_chatmaild(deployer) -> None:
+def _install_remote_venv_with_chatmaild() -> None:
     remove_legacy_artifacts()
     dist_file = _build_chatmaild(dist_dir=Path("chatmaild/dist"))
     remote_base_dir = "/usr/local/lib/chatmaild"
     remote_dist_file = f"{remote_base_dir}/dist/{dist_file.name}"
     remote_venv_dir = f"{remote_base_dir}/venv"
+    root_owned = dict(user="root", group="root", mode="644")
 
     apt.packages(
         name="apt install python3-virtualenv",
         packages=["python3-virtualenv"],
     )
 
-    deployer.ensure_directory(f"{remote_base_dir}/dist")
-    deployer.put_file(
+    files.put(
+        name="Upload chatmaild source package",
         src=dist_file.open("rb"),
         dest=remote_dist_file,
+        create_remote_dir=True,
+        **root_owned,
     )
 
     pip.virtualenv(
@@ -117,43 +122,40 @@ def _install_remote_venv_with_chatmaild(deployer) -> None:
     )
 
 
-def _configure_remote_venv_with_chatmaild(deployer, config) -> None:
+def _configure_remote_venv_with_chatmaild(config) -> None:
     remote_base_dir = "/usr/local/lib/chatmaild"
     remote_chatmail_inipath = f"{remote_base_dir}/chatmail.ini"
+    root_owned = dict(user="root", group="root", mode="644")
 
-    deployer.put_file(
+    files.put(
+        name=f"Upload {remote_chatmail_inipath}",
         src=config._getbytefile(),
         dest=remote_chatmail_inipath,
+        **root_owned,
     )
 
-    deployer.remove_file("/etc/cron.d/chatmail-metrics")
-    deployer.remove_file("/var/www/html/metrics")
+    files.file(
+        path="/etc/cron.d/chatmail-metrics",
+        present=False,
+    )
+    files.file(
+        path="/var/www/html/metrics",
+        present=False,
+    )
 
 
 class UnboundDeployer(Deployer):
     def __init__(self, config):
         self.config = config
+        self.need_restart = False
 
     def install(self):
         # On an IPv4-only system, if unbound is started but not configured,
         # it causes subsequent steps to fail to resolve hosts.
         with blocked_service_startup():
-            # dns-root-data is an optional package
-            # that contains /usr/share/dns/root.key
-            #
-            # This file is copied into /var/lib/unbound/root.key
-            # at the start of "unbound" systemd unit
-            # by /usr/libexec/unbound-helper shell script
-            # from the "unbound" package as of version 1.17.1-2+deb12u4
-            #
-            # The same /var/lib/unbound/root.key can be retrieved directly
-            # following the procedure from
-            # <https://www.rfc-editor.org/info/rfc7958/#section-3.1>
-            # with "unbound-anchor -a /var/lib/unbound/root.key"
-            # We don't install and use "unbound-anchor".
             apt.packages(
                 name="Install unbound",
-                packages=["unbound", "dns-root-data", "dnsutils"],
+                packages=["unbound", "unbound-anchor", "dnsutils"],
             )
 
     def configure(self):
@@ -174,19 +176,41 @@ class UnboundDeployer(Deployer):
         )
         # Configure unbound resolver with Quad9 fallback and a trailing newline
         # (SolusVM bug).
-        self.put_file(
+        files.put(
+            name="Write static resolv.conf",
             src=BytesIO(b"nameserver 127.0.0.1\nnameserver 9.9.9.9\n"),
             dest="/etc/resolv.conf",
-            force=True,
+            user="root",
+            group="root",
+            mode="644",
         )
-        self.ensure_directory(
-            path="/etc/unbound/unbound.conf.d",
-        )
-        self.put_template(
-            "unbound/unbound.conf.j2",
-            "/etc/unbound/unbound.conf.d/chatmail.conf",
-            disable_ipv6=self.config.disable_ipv6,
+        server.shell(
+            name="Generate root keys for validating DNSSEC",
+            commands=[
+                "unbound-anchor -a /var/lib/unbound/root.key || true",
+            ],
         )
+        if self.config.disable_ipv6:
+            files.directory(
+                path="/etc/unbound/unbound.conf.d",
+                present=True,
+                user="root",
+                group="root",
+                mode="755",
+            )
+            conf = files.put(
+                src=get_resource("unbound/unbound.conf.j2"),
+                dest="/etc/unbound/unbound.conf.d/chatmail.conf",
+                user="root",
+                group="root",
+                mode="644",
+            )
+        else:
+            conf = files.file(
+                path="/etc/unbound/unbound.conf.d/chatmail.conf",
+                present=False,
+            )
+        self.need_restart |= conf.changed
 
     def activate(self):
         server.shell(
@@ -196,25 +220,27 @@ class UnboundDeployer(Deployer):
             ],
         )
 
-        self.ensure_service("unbound.service")
-
-        self.ensure_service(
-            "unbound-resolvconf.service",
-            running=False,
-            enabled=False,
+        systemd.service(
+            name="Start and enable unbound",
+            service="unbound.service",
+            running=True,
+            enabled=True,
+            restarted=self.need_restart,
         )
 
 
 class MtastsDeployer(Deployer):
     def configure(self):
         # Remove configuration.
-        self.remove_file("/etc/mta-sts-daemon.yml")
-        self.remove_directory("/usr/local/lib/postfix-mta-sts-resolver")
-        self.remove_file("/etc/systemd/system/mta-sts-daemon.service")
+        files.file("/etc/mta-sts-daemon.yml", present=False)
+        files.directory("/usr/local/lib/postfix-mta-sts-resolver", present=False)
+        files.file("/etc/systemd/system/mta-sts-daemon.service", present=False)
 
     def activate(self):
-        self.ensure_service(
-            "mta-sts-daemon.service",
+        systemd.service(
+            name="Stop MTA-STS daemon",
+            service="mta-sts-daemon.service",
+            daemon_reload=True,
             running=False,
             enabled=False,
         )
@@ -225,7 +251,14 @@ class WebsiteDeployer(Deployer):
         self.config = config
 
     def install(self):
-        self.ensure_directory("/var/www")
+        files.directory(
+            name="Ensure /var/www exists",
+            path="/var/www",
+            user="root",
+            group="root",
+            mode="755",
+            present=True,
+        )
 
     def configure(self):
         www_path, src_dir, build_dir = get_paths(self.config)
@@ -253,20 +286,17 @@ class LegacyRemoveDeployer(Deployer):
     def install(self):
         apt.packages(name="Remove rspamd", packages="rspamd", present=False)
 
-        # unbound-anchor was used to download /var/lib/unbound/root.key
-        # It is replaced by dns-root-data which contains /usr/share/dns/root.key.
-        # unbound systemd unit copies /usr/share/dns/root.key
-        # into /var/lib/unbound/root.key automatically on start
-        # as long as /usr/share/dns/root.key is present.
-        apt.packages(name="Remove unbound-anchor", packages="unbound-anchor", present=False)
-
         # remove historic expunge script
         # which is now implemented through a systemd timer (chatmail-expire)
-        self.remove_file("/etc/cron.d/expunge")
+        files.file(
+            path="/etc/cron.d/expunge",
+            present=False,
+        )
 
         # Remove OBS repository key that is no longer used.
-        self.remove_file("/etc/apt/keyrings/obs-home-deltachat.gpg")
-        self.ensure_line(
+        files.file("/etc/apt/keyrings/obs-home-deltachat.gpg", present=False)
+        files.line(
+            name="Remove DeltaChat OBS home repository from sources.list",
             path="/etc/apt/sources.list",
             line="deb [signed-by=/etc/apt/keyrings/obs-home-deltachat.gpg] https://download.opensuse.org/repositories/home:/deltachat/Debian_12/ ./",
             escape_regex_characters=True,
@@ -274,7 +304,11 @@ class LegacyRemoveDeployer(Deployer):
         )
 
         # prior relay versions used filelogging
-        self.remove_directory("/var/log/journal/")
+        files.directory(
+            name="Ensure old logs on disk are deleted",
+            path="/var/log/journal/",
+            present=False,
+        )
         # remove echobot if it is still running
         if has_systemd() and host.get_fact(SystemdEnabled).get("echobot.service"):
             systemd.service(
@@ -316,13 +350,22 @@ class TurnDeployer(Deployer):
                 "0fb3e792419494e21ecad536464929dba706bb2c88884ed8f1788141d26fc756",
             ),
         }[host.get_fact(facts.server.Arch)]
-        self.download_executable(url, "/usr/local/bin/chatmail-turn", sha256sum)
+
+        existing_sha256sum = host.get_fact(Sha256File, "/usr/local/bin/chatmail-turn")
+        if existing_sha256sum != sha256sum:
+            server.shell(
+                name="Download chatmail-turn",
+                commands=[
+                    f"(curl -L {url} >/usr/local/bin/chatmail-turn.new && (echo '{sha256sum} /usr/local/bin/chatmail-turn.new' | sha256sum -c) && mv /usr/local/bin/chatmail-turn.new /usr/local/bin/chatmail-turn)",
+                    "chmod 755 /usr/local/bin/chatmail-turn",
+                ],
+            )
 
     def configure(self):
-        configure_remote_units(self, self.mail_domain, self.units)
+        configure_remote_units(self.mail_domain, self.units)
 
     def activate(self):
-        activate_remote_units(self, self.units)
+        activate_remote_units(self.units)
 
 
 class IrohDeployer(Deployer):
@@ -340,38 +383,78 @@ class IrohDeployer(Deployer):
                 "f8ef27631fac213b3ef668d02acd5b3e215292746a3fc71d90c63115446008b1",
             ),
         }[host.get_fact(facts.server.Arch)]
-        self.download_executable(
-            url,
-            "/usr/local/bin/iroh-relay",
-            sha256sum,
-            extract="gunzip | tar -xf - ./iroh-relay -O",
-        )
+
+        existing_sha256sum = host.get_fact(Sha256File, "/usr/local/bin/iroh-relay")
+        if existing_sha256sum != sha256sum:
+            server.shell(
+                name="Download iroh-relay",
+                commands=[
+                    f"(curl -L {url} | gunzip | tar -x -f - ./iroh-relay -O >/usr/local/bin/iroh-relay.new && (echo '{sha256sum} /usr/local/bin/iroh-relay.new' | sha256sum -c) && mv /usr/local/bin/iroh-relay.new /usr/local/bin/iroh-relay)",
+                    "chmod 755 /usr/local/bin/iroh-relay",
+                ],
+            )
+
+            self.need_restart = True
 
     def configure(self):
-        self.ensure_systemd_unit("iroh-relay.service")
-        self.put_file("iroh-relay.toml", "/etc/iroh-relay.toml")
+        systemd_unit = files.put(
+            name="Upload iroh-relay systemd unit",
+            src=get_resource("iroh-relay.service"),
+            dest="/etc/systemd/system/iroh-relay.service",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        self.need_restart |= systemd_unit.changed
+
+        iroh_config = files.put(
+            name="Upload iroh-relay config",
+            src=get_resource("iroh-relay.toml"),
+            dest="/etc/iroh-relay.toml",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        self.need_restart |= iroh_config.changed
 
     def activate(self):
-        self.ensure_service(
-            "iroh-relay.service",
+        systemd.service(
+            name="Start and enable iroh-relay",
+            service="iroh-relay.service",
+            running=True,
             enabled=self.enable_iroh_relay,
+            restarted=self.need_restart,
         )
+        self.need_restart = False
 
 
 class JournaldDeployer(Deployer):
     def configure(self):
-        self.put_file("journald.conf", "/etc/systemd/journald.conf")
+        journald_conf = files.put(
+            name="Configure journald",
+            src=get_resource("journald.conf"),
+            dest="/etc/systemd/journald.conf",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        self.need_restart = journald_conf.changed
 
     def activate(self):
-        self.ensure_service("systemd-journald.service")
+        systemd.service(
+            name="Start and enable journald",
+            service="systemd-journald.service",
+            running=True,
+            enabled=True,
+            restarted=self.need_restart,
+        )
+        self.need_restart = False
 
 
 class ChatmailVenvDeployer(Deployer):
     def __init__(self, config):
         self.config = config
         self.units = (
-            # doveauth must restart when chatmaild/ini file changes
-            "doveauth",
             "chatmail-metadata",
             "lastlogin",
             "chatmail-expire",
@@ -381,14 +464,14 @@ class ChatmailVenvDeployer(Deployer):
         )
 
     def install(self):
-        _install_remote_venv_with_chatmaild(self)
+        _install_remote_venv_with_chatmaild()
 
     def configure(self):
-        _configure_remote_venv_with_chatmaild(self, self.config)
-        configure_remote_units(self, self.config.mail_domain_bare, self.units)
+        _configure_remote_venv_with_chatmaild(self.config)
+        configure_remote_units(self.config.mail_domain_bare, self.units)
 
     def activate(self):
-        activate_remote_units(self, self.units)
+        activate_remote_units(self.units)
 
 
 class ChatmailDeployer(Deployer):
@@ -402,9 +485,13 @@ class ChatmailDeployer(Deployer):
         self.mail_domain = config.mail_domain
 
     def install(self):
-        self.put_file(
+        files.put(
+            name="Disable installing recommended packages globally",
             src=BytesIO(b'APT::Install-Recommends "false";\n'),
             dest="/etc/apt/apt.conf.d/00InstallRecommends",
+            user="root",
+            group="root",
+            mode="644",
         )
         apt.update(name="apt update", cache_time=24 * 3600)
         apt.upgrade(name="upgrade apt packages", auto_remove=True)
@@ -421,10 +508,13 @@ class ChatmailDeployer(Deployer):
 
     def configure(self):
         # metadata crashes if the mailboxes dir does not exist
-        self.ensure_directory(
-            str(self.config.mailboxes_dir),
-            owner="vmail",
+        files.directory(
+            name="Ensure vmail mailbox directory exists",
+            path=str(self.config.mailboxes_dir),
+            user="vmail",
+            group="vmail",
             mode="700",
+            present=True,
         )
 
         # This file is used by auth proxy.
@@ -445,7 +535,12 @@ class FcgiwrapDeployer(Deployer):
         )
 
     def activate(self):
-        self.ensure_service("fcgiwrap.service")
+        systemd.service(
+            name="Start and enable fcgiwrap",
+            service="fcgiwrap.service",
+            running=True,
+            enabled=True,
+        )
 
 
 class GithashDeployer(Deployer):
@@ -458,7 +553,12 @@ class GithashDeployer(Deployer):
             git_diff = subprocess.check_output(["git", "diff"]).decode()
         except Exception:
             git_diff = ""
-        self.put_file(src=StringIO(git_hash + git_diff), dest="/etc/chatmail-version")
+        files.put(
+            name="Upload chatmail relay git commit hash",
+            src=StringIO(git_hash + git_diff),
+            dest="/etc/chatmail-version",
+            mode="700",
+        )
 
 
 def get_tls_deployer(config, mail_domain):
@@ -491,17 +591,11 @@ def deploy_chatmail(config_path: Path, disable_mail: bool, website_only: bool) -
         return
 
     # Check if mtail_address interface is available (if configured)
-    if config.mtail_address and config.mtail_address not in (
-        "127.0.0.1",
-        "::1",
-        "localhost",
-    ):
+    if config.mtail_address and config.mtail_address not in ('127.0.0.1', '::1', 'localhost'):
         ipv4_addrs = host.get_fact(hardware.Ipv4Addrs)
         all_addresses = [addr for addrs in ipv4_addrs.values() for addr in addrs]
         if config.mtail_address not in all_addresses:
-            Out().red(
-                f"Deploy failed: mtail_address {config.mtail_address} is not available (VPN up?).\n"
-            )
+            Out().red(f"Deploy failed: mtail_address {config.mtail_address} is not available (VPN up?).\n")
             exit(1)
 
     if not is_in_container():
@@ -520,17 +614,15 @@ def deploy_chatmail(config_path: Path, disable_mail: bool, website_only: bool) -
             ("nginx", 443),
             (["master", "smtpd"], 465),
             (["master", "smtpd"], 587),
-            (["dovecot", "imap-login"], 993),
+            (["imap-login", "dovecot"], 993),
             ("iroh-relay", 3340),
             ("mtail", 3903),
-            (["dovecot", "stats"], 3904),
+            ("stats", 3904),
             ("nginx", 8443),
             (["master", "smtpd"], config.postfix_reinject_port),
             (["master", "smtpd"], config.postfix_reinject_port_incoming),
             ("filtermail", config.filtermail_smtp_port),
             ("filtermail", config.filtermail_smtp_port_incoming),
-            ("filtermail", config.filtermail_http_port_incoming),
-            ("filtermail", config.filtermail_lmtp_port_transport),
         ]
         for service, port in port_services:
             print(f"Checking if port {port} is available for {service}...")
@@ -557,7 +649,7 @@ def deploy_chatmail(config_path: Path, disable_mail: bool, website_only: bool) -
         WebsiteDeployer(config),
         ChatmailVenvDeployer(config),
         MtastsDeployer(),
-        *([] if config.ipv4_relay else [OpendkimDeployer(bare_host)]),
+        OpendkimDeployer(config.mail_domain),
         # Dovecot should be started before Postfix
         # because it creates authentication socket
         # required by Postfix.

cmdeploy/src/cmdeploy/dovecot/deployer.py

@@ -5,13 +5,14 @@ from chatmaild.config import Config
 from pyinfra import host
 from pyinfra.facts.deb import DebPackages
 from pyinfra.facts.server import Arch, Command, Sysctl
-from pyinfra.operations import apt, files, server
+from pyinfra.operations import apt, files, server, systemd
 
 from cmdeploy.basedeploy import (
     Deployer,
     activate_remote_units,
     blocked_service_startup,
     configure_remote_units,
+    get_resource,
     is_in_container,
 )
 
@@ -34,7 +35,7 @@ class DovecotDeployer(Deployer):
     def __init__(self, config, disable_mail):
         self.config = config
         self.disable_mail = disable_mail
-        self.units = []
+        self.units = ["doveauth"]
 
     def install(self):
         arch = host.get_fact(Arch)
@@ -58,21 +59,26 @@ class DovecotDeployer(Deployer):
                     ],
                 )
                 self.need_restart = True
-        self.put_file(
+        files.put(
+            name="Pin dovecot packages to block Debian dist-upgrades",
             src=io.StringIO(
                 "Package: dovecot-*\n"
                 "Pin: version *\n"
                 "Pin-Priority: -1\n"
             ),
             dest="/etc/apt/preferences.d/pin-dovecot",
+            user="root",
+            group="root",
+            mode="644",
         )
 
     def configure(self):
-        configure_remote_units(self, self.config.mail_domain_bare, self.units)
-        _configure_dovecot(self, self.config)
+        configure_remote_units(self.config.mail_domain_bare, self.units)
+        config_restart, self.daemon_reload = _configure_dovecot(self.config)
+        self.need_restart |= config_restart
 
     def activate(self):
-        activate_remote_units(self, self.units)
+        activate_remote_units(self.units)
 
         # Detect stale binary: package installed but service still runs old (deleted) binary.
         if not self.disable_mail and not self.need_restart:
@@ -85,12 +91,19 @@ class DovecotDeployer(Deployer):
             if stale == "STALE":
                 self.need_restart = True
 
-        active = not self.disable_mail
-        self.ensure_service(
-            "dovecot.service",
-            running=active,
-            enabled=active,
+        restart = False if self.disable_mail else self.need_restart
+
+        systemd.service(
+            name="Disable dovecot for now"
+            if self.disable_mail
+            else "Start and enable Dovecot",
+            service="dovecot.service",
+            running=False if self.disable_mail else True,
+            enabled=False if self.disable_mail else True,
+            restarted=restart,
+            daemon_reload=self.daemon_reload,
         )
+        self.need_restart = False
 
 
 def _pick_url(primary, fallback):
@@ -134,19 +147,39 @@ def _download_dovecot_package(package: str, arch: str) -> tuple[str | None, bool
 
     return deb_filename, True
 
-def _configure_dovecot(deployer, config: Config, debug: bool = False):
+
+def _configure_dovecot(config: Config, debug: bool = False) -> tuple[bool, bool]:
     """Configures Dovecot IMAP server."""
-    deployer.put_template(
-        "dovecot/dovecot.conf.j2",
-        "/etc/dovecot/dovecot.conf",
+    need_restart = False
+    daemon_reload = False
+
+    main_config = files.template(
+        src=get_resource("dovecot/dovecot.conf.j2"),
+        dest="/etc/dovecot/dovecot.conf",
+        user="root",
+        group="root",
+        mode="644",
         config=config,
         debug=debug,
         disable_ipv6=config.disable_ipv6,
     )
-    deployer.put_file("dovecot/auth.conf", "/etc/dovecot/auth.conf")
-    deployer.put_file(
-        "dovecot/push_notification.lua", "/etc/dovecot/push_notification.lua"
+    need_restart |= main_config.changed
+    auth_config = files.put(
+        src=get_resource("dovecot/auth.conf"),
+        dest="/etc/dovecot/auth.conf",
+        user="root",
+        group="root",
+        mode="644",
     )
+    need_restart |= auth_config.changed
+    lua_push_notification_script = files.put(
+        src=get_resource("dovecot/push_notification.lua"),
+        dest="/etc/dovecot/push_notification.lua",
+        user="root",
+        group="root",
+        mode="644",
+    )
+    need_restart |= lua_push_notification_script.changed
 
     # as per https://doc.dovecot.org/2.3/configuration_manual/os/
     # it is recommended to set the following inotify limits
@@ -170,20 +203,25 @@ def _configure_dovecot(deployer, config: Config, debug: bool = False):
             persist=True,
         )
 
-    deployer.ensure_line(
+    timezone_env = files.line(
         name="Set TZ environment variable",
         path="/etc/environment",
         line="TZ=:/etc/localtime",
     )
+    need_restart |= timezone_env.changed
 
-    deployer.put_file(
-        "service/10_restart_on_failure.conf",
-        "/etc/systemd/system/dovecot.service.d/10_restart.conf",
+    restart_conf = files.put(
+        name="dovecot: restart automatically on failure",
+        src=get_resource("service/10_restart.conf"),
+        dest="/etc/systemd/system/dovecot.service.d/10_restart.conf",
     )
+    daemon_reload |= restart_conf.changed
 
     # Validate dovecot configuration before restart
-    if deployer.need_restart:
+    if need_restart:
         server.shell(
             name="Validate dovecot configuration",
             commands=["doveconf -n >/dev/null"],
         )
+
+    return need_restart, daemon_reload

cmdeploy/src/cmdeploy/dovecot/dovecot.conf.j2

@@ -37,15 +37,11 @@ default_client_limit = 20000
 # the following warning will be logged:
 #   Warning: service(imap): process_limit (1024) reached, client connections are being dropped
 service imap {
-  process_limit = {{ config.max_imap_connections }}
+  process_limit = 50000
 }
 
-{% if config.privacy_mail %}
-# Advertised to clients as IMAP METADATA /shared/admin (RFC 5464).
-# The privacy_mail contact from chatmail.ini is used because it is
-# the only address set by an operator.
-mail_server_admin = mailto:{{ config.privacy_mail }}
-{% endif %}
+mail_server_admin = mailto:root@{{ config.mail_domain }}
+mail_server_comment = Chatmail server
 
 # `zlib` enables compressing messages stored in the maildir.
 # See

cmdeploy/src/cmdeploy/external/deployer.py

@@ -1,7 +1,10 @@
+import io
+
 from pyinfra import host
 from pyinfra.facts.files import File
+from pyinfra.operations import files, systemd
 
-from ..basedeploy import Deployer
+from cmdeploy.basedeploy import Deployer, get_resource
 
 
 class ExternalTlsDeployer(Deployer):
@@ -20,22 +23,45 @@ class ExternalTlsDeployer(Deployer):
     def configure(self):
         # Verify cert and key exist on the remote host using pyinfra facts.
         for path in (self.cert_path, self.key_path):
-            if host.get_fact(File, path=path) is None:
+            info = host.get_fact(File, path=path)
+            if info is None:
                 raise Exception(f"External TLS file not found on server: {path}")
 
-        self.ensure_systemd_unit(
-            "external/tls-cert-reload.path.j2",
-            cert_path=self.cert_path,
-        )
-        self.ensure_systemd_unit(
-            "external/tls-cert-reload.service",
+        # Deploy the .path unit (templated with the cert path).
+        # pkg=__package__ is required here because the resource files
+        # live in cmdeploy.external, not the default cmdeploy package.
+        source = get_resource("tls-cert-reload.path.f", pkg=__package__)
+        content = source.read_text().format(cert_path=self.cert_path).encode()
+
+        path_unit = files.put(
+            name="Upload tls-cert-reload.path",
+            src=io.BytesIO(content),
+            dest="/etc/systemd/system/tls-cert-reload.path",
+            user="root",
+            group="root",
+            mode="644",
         )
 
+        service_unit = files.put(
+            name="Upload tls-cert-reload.service",
+            src=get_resource("tls-cert-reload.service", pkg=__package__),
+            dest="/etc/systemd/system/tls-cert-reload.service",
+            user="root",
+            group="root",
+            mode="644",
+        )
+
+        if path_unit.changed or service_unit.changed:
+            self.need_restart = True
+
     def activate(self):
-        # No explicit reload needed here: dovecot/nginx read the cert
-        # on startup, and the .path watcher handles live changes.
-        self.ensure_service(
-            "tls-cert-reload.path",
+        systemd.service(
+            name="Enable tls-cert-reload path watcher",
+            service="tls-cert-reload.path",
             running=True,
             enabled=True,
+            restarted=self.need_restart,
+            daemon_reload=self.need_restart,
         )
+        # No explicit reload needed here: dovecot/nginx read the cert
+        # on startup, and the .path watcher handles live changes.

cmdeploy/src/cmdeploy/external/tls-cert-reload.path.f

@@ -9,7 +9,7 @@
 Description=Watch TLS certificate for changes
 
 [Path]
-PathChanged={{ cert_path }}
+PathChanged={cert_path}
 
 [Install]
 WantedBy=multi-user.target

cmdeploy/src/cmdeploy/filtermail/deployer.py

@@ -1,8 +1,9 @@
 import os
 
 from pyinfra import facts, host
+from pyinfra.operations import files, systemd
 
-from cmdeploy.basedeploy import Deployer
+from cmdeploy.basedeploy import Deployer, get_resource
 
 
 class FiltermailDeployer(Deployer):
@@ -10,31 +11,54 @@ class FiltermailDeployer(Deployer):
     bin_path = "/usr/local/bin/filtermail"
     config_path = "/usr/local/lib/chatmaild/chatmail.ini"
 
+    def __init__(self):
+        self.need_restart = False
+
     def install(self):
         local_bin = os.environ.get("CHATMAIL_FILTERMAIL_BINARY")
         if local_bin:
-            self.put_executable(
+            self.need_restart |= files.put(
+                name="Upload locally built filtermail",
                 src=local_bin,
                 dest=self.bin_path,
-            )
+                mode="755",
+            ).changed
             return
 
         arch = host.get_fact(facts.server.Arch)
-        url = f"https://github.com/chatmail/filtermail/releases/download/v0.7.4/filtermail-{arch}"
+        url = f"https://github.com/chatmail/filtermail/releases/download/v0.6.4/filtermail-{arch}"
         sha256sum = {
-            "x86_64": "484cb8dff083134aefba9fce4a6b7ef4784a0f0e28e5108ecf8bb9e58a44fd2c",
-            "aarch64": "66aa0ca2ca9add7a12d92883d76f8786384092adfde24a3d3a1d0b1f30d23a9e",
+            "x86_64": "5295115952c72e4c4ec3c85546e094b4155a4c702c82bd71fcdcb744dc73adf6",
+            "aarch64": "6892244f17b8f26ccb465766e96028e7222b3c8adefca9fc6bfe9ff332ca8dff",
         }[arch]
-        self.download_executable(url, self.bin_path, sha256sum)
+        self.need_restart |= files.download(
+            name="Download filtermail",
+            src=url,
+            sha256sum=sha256sum,
+            dest=self.bin_path,
+            mode="755",
+        ).changed
 
     def configure(self):
         for service in self.services:
-            self.ensure_systemd_unit(
-                f"filtermail/{service}.service.j2",
+            self.need_restart |= files.template(
+                src=get_resource(f"filtermail/{service}.service.j2"),
+                dest=f"/etc/systemd/system/{service}.service",
+                user="root",
+                group="root",
+                mode="644",
                 bin_path=self.bin_path,
                 config_path=self.config_path,
-            )
+            ).changed
 
     def activate(self):
         for service in self.services:
-            self.ensure_service(f"{service}.service")
+            systemd.service(
+                name=f"Start and enable {service}",
+                service=f"{service}.service",
+                running=True,
+                enabled=True,
+                restarted=self.need_restart,
+                daemon_reload=True,
+            )
+        self.need_restart = False

cmdeploy/src/cmdeploy/filtermail/filtermail-transport.service.j2

@@ -6,7 +6,6 @@ ExecStart={{ bin_path }} {{ config_path }} transport
 Restart=always
 RestartSec=30
 User=vmail
-LimitNOFILE=524288
 
 [Install]
 WantedBy=multi-user.target

cmdeploy/src/cmdeploy/mtail/delivered_mail.mtail

@@ -28,13 +28,6 @@ counter created_nonci_accounts
   }
 }
 
-# doveauth refusing new addresses because a chatmail.ini
-# system resource limit is exceeded.
-counter rejected_registrations
-/registration rejected: / {
-  rejected_registrations++
-}
-
 counter postfix_timeouts
 /timeout after DATA/ {
   postfix_timeouts++
@@ -80,11 +73,6 @@ counter incoming_unencrypted_mail_count
   filtered_incoming_mail_count++
 }
 
-counter incoming_mailer_daemon_mail_count
-/Incoming: Filtering mailer-daemon message from/ {
-  incoming_mailer_daemon_mail_count++
-  filtered_incoming_mail_count++
-}
 
 counter rejected_unencrypted_mail_count
 /Rejected unencrypted mail/ {

cmdeploy/src/cmdeploy/mtail/deployer.py

@@ -1,7 +1,10 @@
 from pyinfra import facts, host
-from pyinfra.operations import apt
+from pyinfra.operations import apt, files, server, systemd
 
-from cmdeploy.basedeploy import Deployer
+from cmdeploy.basedeploy import (
+    Deployer,
+    get_resource,
+)
 
 
 class MtailDeployer(Deployer):
@@ -15,30 +18,51 @@ class MtailDeployer(Deployer):
         (url, sha256sum) = {
             "x86_64": (
                 "https://github.com/google/mtail/releases/download/v3.0.8/mtail_3.0.8_linux_amd64.tar.gz",
-                "d55cb601049c5e61eabab29998dbbcea95d480e5448544f9470337ba2eea882e",
+                "123c2ee5f48c3eff12ebccee38befd2233d715da736000ccde49e3d5607724e4",
             ),
             "aarch64": (
                 "https://github.com/google/mtail/releases/download/v3.0.8/mtail_3.0.8_linux_arm64.tar.gz",
-                "f748db8ad2a1e0b63684d4c8868cf6a373a20f7e6922e5ece601fff0ee00eb1a",
+                "aa04811c0929b6754408676de520e050c45dddeb3401881888a092c9aea89cae",
             ),
         }[host.get_fact(facts.server.Arch)]
-        self.download_executable(
-            url,
-            "/usr/local/bin/mtail",
-            sha256sum,
-            extract="gunzip | tar -xf - mtail -O",
+
+        server.shell(
+            name="Download mtail",
+            commands=[
+                f"(echo '{sha256sum} /usr/local/bin/mtail' | sha256sum -c) || (curl -L {url} | gunzip | tar -x -f - mtail -O >/usr/local/bin/mtail.new && mv /usr/local/bin/mtail.new /usr/local/bin/mtail)",
+                "chmod 755 /usr/local/bin/mtail",
+            ],
         )
 
     def configure(self):
         # Using our own systemd unit instead of `/usr/lib/systemd/system/mtail.service`.
         # This allows to read from journalctl instead of log files.
-        self.ensure_systemd_unit(
-            "mtail/mtail.service.j2",
+        files.template(
+            src=get_resource("mtail/mtail.service.j2"),
+            dest="/etc/systemd/system/mtail.service",
+            user="root",
+            group="root",
+            mode="644",
             address=self.mtail_address or "127.0.0.1",
             port=3903,
         )
-        self.put_file("mtail/delivered_mail.mtail", "/etc/mtail/delivered_mail.mtail")
+
+        mtail_conf = files.put(
+            name="Mtail configuration",
+            src=get_resource("mtail/delivered_mail.mtail"),
+            dest="/etc/mtail/delivered_mail.mtail",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        self.need_restart = mtail_conf.changed
 
     def activate(self):
-        active = bool(self.mtail_address)
-        self.ensure_service("mtail.service", running=active, enabled=active)
+        systemd.service(
+            name="Start and enable mtail",
+            service="mtail.service",
+            running=bool(self.mtail_address),
+            enabled=bool(self.mtail_address),
+            restarted=self.need_restart,
+        )
+        self.need_restart = False

cmdeploy/src/cmdeploy/mtail/mtail.service.j2

@@ -1,13 +1,11 @@
 [Unit]
 Description=mtail
-After=network-online.target
-Wants=network-online.target
+After=multi-user.target
 
 [Service]
 Type=simple
 ExecStart=/bin/sh -c "journalctl -f -o short-iso -n 0 | /usr/local/bin/mtail --address={{ address }} --port={{ port }} --progs /etc/mtail --logtostderr --logs -"
 Restart=on-failure
-RestartSec=2s
 
 [Install]
 WantedBy=multi-user.target

cmdeploy/src/cmdeploy/nginx/deployer.py

@@ -1,5 +1,5 @@
 from chatmaild.config import Config
-from pyinfra.operations import apt
+from pyinfra.operations import apt, files, systemd
 
 from cmdeploy.basedeploy import (
     Deployer,
@@ -31,50 +31,87 @@ class NginxDeployer(Deployer):
         # For documentation about policy-rc.d, see:
         # https://people.debian.org/~hmh/invokerc.d-policyrc.d-specification.txt
         #
-        self.put_executable(src="policy-rc.d", dest="/usr/sbin/policy-rc.d")
+        files.put(
+            src=get_resource("policy-rc.d"),
+            dest="/usr/sbin/policy-rc.d",
+            user="root",
+            group="root",
+            mode="755",
+        )
 
         apt.packages(
             name="Install nginx",
             packages=["nginx", "libnginx-mod-stream"],
         )
 
-        self.remove_file("/usr/sbin/policy-rc.d")
+        files.file("/usr/sbin/policy-rc.d", present=False)
 
     def configure(self):
-        _configure_nginx(self, self.config)
+        self.need_restart = _configure_nginx(self.config)
 
     def activate(self):
-        self.ensure_service("nginx.service")
+        systemd.service(
+            name="Start and enable nginx",
+            service="nginx.service",
+            running=True,
+            enabled=True,
+            restarted=self.need_restart,
+        )
+        self.need_restart = False
 
 
-def _configure_nginx(deployer, config: Config, debug: bool = False):
+def _configure_nginx(config: Config, debug: bool = False) -> bool:
     """Configures nginx HTTP server."""
+    need_restart = False
 
-    deployer.put_template(
-        "nginx/nginx.conf.j2",
-        "/etc/nginx/nginx.conf",
+    main_config = files.template(
+        src=get_resource("nginx/nginx.conf.j2"),
+        dest="/etc/nginx/nginx.conf",
+        user="root",
+        group="root",
+        mode="644",
         config=config,
         disable_ipv6=config.disable_ipv6,
     )
+    need_restart |= main_config.changed
 
-    deployer.put_template(
-        "nginx/autoconfig.xml.j2",
-        "/var/www/html/.well-known/autoconfig/mail/config-v1.1.xml",
+    autoconfig = files.template(
+        src=get_resource("nginx/autoconfig.xml.j2"),
+        dest="/var/www/html/.well-known/autoconfig/mail/config-v1.1.xml",
+        user="root",
+        group="root",
+        mode="644",
         config=config,
     )
+    need_restart |= autoconfig.changed
 
-    deployer.put_template(
-        "nginx/mta-sts.txt.j2",
-        "/var/www/html/.well-known/mta-sts.txt",
+    mta_sts_config = files.template(
+        src=get_resource("nginx/mta-sts.txt.j2"),
+        dest="/var/www/html/.well-known/mta-sts.txt",
+        user="root",
+        group="root",
+        mode="644",
         config=config,
     )
+    need_restart |= mta_sts_config.changed
 
     # install CGI newemail script
     #
     cgi_dir = "/usr/lib/cgi-bin"
-    deployer.ensure_directory(cgi_dir)
+    files.directory(
+        name=f"Ensure {cgi_dir} exists",
+        path=cgi_dir,
+        user="root",
+        group="root",
+    )
 
-    deployer.put_executable(
+    files.put(
+        name="Upload cgi newemail.py script",
         src=get_resource("newemail.py", pkg="chatmaild").open("rb"),
         dest=f"{cgi_dir}/newemail.py",
+        user="root",
+        group="root",
+        mode="755",
     )
+
+    return need_restart

cmdeploy/src/cmdeploy/nginx/nginx.conf.j2

@@ -42,9 +42,6 @@ stream {
 }
 
 http {
-	# access_log setting is inherited by all server sections
-	access_log syslog:server=unix:/dev/log,facility=local7;
-
 {% if config.tls_cert_mode == "self" %}
 	limit_req_zone $binary_remote_addr zone=newaccount:10m rate=2r/s;
 {% endif %}
@@ -72,7 +69,9 @@ http {
 
 		index index.html index.htm;
 
-		server_name {{ config.mail_domain }} mta-sts.{{ config.mail_domain }};
+		server_name {{ config.mail_domain }} www.{{ config.mail_domain }} mta-sts.{{ config.mail_domain }};
+
+		access_log syslog:server=unix:/dev/log,facility=local7;
 
 		location /mxdeliv {
 		    proxy_pass http://127.0.0.1:{{ config.filtermail_http_port_incoming }};
@@ -128,10 +127,7 @@ http {
                         proxy_set_header Connection "upgrade";
                 }
 
-		# Endpoints Iroh uses for net_report probes and that clients
-		# probe to tell whether this relay works. Both paths are served
-		# by iroh-relay 0.35 and by the 1.0 line.
-		location /ping {
+		location /relay/probe {
                         proxy_pass http://127.0.0.1:3340;
                         proxy_http_version 1.1;
 		}
@@ -147,6 +143,7 @@ http {
 		listen 127.0.0.1:8443 ssl;
 		server_name www.{{ config.mail_domain }};
 		return 301 $scheme://{{ config.mail_domain }}$request_uri;
+		access_log syslog:server=unix:/dev/log,facility=local7;
 	}
 
 	server {

cmdeploy/src/cmdeploy/opendkim/deployer.py

@@ -4,9 +4,9 @@ Installs OpenDKIM
 
 from pyinfra import host
 from pyinfra.facts.files import File
-from pyinfra.operations import apt, files, server
+from pyinfra.operations import apt, files, server, systemd
 
-from cmdeploy.basedeploy import Deployer
+from cmdeploy.basedeploy import Deployer, get_resource
 
 
 class OpendkimDeployer(Deployer):
@@ -25,39 +25,65 @@ class OpendkimDeployer(Deployer):
         domain = self.mail_domain
         dkim_selector = "opendkim"
         """Configures OpenDKIM"""
+        need_restart = False
 
-        self.put_template(
-            "opendkim/opendkim.conf",
-            "/etc/opendkim.conf",
+        main_config = files.template(
+            src=get_resource("opendkim/opendkim.conf"),
+            dest="/etc/opendkim.conf",
+            user="root",
+            group="root",
+            mode="644",
             config={"domain_name": domain, "opendkim_selector": dkim_selector},
         )
+        need_restart |= main_config.changed
 
-        self.remove_file("/etc/opendkim/screen.lua")
-        self.remove_file("/etc/opendkim/final.lua")
+        screen_script = files.file(
+            path="/etc/opendkim/screen.lua",
+            present=False,
+        )
+        need_restart |= screen_script.changed
 
-        self.ensure_directory(
-            "/etc/opendkim",
-            owner="opendkim",
+        final_script = files.file(
+            path="/etc/opendkim/final.lua",
+            present=False,
+        )
+        need_restart |= final_script.changed
+
+        files.directory(
+            name="Add opendkim directory to /etc",
+            path="/etc/opendkim",
+            user="opendkim",
+            group="opendkim",
             mode="750",
+            present=True,
         )
 
-        self.put_template(
-            "opendkim/KeyTable",
-            "/etc/dkimkeys/KeyTable",
-            owner="opendkim",
+        keytable = files.template(
+            src=get_resource("opendkim/KeyTable"),
+            dest="/etc/dkimkeys/KeyTable",
+            user="opendkim",
+            group="opendkim",
+            mode="644",
             config={"domain_name": domain, "opendkim_selector": dkim_selector},
         )
+        need_restart |= keytable.changed
 
-        self.put_template(
-            "opendkim/SigningTable",
-            "/etc/dkimkeys/SigningTable",
-            owner="opendkim",
+        signing_table = files.template(
+            src=get_resource("opendkim/SigningTable"),
+            dest="/etc/dkimkeys/SigningTable",
+            user="opendkim",
+            group="opendkim",
+            mode="644",
             config={"domain_name": domain, "opendkim_selector": dkim_selector},
         )
-        self.ensure_directory(
-            "/var/spool/postfix/opendkim",
-            owner="opendkim",
+        need_restart |= signing_table.changed
+        files.directory(
+            name="Add opendkim socket directory to /var/spool/postfix",
+            path="/var/spool/postfix/opendkim",
+            user="opendkim",
+            group="opendkim",
             mode="750",
+            present=True,
         )
 
         if not host.get_fact(File, f"/etc/dkimkeys/{dkim_selector}.private"):
@@ -70,10 +96,12 @@ class OpendkimDeployer(Deployer):
                 _su_user="opendkim",
             )
 
-        self.put_file(
-            "opendkim/systemd.conf",
-            "/etc/systemd/system/opendkim.service.d/10-prevent-memory-leak.conf",
+        service_file = files.put(
+            name="Configure opendkim to restart once a day",
+            src=get_resource("opendkim/systemd.conf"),
+            dest="/etc/systemd/system/opendkim.service.d/10-prevent-memory-leak.conf",
         )
+        need_restart |= service_file.changed
 
         files.file(
             name="chown opendkim: /etc/dkimkeys/opendkim.private",
@@ -82,5 +110,15 @@ class OpendkimDeployer(Deployer):
             group="opendkim",
         )
 
+        self.need_restart = need_restart
+
     def activate(self):
-        self.ensure_service("opendkim.service")
+        systemd.service(
+            name="Start and enable OpenDKIM",
+            service="opendkim.service",
+            running=True,
+            enabled=True,
+            daemon_reload=self.need_restart,
+            restarted=self.need_restart,
+        )
+        self.need_restart = False

cmdeploy/src/cmdeploy/postfix/deployer.py

@@ -1,10 +1,11 @@
-from pyinfra.operations import apt, server
+from pyinfra.operations import apt, files, server, systemd
 
-from cmdeploy.basedeploy import Deployer
+from cmdeploy.basedeploy import Deployer, get_resource
 
 
 class PostfixDeployer(Deployer):
     required_users = [("postfix", None, ["opendkim"])]
+    daemon_reload = False
 
     def __init__(self, config, disable_mail):
         self.config = config
@@ -18,46 +19,81 @@ class PostfixDeployer(Deployer):
 
     def configure(self):
         config = self.config
+        need_restart = False
 
-        self.put_template(
-            "postfix/main.cf.j2",
-            "/etc/postfix/main.cf",
+        main_config = files.template(
+            src=get_resource("postfix/main.cf.j2"),
+            dest="/etc/postfix/main.cf",
+            user="root",
+            group="root",
+            mode="644",
             config=config,
             disable_ipv6=config.disable_ipv6,
         )
+        need_restart |= main_config.changed
 
-        self.put_template(
-            "postfix/master.cf.j2",
-            "/etc/postfix/master.cf",
+        master_config = files.template(
+            src=get_resource("postfix/master.cf.j2"),
+            dest="/etc/postfix/master.cf",
+            user="root",
+            group="root",
+            mode="644",
             debug=False,
             config=config,
         )
+        need_restart |= master_config.changed
 
-        self.put_file(
-            "postfix/submission_header_cleanup",
-            "/etc/postfix/submission_header_cleanup",
+        header_cleanup = files.put(
+            src=get_resource("postfix/submission_header_cleanup"),
+            dest="/etc/postfix/submission_header_cleanup",
+            user="root",
+            group="root",
+            mode="644",
         )
-        self.put_file("postfix/lmtp_header_cleanup", "/etc/postfix/lmtp_header_cleanup")
+        need_restart |= header_cleanup.changed
 
-        res = self.put_file(
-            "postfix/smtp_tls_policy_map", "/etc/postfix/smtp_tls_policy_map"
+        lmtp_header_cleanup = files.put(
+            src=get_resource("postfix/lmtp_header_cleanup"),
+            dest="/etc/postfix/lmtp_header_cleanup",
+            user="root",
+            group="root",
+            mode="644",
         )
-        tls_policy_changed = res.changed
-        if tls_policy_changed:
+        need_restart |= lmtp_header_cleanup.changed
+
+        tls_policy_map = files.put(
+            name="Upload SMTP TLS Policy that accepts self-signed certificates for IP-only hosts",
+            src=get_resource("postfix/smtp_tls_policy_map"),
+            dest="/etc/postfix/smtp_tls_policy_map",
+            user="root",
+            group="root",
+            mode="644",
+        )
+        need_restart |= tls_policy_map.changed
+        if tls_policy_map.changed:
             server.shell(
                 commands=["postmap /etc/postfix/smtp_tls_policy_map"],
             )
 
         # Login map that 1:1 maps email address to login.
-        self.put_file("postfix/login_map", "/etc/postfix/login_map")
-
-        self.put_file(
-            "service/10_restart_on_failure.conf",
-            "/etc/systemd/system/postfix@.service.d/10_restart.conf",
+        login_map = files.put(
+            src=get_resource("postfix/login_map"),
+            dest="/etc/postfix/login_map",
+            user="root",
+            group="root",
+            mode="644",
         )
+        need_restart |= login_map.changed
+
+        restart_conf = files.put(
+            name="postfix: restart automatically on failure",
+            src=get_resource("service/10_restart.conf"),
+            dest="/etc/systemd/system/postfix@.service.d/10_restart.conf",
+        )
+        self.daemon_reload = restart_conf.changed
 
         # Validate postfix configuration before restart
-        if self.need_restart:
+        if need_restart:
             server.shell(
                 name="Validate postfix configuration",
                 # Extract stderr and quit with error if non-zero
@@ -65,11 +101,19 @@ class PostfixDeployer(Deployer):
                     """bash -c 'w=$(postconf 2>&1 >/dev/null); [[ -z "$w" ]] || { echo "$w"; false; }'"""
                 ],
             )
+        self.need_restart = need_restart
 
     def activate(self):
-        active = not self.disable_mail
-        self.ensure_service(
-            "postfix.service",
-            running=active,
-            enabled=active,
+        restart = False if self.disable_mail else self.need_restart
+
+        systemd.service(
+            name="disable postfix for now"
+            if self.disable_mail
+            else "Start and enable Postfix",
+            service="postfix.service",
+            running=False if self.disable_mail else True,
+            enabled=False if self.disable_mail else True,
+            restarted=restart,
+            daemon_reload=self.daemon_reload,
         )
+        self.need_restart = False

cmdeploy/src/cmdeploy/postfix/main.cf.j2

@@ -53,15 +53,13 @@ smtpd_tls_exclude_ciphers = aNULL, RC4, MD5, DES
 # See <https://www.postfix.org/FORWARD_SECRECY_README.html#server_fs>.
 tls_preempt_cipherlist = yes
 
-# Reject by default, override per smtpd in master.cf
-smtpd_relay_restrictions = reject
+smtpd_relay_restrictions = permit_mynetworks permit_sasl_authenticated defer_unauth_destination
 myhostname = {{ config.postfix_myhostname }}
 alias_maps = hash:/etc/aliases
 alias_database = hash:/etc/aliases
 
 # When postfix receives mail for $mydestination,
 # it hands it over to dovecot via $local_transport.
-# Note: IP literals must be handled via local delivery / mydestination.
 mydestination = {{ config.mail_domain }}
 local_transport = lmtp:unix:private/dovecot-lmtp
 # postfix doesn't check whether local users exist or not:
@@ -85,14 +83,6 @@ inet_protocols = all
 
 lmtp_header_checks = regexp:/etc/postfix/lmtp_header_cleanup
 
-# Do not apply header checks to MIME headers
-# and other headers that are actually part of the message body.
-# Reference:
-# <https://www.postfix.org/postconf.5.html#disable_mime_input_processing>
-# <https://www.postfix.org/header_checks.5.html>
-# <https://stump.io/blog/2020/11/29/a-little-gotcha-with-postfixs-header_checks/>
-disable_mime_input_processing = yes
-
 mua_client_restrictions = permit_sasl_authenticated, reject
 mua_sender_restrictions = reject_sender_login_mismatch, permit_sasl_authenticated, reject
 mua_helo_restrictions = permit_mynetworks, reject_invalid_helo_hostname, reject_non_fqdn_helo_hostname, permit
@@ -110,28 +100,5 @@ smtpd_peername_lookup = no
 # so instead this is handled in filtermail.
 # We use LMTP instead SMTP so we can communicate per-recipient errors back to postfix.
 default_transport = lmtp-filtermail:inet:[127.0.0.1]:{{ config.filtermail_lmtp_port_transport }}
-
-# All deliveries over lmtp-filtermail are treated
-# as having the same destination [127.0.0.1],
-# so it is not possible to limit per-destination concurrency here,
-# it is a job for filtermail-transport.
-# Total number of parallel deliveries is limited
-# by "maxproc" column in /etc/postfix/master.cf for lmtp-filtermail.
-# Settings below are to prevent Postfix queue manager
-# from limiting the number of LMTP connections to filtermail-transport.
-# Read <https://www.postfix.org/TUNING_README.html#rope> and
-# <https://www.postfix.org/SCHEDULER_README.html> for the details
-# of the Postfix algorithm that we effectively disable here.
 lmtp-filtermail_initial_destination_concurrency=10000
 lmtp-filtermail_destination_concurrency_limit=10000
-
-# Do not try to deliver messages for more than 2 days.
-maximal_queue_lifetime = 2d
-
-{% if not config.ipv4_relay %}
-# DKIM-sign locally generated mail (bounces, DSNs).
-# These bypass smtpd, so they need explicit milter configuration.
-non_smtpd_milters = unix:opendkim/opendkim.sock
-internal_mail_filter_classes = bounce
-milter_macro_daemon_name = ORIGINATING
-{% endif %}

cmdeploy/src/cmdeploy/postfix/master.cf.j2

@@ -17,8 +17,7 @@ smtp      inet  n       -       y       -       -       smtpd
   -o smtpd_tls_security_level=encrypt
   -o smtpd_tls_mandatory_protocols=>=TLSv1.2
   -o smtpd_proxy_filter=127.0.0.1:{{ config.filtermail_smtp_port_incoming }}
-  -o smtpd_relay_restrictions=reject_unauth_destination
-submission inet n       -       y       -       {{ config.max_smtp_connections }}    smtpd
+submission inet n       -       y       -       5000    smtpd
   -o syslog_name=postfix/submission
   -o smtpd_tls_security_level=encrypt
   -o smtpd_tls_mandatory_protocols=>=TLSv1.3
@@ -32,9 +31,9 @@ submission inet n       -       y       -       {{ config.max_smtp_connections }
   -o smtpd_sender_restrictions=$mua_sender_restrictions
   -o smtpd_recipient_restrictions=
   -o smtpd_relay_restrictions=permit_sasl_authenticated,reject
-  -o smtpd_client_connection_count_limit={{ config.max_smtp_connections // 5 }}
+  -o smtpd_client_connection_count_limit=1000
   -o smtpd_proxy_filter=127.0.0.1:{{ config.filtermail_smtp_port }}
-smtps     inet  n       -       y       -       {{ config.max_smtp_connections }}    smtpd
+smtps     inet  n       -       y       -       5000    smtpd
   -o syslog_name=postfix/smtps
   -o smtpd_tls_wrappermode=yes
   -o smtpd_tls_security_level=encrypt
@@ -48,7 +47,7 @@ smtps     inet  n       -       y       -       {{ config.max_smtp_connections }
   -o smtpd_sender_restrictions=$mua_sender_restrictions
   -o smtpd_recipient_restrictions=
   -o smtpd_relay_restrictions=permit_sasl_authenticated,reject
-  -o smtpd_client_connection_count_limit={{ config.max_smtp_connections // 5 }}
+  -o smtpd_client_connection_count_limit=1000
   -o smtpd_proxy_filter=127.0.0.1:{{ config.filtermail_smtp_port }}
 #628       inet  n       -       y       -       -       qmqpd
 pickup    unix  n       -       y       60      1       pickup
@@ -76,19 +75,18 @@ lmtp      unix  -       -       y       -       -       lmtp
 anvil     unix  -       -       y       -       1       anvil
 scache    unix  -       -       y       -       1       scache
 postlog   unix-dgram n  -       n       -       1       postlogd
+filter    unix -        n       n       -       -       lmtp
 # Local SMTP server for reinjecting outgoing filtered mail.
 127.0.0.1:{{ config.postfix_reinject_port }} inet  n       -       n       -       100      smtpd
   -o syslog_name=postfix/reinject
   -o milter_macro_daemon_name=ORIGINATING
   -o cleanup_service_name=authclean
-  -o smtpd_relay_restrictions=permit_mynetworks,reject
 {% if not config.ipv4_relay %}  -o smtpd_milters=unix:opendkim/opendkim.sock
 {% endif %}
 
 # Local SMTP server for reinjecting incoming filtered mail 
 127.0.0.1:{{ config.postfix_reinject_port_incoming }} inet  n       -       n       -       100      smtpd
   -o syslog_name=postfix/reinject_incoming
-  -o smtpd_relay_restrictions=reject_unauth_destination
 
 # Cleanup `Received` headers for authenticated mail
 # to avoid leaking client IP.
@@ -104,15 +102,7 @@ postlog   unix-dgram n  -       n       -       1       postlogd
 authclean unix  n       -       -       -       0       cleanup
   -o header_checks=regexp:/etc/postfix/submission_header_cleanup
 
-# Reducing `maxproc` here may result in a head of line blocking
-# when there are many messages sent to unreachable destinations
-# at the same time.
-# LMTP clients here talk to filtermail-transport.
-# LMTP has no pipelining,
-# so while filtermail-transport tries to deliver the message,
-# possibly waiting for a long connection timeout
-# or talking to a slow server, LMTP client cannot be reused.
-lmtp-filtermail unix  -       -       y       -       500       lmtp
+lmtp-filtermail unix  -       -       y       -       10000       lmtp
   -o syslog_name=postfix/lmtp-filtermail
   -o lmtp_header_checks=
   -o lmtp_tls_security_level=none

cmdeploy/src/cmdeploy/remote/rdns.py

@@ -64,25 +64,21 @@ def get_dkim_entry(mail_domain, pre_command, dkim_selector):
     )
 
 
-def get_authoritative_ns(domain):
-    ns_replies = [
+def query_dns(typ, domain):
+    # Get autoritative nameserver from the SOA record.
+    soa_answers = [
         x.split()
         for x in shell(
-            f"dig -r -q {domain} -t NS +noall +authority +answer", print=log_progress
+            f"dig -r -q {domain} -t SOA +noall +authority +answer", print=log_progress
         ).split("\n")
     ]
-    filtered_replies = [a for a in ns_replies if len(a) >= 5 and a[3] == "NS"]
-    if not filtered_replies:
+    soa = [a for a in soa_answers if len(a) >= 3 and a[3] == "SOA"]
+    if not soa:
         return
-    return filtered_replies[0][4]
-
-
-def query_dns(typ, domain):
-    ns = get_authoritative_ns(domain)
+    ns = soa[0][4]
 
     # Query authoritative nameserver directly to bypass DNS cache.
-    direct_ns = f"@{ns}" if ns else ""
-    res = shell(f"dig {direct_ns} -r -q {domain} -t {typ} +short", print=log_progress)
+    res = shell(f"dig @{ns} -r -q {domain} -t {typ} +short", print=log_progress)
     return next((line for line in res.split("\n") if not line.startswith(";")), "")
 
 

cmdeploy/src/cmdeploy/selfsigned/deployer.py

@@ -1,8 +1,8 @@
 import shlex
 
-from pyinfra.operations import server
+from pyinfra.operations import apt, server
 
-from ..basedeploy import Deployer
+from cmdeploy.basedeploy import Deployer
 
 
 def openssl_selfsigned_args(domain, cert_path, key_path, days=36500):
@@ -34,7 +34,11 @@ class SelfSignedTlsDeployer(Deployer):
         self.cert_path = "/etc/ssl/certs/mailserver.pem"
         self.key_path = "/etc/ssl/private/mailserver.key"
 
-
+    def install(self):
+        apt.packages(
+            name="Install openssl",
+            packages=["openssl"],
+        )
 
     def configure(self):
         args = openssl_selfsigned_args(
@@ -48,5 +52,3 @@ class SelfSignedTlsDeployer(Deployer):
 
     def activate(self):
         pass
-
-

cmdeploy/src/cmdeploy/tests/online/test_0_login.py

@@ -12,7 +12,7 @@ def test_init(tmp_path, maildomain):
     inipath = tmp_path.joinpath("chatmail.ini")
     main(["init", "--config", str(inipath), maildomain])
     config = read_config(inipath)
-    assert config.mail_domain_bare == maildomain
+    assert config.mail_domain == maildomain
 
 
 def test_capabilities(imap):

cmdeploy/src/cmdeploy/tests/online/test_1_basic.py

@@ -5,10 +5,10 @@ import subprocess
 import time
 
 import pytest
-from chatmaild.config import is_valid_ipv4
 
 from cmdeploy import remote
 from cmdeploy.cmdeploy import get_sshexec
+from chatmaild.config import is_valid_ipv4
 
 
 class TestSSHExecutor:
@@ -64,10 +64,8 @@ class TestSSHExecutor:
         else:
             pytest.fail("didn't raise exception")
 
-    def test_opendkim_restarted(self, sshexec, maildomain):
+    def test_opendkim_restarted(self, sshexec):
         """check that opendkim is not running for longer than a day."""
-        if is_valid_ipv4(maildomain):
-            pytest.skip(f"{maildomain} is an IPv4 relay, opendkim is not installed")
         cmd = "systemctl show opendkim --timestamp=utc --property=ActiveEnterTimestamp"
         out = sshexec(call=remote.rshell.shell, kwargs=dict(command=cmd))
         datestring = out.split("=")[1]
@@ -194,34 +192,6 @@ def test_reject_missing_dkim(cmsetup, maildata, from_addr):
             s.sendmail(from_addr=from_addr, to_addrs=recipient.addr, msg=msg)
 
 
-def test_bounces_are_dkim_signed(cmsetup, cmsetup2, maildata, maildomain):
-    # we send a message to non-existant user and expect a bounce message
-    # which will only get through if the bounce message was DKIM-signed
-
-    if is_valid_ipv4(maildomain):
-        pytest.skip("DKIM is not configured on IPv4-only relays")
-
-    sender = cmsetup2.gen_users(1)[0]
-    nonexistent = f"nosuchuser_test42@{cmsetup.maildomain}"
-
-    msg = maildata(
-        "encrypted.eml",
-        from_addr=sender.addr,
-        to_addr=nonexistent,
-    ).as_string()
-    sender.smtp.sendmail(sender.addr, [nonexistent], msg)
-
-    def bounce_in_inbox():
-        messages = sender.imap.fetch_all_messages()
-        for m in messages:
-            if "mail delivery" in m.lower() or "undelivered" in m.lower():
-                return m
-        raise ValueError("bounce not yet in inbox")
-
-    bounce = try_n_times(30, bounce_in_inbox)
-    assert "nosuchuser_test42" in bounce
-
-
 def try_n_times(n, f):
     for _ in range(n - 1):
         try:
@@ -314,15 +284,3 @@ def test_deployed_state(remote):
     # assert len(git_status) == len(remote_version)  # for some reason, we only get 11 lines from remote.iter_output()
     for i in range(len(remote_version)):
         assert git_status[i] == remote_version[i], "You have undeployed changes."
-
-
-def test_nginx_access_log_only_defined_once(sshdomain):
-    sshexec = get_sshexec(sshdomain)
-    conf = sshexec(
-        call=remote.rshell.shell,
-        kwargs=dict(command="nginx -T 2>/dev/null"),
-    )
-    access_logs = [l for l in conf.splitlines() if l.strip().startswith("access_log")]
-    assert len(access_logs) == 1, (
-        f"expected 1 access_log, found {len(access_logs)}: {access_logs}"
-    )

cmdeploy/src/cmdeploy/tests/plugin.py

@@ -1,4 +1,5 @@
 import imaplib
+import ipaddress
 import itertools
 import os
 import random
@@ -9,18 +10,20 @@ import time
 from pathlib import Path
 
 import pytest
-from chatmaild.config import is_valid_ipv4, read_config
-
-
-def format_mail_domain(raw_domain: str) -> str:
-    if is_valid_ipv4(raw_domain):
-        return f"[{raw_domain}]"
-    return raw_domain
+from chatmaild.config import read_config, format_mail_domain, is_valid_ipv4
 
 
 conftestdir = Path(__file__).parent
 
 
+def _is_ip(domain):
+    try:
+        ipaddress.ip_address(domain)
+        return True
+    except ValueError:
+        return False
+
+
 def pytest_configure(config):
     config._benchresults = {}
     config.addinivalue_line(
@@ -59,6 +62,11 @@ def maildomain(chatmail_config):
     return chatmail_config.mail_domain_bare
 
 
+@pytest.fixture(scope="session")
+def maildomain_deliverable(maildomain):
+    return format_mail_domain(maildomain)
+
+
 @pytest.fixture(scope="session")
 def sshdomain(maildomain):
     return os.environ.get("CHATMAIL_SSH", maildomain)
@@ -341,15 +349,15 @@ class ChatmailACFactory:
             account = self.dc.add_account()
             domain_deliverable = format_mail_domain(domain)
             addr, password = self.gencreds(domain_deliverable)
-            if is_valid_ipv4(domain):
+            if _is_ip(domain):
                 # Use DCLOGIN scheme with explicit server hosts,
                 # matching how madmail presents its addresses to users.
                 qr = (
                     f"dclogin:{addr}"
                     f"?p={password}&v=1"
-                    f"&ih={domain}&ip=993&is=ssl"
-                    f"&sh={domain}&sp=465&ss=ssl"
-                    f"&ic=3"
+                    f"&ih={domain}&ip=993"
+                    f"&sh={domain}&sp=465"
+                    f"&ic=3&ss=default"
                 )
                 future = account.add_transport_from_qr.future(qr)
             else:
@@ -360,7 +368,7 @@ class ChatmailACFactory:
 
             # ensure messages stay in INBOX so that they can be
             # concurrently fetched via extra IMAP connections during tests
-            account.set_config("bcc_self", "1")
+            account.set_config("delete_server_after", "10")
             accounts.append(account)
 
         for future in futures:
@@ -415,10 +423,10 @@ class Remote:
     def iter_output(self, logcmd="", ready=None):
         getjournal = "journalctl -f" if not logcmd else logcmd
         print(self.sshdomain)
-        if self.sshdomain in ("@local", "localhost"):
-            command = []
-        else:
-            command = ["ssh", f"root@{self.sshdomain}"]
+        match self.sshdomain:
+            case "@local": command = []
+            case "localhost": command = []
+            case _: command = ["ssh", f"root@{self.sshdomain}"]
         [command.append(arg) for arg in getjournal.split()]
         popen = subprocess.Popen(
             command,
@@ -465,11 +473,6 @@ def cmsetup(maildomain, gencreds, ssl_context):
     return CMSetup(maildomain, gencreds, ssl_context)
 
 
-@pytest.fixture
-def cmsetup2(maildomain2, gencreds, ssl_context):
-    return CMSetup(maildomain2, gencreds, ssl_context)
-
-
 class CMSetup:
     def __init__(self, maildomain, gencreds, ssl_context):
         self.maildomain = maildomain
@@ -480,7 +483,7 @@ class CMSetup:
         print(f"Creating {num} online users")
         users = []
         for i in range(num):
-            addr, password = self.gencreds(format_mail_domain(self.maildomain))
+            addr, password = self.gencreds()
             user = CMUser(self.maildomain, addr, password, self.ssl_context)
             assert user.smtp
             users.append(user)

cmdeploy/src/cmdeploy/tests/test_basedeploy.py

@@ -1,118 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-from cmdeploy.basedeploy import Deployer
-
-
-def test_put_file_restart_and_reload():
-    deployer = Deployer()
-    mock_res = MagicMock()
-    mock_res.changed = True
-
-    with patch("cmdeploy.basedeploy.files.put", return_value=mock_res):
-        deployer.put_file("foo.conf", "/etc/foo.conf")
-        assert deployer.need_restart is True
-        assert deployer.daemon_reload is False
-
-        deployer = Deployer()
-
-        deployer.put_file("test.service", "/etc/systemd/system/test.service")
-        assert deployer.need_restart is True
-        assert deployer.daemon_reload is True
-
-
-def test_remove_file():
-    deployer = Deployer()
-    mock_res = MagicMock()
-    mock_res.changed = True
-
-    with patch("cmdeploy.basedeploy.files.file", return_value=mock_res) as mock_file:
-        deployer.remove_file("/etc/foo.conf")
-        mock_file.assert_called_once_with(
-            name="Remove /etc/foo.conf", path="/etc/foo.conf", present=False
-        )
-        assert deployer.need_restart is True
-
-
-def test_ensure_systemd_unit():
-    deployer = Deployer()
-    mock_res = MagicMock()
-    mock_res.changed = True
-
-    # Plain service file
-    with patch("cmdeploy.basedeploy.files.put", return_value=mock_res) as mock_put:
-        deployer.ensure_systemd_unit("iroh-relay.service")
-        assert (
-            mock_put.call_args.kwargs["dest"]
-            == "/etc/systemd/system/iroh-relay.service"
-        )
-        assert deployer.need_restart is True
-        assert deployer.daemon_reload is True
-
-    deployer = Deployer()
-
-    # Template (.j2) dispatches to put_template and strips .j2 suffix
-    with patch("cmdeploy.basedeploy.files.template", return_value=mock_res) as mock_tpl:
-        deployer.ensure_systemd_unit(
-            "filtermail/chatmaild.service.j2",
-            bin_path="/usr/local/bin/filtermail",
-        )
-        assert (
-            mock_tpl.call_args.kwargs["dest"] == "/etc/systemd/system/chatmaild.service"
-        )
-
-    deployer = Deployer()
-
-    # Explicit dest_name override
-    with patch("cmdeploy.basedeploy.files.put", return_value=mock_res) as mock_put:
-        deployer.ensure_systemd_unit(
-            "acmetool/acmetool-reconcile.timer",
-            dest_name="acmetool-reconcile.timer",
-        )
-        assert (
-            mock_put.call_args.kwargs["dest"]
-            == "/etc/systemd/system/acmetool-reconcile.timer"
-        )
-
-
-def test_ensure_service():
-    with patch("cmdeploy.basedeploy.systemd.service") as mock_svc:
-        deployer = Deployer()
-        deployer.need_restart = True
-        deployer.daemon_reload = True
-        deployer.ensure_service("nginx.service")
-        mock_svc.assert_called_once_with(
-            name="Start and enable nginx.service",
-            service="nginx.service",
-            running=True,
-            enabled=True,
-            restarted=True,
-            daemon_reload=True,
-        )
-        # daemon_reload is cleared to avoid multiple systemctl daemon-reload calls
-        # need_restart is kept to ensure all subsequent services also restart
-        assert deployer.need_restart is True
-        assert deployer.daemon_reload is False
-
-    with patch("cmdeploy.basedeploy.systemd.service") as mock_svc:
-        # Stopping suppresses restarted even when need_restart is True
-        deployer = Deployer()
-        deployer.need_restart = True
-        deployer.daemon_reload = True
-        deployer.ensure_service(
-            "mta-sts-daemon.service",
-            running=False,
-            enabled=False,
-        )
-        assert mock_svc.call_args.kwargs["restarted"] is False
-        assert deployer.need_restart is True
-
-    with patch("cmdeploy.basedeploy.systemd.service") as mock_svc:
-        # Multiple calls: daemon_reload resets after first, need_restart persists
-        deployer = Deployer()
-        deployer.need_restart = True
-        deployer.daemon_reload = True
-        deployer.ensure_service("chatmaild.service")
-        deployer.ensure_service("chatmaild-metadata.service")
-        second_call = mock_svc.call_args_list[1]
-        assert second_call.kwargs["restarted"] is True
-        assert second_call.kwargs["daemon_reload"] is False

cmdeploy/src/cmdeploy/tests/test_dns.py

@@ -4,7 +4,6 @@ import pytest
 
 from cmdeploy import remote
 from cmdeploy.dns import check_full_zone, check_initial_remote_data, parse_zone_records
-from cmdeploy.remote.rdns import get_authoritative_ns
 
 
 @pytest.fixture
@@ -15,15 +14,11 @@ def mockdns_base(monkeypatch):
         if command.startswith("dig"):
             if command == "dig":
                 return "."
-            if "with.public.soa" in command and "NS" in command:
-                return "domain.with.public.soa. 2419 IN NS ns1.first-ns.de."
-            if "with.hidden.soa" in command and "NS" in command:
+            if "SOA" in command:
                 return (
-                    "domain.with.hidden.soa. 2137 IN NS ns1.desec.io.\n"
-                    "domain.with.hidden.soa. 2137 IN NS ns2.desec.org."
+                    "delta.chat. 21600 IN SOA ns1.first-ns.de. dns.hetzner.com."
+                    " 2025102800 14400 1800 604800 3600"
                 )
-            if "NS" in command:
-                return "delta.chat. 21600 IN NS ns1.first-ns.de."
             command_chunks = command.split()
             domain, typ = command_chunks[4], command_chunks[6]
             try:
@@ -130,17 +125,6 @@ class TestPerformInitialChecks:
         assert not l
 
 
-@pytest.mark.parametrize(
-    ("domain", "ns"),
-    [
-        ("domain.with.public.soa", "ns1.first-ns.de."),
-        ("domain.with.hidden.soa", "ns1.desec.io."),
-    ],
-)
-def test_get_authoritative_ns(domain, ns, mockdns):
-    assert get_authoritative_ns(domain) == ns
-
-
 def test_parse_zone_records():
     text = """
     ; This is a comment

cmdeploy/src/cmdeploy/tests/test_dovecot_deployer.py

@@ -23,7 +23,8 @@ def make_host(*fact_pairs):
         if cls not in facts:
             registered = ", ".join(c.__name__ for c in facts)
             raise LookupError(
-                f"unexpected get_fact({cls.__name__}); only registered: {registered}"
+                f"unexpected get_fact({cls.__name__}); "
+                f"only registered: {registered}"
             )
         return facts[cls]
 

cmdeploy/src/cmdeploy/unbound/unbound.conf.j2

@@ -1,7 +1,4 @@
-# Managed by cmdeploy
+# Managed by cmdeploy: disable IPv6 in unbound.
 server:
-{% if disable_ipv6 %}
   interface: 127.0.0.1
   do-ip6: no
-{% endif %}
-  cache-max-negative-ttl: 0

doc/source/faq.rst

@@ -15,7 +15,6 @@ goes beyond what classic email servers offer:
    streaming, privacy-preserving Push Notifications for Apple, Google, and `Ubuntu Touch <https://docs.ubports.com/en/latest/appdev/guides/pushnotifications.html>`_;
 
 -  **Security Enforcement**: only strict TLS, DKIM and OpenPGP with minimized metadata accepted
-   (DKIM is not enforced on :ref:`IP-only relays <iponly>`)
 
 -  **Reliable Federation and Decentralization:** No spam or IP reputation checks, federating
    depends on established IETF standards and protocols.
@@ -48,29 +47,6 @@ Dovecot, and are configured to run unattended without much maintenance
 effort. Chatmail relays happily run on low-end hardware like a Raspberry
 Pi.
 
-.. _upgrade:
-
-How can I upgrade my chatmail relay?
-------------------------------------
-
-To upgrade to the latest ``main`` branch,
-``cd`` into your local checkout of `https://github.com/chatmail/relay/`_
-and run the following commands:
-
-   ::
-
-       git pull origin main --rebase --autostash
-       scripts/initenv.sh
-       scripts/cmdeploy run
-
-If you don't want the latest development version,
-but a specific tagged release like `1.10.0 <https://github.com/chatmail/relay/releases/tag/1.10.0>`_,
-run ``git pull origin 1.10.0`` instead.
-
-If you made local changes for your setup,
-they will be reapplied as long as they don't conflict with the upgrade.
-If a conflict arises, ``git status`` will tell you how to resolve it.
-
 
 How trustable are chatmail relays?
 ----------------------------------

doc/source/getting_started.rst

@@ -27,7 +27,7 @@ You will need the following:
    paramiko <https://github.com/paramiko/paramiko/issues/2191>`_)
 
 -  Control over a domain through a DNS provider of your choice
-   (there is experimental support for :ref:`IP-only relays <iponly>`).
+   (there is experimental support for :ref:`DNS-less relays <iponly>`).
 
 
 .. _setup:
@@ -101,15 +101,6 @@ steps. Please substitute it with your own domain.
    configure at your DNS provider (it can take some time until they are
    public).
 
-
-
-Docker installation
--------------------
-
-There is experimental support for running chatmail via Docker.
-A monolithic image based on the above cmdeploy method is available `through a separate repository <https://github.com/chatmail/docker/pkgs/container/docker>`_.
-See the `chatmail/docker README <https://github.com/chatmail/docker>`_ for full setup instructions.
-
 Other helpful commands
 ----------------------
 
@@ -199,93 +190,6 @@ creating addresses, login with ssh to the deployment machine and run:
 Chatmail address creation will be denied while this file is present.
 
 
-.. _system-limits:
-
-Configurable System Limits
---------------------------
-
-Limits for auto-rejecting address creation
-..........................................
-
-A relay refuses creation of new addresses
-when the machine runs low on resources,
-but existing addresses keep working.
-
-Three ``chatmail.ini`` settings control this,
-shown here with their defaults::
-
-    max_load_1m = 5
-    min_available_memory = 200M
-    min_free_disk_space = 1G
-
-- ``max_load_1m`` is the maximum 1-minute load average,
-  as reported by ``uptime``;
-  it counts processes waiting for disk I/O as well as for CPU.
-  It is deliberately not scaled by the number of CPUs
-  because I/O rather than CPU is what typically limits a relay.
-
-- ``min_available_memory`` is the minimum memory available without swapping.
-
-- ``min_free_disk_space`` is the minimum free disk space
-  on the file system holding the mailboxes.
-
-The defaults suit the small machine described in
-`Minimal requirements and prerequisites`_.
-
-.. note::
-
-   If you run a bigger machine,
-   raise ``max_load_1m`` after watching ``uptime`` under typical load.
-
-Rejections are logged by the ``doveauth`` service,
-so you can check whether a limit is set too tightly::
-
-    journalctl -u doveauth --grep 'registration rejected'
-
-If ``mtail_address`` is set, rejections are also counted
-in the ``rejected_registrations`` metric.
-
-
-Overall IMAP and SMTP connection limits
-.......................................
-
-Two further settings bound how many connections
-the relay accepts at all, again shown with their defaults::
-
-    max_imap_connections = 10000
-    max_smtp_connections = 1000
-
-``max_imap_connections`` becomes the Dovecot imap process limit,
-and ``max_smtp_connections`` the Postfix process limit
-on each of the submission and smtps ports.
-A single client IP may use up to a fifth of ``max_smtp_connections``.
-Each connection costs memory,
-so these limits defend the relay against running out of RAM.
-
-Unless ``imap_compress`` is enabled,
-an IMAP connection that is idle for ``imap_hibernate_timeout``
-is handed over to the ``imap-hibernate`` process
-and does not count towards ``max_imap_connections``,
-which is why a relay can serve far more IMAP clients
-than this setting suggests.
-
-If you run a large relay with 10k or 100k's of addresses,
-check current connection counts before upgrading
-and set the limits accordingly.
-
-To see how close a running relay is to these two limits,
-copy ``scripts/check-connections.sh`` from the relay repository
-onto the relay and run it there::
-
-    imap             5  ports 143,993   (max_imap_connections)
-                     5  dovecot sessions, 0 of them in an active imap process
-    submission       0  ports 465,587   (max_smtp_connections per port)
-    incoming         0  port 25         (from other relays, no chatmail.ini limit)
-
-It counts established sockets with ``ss``
-and cross-checks the IMAP number against ``doveadm who``.
-
-
 Running a relay with self-signed certificates
 ----------------------------------------------
 

doc/source/iponly.rst

@@ -24,17 +24,6 @@ Drawbacks
   the chatmail core's end-to-end encryption should suffice in most scenarios though.
 
 - your messages will not be DKIM-signed;
-  experimentally, most chatmail relays accept non-DKIM-signed messages from IP-only relays,
+  experimentally, most chatmail relays accept non-DKIM-signed messages from IPv4-only relays,
   but some relays might not accept messages from yours.
 
-
-Email addresses
----------------
-
-When running without a domain,
-your chatmail addresses will use the IPv4 address
-in brackets as the domain part,
-for example ``user@[13.12.23.42]``.
-This is a valid email address format
-according to :rfc:`5321`.
-

doc/source/overview.rst

@@ -156,7 +156,6 @@ Chatmail relay dependency diagram
         postfix --- |10083|filtermail-transport;
         filtermail-outgoing --- |10025 reinject|postfix;
         filtermail-incoming --- |10026 reinject|postfix;
-        postfix --- |milter opendkim.sock|OpenDKIM
         dovecot --- |doveauth.socket|doveauth;
         dovecot --- |message delivery|maildir["maildir
         /home/vmail/.../user"];
@@ -180,51 +179,26 @@ Chatmail relay dependency diagram
         style nginx-right fill:#f66;
         style postfix fill:#f66;
         style dovecot fill:#f66;
-        style OpenDKIM fill:#f66;
         style notification-proxy fill:#f66;
 
-Accepting and delivering mail
------------------------------
+Message between users on the same relay
+---------------------------------------
 
 .. mermaid::
-    :caption: This diagram shows all the paths a message can take.
+    :caption: This diagram shows the path a non-federated message takes.
 
-    flowchart LR
-        subgraph chatmail relay
-            subgraph postfix
-                qmgr .-> lmtp-filtermail["lmtp/lmtp-filtermail (default_transport)"]
-                qmgr .-> lmtp["lmtp (local_transport)"]
-                lmtp --> cleanup["cleanup (lmtp_header_cleanup)"]
-                bounce
-                smtpd-submission["smtpd/submission"]
-                smtpd-smtps["smtpd/smtps"]
-                smtpd-reinject-outgoing["smtpd/reinject-outgoing"] --> authclean["cleanup/authclean (submission_header_cleanup)"]
-                authclean --> qmgr
-                smtpd-smtp["smtpd/smtp"]
-                smtpd-reinject-incoming["smtpd/reinject-incoming"] --> qmgr
-            end
-            lmtp-filtermail --LMTP inet:10083--> filtermail-transport
-            cleanup --LMTP unix:private/dovecot-lmtp --> dovecot
-            dovecot --> maildir
-            smtpd-submission --SMTP inet:10080--> filtermail-outgoing
-            smtpd-smtps --SMTP inet:10080--> filtermail-outgoing
-            filtermail-outgoing --SMTP inet:10025--> smtpd-reinject-outgoing
-            open-dkim["OpenDKIM (signing only)"] <--milter unix:opendkim/opendkim.sock--> smtpd-reinject-outgoing
-            bounce <--milter unix:opendkim/opendkim.sock--> open-dkim
-            bounce --> qmgr
-            nginx
-            smtpd-smtp -.SMTP inet:10081.-> filtermail-incoming
-            nginx -.HTTP inet:10082.-> filtermail-incoming
-            filtermail-incoming --SMTP inet:10026--> smtpd-reinject-incoming
-        end
-        filtermail-transport -.SMTP inet:25.-> mta1[Remote relay]
-        filtermail-transport -.HTTPS /mxdeliv.-> mta1
-        client[Client] -.SMTP inet:587.-> smtpd-submission
-        client -.SMTP inet:465.-> smtpd-smtps
-        client -.SMTP inet:443.-> nginx
-        nginx -.SMTP inet:465.-> smtpd-smtps
-        mta2[Remote relay] -.SMTP inet:25.-> smtpd-smtp
-        mta2 -.HTTPS /mxdeliv.-> nginx
+    graph LR;
+        sender --> |465|smtps/smtpd;
+        sender --> |587|submission/smtpd;
+        smtps/smtpd --> |10080|filtermail;
+        submission/smtpd --> |10080|filtermail;
+        filtermail --> |10025|smtpd_reinject;
+        smtpd_reinject --> cleanup;
+        cleanup --> qmgr;
+        qmgr --> smtpd_accepts_message;
+        qmgr --> |lmtp|dovecot;
+        dovecot --> recipient;
+        dovecot --> sender's_other_devices;
 
 Operational details of a chatmail relay
 ----------------------------------------
@@ -291,8 +265,7 @@ from the chatmail relay server.
 Email domain authentication (DKIM)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Chatmail relays enforce :rfc:`DKIM <6376>` to authenticate incoming emails
-(except for :ref:`IP-only relays <iponly>`).
+Chatmail relays enforce :rfc:`DKIM <6376>` to authenticate incoming emails.
 Incoming emails must have a valid DKIM signature with
 Signing Domain Identifier (SDID, ``d=`` parameter in the DKIM-Signature
 header) equal to the ``From:`` header domain. This property is checked

scripts/check-connections.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-#
-# Show current IMAP and SMTP connections on a chatmail relay,
-# to compare against the max_imap_connections and max_smtp_connections
-# settings in chatmail.ini.  Run this on the relay itself.
-set -e
-
-# Count established TCP connections whose local port is one of the arguments.
-established() {
-    filter=$(printf 'sport = :%s or ' "$@")
-    ss -Htn state established "( ${filter% or } )" | wc -l
-}
-
-# doveadm prints a header line and then one line per logged-in user,
-# with that user's number of connections in the second column.
-sessions=$(doveadm who | awk 'NR > 1 { n += $2 } END { print n + 0 }')
-
-# Unless imap_compress is enabled, connections idle for
-# imap_hibernate_timeout are handed over to the imap-hibernate
-# process, so they cost no imap process while idle.
-active=$(pgrep -x imap | wc -l)
-
-printf 'imap        %6d  ports 143,993   (max_imap_connections)\n' "$(established 143 993)"
-printf '            %6d  dovecot sessions, %d of them in an active imap process\n' "$sessions" "$active"
-printf 'submission  %6d  ports 465,587   (max_smtp_connections per port)\n' "$(established 465 587)"
-printf 'incoming    %6d  port 25         (from other relays, no chatmail.ini limit)\n' "$(established 25)"