1 parent
24670a3c2d
commit
bf1e69f480
70 files changed
+1581
-262
No files matched your search
@@ -104,3 +104,40 @@ func TestMaintenanceGuardDrainsRequestsAndKeepsRestartRoute(t *testing.T) {
|
||||
t.Fatal("cleanup wrote to frozen source")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMaintenanceDrainsBackgroundDeliveryBeforeFreeze(t *testing.T) {
|
||||
executor := &PortableExecutor{}
|
||||
service := NewService(&DatabaseExecutor{portable: executor})
|
||||
previous := Current()
|
||||
SetCurrent(service)
|
||||
t.Cleanup(func() { SetCurrent(previous) })
|
||||
entered, finish, done := make(chan struct{}), make(chan struct{}), make(chan struct{})
|
||||
go func() {
|
||||
defer close(done)
|
||||
_ = WhileWritable(func() error {
|
||||
close(entered)
|
||||
<-finish
|
||||
return nil
|
||||
})
|
||||
}()
|
||||
<-entered
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
|
||||
defer cancel()
|
||||
release, err := service.drainRequests(ctx)
|
||||
release()
|
||||
close(finish)
|
||||
<-done
|
||||
if !errors.Is(err, context.DeadlineExceeded) {
|
||||
t.Fatalf("migration did not wait for delivery: %v", err)
|
||||
}
|
||||
release, err = service.drainRequests(context.Background())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
executor.paused.Store(true)
|
||||
release()
|
||||
called := false
|
||||
if err := WhileWritable(func() error { called = true; return nil }); err != nil || called {
|
||||
t.Fatal("delivery started after source freeze")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,172 @@
|
||||
package outbox
|
||||
|
||||
import (
|
||||
stdcontext "context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Smail/dto/parsemail"
|
||||
"git.pcux.cn/xuans/Smail/hooks"
|
||||
"git.pcux.cn/xuans/Smail/models"
|
||||
"git.pcux.cn/xuans/Smail/services/dbmigration"
|
||||
"git.pcux.cn/xuans/Smail/utils/context"
|
||||
"git.pcux.cn/xuans/Smail/utils/send"
|
||||
"git.pcux.cn/xuans/Smail/utils/smtp"
|
||||
log "github.com/sirupsen/logrus"
|
||||
"xorm.io/xorm"
|
||||
)
|
||||
|
||||
type Runtime struct {
|
||||
engine *xorm.Engine
|
||||
stop chan struct{}
|
||||
done chan struct{}
|
||||
once sync.Once
|
||||
deliver func(*context.Context, *parsemail.Email, string) error
|
||||
}
|
||||
|
||||
func Start(engine *xorm.Engine) (*Runtime, error) {
|
||||
if err := recoverInterrupted(engine); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: send.SendRecipientTriggered}
|
||||
go r.loop()
|
||||
return r, nil
|
||||
}
|
||||
|
||||
func (r *Runtime) Stop(ctx stdcontext.Context) error {
|
||||
if r == nil {
|
||||
return nil
|
||||
}
|
||||
r.once.Do(func() { close(r.stop) })
|
||||
select {
|
||||
case <-r.done:
|
||||
return nil
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Runtime) loop() {
|
||||
defer close(r.done)
|
||||
ticker := time.NewTicker(time.Second)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-r.stop:
|
||||
return
|
||||
default:
|
||||
}
|
||||
var jobs []models.OutboundDelivery
|
||||
err := r.engine.Where("state = ? AND next_attempt <= ?", queued, time.Now().Unix()).Asc("id").Limit(20).Find(&jobs)
|
||||
if err != nil {
|
||||
log.WithError(err).Error("读取持久投递队列失败")
|
||||
}
|
||||
for _, job := range jobs {
|
||||
select {
|
||||
case <-r.stop:
|
||||
return
|
||||
default:
|
||||
}
|
||||
if err := r.process(job); err != nil {
|
||||
log.WithError(err).WithField("delivery_id", job.ID).Error("处理持久投递队列失败")
|
||||
}
|
||||
}
|
||||
select {
|
||||
case <-r.stop:
|
||||
return
|
||||
case <-ticker.C:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Runtime) process(job models.OutboundDelivery) error {
|
||||
// 迁移必须等待 SMTP 及结果落库结束,冻结源库后不再领取任务。
|
||||
return dbmigration.WhileWritable(func() error { return r.processWritable(job) })
|
||||
}
|
||||
|
||||
func (r *Runtime) processWritable(job models.OutboundDelivery) error {
|
||||
// 读取失败时尚未开始投递,保留排队状态供数据库恢复后继续处理。
|
||||
var stored models.Email
|
||||
emailFound, err := r.engine.ID(job.EmailID).Get(&stored)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var user models.User
|
||||
userFound := false
|
||||
if emailFound {
|
||||
userFound, err = r.engine.ID(stored.SendUserID).Get(&user)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
owned, err := claim(r.engine, &job)
|
||||
if err != nil || !owned {
|
||||
return err
|
||||
}
|
||||
ctx := &context.Context{Context: stdcontext.Background()}
|
||||
var message *parsemail.Email
|
||||
deliveryErr := func() (result error) {
|
||||
defer func() {
|
||||
if value := recover(); value != nil {
|
||||
result = &smtp.DeliveryUncertainError{Cause: fmt.Errorf("投递任务异常: %v", value)}
|
||||
}
|
||||
}()
|
||||
if !emailFound {
|
||||
return errors.New("待投递邮件已不存在")
|
||||
}
|
||||
if !userFound || user.Disabled != 0 {
|
||||
return errors.New("发件账号不可用,已停止投递")
|
||||
}
|
||||
ctx.UserID, ctx.UserAccount, ctx.UserName, ctx.Role = user.ID, user.Account, user.Name, user.EffectiveRole()
|
||||
message, err = parsemail.NewEmailFromModel(stored)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return r.deliver(ctx, message, job.Recipient)
|
||||
}()
|
||||
// 只重试结果落库,绝不因数据库故障再次调用 SMTP。
|
||||
var terminal bool
|
||||
for attempt := 0; attempt < 3; attempt++ {
|
||||
terminal, err = finish(r.engine, job, deliveryErr)
|
||||
if err == nil {
|
||||
break
|
||||
}
|
||||
time.Sleep(time.Second)
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("投递结果写入失败,保留在途记录并禁止自动重投: %w", err)
|
||||
}
|
||||
if terminal && message != nil {
|
||||
r.notify(ctx, message, job.EmailID)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Runtime) notify(ctx *context.Context, message *parsemail.Email, emailID int) {
|
||||
var jobs []models.OutboundDelivery
|
||||
if err := r.engine.Where("email_id = ?", emailID).Find(&jobs); err != nil {
|
||||
log.WithError(err).Error("读取投递结果用于插件通知失败")
|
||||
return
|
||||
}
|
||||
failures := make(map[string]error)
|
||||
for _, job := range jobs {
|
||||
if job.State != accepted {
|
||||
failures[job.Recipient] = errors.New(job.LastError)
|
||||
}
|
||||
}
|
||||
for _, hook := range hooks.Snapshot() {
|
||||
if hook == nil {
|
||||
continue
|
||||
}
|
||||
func() {
|
||||
defer func() {
|
||||
if recover() != nil {
|
||||
log.Error("投递完成插件发生异常")
|
||||
}
|
||||
}()
|
||||
hook.SendAfter(ctx, message, failures)
|
||||
}()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
package outbox
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Smail/consts"
|
||||
"git.pcux.cn/xuans/Smail/db"
|
||||
"git.pcux.cn/xuans/Smail/dto/parsemail"
|
||||
"git.pcux.cn/xuans/Smail/models"
|
||||
"git.pcux.cn/xuans/Smail/services/logstore"
|
||||
"git.pcux.cn/xuans/Smail/utils/send"
|
||||
"git.pcux.cn/xuans/Smail/utils/smtp"
|
||||
"xorm.io/xorm"
|
||||
)
|
||||
|
||||
const (
|
||||
queued = "queued"
|
||||
running = "running"
|
||||
accepted = "accepted"
|
||||
failed = "failed"
|
||||
uncertain = "uncertain"
|
||||
maxAttempts = 5
|
||||
uncertainMessage = "投递结果不确定,已暂停自动重试,请先核对收件结果"
|
||||
)
|
||||
|
||||
// Enqueue 必须与邮件及用户关联在同一事务内保存,不保存验证码或恢复令牌。
|
||||
func Enqueue(session *xorm.Session, email models.Email) error {
|
||||
message, err := parsemail.NewEmailFromModel(email)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
seen := make(map[string]bool)
|
||||
for _, user := range append(append(message.To, message.Cc...), message.Bcc...) {
|
||||
if user == nil || user.EmailAddress == "" {
|
||||
return errors.New("队列收件人不能为空")
|
||||
}
|
||||
// 本地部分保留大小写,仅合并完全相同的 SMTP 信封地址。
|
||||
address := user.EmailAddress
|
||||
if at := strings.LastIndexByte(address, '@'); at >= 0 {
|
||||
address = address[:at+1] + strings.ToLower(address[at+1:])
|
||||
}
|
||||
if seen[address] {
|
||||
continue
|
||||
}
|
||||
seen[address] = true
|
||||
job := models.OutboundDelivery{EmailID: email.Id, Recipient: address, State: queued}
|
||||
if _, err := session.Insert(&job); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if len(seen) == 0 {
|
||||
return errors.New("队列必须包含收件人")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func summarize(jobs []models.OutboundDelivery) (int8, string, bool) {
|
||||
counts := make(map[string]int)
|
||||
reasons := make(map[string]bool)
|
||||
for _, job := range jobs {
|
||||
counts[job.State]++
|
||||
if job.LastError != "" {
|
||||
reasons[job.LastError] = true
|
||||
}
|
||||
}
|
||||
if counts[queued]+counts[running] > 0 {
|
||||
return consts.EmailStatusDeliveryPending, "", false
|
||||
}
|
||||
details := make([]string, 0, len(reasons))
|
||||
for reason := range reasons {
|
||||
details = append(details, reason)
|
||||
}
|
||||
sort.Strings(details)
|
||||
suffix := ""
|
||||
if len(details) > 0 {
|
||||
suffix = ";原因:" + strings.Join(details, ";")
|
||||
}
|
||||
if counts[uncertain] > 0 {
|
||||
return consts.EmailStatusDeliveryUncertain, fmt.Sprintf("%s;已接收 %d,结果不确定 %d,失败 %d", uncertainMessage, counts[accepted], counts[uncertain], counts[failed]) + suffix, true
|
||||
}
|
||||
if len(jobs) > 0 && counts[accepted] == len(jobs) {
|
||||
return consts.EmailStatusSent, "", true
|
||||
}
|
||||
return consts.EmailStatusFail, fmt.Sprintf("投递未全部完成;已接收 %d,失败 %d。已接收的收件人不会自动重投", counts[accepted], counts[failed]) + suffix, true
|
||||
}
|
||||
|
||||
func syncStatus(session *xorm.Session, emailID int) (bool, error) {
|
||||
var jobs []models.OutboundDelivery
|
||||
if err := session.Where("email_id = ?", emailID).Find(&jobs); err != nil {
|
||||
return false, err
|
||||
}
|
||||
status, message, terminal := summarize(jobs)
|
||||
if _, err := session.ID(emailID).Cols("status", "error").Update(&models.Email{Status: status, Error: sql.NullString{String: message, Valid: true}}); err != nil {
|
||||
return false, err
|
||||
}
|
||||
// 不改动用户已放入回收站的关联状态。
|
||||
_, err := session.Where("email_id = ? AND status <> ?", emailID, consts.EmailStatusDel).Cols("status").Update(&models.UserEmail{Status: status})
|
||||
return terminal, err
|
||||
}
|
||||
|
||||
// recoverInterrupted 只在独占运行实例启动时执行,在途记录绝不重新排队。
|
||||
func recoverInterrupted(engine *xorm.Engine) error {
|
||||
return db.Transaction(engine, func(session *xorm.Session) error {
|
||||
// 旧版本未记录 SMTP 尝试边界,只标记待核对,不能当作未发送任务导入。
|
||||
var legacy []models.Email
|
||||
if err := session.Where("type = ? AND status = ? AND id NOT IN (SELECT email_id FROM outbound_delivery)", consts.EmailTypeSend, consts.EmailStatusDeliveryPending).Find(&legacy); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, email := range legacy {
|
||||
if _, err := session.ID(email.Id).Cols("status", "error").Update(&models.Email{Status: consts.EmailStatusDeliveryUncertain, Error: sql.NullString{String: uncertainMessage, Valid: true}}); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := session.Where("email_id = ? AND status = ?", email.Id, consts.EmailStatusDeliveryPending).Cols("status").Update(&models.UserEmail{Status: consts.EmailStatusDeliveryUncertain}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
var interrupted []models.OutboundDelivery
|
||||
if err := session.Where("state = ?", running).Find(&interrupted); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := session.Where("state = ?", running).Cols("state", "last_error").Update(&models.OutboundDelivery{State: uncertain, LastError: uncertainMessage}); err != nil {
|
||||
return err
|
||||
}
|
||||
seen := make(map[int]bool)
|
||||
for _, job := range interrupted {
|
||||
if !seen[job.EmailID] {
|
||||
if _, err := syncStatus(session, job.EmailID); err != nil {
|
||||
return err
|
||||
}
|
||||
seen[job.EmailID] = true
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func claim(engine *xorm.Engine, job *models.OutboundDelivery) (bool, error) {
|
||||
update := *job
|
||||
update.State = running
|
||||
update.Attempts++
|
||||
count, err := engine.ID(job.ID).Where("state = ? AND attempts = ? AND next_attempt <= ?", queued, job.Attempts, time.Now().Unix()).Cols("state", "attempts").Update(&update)
|
||||
if err == nil && count == 1 {
|
||||
*job = update
|
||||
}
|
||||
return count == 1, err
|
||||
}
|
||||
|
||||
func finish(engine *xorm.Engine, job models.OutboundDelivery, deliveryErr error) (bool, error) {
|
||||
job.State, job.LastError, job.NextAttempt = accepted, "", 0
|
||||
if deliveryErr != nil {
|
||||
// 不保存远端响应原文,避免凭据或恶意超长内容进入数据库和页面。
|
||||
job.State, job.LastError = failed, logstore.MailFailureReason(deliveryErr)
|
||||
if smtp.IsDeliveryUncertain(deliveryErr) {
|
||||
job.State = uncertain
|
||||
job.LastError = uncertainMessage
|
||||
} else if send.Retryable(deliveryErr) && job.Attempts < maxAttempts {
|
||||
job.State = queued
|
||||
job.NextAttempt = time.Now().Add(time.Minute * time.Duration(1<<(job.Attempts-1))).Unix()
|
||||
}
|
||||
}
|
||||
terminal := false
|
||||
err := db.Transaction(engine, func(session *xorm.Session) error {
|
||||
count, err := session.ID(job.ID).Where("state = ? AND attempts = ?", running, job.Attempts).Cols("state", "last_error", "next_attempt").Update(&job)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if count != 1 {
|
||||
return errors.New("投递任务状态已发生变化")
|
||||
}
|
||||
terminal, err = syncStatus(session, job.EmailID)
|
||||
return err
|
||||
})
|
||||
return terminal, err
|
||||
}
|
||||
@@ -0,0 +1,340 @@
|
||||
package outbox
|
||||
|
||||
import (
|
||||
stdcontext "context"
|
||||
"errors"
|
||||
"io"
|
||||
"net/textproto"
|
||||
"strings"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Smail/consts"
|
||||
"git.pcux.cn/xuans/Smail/db"
|
||||
"git.pcux.cn/xuans/Smail/dto/parsemail"
|
||||
"git.pcux.cn/xuans/Smail/models"
|
||||
"git.pcux.cn/xuans/Smail/utils/context"
|
||||
"git.pcux.cn/xuans/Smail/utils/smtp"
|
||||
"xorm.io/xorm"
|
||||
)
|
||||
|
||||
func queueFixture(t *testing.T) (*xorm.Engine, models.Email, []models.OutboundDelivery) {
|
||||
t.Helper()
|
||||
engine, err := xorm.NewEngine("sqlite", ":memory:")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
engine.SetMaxOpenConns(1)
|
||||
t.Cleanup(func() { engine.Close() })
|
||||
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.User{}, &models.OutboundDelivery{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
user := models.User{Account: "sender", Name: "sender", Password: "test", Role: "user"}
|
||||
if _, err := engine.Insert(&user); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
email := models.Email{Type: consts.EmailTypeSend, Status: consts.EmailStatusDeliveryPending, SendUserID: user.ID, FromAddress: "sender@example.com", To: `[{"EmailAddress":"one@example.com"},{"EmailAddress":"two@example.com"}]`, Cc: `[{"EmailAddress":"one@EXAMPLE.com"}]`, MsgID: "stable@example.com"}
|
||||
err = db.Transaction(engine, func(session *xorm.Session) error {
|
||||
if _, err := session.Insert(&email); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := session.Insert(&models.UserEmail{UserID: user.ID, EmailID: email.Id, Status: consts.EmailStatusDeliveryPending}); err != nil {
|
||||
return err
|
||||
}
|
||||
return Enqueue(session, email)
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var jobs []models.OutboundDelivery
|
||||
if err := engine.Asc("id").Find(&jobs); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(jobs) != 2 {
|
||||
t.Fatalf("duplicate recipient: %v", jobs)
|
||||
}
|
||||
return engine, email, jobs
|
||||
}
|
||||
|
||||
func assertStatus(t *testing.T, engine *xorm.Engine, emailID int, status int8) {
|
||||
t.Helper()
|
||||
var email models.Email
|
||||
var relation models.UserEmail
|
||||
if ok, err := engine.ID(emailID).Get(&email); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, err := engine.Where("email_id = ?", emailID).Get(&relation); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if email.Status != status || relation.Status != status {
|
||||
t.Fatalf("email=%d relation=%d want=%d", email.Status, relation.Status, status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClaimAndPartialResults(t *testing.T) {
|
||||
engine, email, jobs := queueFixture(t)
|
||||
first := jobs[0]
|
||||
if ok, err := claim(engine, &first); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, err := claim(engine, &jobs[0]); err != nil || ok {
|
||||
t.Fatalf("duplicate claim: %v %v", ok, err)
|
||||
}
|
||||
if _, err := finish(engine, first, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryPending)
|
||||
second := jobs[1]
|
||||
if ok, err := claim(engine, &second); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := finish(engine, second, &textproto.Error{Code: 451, Msg: "later"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var queuedJob models.OutboundDelivery
|
||||
if _, err := engine.ID(second.ID).Get(&queuedJob); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if queuedJob.State != queued || queuedJob.NextAttempt <= time.Now().Unix() {
|
||||
t.Fatalf("retry state=%+v", queuedJob)
|
||||
}
|
||||
if ok, err := claim(engine, &queuedJob); err != nil || ok {
|
||||
t.Fatal("retry was claimed before backoff elapsed")
|
||||
}
|
||||
if _, err := engine.ID(queuedJob.ID).Cols("next_attempt").Update(&models.OutboundDelivery{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, err := claim(engine, &queuedJob); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := finish(engine, queuedJob, &textproto.Error{Code: 550, Msg: "rejected"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assertStatus(t, engine, email.Id, consts.EmailStatusFail)
|
||||
if ok, err := claim(engine, &first); err != nil || ok {
|
||||
t.Fatal("accepted job was claimed again")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRestartDoesNotResendInterruptedOrAccepted(t *testing.T) {
|
||||
engine, email, jobs := queueFixture(t)
|
||||
for i := range jobs {
|
||||
if ok, err := claim(engine, &jobs[i]); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if _, err := finish(engine, jobs[0], nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := recoverInterrupted(engine); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryUncertain)
|
||||
var stored []models.OutboundDelivery
|
||||
if err := engine.Asc("id").Find(&stored); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if stored[0].State != accepted || stored[1].State != uncertain {
|
||||
t.Fatalf("states=%+v", stored)
|
||||
}
|
||||
if err := recoverInterrupted(engine); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUncertainDATAIsNeverRetried(t *testing.T) {
|
||||
engine, _, jobs := queueFixture(t)
|
||||
job := jobs[0]
|
||||
if ok, err := claim(engine, &job); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := finish(engine, job, &smtp.DeliveryUncertainError{Cause: io.EOF}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, err := claim(engine, &job); err != nil || ok {
|
||||
t.Fatal("uncertain job was claimed again")
|
||||
}
|
||||
}
|
||||
|
||||
func TestResultFailureRollsBackAndNeverRedelivers(t *testing.T) {
|
||||
engine, email, jobs := queueFixture(t)
|
||||
if _, err := engine.Exec("CREATE TRIGGER reject_result BEFORE UPDATE ON user_email BEGIN SELECT RAISE(ABORT, 'injected failure'); END"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var calls atomic.Int32
|
||||
r := &Runtime{engine: engine, deliver: func(_ *context.Context, e *parsemail.Email, recipient string) error {
|
||||
calls.Add(1)
|
||||
if e.MsgID != "stable@example.com" || len(e.To) != 2 || recipient != "one@example.com" {
|
||||
t.Fatal("envelope changed message headers")
|
||||
}
|
||||
return nil
|
||||
}}
|
||||
if err := r.process(jobs[0]); err == nil {
|
||||
t.Fatal("result failure was ignored")
|
||||
}
|
||||
if err := r.process(jobs[0]); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if calls.Load() != 1 {
|
||||
t.Fatalf("SMTP called %d times", calls.Load())
|
||||
}
|
||||
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryPending)
|
||||
var job models.OutboundDelivery
|
||||
if _, err := engine.ID(jobs[0].ID).Get(&job); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if job.State != running {
|
||||
t.Fatalf("state=%s", job.State)
|
||||
}
|
||||
}
|
||||
|
||||
func TestQueuedJobsSurviveRestartAndDrain(t *testing.T) {
|
||||
engine, email, _ := queueFixture(t)
|
||||
if err := recoverInterrupted(engine); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var calls atomic.Int32
|
||||
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error { calls.Add(1); return nil }}
|
||||
go r.loop()
|
||||
deadline := time.Now().Add(3 * time.Second)
|
||||
for calls.Load() < 2 && time.Now().Before(deadline) {
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), time.Second)
|
||||
defer cancel()
|
||||
if err := r.Stop(ctx); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if calls.Load() != 2 {
|
||||
t.Fatalf("calls=%d", calls.Load())
|
||||
}
|
||||
assertStatus(t, engine, email.Id, consts.EmailStatusSent)
|
||||
}
|
||||
|
||||
func TestRetryLimitAndSafeFailureDetails(t *testing.T) {
|
||||
engine, _, jobs := queueFixture(t)
|
||||
job := jobs[0]
|
||||
for attempt := 1; attempt <= maxAttempts; attempt++ {
|
||||
if _, err := engine.ID(job.ID).Cols("next_attempt").Update(&models.OutboundDelivery{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ok, err := claim(engine, &job); err != nil || !ok {
|
||||
t.Fatalf("claim %d: %v", attempt, err)
|
||||
}
|
||||
before := time.Now().Unix()
|
||||
if _, err := finish(engine, job, &textproto.Error{Code: 451, Msg: "sensitive-remote-response"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var refreshed models.OutboundDelivery
|
||||
if found, err := engine.ID(job.ID).Get(&refreshed); err != nil || !found {
|
||||
t.Fatal(err)
|
||||
}
|
||||
job = refreshed
|
||||
if strings.Contains(job.LastError, "sensitive") || !strings.Contains(job.LastError, "451") {
|
||||
t.Fatalf("unsafe or missing failure details: %s", job.LastError)
|
||||
}
|
||||
if attempt < maxAttempts {
|
||||
minimum := before + int64(60*(1<<(attempt-1)))
|
||||
if job.State != queued || job.NextAttempt < minimum || job.NextAttempt > minimum+2 {
|
||||
t.Fatalf("unexpected backoff: %+v", job)
|
||||
}
|
||||
} else if job.State != failed || job.NextAttempt != 0 {
|
||||
t.Fatalf("retry limit ignored: %+v", job)
|
||||
}
|
||||
}
|
||||
status, message, terminal := summarize([]models.OutboundDelivery{job})
|
||||
if status != consts.EmailStatusFail || !terminal || !strings.Contains(message, "451") {
|
||||
t.Fatalf("failure summary: %d %s %v", status, message, terminal)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegacyPendingIsUncertainWithoutEnqueue(t *testing.T) {
|
||||
engine, _, _ := queueFixture(t)
|
||||
email := models.Email{Type: consts.EmailTypeSend, Status: consts.EmailStatusDeliveryPending}
|
||||
if _, err := engine.Insert(&email); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := engine.Insert(&models.UserEmail{UserID: 1, EmailID: email.Id, Status: consts.EmailStatusDeliveryPending}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := recoverInterrupted(engine); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
assertStatus(t, engine, email.Id, consts.EmailStatusDeliveryUncertain)
|
||||
count, err := engine.Where("email_id = ?", email.Id).Count(&models.OutboundDelivery{})
|
||||
if err != nil || count != 0 {
|
||||
t.Fatalf("legacy message enqueued: %d %v", count, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadFailureDoesNotClaimOrDeliver(t *testing.T) {
|
||||
engine, _, jobs := queueFixture(t)
|
||||
if _, err := engine.Exec("ALTER TABLE email RENAME TO unavailable_email"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
r := &Runtime{engine: engine, deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error {
|
||||
t.Fatal("SMTP called despite read failure")
|
||||
return nil
|
||||
}}
|
||||
if err := r.process(jobs[0]); err == nil {
|
||||
t.Fatal("read failure ignored")
|
||||
}
|
||||
var job models.OutboundDelivery
|
||||
if _, err := engine.ID(jobs[0].ID).Get(&job); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if job.State != queued || job.Attempts != 0 {
|
||||
t.Fatalf("read failure consumed attempt: %+v", job)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStopTimeoutDoesNotStartAnotherDelivery(t *testing.T) {
|
||||
engine, _, _ := queueFixture(t)
|
||||
entered, release := make(chan struct{}), make(chan struct{})
|
||||
var calls atomic.Int32
|
||||
r := &Runtime{engine: engine, stop: make(chan struct{}), done: make(chan struct{}), deliver: func(_ *context.Context, _ *parsemail.Email, _ string) error {
|
||||
if calls.Add(1) == 1 {
|
||||
close(entered)
|
||||
}
|
||||
<-release
|
||||
return nil
|
||||
}}
|
||||
go r.loop()
|
||||
<-entered
|
||||
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), 20*time.Millisecond)
|
||||
defer cancel()
|
||||
err := r.Stop(ctx)
|
||||
close(release)
|
||||
if !errors.Is(err, stdcontext.DeadlineExceeded) {
|
||||
t.Fatalf("stop did not time out: %v", err)
|
||||
}
|
||||
if err := r.Stop(stdcontext.Background()); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if calls.Load() != 1 {
|
||||
t.Fatalf("delivery started after stop: %d", calls.Load())
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliveryDoesNotRestoreTrashedRelation(t *testing.T) {
|
||||
engine, email, jobs := queueFixture(t)
|
||||
if _, err := engine.Where("email_id = ?", email.Id).Cols("status").Update(&models.UserEmail{Status: consts.EmailStatusDel}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, job := range jobs {
|
||||
if ok, err := claim(engine, &job); err != nil || !ok {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := finish(engine, job, nil); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
var relation models.UserEmail
|
||||
if _, err := engine.Where("email_id = ?", email.Id).Get(&relation); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if relation.Status != consts.EmailStatusDel {
|
||||
t.Fatal("delivery restored trashed message")
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user