Describe child agent directories and limits

[onechat] / whatsapp.go

diff --git a/whatsapp.go b/whatsapp.go
index 95e1d54ea01e80f8216f29e38d63a56a479cc07a..0c68a44ace8a0184b89789e473537d75ec876199 100644 (file)
--- a/whatsapp.go
+++ b/whatsapp.go
@@ -2,6 +2,7 @@ package main
 
 import (
        "context"
+       "database/sql"
        "errors"
        "fmt"
        "log/slog"
@@ -163,7 +164,9 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge
 // of the client that asked. A logout from the phone comes as an event of the
 // library, and Run deletes the session. The mutex protects the session, the
 // client, and the state of the connection, which the event handler of the
-// library changes from its own goroutines.
+// library changes from its own goroutines. The sessionMutex serializes session
+// creation, close, removal, and snapshots. It is held before mutex, and stays
+// held when removal releases mutex for client callbacks.
 //
 // The inbox puts the text messages into batches and logs them, and groups
 // holds the names of the groups. Both get a WhatsAppLink from link for each
@@ -188,6 +191,7 @@ type WhatsApp struct {
        groups      *WhatsAppGroups
        inbox       *WhatsAppInbox
 
+       sessionMutex   sync.Mutex
        mutex          sync.Mutex
        container      *sqlstore.Container
        device         *store.Device
@@ -374,8 +378,62 @@ func (w *WhatsApp) Status() string {
        }
 }
 
+// BackupSession writes a consistent SQLite snapshot to path while the session
+// cannot be created, closed, or removed. The source opens without creation
+// permission. No session file means no linked state to copy.
+func (w *WhatsApp) BackupSession(ctx context.Context, path string) (err error) {
+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+
+       w.mutex.Lock()
+       defer w.mutex.Unlock()
+
+       _, err = os.Stat(w.sessionPath())
+       if errors.Is(err, os.ErrNotExist) {
+               return nil
+       }
+
+       if err != nil {
+               return fmt.Errorf("read session file: %w", err)
+       }
+
+       err = os.MkdirAll(filepath.Dir(path), 0o700)
+       if err != nil {
+               return fmt.Errorf("create session snapshot directory: %w", err)
+       }
+
+       address, err := whatsappSessionAddress(w.sessionPath())
+       if err != nil {
+               return fmt.Errorf("find session database: %w", err)
+       }
+
+       database, err := sql.Open("sqlite", address+"&mode=rw")
+       if err != nil {
+               return fmt.Errorf("open session snapshot source: %w", err)
+       }
+
+       defer func() {
+               err = errors.Join(err, database.Close())
+       }()
+
+       _, err = database.ExecContext(ctx, "VACUUM INTO ?", path)
+       if err != nil {
+               return fmt.Errorf("snapshot session database: %w", err)
+       }
+
+       err = os.Chmod(path, 0o600)
+       if err != nil {
+               return fmt.Errorf("set session snapshot mode: %w", err)
+       }
+
+       return nil
+}
+
 // Close closes the session database.
 func (w *WhatsApp) Close() error {
+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+
        w.mutex.Lock()
        defer w.mutex.Unlock()
 
@@ -618,8 +676,12 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str
 }
 
 // removeSession ends the connection, closes the session database, and deletes
-// its files.
+// its files. The session lock covers the cleanup after mutex is released, so a
+// snapshot or a new session cannot open files that cleanup removes.
 func (w *WhatsApp) removeSession() error {
+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+
        w.mutex.Lock()
 
        client := w.client
@@ -773,6 +835,9 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string,
 // directory and the file of the session first, with their modes, when they do
 // not exist.
 func (w *WhatsApp) newDevice(ctx context.Context) (*store.Device, error) {
+       w.sessionMutex.Lock()
+       defer w.sessionMutex.Unlock()
+
        w.mutex.Lock()
        defer w.mutex.Unlock()