automatic merge to finish v1.0.0

Author: cars10

.github/workflows/build.yml

@@ -11,7 +11,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     permissions:
-      contents: read
+      contents: write
       packages: write
 
     steps:
@@ -28,12 +28,13 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - uses: martinbeentjes/npm-get-version-action@v1.3.1
+      - uses: martinbeentjes/npm-get-version-action@v1
         id: package-version
         with:
           path: frontend
 
-      - uses: docker/build-push-action@v5
+      - uses: docker/build-push-action@v6
+        id: build
         with:
           context: .
           push: true
@@ -43,6 +44,28 @@ jobs:
             cars10/mailfang:${{ steps.package-version.outputs.current-version }}
             ghcr.io/cars10/mailfang:${{ steps.package-version.outputs.current-version }}
 
+      - name: extract binary from image
+        run: |
+          docker create --name extract cars10/mailfang:${{ steps.package-version.outputs.current-version }}
+          docker cp extract:/usr/bin/mailfang ./mailfang-linux-amd64
+          docker rm extract
+          chmod +x ./mailfang-linux-amd64
+
+      - name: prepare release notes from changelog
+        run: |
+          # Extract first version block (newest) from CHANGELOG.md
+          awk 'found && /^## [0-9]/ { exit } /^## [0-9]/ { found=1 } found' CHANGELOG.md > release_notes.txt
+
+      - name: create and publish release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          VERSION="${{ steps.package-version.outputs.current-version }}"
+          gh release create "v${VERSION}" \
+            ./mailfang-linux-amd64 \
+            --title "v${VERSION}" \
+            --notes-file release_notes.txt
+
       - name: deploy
         run: |
           curl -X POST https://autodok.cars10k.de/update \

CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.0.0
+
+Initial release of MailFang. Send emails to mailfang and text them locally. 

README.md

@@ -2,6 +2,8 @@
 
 MailFang is the email testing tool that you've been waiting for. It provides a local smtp server and a modern webui to view your emails.
 
+![MailFang screenshot](screenshot.jpg)
+
 **[Live Demo](https://demo.mailfang.com)**
 
 ## About
@@ -45,7 +47,7 @@ Use the [existing image](https://hub.docker.com/r/cars10/mailfang) from docker h
 docker run --name mailfang \
            -p 3000:3000 \
            -p 2525:2525 \
-           -d cars10/mailfang
+           cars10/mailfang
 ```
 
 The services will be reachable via:
@@ -71,7 +73,6 @@ To send emails to Mailfang simply configure your email service to use the respec
 config.action_mailer.smtp_settings = {
   address:         "0.0.0.0",
   port:            2525,
-  domain:          "example.com",
   authentication:  "plain"
 }
 ```
@@ -96,7 +97,7 @@ You can configure MailFang via command-line arguments or environment variables.
 
 ### Available Options
 
-All configuration options are optional. The smtp server will accept all connection if no credentials are configured.
+All configuration options are optional. The smtp server will accept all connections if no credentials are configured.
 
 | Option | Environment Variable | Description | Binary Default | Docker Default |
 |--------|---------------------|-------------|----------------|----------------|
@@ -128,7 +129,7 @@ docker run --name mailfang \
 
 MailFang saves emails in a local sqlite database. To persist the data:
 
-When running via docker use `DATABASE_URL=sqlite:///data/mailfang.db` and mount a volume to `/data`.
+When running via docker mount a volume to `/data`.
 
 The binary defaults to `./mailfang.db`, change it by using `--database-url sqlite:///path/to/mailfang.db` or via environment variables `DATABASE_URL=sqlite:///path/to/mailfang.db`
 
@@ -143,7 +144,7 @@ It supports the following authorization methods:
 * `LOGIN`
 * `CRAM-MD5`
 
-By default it only accepts a maximum of `4` emails at the same time. This is configurable via `--smtp-max-connections 12` or `SMTP_MAX_CONNECTIONS=12`.
+By default it accepts a maximum of `4` open connections at the same time. This is configurable via `--smtp-max-connections 12` or `SMTP_MAX_CONNECTIONS=12`.
 
 ## Development
 
@@ -157,6 +158,14 @@ By default it only accepts a maximum of `4` emails at the same time. This is con
 
 Run `make dev` to start the frontend and backend, access the frontend on `http://localhost:5173`.
 
+## Alternatives & Inspiration
+
+MailFang is inspired partly by tools like:
+
+* mailcatcher
+* mailhog
+* JSX Email
+
 ## License
 
 GNU GPL v3

backend/src/main.rs

@@ -19,8 +19,25 @@ impl diesel::r2d2::CustomizeConnection<SqliteConnection, diesel::r2d2::Error>
     for ConnectionOptions
 {
     fn on_acquire(&self, conn: &mut SqliteConnection) -> Result<(), diesel::r2d2::Error> {
-        conn.batch_execute("PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 30000;")
-            .map_err(diesel::r2d2::Error::QueryError)
+        let map_err = |e| diesel::r2d2::Error::QueryError(e);
+        // Sleep if the database is busy, up to 2 seconds.
+        conn.batch_execute("PRAGMA busy_timeout = 2000;")
+            .map_err(map_err)?;
+        // Better write-concurrency.
+        conn.batch_execute("PRAGMA journal_mode = WAL;")
+            .map_err(map_err)?;
+        // Fsync only in critical moments.
+        conn.batch_execute("PRAGMA synchronous = NORMAL;")
+            .map_err(map_err)?;
+        // Write WAL changes back every 1000 pages (~1MB WAL). May affect readers if increased.
+        conn.batch_execute("PRAGMA wal_autocheckpoint = 1000;")
+            .map_err(map_err)?;
+        // Free space by truncating possibly massive WAL files from the last run.
+        conn.batch_execute("PRAGMA wal_checkpoint(TRUNCATE);")
+            .map_err(map_err)?;
+        conn.batch_execute("PRAGMA foreign_keys = ON;")
+            .map_err(map_err)?;
+        Ok(())
     }
 }
 

backend/src/smtp/server.rs

@@ -1,13 +1,13 @@
 use super::parser::{EmailAttachment, parse_email_details};
 use chrono::Utc;
 use futures::{SinkExt, StreamExt};
-use r2d2::Pool;
 use rand::Rng;
 use smtp_proto::Request;
 use std::fmt;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::Semaphore;
 use tokio_util::codec::{Framed, LinesCodec, LinesCodecError};
 use tracing::{error, info};
 use uuid::Uuid;
@@ -27,29 +27,6 @@ pub type Result<T> = std::result::Result<T, SmtpError>;
 /// Callback function type for handling received emails
 pub type OnReceiveCallback = Arc<dyn Fn(&Email) + Send + Sync>;
 
-#[derive(Debug)]
-struct ConnectionSlot;
-
-#[derive(Debug)]
-struct ConnectionManager;
-
-impl r2d2::ManageConnection for ConnectionManager {
-    type Connection = ConnectionSlot;
-    type Error = std::io::Error;
-
-    fn connect(&self) -> std::result::Result<Self::Connection, Self::Error> {
-        Ok(ConnectionSlot)
-    }
-
-    fn is_valid(&self, _conn: &mut Self::Connection) -> std::result::Result<(), Self::Error> {
-        Ok(())
-    }
-
-    fn has_broken(&self, _conn: &mut Self::Connection) -> bool {
-        false
-    }
-}
-
 pub struct SmtpServer {
     addr: SocketAddr,
     on_receive: Option<OnReceiveCallback>,
@@ -96,51 +73,30 @@ impl SmtpServer {
         let listener = TcpListener::bind(self.addr).await?;
         let on_receive = self.on_receive.clone();
 
-        let manager = ConnectionManager;
-        let pool = Arc::new(
-            Pool::builder()
-                .max_size(self.max_connections as u32)
-                .build(manager)
-                .map_err(|e| {
-                    SmtpError::Io(std::io::Error::new(
-                        std::io::ErrorKind::Other,
-                        format!("Failed to create connection pool: {}", e),
-                    ))
-                })?,
-        );
+        // Only accept new TCP connections when we have a slot (enforces max_connections at accept time)
+        let semaphore = Arc::new(Semaphore::new(self.max_connections));
 
         info!(
             component = "smtp",
             "SMTP server listening on {} (max connections: {})", self.addr, self.max_connections
         );
 
         loop {
+            // Wait for a free slot before accepting; this ensures we never accept more than max_connections
+            let permit = semaphore
+                .clone()
+                .acquire_owned()
+                .await
+                .map_err(|_| SmtpError::Io(std::io::Error::new(std::io::ErrorKind::Other, "semaphore closed")))?;
+
             let (stream, peer) = listener.accept().await?;
             info!(component = "smtp", peer = %peer, "Connection accepted");
             let on_receive = on_receive.clone();
-            let pool = pool.clone();
-
             let auth_username = self.auth_username.clone();
             let auth_password = self.auth_password.clone();
-            tokio::spawn(async move {
-                let connection_result = tokio::task::spawn_blocking({
-                    let pool = pool.clone();
-                    move || pool.get()
-                })
-                .await;
-
-                let _ = match connection_result {
-                    Ok(Ok(conn)) => conn,
-                    Ok(Err(e)) => {
-                        error!(component = "smtp", peer = %peer, "Failed to get connection from pool: {}", e);
-                        return;
-                    }
-                    Err(e) => {
-                        error!(component = "smtp", peer = %peer, "Failed to spawn blocking task: {}", e);
-                        return;
-                    }
-                };
 
+            tokio::spawn(async move {
+                let _permit = permit; // released when task ends
                 if let Err(err) =
                     handle_connection(stream, on_receive, auth_username, auth_password, peer).await
                 {

release.sh

@@ -17,7 +17,7 @@ cd backend
 sed -e "s/\"version\":\s\".*\"/\"version\": \"$VERSION\"/" -i Cargo.toml
 cd ..
 
-git commit -am "bumps version to $VERSION"
+git commit --allow-empty -am "bumps version to $VERSION"
 
 git push
 
@@ -26,7 +26,7 @@ git merge main -m "automatic merge to finish v$VERSION"
 
 git push
 
-git tag -a "v$VERSION"
+git tag -a "v$VERSION" -m "v$VERSION"
 git push --tags
 
 git checkout main