feat(GODT-2585): Server Manager

Add a dedicated go-routine whose sole responsibility is to manage the
life time of the IMAP and SMTP servers and their listeners.

The current implementation behaves the same way as the previous state.
The new behavior will be implemented in a follow MR.

cpc/cpc.go

@@ -20,6 +20,7 @@ package cpc
 import (
 	"context"
 	"errors"
+	"fmt"
 )
 
 var ErrRequestHasNoReply = errors.New("request has no reply channel")
@@ -94,6 +95,10 @@ func (c *CPC) Receive(ctx context.Context, f func(context.Context, *Request)) {
 	}
 }
 
+func (c *CPC) ReceiveCh() <-chan *Request {
+	return c.request
+}
+
 func (c *CPC) Close() {
 	close(c.request)
 }
@@ -108,6 +113,22 @@ func (c *CPC) SendWithReply(ctx context.Context, value any) (any, error) {
 	return c.executeReplyImpl(ctx, NewRequest(value))
 }
 
+func SendWithReplyType[T any](ctx context.Context, c *CPC, value any) (T, error) {
+	val, err := c.executeReplyImpl(ctx, NewRequest(value))
+	if err != nil {
+		var t T
+		return t, err
+	}
+
+	switch vt := val.(type) {
+	case T:
+		return vt, nil
+	default:
+		var t T
+		return t, fmt.Errorf("reply type does not match")
+	}
+}
+
 func (c *CPC) executeNoReplyImpl(ctx context.Context, request *Request) error {
 	select {
 	case <-ctx.Done():

internal/bridge/bridge.go

@@ -29,7 +29,6 @@ import (
 	"time"
 
 	"github.com/Masterminds/semver/v3"
-	"github.com/ProtonMail/gluon"
 	"github.com/ProtonMail/gluon/async"
 	imapEvents "github.com/ProtonMail/gluon/events"
 	"github.com/ProtonMail/gluon/imap"
@@ -45,7 +44,6 @@ import (
 	"github.com/ProtonMail/proton-bridge/v3/internal/user"
 	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
 	"github.com/bradenaw/juniper/xslices"
-	"github.com/emersion/go-smtp"
 	"github.com/go-resty/resty/v2"
 	"github.com/sirupsen/logrus"
 )
@@ -67,13 +65,7 @@ type Bridge struct {
 	tlsConfig *tls.Config
 
 	// imapServer is the bridge's IMAP server.
-	imapServer   *gluon.Server
+	imapEventCh chan imapEvents.Event
-	imapListener net.Listener
-	imapEventCh  chan imapEvents.Event
-
-	// smtpServer is the bridge's SMTP server.
-	smtpServer   *smtp.Server
-	smtpListener net.Listener
 
 	// updater is the bridge's updater.
 	updater   Updater
@@ -134,6 +126,8 @@ type Bridge struct {
 	goHeartbeat func()
 
 	uidValidityGenerator imap.UIDValidityGenerator
+
+	serverManager *ServerManager
 }
 
 // New creates a new bridge.
@@ -224,16 +218,6 @@ func newBridge(
 		return nil, fmt.Errorf("failed to load TLS config: %w", err)
 	}
 
-	gluonCacheDir, err := getGluonDir(vault)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get Gluon directory: %w", err)
-	}
-
-	gluonDataDir, err := locator.ProvideGluonDataPath()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get Gluon Database directory: %w", err)
-	}
-
 	firstStart := vault.GetFirstStart()
 	if err := vault.SetFirstStart(false); err != nil {
 		return nil, fmt.Errorf("failed to save first start indicator: %w", err)
@@ -246,23 +230,6 @@ func newBridge(
 
 	identifier.SetClientString(vault.GetLastUserAgent())
 
-	imapServer, err := newIMAPServer(
-		gluonCacheDir,
-		gluonDataDir,
-		curVersion,
-		tlsConfig,
-		reporter,
-		logIMAPClient,
-		logIMAPServer,
-		imapEventCh,
-		tasks,
-		uidValidityGenerator,
-		panicHandler,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create IMAP server: %w", err)
-	}
-
 	focusService, err := focus.NewService(locator, curVersion, panicHandler)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create focus service: %w", err)
@@ -279,7 +246,6 @@ func newBridge(
 		identifier: identifier,
 
 		tlsConfig:   tlsConfig,
-		imapServer:  imapServer,
 		imapEventCh: imapEventCh,
 
 		updater:   updater,
@@ -306,9 +272,13 @@ func newBridge(
 		tasks: tasks,
 
 		uidValidityGenerator: uidValidityGenerator,
+
+		serverManager: newServerManager(),
 	}
 
-	bridge.smtpServer = newSMTPServer(bridge, tlsConfig, logSMTP)
+	if err := bridge.serverManager.Init(bridge); err != nil {
+		return nil, err
+	}
 
 	return bridge, nil
 }
@@ -381,10 +351,6 @@ func (bridge *Bridge) init(tlsReporter TLSReporter) error {
 		})
 	})
 
-	// We need to load users before we can start the IMAP and SMTP servers.
-	// We must only start the servers once.
-	var once sync.Once
-
 	// Attempt to load users from the vault when triggered.
 	bridge.goLoad = bridge.tasks.Trigger(func(ctx context.Context) {
 		if err := bridge.loadUsers(ctx); err != nil {
@@ -396,17 +362,6 @@ func (bridge *Bridge) init(tlsReporter TLSReporter) error {
 		}
 
 		bridge.publish(events.AllUsersLoaded{})
-
-		// Once all users have been loaded, start the bridge's IMAP and SMTP servers.
-		once.Do(func() {
-			if err := bridge.serveIMAP(); err != nil {
-				logrus.WithError(err).Error("Failed to start IMAP server")
-			}
-
-			if err := bridge.serveSMTP(); err != nil {
-				logrus.WithError(err).Error("Failed to start SMTP server")
-			}
-		})
 	})
 	defer bridge.goLoad()
 
@@ -452,14 +407,9 @@ func (bridge *Bridge) GetErrors() []error {
 func (bridge *Bridge) Close(ctx context.Context) {
 	logrus.Info("Closing bridge")
 
-	// Close the IMAP server.
+	// Close the servers
-	if err := bridge.closeIMAP(ctx); err != nil {
+	if err := bridge.serverManager.CloseServers(ctx); err != nil {
-		logrus.WithError(err).Error("Failed to close IMAP server")
+		logrus.WithError(err).Error("Failed to close servers")
-	}
-
-	// Close the SMTP server.
-	if err := bridge.closeSMTP(); err != nil {
-		logrus.WithError(err).Error("Failed to close SMTP server")
 	}
 
 	// Close all users.

internal/bridge/bridge_test.go

@@ -834,8 +834,8 @@ func withBridgeNoMocks(
 	waitForEvent(t, eventCh, events.SMTPServerReady{})
 
 	// Set random IMAP and SMTP ports for the tests.
-	require.NoError(t, bridge.SetIMAPPort(0))
+	require.NoError(t, bridge.SetIMAPPort(ctx, 0))
-	require.NoError(t, bridge.SetSMTPPort(0))
+	require.NoError(t, bridge.SetSMTPPort(ctx, 0))
 
 	// Close the bridge when done.
 	defer bridge.Close(ctx)

internal/bridge/configure.go

@@ -18,6 +18,7 @@
 package bridge
 
 import (
+	"context"
 	"strings"
 
 	"github.com/ProtonMail/proton-bridge/v3/internal/clientconfig"
@@ -31,7 +32,7 @@ import (
 
 // ConfigureAppleMail configures apple mail for the given userID and address.
 // If configuring apple mail for Catalina or newer, it ensures Bridge is using SSL.
-func (bridge *Bridge) ConfigureAppleMail(userID, address string) error {
+func (bridge *Bridge) ConfigureAppleMail(ctx context.Context, userID, address string) error {
 	logrus.WithFields(logrus.Fields{
 		"userID":  userID,
 		"address": logging.Sensitive(address),
@@ -56,7 +57,7 @@ func (bridge *Bridge) ConfigureAppleMail(userID, address string) error {
 		}
 
 		if useragent.IsCatalinaOrNewer() && !bridge.vault.GetSMTPSSL() {
-			if err := bridge.SetSMTPSSL(true); err != nil {
+			if err := bridge.SetSMTPSSL(ctx, true); err != nil {
 				return err
 			}
 		}

internal/bridge/imap.go

@@ -20,7 +20,6 @@ package bridge
 import (
 	"context"
 	"crypto/tls"
-	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -37,203 +36,21 @@ import (
 	"github.com/ProtonMail/proton-bridge/v3/internal/events"
 	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
 	"github.com/ProtonMail/proton-bridge/v3/internal/user"
-	"github.com/ProtonMail/proton-bridge/v3/internal/vault"
 	"github.com/sirupsen/logrus"
 )
 
-func (bridge *Bridge) serveIMAP() error {
+func (bridge *Bridge) restartIMAP(ctx context.Context) error {
-	port, err := func() (int, error) {
+	return bridge.serverManager.RestartIMAP(ctx)
-		if bridge.imapServer == nil {
-			return 0, fmt.Errorf("no IMAP server instance running")
-		}
-
-		logrus.WithFields(logrus.Fields{
-			"port": bridge.vault.GetIMAPPort(),
-			"ssl":  bridge.vault.GetIMAPSSL(),
-		}).Info("Starting IMAP server")
-
-		imapListener, err := newListener(bridge.vault.GetIMAPPort(), bridge.vault.GetIMAPSSL(), bridge.tlsConfig)
-		if err != nil {
-			return 0, fmt.Errorf("failed to create IMAP listener: %w", err)
-		}
-
-		bridge.imapListener = imapListener
-
-		if err := bridge.imapServer.Serve(context.Background(), bridge.imapListener); err != nil {
-			return 0, fmt.Errorf("failed to serve IMAP: %w", err)
-		}
-
-		if err := bridge.vault.SetIMAPPort(getPort(imapListener.Addr())); err != nil {
-			return 0, fmt.Errorf("failed to store IMAP port in vault: %w", err)
-		}
-
-		return getPort(imapListener.Addr()), nil
-	}()
-
-	if err != nil {
-		bridge.publish(events.IMAPServerError{
-			Error: err,
-		})
-
-		return err
-	}
-
-	bridge.publish(events.IMAPServerReady{
-		Port: port,
-	})
-
-	return nil
-}
-
-func (bridge *Bridge) restartIMAP() error {
-	logrus.Info("Restarting IMAP server")
-
-	if bridge.imapListener != nil {
-		if err := bridge.imapListener.Close(); err != nil {
-			return fmt.Errorf("failed to close IMAP listener: %w", err)
-		}
-
-		bridge.publish(events.IMAPServerStopped{})
-	}
-
-	return bridge.serveIMAP()
-}
-
-func (bridge *Bridge) closeIMAP(ctx context.Context) error {
-	logrus.Info("Closing IMAP server")
-
-	if bridge.imapServer != nil {
-		if err := bridge.imapServer.Close(ctx); err != nil {
-			return fmt.Errorf("failed to close IMAP server: %w", err)
-		}
-
-		bridge.imapServer = nil
-	}
-
-	if bridge.imapListener != nil {
-		if err := bridge.imapListener.Close(); err != nil {
-			return fmt.Errorf("failed to close IMAP listener: %w", err)
-		}
-	}
-
-	bridge.publish(events.IMAPServerStopped{})
-
-	return nil
 }
 
 // addIMAPUser connects the given user to gluon.
 func (bridge *Bridge) addIMAPUser(ctx context.Context, user *user.User) error {
-	if bridge.imapServer == nil {
+	return bridge.serverManager.AddIMAPUser(ctx, user)
-		return fmt.Errorf("no imap server instance running")
-	}
-
-	imapConn, err := user.NewIMAPConnectors()
-	if err != nil {
-		return fmt.Errorf("failed to create IMAP connectors: %w", err)
-	}
-
-	for addrID, imapConn := range imapConn {
-		log := logrus.WithFields(logrus.Fields{
-			"userID": user.ID(),
-			"addrID": addrID,
-		})
-
-		if gluonID, ok := user.GetGluonID(addrID); ok {
-			log.WithField("gluonID", gluonID).Info("Loading existing IMAP user")
-
-			// Load the user, checking whether the DB was newly created.
-			isNew, err := bridge.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey())
-			if err != nil {
-				return fmt.Errorf("failed to load IMAP user: %w", err)
-			}
-
-			if isNew {
-				// If the DB was newly created, clear the sync status; gluon's DB was not found.
-				logrus.Warn("IMAP user DB was newly created, clearing sync status")
-
-				// Remove the user from IMAP so we can clear the sync status.
-				if err := bridge.imapServer.RemoveUser(ctx, gluonID, false); err != nil {
-					return fmt.Errorf("failed to remove IMAP user: %w", err)
-				}
-
-				// Clear the sync status -- we need to resync all messages.
-				if err := user.ClearSyncStatus(); err != nil {
-					return fmt.Errorf("failed to clear sync status: %w", err)
-				}
-
-				// Add the user back to the IMAP server.
-				if isNew, err := bridge.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey()); err != nil {
-					return fmt.Errorf("failed to add IMAP user: %w", err)
-				} else if isNew {
-					panic("IMAP user should already have a database")
-				}
-			} else if status := user.GetSyncStatus(); !status.HasLabels {
-				// Otherwise, the DB already exists -- if the labels are not yet synced, we need to re-create the DB.
-				if err := bridge.imapServer.RemoveUser(ctx, gluonID, true); err != nil {
-					return fmt.Errorf("failed to remove old IMAP user: %w", err)
-				}
-
-				if err := user.RemoveGluonID(addrID, gluonID); err != nil {
-					return fmt.Errorf("failed to remove old IMAP user ID: %w", err)
-				}
-
-				gluonID, err := bridge.imapServer.AddUser(ctx, imapConn, user.GluonKey())
-				if err != nil {
-					return fmt.Errorf("failed to add IMAP user: %w", err)
-				}
-
-				if err := user.SetGluonID(addrID, gluonID); err != nil {
-					return fmt.Errorf("failed to set IMAP user ID: %w", err)
-				}
-
-				log.WithField("gluonID", gluonID).Info("Re-created IMAP user")
-			}
-		} else {
-			log.Info("Creating new IMAP user")
-
-			gluonID, err := bridge.imapServer.AddUser(ctx, imapConn, user.GluonKey())
-			if err != nil {
-				return fmt.Errorf("failed to add IMAP user: %w", err)
-			}
-
-			if err := user.SetGluonID(addrID, gluonID); err != nil {
-				return fmt.Errorf("failed to set IMAP user ID: %w", err)
-			}
-
-			log.WithField("gluonID", gluonID).Info("Created new IMAP user")
-		}
-	}
-
-	// Trigger a sync for the user, if needed.
-	user.TriggerSync()
-
-	return nil
 }
 
 // removeIMAPUser disconnects the given user from gluon, optionally also removing its files.
 func (bridge *Bridge) removeIMAPUser(ctx context.Context, user *user.User, withData bool) error {
-	if bridge.imapServer == nil {
+	return bridge.serverManager.RemoveIMAPUser(ctx, user, withData)
-		return fmt.Errorf("no imap server instance running")
-	}
-
-	logrus.WithFields(logrus.Fields{
-		"userID":   user.ID(),
-		"withData": withData,
-	}).Debug("Removing IMAP user")
-
-	for addrID, gluonID := range user.GetGluonIDs() {
-		if err := bridge.imapServer.RemoveUser(ctx, gluonID, withData); err != nil {
-			return fmt.Errorf("failed to remove IMAP user: %w", err)
-		}
-
-		if withData {
-			if err := user.RemoveGluonID(addrID, gluonID); err != nil {
-				return fmt.Errorf("failed to remove IMAP user ID: %w", err)
-			}
-		}
-	}
-
-	return nil
 }
 
 func (bridge *Bridge) handleIMAPEvent(event imapEvents.Event) {
@@ -267,14 +84,6 @@ func (bridge *Bridge) handleIMAPEvent(event imapEvents.Event) {
 	}
 }
 
-func getGluonDir(encVault *vault.Vault) (string, error) {
-	if err := os.MkdirAll(encVault.GetGluonCacheDir(), 0o700); err != nil {
-		return "", fmt.Errorf("failed to create gluon dir: %w", err)
-	}
-
-	return encVault.GetGluonCacheDir(), nil
-}
-
 func ApplyGluonCachePathSuffix(basePath string) string {
 	return filepath.Join(basePath, "backend", "store")
 }

internal/bridge/server_manager.go

@@ -0,0 +1,620 @@
+// Copyright (c) 2023 Proton AG
+//
+// This file is part of Proton Mail Bridge.
+//
+// Proton Mail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Proton Mail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Proton Mail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package bridge
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"path/filepath"
+
+	"github.com/ProtonMail/gluon"
+	"github.com/ProtonMail/gluon/connector"
+	"github.com/ProtonMail/gluon/logging"
+	"github.com/ProtonMail/proton-bridge/v3/cpc"
+	"github.com/ProtonMail/proton-bridge/v3/internal/events"
+	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
+	"github.com/ProtonMail/proton-bridge/v3/internal/user"
+	"github.com/emersion/go-smtp"
+	"github.com/sirupsen/logrus"
+)
+
+// ServerManager manages the IMAP & SMTP servers and their listeners.
+type ServerManager struct {
+	requests *cpc.CPC
+
+	imapServer   *gluon.Server
+	imapListener net.Listener
+
+	smtpServer   *smtp.Server
+	smtpListener net.Listener
+}
+
+func newServerManager() *ServerManager {
+	return &ServerManager{
+		requests: cpc.NewCPC(),
+	}
+}
+
+func (sm *ServerManager) Init(bridge *Bridge) error {
+	imapServer, err := createIMAPServer(bridge)
+	if err != nil {
+		return err
+	}
+
+	smtpServer := createSMTPServer(bridge)
+
+	sm.imapServer = imapServer
+	sm.smtpServer = smtpServer
+
+	bridge.tasks.Once(func(ctx context.Context) {
+		logging.DoAnnotated(ctx, func(ctx context.Context) {
+			sm.run(ctx, bridge)
+		}, logging.Labels{
+			"service": "server-manager",
+		})
+	})
+
+	return nil
+}
+
+func (sm *ServerManager) CloseServers(ctx context.Context) error {
+	defer sm.requests.Close()
+	_, err := sm.requests.SendWithReply(ctx, &smRequestClose{})
+
+	return err
+}
+
+func (sm *ServerManager) RestartIMAP(ctx context.Context) error {
+	_, err := sm.requests.SendWithReply(ctx, &smRequestRestartIMAP{})
+
+	return err
+}
+
+func (sm *ServerManager) RestartSMTP(ctx context.Context) error {
+	_, err := sm.requests.SendWithReply(ctx, &smRequestRestartSMTP{})
+
+	return err
+}
+
+func (sm *ServerManager) AddIMAPUser(ctx context.Context, user *user.User) error {
+	_, err := sm.requests.SendWithReply(ctx, &smRequestAddIMAPUser{user: user})
+
+	return err
+}
+
+func (sm *ServerManager) RemoveIMAPUser(ctx context.Context, user *user.User, withData bool) error {
+	_, err := sm.requests.SendWithReply(ctx, &smRequestRemoveIMAPUser{
+		user:     user,
+		withData: withData,
+	})
+
+	return err
+}
+
+func (sm *ServerManager) SetGluonDir(ctx context.Context, gluonDir string) error {
+	_, err := sm.requests.SendWithReply(ctx, &smRequestSetGluonDir{
+		dir: gluonDir,
+	})
+
+	return err
+}
+
+func (sm *ServerManager) AddGluonUser(ctx context.Context, conn connector.Connector, passphrase []byte) (string, error) {
+	reply, err := cpc.SendWithReplyType[string](ctx, sm.requests, &smRequestAddGluonUser{
+		conn:       conn,
+		passphrase: passphrase,
+	})
+
+	return reply, err
+}
+
+func (sm *ServerManager) RemoveGluonUser(ctx context.Context, gluonID string) error {
+	_, err := sm.requests.SendWithReply(ctx, &smRequestRemoveGluonUser{
+		userID: gluonID,
+	})
+
+	return err
+}
+
+func (sm *ServerManager) run(ctx context.Context, bridge *Bridge) {
+	eventCh, cancel := bridge.GetEvents()
+	defer cancel()
+
+	for {
+		select {
+		case <-ctx.Done():
+			sm.handleClose(ctx, bridge)
+			return
+
+		case evt := <-eventCh:
+			switch evt.(type) {
+			case events.ConnStatusDown:
+				// Handle connect down.
+
+			case events.ConnStatusUp:
+				// Handle connect up.
+
+			case events.AllUsersLoaded:
+				if err := sm.serveIMAP(ctx, bridge); err != nil {
+					logrus.WithError(err).Error("Failed to start IMAP server")
+				}
+
+				if err := sm.serveSMTP(bridge); err != nil {
+					logrus.WithError(err).Error("Failed to start SMTP server")
+				}
+			}
+
+		case request, ok := <-sm.requests.ReceiveCh():
+			if !ok {
+				return
+			}
+
+			switch r := request.Value.(type) {
+			case *smRequestClose:
+				sm.handleClose(ctx, bridge)
+				request.SendReply(ctx, nil, nil)
+				return
+
+			case *smRequestRestartSMTP:
+				err := sm.restartSMTP(bridge)
+				request.SendReply(ctx, nil, err)
+
+			case *smRequestRestartIMAP:
+				err := sm.restartIMAP(ctx, bridge)
+				request.SendReply(ctx, nil, err)
+
+			case *smRequestAddIMAPUser:
+				err := sm.handleAddIMAPUser(ctx, r.user)
+				request.SendReply(ctx, nil, err)
+
+			case *smRequestRemoveIMAPUser:
+				err := sm.handleRemoveIMAPUser(ctx, r.user, r.withData)
+				request.SendReply(ctx, nil, err)
+
+			case *smRequestSetGluonDir:
+				err := sm.handleSetGluonDir(ctx, bridge, r.dir)
+				request.SendReply(ctx, nil, err)
+
+			case *smRequestAddGluonUser:
+				id, err := sm.handleAddGluonUser(ctx, r.conn, r.passphrase)
+				request.SendReply(ctx, id, err)
+
+			case *smRequestRemoveGluonUser:
+				err := sm.handleRemoveGluonUser(ctx, r.userID)
+				request.SendReply(ctx, nil, err)
+			}
+		}
+	}
+}
+
+func (sm *ServerManager) handleClose(ctx context.Context, bridge *Bridge) {
+	// Close the IMAP server.
+	if err := sm.closeIMAPServer(ctx, bridge); err != nil {
+		logrus.WithError(err).Error("Failed to close IMAP server")
+	}
+
+	// Close the SMTP server.
+	if err := sm.closeSMTPServer(bridge); err != nil {
+		logrus.WithError(err).Error("Failed to close SMTP server")
+	}
+}
+
+func (sm *ServerManager) handleAddIMAPUser(ctx context.Context, user *user.User) error {
+	if sm.imapServer == nil {
+		return fmt.Errorf("no imap server instance running")
+	}
+
+	imapConn, err := user.NewIMAPConnectors()
+	if err != nil {
+		return fmt.Errorf("failed to create IMAP connectors: %w", err)
+	}
+
+	for addrID, imapConn := range imapConn {
+		log := logrus.WithFields(logrus.Fields{
+			"userID": user.ID(),
+			"addrID": addrID,
+		})
+
+		if gluonID, ok := user.GetGluonID(addrID); ok {
+			log.WithField("gluonID", gluonID).Info("Loading existing IMAP user")
+
+			// Load the user, checking whether the DB was newly created.
+			isNew, err := sm.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey())
+			if err != nil {
+				return fmt.Errorf("failed to load IMAP user: %w", err)
+			}
+
+			if isNew {
+				// If the DB was newly created, clear the sync status; gluon's DB was not found.
+				logrus.Warn("IMAP user DB was newly created, clearing sync status")
+
+				// Remove the user from IMAP so we can clear the sync status.
+				if err := sm.imapServer.RemoveUser(ctx, gluonID, false); err != nil {
+					return fmt.Errorf("failed to remove IMAP user: %w", err)
+				}
+
+				// Clear the sync status -- we need to resync all messages.
+				if err := user.ClearSyncStatus(); err != nil {
+					return fmt.Errorf("failed to clear sync status: %w", err)
+				}
+
+				// Add the user back to the IMAP server.
+				if isNew, err := sm.imapServer.LoadUser(ctx, imapConn, gluonID, user.GluonKey()); err != nil {
+					return fmt.Errorf("failed to add IMAP user: %w", err)
+				} else if isNew {
+					panic("IMAP user should already have a database")
+				}
+			} else if status := user.GetSyncStatus(); !status.HasLabels {
+				// Otherwise, the DB already exists -- if the labels are not yet synced, we need to re-create the DB.
+				if err := sm.imapServer.RemoveUser(ctx, gluonID, true); err != nil {
+					return fmt.Errorf("failed to remove old IMAP user: %w", err)
+				}
+
+				if err := user.RemoveGluonID(addrID, gluonID); err != nil {
+					return fmt.Errorf("failed to remove old IMAP user ID: %w", err)
+				}
+
+				gluonID, err := sm.imapServer.AddUser(ctx, imapConn, user.GluonKey())
+				if err != nil {
+					return fmt.Errorf("failed to add IMAP user: %w", err)
+				}
+
+				if err := user.SetGluonID(addrID, gluonID); err != nil {
+					return fmt.Errorf("failed to set IMAP user ID: %w", err)
+				}
+
+				log.WithField("gluonID", gluonID).Info("Re-created IMAP user")
+			}
+		} else {
+			log.Info("Creating new IMAP user")
+
+			gluonID, err := sm.imapServer.AddUser(ctx, imapConn, user.GluonKey())
+			if err != nil {
+				return fmt.Errorf("failed to add IMAP user: %w", err)
+			}
+
+			if err := user.SetGluonID(addrID, gluonID); err != nil {
+				return fmt.Errorf("failed to set IMAP user ID: %w", err)
+			}
+
+			log.WithField("gluonID", gluonID).Info("Created new IMAP user")
+		}
+	}
+
+	// Trigger a sync for the user, if needed.
+	user.TriggerSync()
+
+	return nil
+}
+
+func (sm *ServerManager) handleRemoveIMAPUser(ctx context.Context, user *user.User, withData bool) error {
+	if sm.imapServer == nil {
+		return fmt.Errorf("no imap server instance running")
+	}
+
+	logrus.WithFields(logrus.Fields{
+		"userID":   user.ID(),
+		"withData": withData,
+	}).Debug("Removing IMAP user")
+
+	for addrID, gluonID := range user.GetGluonIDs() {
+		if err := sm.imapServer.RemoveUser(ctx, gluonID, withData); err != nil {
+			return fmt.Errorf("failed to remove IMAP user: %w", err)
+		}
+
+		if withData {
+			if err := user.RemoveGluonID(addrID, gluonID); err != nil {
+				return fmt.Errorf("failed to remove IMAP user ID: %w", err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func createIMAPServer(bridge *Bridge) (*gluon.Server, error) {
+	gluonDataDir, err := bridge.GetGluonDataDir()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get Gluon Database directory: %w", err)
+	}
+
+	return newIMAPServer(
+		bridge.vault.GetGluonCacheDir(),
+		gluonDataDir,
+		bridge.curVersion,
+		bridge.tlsConfig,
+		bridge.reporter,
+		bridge.logIMAPClient,
+		bridge.logIMAPServer,
+		bridge.imapEventCh,
+		bridge.tasks,
+		bridge.uidValidityGenerator,
+		bridge.panicHandler,
+	)
+}
+
+func createSMTPServer(bridge *Bridge) *smtp.Server {
+	return newSMTPServer(bridge, bridge.tlsConfig, bridge.logSMTP)
+}
+
+func (sm *ServerManager) closeSMTPServer(bridge *Bridge) error {
+	// We close the listener ourselves even though it's also closed by smtpServer.Close().
+	// This is because smtpServer.Serve() is called in a separate goroutine and might be executed
+	// after we've already closed the server. However, go-smtp has a bug; it blocks on the listener
+	// even after the server has been closed. So we close the listener ourselves to unblock it.
+	logrus.Info("Closing SMTP server")
+
+	if sm.smtpListener != nil {
+		if err := sm.smtpListener.Close(); err != nil {
+			return fmt.Errorf("failed to close SMTP listener: %w", err)
+		}
+	}
+
+	if err := sm.smtpServer.Close(); err != nil {
+		logrus.WithError(err).Debug("Failed to close SMTP server (expected -- we close the listener ourselves)")
+	}
+
+	bridge.publish(events.SMTPServerStopped{})
+
+	return nil
+}
+
+func (sm *ServerManager) closeIMAPServer(ctx context.Context, bridge *Bridge) error {
+	logrus.Info("Closing IMAP server")
+
+	if sm.imapServer != nil {
+		if err := sm.imapServer.Close(ctx); err != nil {
+			return fmt.Errorf("failed to close IMAP server: %w", err)
+		}
+
+		sm.imapServer = nil
+	}
+
+	if sm.imapListener != nil {
+		if err := sm.imapListener.Close(); err != nil {
+			return fmt.Errorf("failed to close IMAP listener: %w", err)
+		}
+
+		sm.imapListener = nil
+	}
+
+	bridge.publish(events.IMAPServerStopped{})
+
+	return nil
+}
+
+func (sm *ServerManager) restartIMAP(ctx context.Context, bridge *Bridge) error {
+	logrus.Info("Restarting IMAP server")
+
+	if sm.imapListener != nil {
+		if err := sm.imapListener.Close(); err != nil {
+			return fmt.Errorf("failed to close IMAP listener: %w", err)
+		}
+
+		sm.imapListener = nil
+
+		bridge.publish(events.IMAPServerStopped{})
+	}
+
+	return sm.serveIMAP(ctx, bridge)
+}
+
+func (sm *ServerManager) restartSMTP(bridge *Bridge) error {
+	logrus.Info("Restarting SMTP server")
+
+	if err := sm.closeSMTPServer(bridge); err != nil {
+		return fmt.Errorf("failed to close SMTP: %w", err)
+	}
+
+	bridge.publish(events.SMTPServerStopped{})
+
+	sm.smtpServer = newSMTPServer(bridge, bridge.tlsConfig, bridge.logSMTP)
+
+	return sm.serveSMTP(bridge)
+}
+
+func (sm *ServerManager) serveSMTP(bridge *Bridge) error {
+	port, err := func() (int, error) {
+		logrus.WithFields(logrus.Fields{
+			"port": bridge.vault.GetSMTPPort(),
+			"ssl":  bridge.vault.GetSMTPSSL(),
+		}).Info("Starting SMTP server")
+
+		smtpListener, err := newListener(bridge.vault.GetSMTPPort(), bridge.vault.GetSMTPSSL(), bridge.tlsConfig)
+		if err != nil {
+			return 0, fmt.Errorf("failed to create SMTP listener: %w", err)
+		}
+
+		sm.smtpListener = smtpListener
+
+		bridge.tasks.Once(func(context.Context) {
+			if err := sm.smtpServer.Serve(smtpListener); err != nil {
+				logrus.WithError(err).Info("SMTP server stopped")
+			}
+		})
+
+		if err := bridge.vault.SetSMTPPort(getPort(smtpListener.Addr())); err != nil {
+			return 0, fmt.Errorf("failed to store SMTP port in vault: %w", err)
+		}
+
+		return getPort(smtpListener.Addr()), nil
+	}()
+
+	if err != nil {
+		bridge.publish(events.SMTPServerError{
+			Error: err,
+		})
+
+		return err
+	}
+
+	bridge.publish(events.SMTPServerReady{
+		Port: port,
+	})
+
+	return nil
+}
+
+func (sm *ServerManager) serveIMAP(ctx context.Context, bridge *Bridge) error {
+	port, err := func() (int, error) {
+		if sm.imapServer == nil {
+			return 0, fmt.Errorf("no IMAP server instance running")
+		}
+
+		logrus.WithFields(logrus.Fields{
+			"port": bridge.vault.GetIMAPPort(),
+			"ssl":  bridge.vault.GetIMAPSSL(),
+		}).Info("Starting IMAP server")
+
+		imapListener, err := newListener(bridge.vault.GetIMAPPort(), bridge.vault.GetIMAPSSL(), bridge.tlsConfig)
+		if err != nil {
+			return 0, fmt.Errorf("failed to create IMAP listener: %w", err)
+		}
+
+		sm.imapListener = imapListener
+
+		if err := sm.imapServer.Serve(ctx, sm.imapListener); err != nil {
+			return 0, fmt.Errorf("failed to serve IMAP: %w", err)
+		}
+
+		if err := bridge.vault.SetIMAPPort(getPort(imapListener.Addr())); err != nil {
+			return 0, fmt.Errorf("failed to store IMAP port in vault: %w", err)
+		}
+
+		return getPort(imapListener.Addr()), nil
+	}()
+
+	if err != nil {
+		bridge.publish(events.IMAPServerError{
+			Error: err,
+		})
+
+		return err
+	}
+
+	bridge.publish(events.IMAPServerReady{
+		Port: port,
+	})
+
+	return nil
+}
+
+func (sm *ServerManager) handleSetGluonDir(ctx context.Context, bridge *Bridge, newGluonDir string) error {
+	return safe.RLockRet(func() error {
+		currentGluonDir := bridge.GetGluonCacheDir()
+		newGluonDir = filepath.Join(newGluonDir, "gluon")
+		if newGluonDir == currentGluonDir {
+			return fmt.Errorf("new gluon dir is the same as the old one")
+		}
+
+		if err := sm.closeIMAPServer(context.Background(), bridge); err != nil {
+			return fmt.Errorf("failed to close IMAP: %w", err)
+		}
+
+		if err := bridge.moveGluonCacheDir(currentGluonDir, newGluonDir); err != nil {
+			logrus.WithError(err).Error("failed to move GluonCacheDir")
+
+			if err := bridge.vault.SetGluonDir(currentGluonDir); err != nil {
+				return fmt.Errorf("failed to revert GluonCacheDir: %w", err)
+			}
+		}
+
+		bridge.heartbeat.SetCacheLocation(newGluonDir)
+
+		gluonDataDir, err := bridge.GetGluonDataDir()
+		if err != nil {
+			return fmt.Errorf("failed to get Gluon Database directory: %w", err)
+		}
+
+		imapServer, err := newIMAPServer(
+			bridge.vault.GetGluonCacheDir(),
+			gluonDataDir,
+			bridge.curVersion,
+			bridge.tlsConfig,
+			bridge.reporter,
+			bridge.logIMAPClient,
+			bridge.logIMAPServer,
+			bridge.imapEventCh,
+			bridge.tasks,
+			bridge.uidValidityGenerator,
+			bridge.panicHandler,
+		)
+		if err != nil {
+			return fmt.Errorf("failed to create new IMAP server: %w", err)
+		}
+
+		sm.imapServer = imapServer
+
+		for _, bridgeUser := range bridge.users {
+			if err := sm.handleAddIMAPUser(ctx, bridgeUser); err != nil {
+				return fmt.Errorf("failed to add users to new IMAP server: %w", err)
+			}
+		}
+
+		if err := sm.serveIMAP(ctx, bridge); err != nil {
+			return fmt.Errorf("failed to serve IMAP: %w", err)
+		}
+
+		return nil
+	}, bridge.usersLock)
+}
+
+func (sm *ServerManager) handleAddGluonUser(ctx context.Context, conn connector.Connector, passphrase []byte) (string, error) {
+	if sm.imapServer == nil {
+		return "", fmt.Errorf("no imap server instance running")
+	}
+
+	return sm.imapServer.AddUser(ctx, conn, passphrase)
+}
+
+func (sm *ServerManager) handleRemoveGluonUser(ctx context.Context, userID string) error {
+	if sm.imapServer == nil {
+		return fmt.Errorf("no imap server instance running")
+	}
+
+	return sm.imapServer.RemoveUser(ctx, userID, true)
+}
+
+type smRequestClose struct{}
+
+type smRequestRestartIMAP struct{}
+
+type smRequestRestartSMTP struct{}
+
+type smRequestAddIMAPUser struct {
+	user *user.User
+}
+
+type smRequestRemoveIMAPUser struct {
+	user     *user.User
+	withData bool
+}
+
+type smRequestSetGluonDir struct {
+	dir string
+}
+
+type smRequestAddGluonUser struct {
+	conn       connector.Connector
+	passphrase []byte
+}
+
+type smRequestRemoveGluonUser struct {
+	userID string
+}

internal/bridge/settings.go

@@ -22,7 +22,6 @@ import (
 	"fmt"
 	"net"
 	"os"
-	"path/filepath"
 
 	"github.com/Masterminds/semver/v3"
 	"github.com/ProtonMail/proton-bridge/v3/internal/safe"
@@ -55,7 +54,7 @@ func (bridge *Bridge) GetIMAPPort() int {
 	return bridge.vault.GetIMAPPort()
 }
 
-func (bridge *Bridge) SetIMAPPort(newPort int) error {
+func (bridge *Bridge) SetIMAPPort(ctx context.Context, newPort int) error {
 	if newPort == bridge.vault.GetIMAPPort() {
 		return nil
 	}
@@ -66,14 +65,14 @@ func (bridge *Bridge) SetIMAPPort(newPort int) error {
 
 	bridge.heartbeat.SetIMAPPort(newPort)
 
-	return bridge.restartIMAP()
+	return bridge.restartIMAP(ctx)
 }
 
 func (bridge *Bridge) GetIMAPSSL() bool {
 	return bridge.vault.GetIMAPSSL()
 }
 
-func (bridge *Bridge) SetIMAPSSL(newSSL bool) error {
+func (bridge *Bridge) SetIMAPSSL(ctx context.Context, newSSL bool) error {
 	if newSSL == bridge.vault.GetIMAPSSL() {
 		return nil
 	}
@@ -84,14 +83,14 @@ func (bridge *Bridge) SetIMAPSSL(newSSL bool) error {
 
 	bridge.heartbeat.SetIMAPConnectionMode(newSSL)
 
-	return bridge.restartIMAP()
+	return bridge.restartIMAP(ctx)
 }
 
 func (bridge *Bridge) GetSMTPPort() int {
 	return bridge.vault.GetSMTPPort()
 }
 
-func (bridge *Bridge) SetSMTPPort(newPort int) error {
+func (bridge *Bridge) SetSMTPPort(ctx context.Context, newPort int) error {
 	if newPort == bridge.vault.GetSMTPPort() {
 		return nil
 	}
@@ -102,14 +101,14 @@ func (bridge *Bridge) SetSMTPPort(newPort int) error {
 
 	bridge.heartbeat.SetSMTPPort(newPort)
 
-	return bridge.restartSMTP()
+	return bridge.restartSMTP(ctx)
 }
 
 func (bridge *Bridge) GetSMTPSSL() bool {
 	return bridge.vault.GetSMTPSSL()
 }
 
-func (bridge *Bridge) SetSMTPSSL(newSSL bool) error {
+func (bridge *Bridge) SetSMTPSSL(ctx context.Context, newSSL bool) error {
 	if newSSL == bridge.vault.GetSMTPSSL() {
 		return nil
 	}
@@ -120,7 +119,7 @@ func (bridge *Bridge) SetSMTPSSL(newSSL bool) error {
 
 	bridge.heartbeat.SetSMTPConnectionMode(newSSL)
 
-	return bridge.restartSMTP()
+	return bridge.restartSMTP(ctx)
 }
 
 func (bridge *Bridge) GetGluonCacheDir() string {
@@ -132,63 +131,7 @@ func (bridge *Bridge) GetGluonDataDir() (string, error) {
 }
 
 func (bridge *Bridge) SetGluonDir(ctx context.Context, newGluonDir string) error {
-	return safe.RLockRet(func() error {
+	return bridge.serverManager.SetGluonDir(ctx, newGluonDir)
-		currentGluonDir := bridge.GetGluonCacheDir()
-		newGluonDir = filepath.Join(newGluonDir, "gluon")
-		if newGluonDir == currentGluonDir {
-			return fmt.Errorf("new gluon dir is the same as the old one")
-		}
-
-		if err := bridge.closeIMAP(context.Background()); err != nil {
-			return fmt.Errorf("failed to close IMAP: %w", err)
-		}
-
-		if err := bridge.moveGluonCacheDir(currentGluonDir, newGluonDir); err != nil {
-			logrus.WithError(err).Error("failed to move GluonCacheDir")
-
-			if err := bridge.vault.SetGluonDir(currentGluonDir); err != nil {
-				return fmt.Errorf("failed to revert GluonCacheDir: %w", err)
-			}
-		}
-
-		bridge.heartbeat.SetCacheLocation(newGluonDir)
-
-		gluonDataDir, err := bridge.GetGluonDataDir()
-		if err != nil {
-			return fmt.Errorf("failed to get Gluon Database directory: %w", err)
-		}
-
-		imapServer, err := newIMAPServer(
-			bridge.vault.GetGluonCacheDir(),
-			gluonDataDir,
-			bridge.curVersion,
-			bridge.tlsConfig,
-			bridge.reporter,
-			bridge.logIMAPClient,
-			bridge.logIMAPServer,
-			bridge.imapEventCh,
-			bridge.tasks,
-			bridge.uidValidityGenerator,
-			bridge.panicHandler,
-		)
-		if err != nil {
-			return fmt.Errorf("failed to create new IMAP server: %w", err)
-		}
-
-		bridge.imapServer = imapServer
-
-		for _, user := range bridge.users {
-			if err := bridge.addIMAPUser(ctx, user); err != nil {
-				return fmt.Errorf("failed to add users to new IMAP server: %w", err)
-			}
-		}
-
-		if err := bridge.serveIMAP(); err != nil {
-			return fmt.Errorf("failed to serve IMAP: %w", err)
-		}
-
-		return nil
-	}, bridge.usersLock)
 }
 
 func (bridge *Bridge) moveGluonCacheDir(oldGluonDir, newGluonDir string) error {

internal/bridge/settings_test.go

@@ -57,7 +57,7 @@ func TestBridge_Settings_IMAPPort(t *testing.T) {
 			curPort := bridge.GetIMAPPort()
 
 			// Set the port to 1144.
-			require.NoError(t, bridge.SetIMAPPort(1144))
+			require.NoError(t, bridge.SetIMAPPort(ctx, 1144))
 
 			// Get the new setting.
 			require.Equal(t, 1144, bridge.GetIMAPPort())
@@ -75,7 +75,7 @@ func TestBridge_Settings_IMAPSSL(t *testing.T) {
 			require.False(t, bridge.GetIMAPSSL())
 
 			// Enable IMAP SSL.
-			require.NoError(t, bridge.SetIMAPSSL(true))
+			require.NoError(t, bridge.SetIMAPSSL(ctx, true))
 
 			// Get the new setting.
 			require.True(t, bridge.GetIMAPSSL())
@@ -89,7 +89,7 @@ func TestBridge_Settings_SMTPPort(t *testing.T) {
 			curPort := bridge.GetSMTPPort()
 
 			// Set the port to 1024.
-			require.NoError(t, bridge.SetSMTPPort(1024))
+			require.NoError(t, bridge.SetSMTPPort(ctx, 1024))
 
 			// Get the new setting.
 			require.Equal(t, 1024, bridge.GetSMTPPort())
@@ -107,7 +107,7 @@ func TestBridge_Settings_SMTPSSL(t *testing.T) {
 			require.False(t, bridge.GetSMTPSSL())
 
 			// Enable SMTP SSL.
-			require.NoError(t, bridge.SetSMTPSSL(true))
+			require.NoError(t, bridge.SetSMTPSSL(ctx, true))
 
 			// Get the new setting.
 			require.True(t, bridge.GetSMTPSSL())

internal/bridge/smtp.go

@@ -20,93 +20,16 @@ package bridge
 import (
 	"context"
 	"crypto/tls"
-	"fmt"
-
-	"github.com/ProtonMail/proton-bridge/v3/internal/events"
-	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
 
 	"github.com/ProtonMail/proton-bridge/v3/internal/constants"
+	"github.com/ProtonMail/proton-bridge/v3/internal/logging"
 	"github.com/emersion/go-sasl"
 	"github.com/emersion/go-smtp"
 	"github.com/sirupsen/logrus"
 )
 
-func (bridge *Bridge) serveSMTP() error {
+func (bridge *Bridge) restartSMTP(ctx context.Context) error {
-	port, err := func() (int, error) {
+	return bridge.serverManager.RestartSMTP(ctx)
-		logrus.WithFields(logrus.Fields{
-			"port": bridge.vault.GetSMTPPort(),
-			"ssl":  bridge.vault.GetSMTPSSL(),
-		}).Info("Starting SMTP server")
-
-		smtpListener, err := newListener(bridge.vault.GetSMTPPort(), bridge.vault.GetSMTPSSL(), bridge.tlsConfig)
-		if err != nil {
-			return 0, fmt.Errorf("failed to create SMTP listener: %w", err)
-		}
-
-		bridge.smtpListener = smtpListener
-
-		bridge.tasks.Once(func(context.Context) {
-			if err := bridge.smtpServer.Serve(smtpListener); err != nil {
-				logrus.WithError(err).Info("SMTP server stopped")
-			}
-		})
-
-		if err := bridge.vault.SetSMTPPort(getPort(smtpListener.Addr())); err != nil {
-			return 0, fmt.Errorf("failed to store SMTP port in vault: %w", err)
-		}
-
-		return getPort(smtpListener.Addr()), nil
-	}()
-
-	if err != nil {
-		bridge.publish(events.SMTPServerError{
-			Error: err,
-		})
-
-		return err
-	}
-
-	bridge.publish(events.SMTPServerReady{
-		Port: port,
-	})
-
-	return nil
-}
-
-func (bridge *Bridge) restartSMTP() error {
-	logrus.Info("Restarting SMTP server")
-
-	if err := bridge.closeSMTP(); err != nil {
-		return fmt.Errorf("failed to close SMTP: %w", err)
-	}
-
-	bridge.publish(events.SMTPServerStopped{})
-
-	bridge.smtpServer = newSMTPServer(bridge, bridge.tlsConfig, bridge.logSMTP)
-
-	return bridge.serveSMTP()
-}
-
-// We close the listener ourselves even though it's also closed by smtpServer.Close().
-// This is because smtpServer.Serve() is called in a separate goroutine and might be executed
-// after we've already closed the server. However, go-smtp has a bug; it blocks on the listener
-// even after the server has been closed. So we close the listener ourselves to unblock it.
-func (bridge *Bridge) closeSMTP() error {
-	logrus.Info("Closing SMTP server")
-
-	if bridge.smtpListener != nil {
-		if err := bridge.smtpListener.Close(); err != nil {
-			return fmt.Errorf("failed to close SMTP listener: %w", err)
-		}
-	}
-
-	if err := bridge.smtpServer.Close(); err != nil {
-		logrus.WithError(err).Debug("Failed to close SMTP server (expected -- we close the listener ourselves)")
-	}
-
-	bridge.publish(events.SMTPServerStopped{})
-
-	return nil
 }
 
 func newSMTPServer(bridge *Bridge, tlsConfig *tls.Config, logSMTP bool) *smtp.Server {

internal/bridge/user_events.go

@@ -75,11 +75,7 @@ func (bridge *Bridge) handleUserAddressCreated(ctx context.Context, user *user.U
 		return nil
 	}
 
-	if bridge.imapServer == nil {
+	gluonID, err := bridge.serverManager.AddGluonUser(ctx, user.NewIMAPConnector(event.AddressID), user.GluonKey())
-		return fmt.Errorf("no imap server instance running")
-	}
-
-	gluonID, err := bridge.imapServer.AddUser(ctx, user.NewIMAPConnector(event.AddressID), user.GluonKey())
 	if err != nil {
 		return fmt.Errorf("failed to add user to IMAP server: %w", err)
 	}
@@ -96,7 +92,7 @@ func (bridge *Bridge) handleUserAddressEnabled(ctx context.Context, user *user.U
 		return nil
 	}
 
-	gluonID, err := bridge.imapServer.AddUser(ctx, user.NewIMAPConnector(event.AddressID), user.GluonKey())
+	gluonID, err := bridge.serverManager.AddGluonUser(ctx, user.NewIMAPConnector(event.AddressID), user.GluonKey())
 	if err != nil {
 		return fmt.Errorf("failed to add user to IMAP server: %w", err)
 	}
@@ -118,7 +114,7 @@ func (bridge *Bridge) handleUserAddressDisabled(ctx context.Context, user *user.
 		return fmt.Errorf("gluon ID not found for address %s", event.AddressID)
 	}
 
-	if err := bridge.imapServer.RemoveUser(ctx, gluonID, true); err != nil {
+	if err := bridge.serverManager.RemoveGluonUser(ctx, gluonID); err != nil {
 		return fmt.Errorf("failed to remove user from IMAP server: %w", err)
 	}
 
@@ -134,16 +130,12 @@ func (bridge *Bridge) handleUserAddressDeleted(ctx context.Context, user *user.U
 		return nil
 	}
 
-	if bridge.imapServer == nil {
-		return fmt.Errorf("no imap server instance running")
-	}
-
 	gluonID, ok := user.GetGluonID(event.AddressID)
 	if !ok {
 		return fmt.Errorf("gluon ID not found for address %s", event.AddressID)
 	}
 
-	if err := bridge.imapServer.RemoveUser(ctx, gluonID, true); err != nil {
+	if err := bridge.serverManager.handleRemoveGluonUser(ctx, gluonID); err != nil {
 		return fmt.Errorf("failed to remove user from IMAP server: %w", err)
 	}
 

internal/frontend/cli/accounts.go

@@ -297,7 +297,7 @@ func (f *frontendCLI) configureAppleMail(c *ishell.Context) {
 		return
 	}
 
-	if err := f.bridge.ConfigureAppleMail(user.UserID, user.Addresses[0]); err != nil {
+	if err := f.bridge.ConfigureAppleMail(context.Background(), user.UserID, user.Addresses[0]); err != nil {
 		f.printAndLogError(err)
 		return
 	}

internal/frontend/cli/system.go

@@ -61,7 +61,7 @@ func (f *frontendCLI) changeIMAPSecurity(_ *ishell.Context) {
 	msg := fmt.Sprintf("Are you sure you want to change IMAP setting to %q", newSecurity)
 
 	if f.yesNoQuestion(msg) {
-		if err := f.bridge.SetIMAPSSL(!f.bridge.GetIMAPSSL()); err != nil {
+		if err := f.bridge.SetIMAPSSL(context.Background(), !f.bridge.GetIMAPSSL()); err != nil {
 			f.printAndLogError(err)
 			return
 		}
@@ -80,7 +80,7 @@ func (f *frontendCLI) changeSMTPSecurity(_ *ishell.Context) {
 	msg := fmt.Sprintf("Are you sure you want to change SMTP setting to %q", newSecurity)
 
 	if f.yesNoQuestion(msg) {
-		if err := f.bridge.SetSMTPSSL(!f.bridge.GetSMTPSSL()); err != nil {
+		if err := f.bridge.SetSMTPSSL(context.Background(), !f.bridge.GetSMTPSSL()); err != nil {
 			f.printAndLogError(err)
 			return
 		}
@@ -103,7 +103,7 @@ func (f *frontendCLI) changeIMAPPort(c *ishell.Context) {
 		return
 	}
 
-	if err := f.bridge.SetIMAPPort(newIMAPPortInt); err != nil {
+	if err := f.bridge.SetIMAPPort(context.Background(), newIMAPPortInt); err != nil {
 		f.printAndLogError(err)
 		return
 	}
@@ -125,7 +125,7 @@ func (f *frontendCLI) changeSMTPPort(c *ishell.Context) {
 		return
 	}
 
-	if err := f.bridge.SetSMTPPort(newSMTPPortInt); err != nil {
+	if err := f.bridge.SetSMTPPort(context.Background(), newSMTPPortInt); err != nil {
 		f.printAndLogError(err)
 		return
 	}

internal/frontend/grpc/service_methods.go

@@ -668,7 +668,7 @@ func (s *Service) MailServerSettings(_ context.Context, _ *emptypb.Empty) (*Imap
 	}, nil
 }
 
-func (s *Service) SetMailServerSettings(_ context.Context, settings *ImapSmtpSettings) (*emptypb.Empty, error) {
+func (s *Service) SetMailServerSettings(ctx context.Context, settings *ImapSmtpSettings) (*emptypb.Empty, error) {
 	s.log.
 		WithField("ImapPort", settings.ImapPort).
 		WithField("SmtpPort", settings.SmtpPort).
@@ -682,28 +682,28 @@ func (s *Service) SetMailServerSettings(_ context.Context, settings *ImapSmtpSet
 		defer func() { _ = s.SendEvent(NewChangeMailServerSettingsFinishedEvent()) }()
 
 		if s.bridge.GetIMAPSSL() != settings.UseSSLForImap {
-			if err := s.bridge.SetIMAPSSL(settings.UseSSLForImap); err != nil {
+			if err := s.bridge.SetIMAPSSL(ctx, settings.UseSSLForImap); err != nil {
 				s.log.WithError(err).Error("Failed to set IMAP SSL")
 				_ = s.SendEvent(NewMailServerSettingsErrorEvent(MailServerSettingsErrorType_IMAP_CONNECTION_MODE_CHANGE_ERROR))
 			}
 		}
 
 		if s.bridge.GetSMTPSSL() != settings.UseSSLForSmtp {
-			if err := s.bridge.SetSMTPSSL(settings.UseSSLForSmtp); err != nil {
+			if err := s.bridge.SetSMTPSSL(ctx, settings.UseSSLForSmtp); err != nil {
 				s.log.WithError(err).Error("Failed to set SMTP SSL")
 				_ = s.SendEvent(NewMailServerSettingsErrorEvent(MailServerSettingsErrorType_SMTP_CONNECTION_MODE_CHANGE_ERROR))
 			}
 		}
 
 		if s.bridge.GetIMAPPort() != int(settings.ImapPort) {
-			if err := s.bridge.SetIMAPPort(int(settings.ImapPort)); err != nil {
+			if err := s.bridge.SetIMAPPort(ctx, int(settings.ImapPort)); err != nil {
 				s.log.WithError(err).Error("Failed to set IMAP port")
 				_ = s.SendEvent(NewMailServerSettingsErrorEvent(MailServerSettingsErrorType_IMAP_PORT_CHANGE_ERROR))
 			}
 		}
 
 		if s.bridge.GetSMTPPort() != int(settings.SmtpPort) {
-			if err := s.bridge.SetSMTPPort(int(settings.SmtpPort)); err != nil {
+			if err := s.bridge.SetSMTPPort(ctx, int(settings.SmtpPort)); err != nil {
 				s.log.WithError(err).Error("Failed to set SMTP port")
 				_ = s.SendEvent(NewMailServerSettingsErrorEvent(MailServerSettingsErrorType_SMTP_PORT_CHANGE_ERROR))
 			}

internal/frontend/grpc/service_user.go

@@ -147,12 +147,12 @@ func (s *Service) RemoveUser(_ context.Context, userID *wrapperspb.StringValue)
 	return &emptypb.Empty{}, nil
 }
 
-func (s *Service) ConfigureUserAppleMail(_ context.Context, request *ConfigureAppleMailRequest) (*emptypb.Empty, error) {
+func (s *Service) ConfigureUserAppleMail(ctx context.Context, request *ConfigureAppleMailRequest) (*emptypb.Empty, error) {
 	s.log.WithField("UserID", request.UserID).WithField("Address", request.Address).Debug("ConfigureUserAppleMail")
 
 	sslWasEnabled := s.bridge.GetSMTPSSL()
 
-	if err := s.bridge.ConfigureAppleMail(request.UserID, request.Address); err != nil {
+	if err := s.bridge.ConfigureAppleMail(ctx, request.UserID, request.Address); err != nil {
 		s.log.WithField("userID", request.UserID).Error("Cannot configure AppleMail for user")
 		return nil, status.Error(codes.Internal, "Apple Mail config failed")
 	}

tests/bridge_test.go

@@ -60,11 +60,11 @@ func (s *scenario) theAPIRequiresBridgeVersion(version string) error {
 }
 
 func (s *scenario) theUserChangesTheIMAPPortTo(port int) error {
-	return s.t.bridge.SetIMAPPort(port)
+	return s.t.bridge.SetIMAPPort(context.Background(), port)
 }
 
 func (s *scenario) theUserChangesTheSMTPPortTo(port int) error {
-	return s.t.bridge.SetSMTPPort(port)
+	return s.t.bridge.SetSMTPPort(context.Background(), port)
 }
 
 func (s *scenario) theUserSetsTheAddressModeOfUserTo(user, mode string) error {
@@ -144,11 +144,11 @@ func (s *scenario) theUserHasEnabledAlternativeRouting() error {
 }
 
 func (s *scenario) theUserSetIMAPModeToSSL() error {
-	return s.t.bridge.SetIMAPSSL(true)
+	return s.t.bridge.SetIMAPSSL(context.Background(), true)
 }
 
 func (s *scenario) theUserSetSMTPModeToSSL() error {
-	return s.t.bridge.SetSMTPSSL(true)
+	return s.t.bridge.SetSMTPSSL(context.Background(), true)
 }
 
 func (s *scenario) theUserReportsABug() error {