X-Git-Url: http://git.giacomolli.uk/onechat/blobdiff_plain/522d7fd117285e4e4ce3ea5ec9b5a1722521b681..5a93b6124068c2a8748fc0bfbb2a2d151815bcf0:/whatsapp.go?ds=inline diff --git a/whatsapp.go b/whatsapp.go index 6e1e1e6..0c68a44 100644 --- a/whatsapp.go +++ b/whatsapp.go @@ -2,9 +2,10 @@ package main import ( "context" + "database/sql" "errors" "fmt" - "log" + "log/slog" "net/url" "os" "path/filepath" @@ -103,7 +104,7 @@ type WhatsAppClient interface { // the account, so a file that another user can read is an error. The clock // gives the times of the status, logger gets the failures, and newClient makes // the client of a device with its event handler. -func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *log.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) { +func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logger *slog.Logger, newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient) (*WhatsApp, error) { w := &WhatsApp{ dir: filepath.Join(dir, whatsappDirName), clock: clock, @@ -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 @@ -179,7 +182,7 @@ func openWhatsApp(ctx context.Context, dir string, clock func() time.Time, logge type WhatsApp struct { dir string clock func() time.Time - logger *log.Logger + logger *slog.Logger newClient func(device *store.Device, handle func(event any) bool) WhatsAppClient noticeDelay time.Duration requests chan WhatsAppRequest @@ -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() @@ -487,7 +545,7 @@ func (w *WhatsApp) connect(ctx context.Context) bool { w.mutex.Unlock() if first { - w.logger.Printf("first connect failed, retrying: %s", cause) + w.logger.Warn("first connect failed, retrying", "err", cause) } return true @@ -538,7 +596,7 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error { return nil } - w.logger.Print("logged out by the phone, run /whatsapp pair PHONE") + w.logger.Error("logged out by the phone, run /whatsapp pair PHONE") err := w.inbox.deliver(ctx, l, w.link(), true) if err != nil { @@ -547,12 +605,12 @@ func (w *WhatsApp) loggedOut(ctx context.Context, l *TurnLoop) error { err = w.removeSession() if err != nil { - w.logger.Printf("session delete failed: %v", err) + w.logger.Error("session delete failed", "err", err) } err = l.note("WhatsApp was unlinked from the phone.") if err != nil { - w.logger.Printf("chat note failed: %v", err) + w.logger.Error("chat note failed", "err", err) } w.broadcast("WhatsApp was unlinked from the phone. Run /whatsapp pair PHONE to link it again.") @@ -599,11 +657,11 @@ func (w *WhatsApp) unlink(ctx context.Context, l *TurnLoop, answer func(text str return nil } - w.logger.Print("unlinked") + w.logger.Info("unlinked") err = l.note("WhatsApp is unlinked.") if err != nil { - w.logger.Printf("chat note failed: %v", err) + w.logger.Error("chat note failed", "err", err) } if client == nil || logoutErr != nil { @@ -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 @@ -751,11 +813,11 @@ func (w *WhatsApp) pair(ctx, runCtx context.Context, l *TurnLoop, phone string, linked = true w.linkedBy(client) - w.logger.Print("linked") + w.logger.Info("linked") err = l.note("WhatsApp is linked.") if err != nil { - w.logger.Printf("chat note failed: %v", err) + w.logger.Error("chat note failed", "err", err) } answer("WhatsApp is linked to +" + phone + ".") @@ -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() @@ -848,6 +913,10 @@ func (w *WhatsApp) handle(event any) bool { var notice, line string + level := slog.LevelInfo + + var attrs []any + w.mutex.Lock() switch event := event.(type) { @@ -859,7 +928,8 @@ func (w *WhatsApp) handle(event any) bool { case w.disconnectedAt.IsZero(): line = "connected" default: - line = "connected again after " + durationText(w.clock().Sub(w.disconnectedAt)) + line = "connected again" + attrs = append(attrs, "after", w.clock().Sub(w.disconnectedAt)) } w.connected = true @@ -876,6 +946,7 @@ func (w *WhatsApp) handle(event any) bool { case *events.Disconnected: connected := w.connected if w.startOutage() { + level = slog.LevelWarn line = "disconnected, retrying" if !connected { line = "first connect failed, retrying" @@ -893,7 +964,9 @@ func (w *WhatsApp) handle(event any) bool { w.connected = false w.noticed = true notice = "WhatsApp is disconnected and does not connect again by itself: " + event.PermanentDisconnectDescription() + ". Restart the daemon to try again." - line = "disconnected for good, restart to retry: " + whatsappRedact(w.own, event.PermanentDisconnectDescription()) + level = slog.LevelError + line = "disconnected for good, restart to retry" + attrs = append(attrs, "err", whatsappRedact(w.own, event.PermanentDisconnectDescription())) } } @@ -904,7 +977,7 @@ func (w *WhatsApp) handle(event any) bool { w.mutex.Unlock() if line != "" { - w.logger.Print(line) + w.logger.Log(context.Background(), level, line, attrs...) } if notice != "" {