修复生产审查凭据泄露风险并增加持久投递队列
This commit is contained in:
1 parent
071460ed9a
commit
6b009197bc
70 files changed
+1581
-262
No files matched your search
@@ -26,4 +26,7 @@ const (
|
||||
|
||||
// EmailStatusDeliveryPending marks an outbound audit whose delivery result is not final.
|
||||
EmailStatusDeliveryPending int8 = 6
|
||||
|
||||
// EmailStatusDeliveryUncertain 禁止自动重投,需人工核对接收结果。
|
||||
EmailStatusDeliveryUncertain int8 = 7
|
||||
)
|
||||
@@ -10,17 +10,14 @@ import (
|
||||
"git.pcux.cn/xuans/Smail/dto/parsemail"
|
||||
"git.pcux.cn/xuans/Smail/dto/response"
|
||||
"git.pcux.cn/xuans/Smail/hooks"
|
||||
"git.pcux.cn/xuans/Smail/hooks/framework"
|
||||
"git.pcux.cn/xuans/Smail/i18n"
|
||||
"git.pcux.cn/xuans/Smail/models"
|
||||
"git.pcux.cn/xuans/Smail/services/access"
|
||||
"git.pcux.cn/xuans/Smail/services/outbox"
|
||||
|
||||
"git.pcux.cn/xuans/Smail/utils/async"
|
||||
"git.pcux.cn/xuans/Smail/utils/context"
|
||||
"git.pcux.cn/xuans/Smail/utils/send"
|
||||
"git.pcux.cn/xuans/Smail/utils/validation"
|
||||
log "github.com/sirupsen/logrus"
|
||||
"github.com/spf13/cast"
|
||||
"mime"
|
||||
"net/http"
|
||||
"strings"
|
||||
@@ -274,61 +271,12 @@ func Send(ctx *context.Context, w http.ResponseWriter, req *http.Request) {
|
||||
}
|
||||
RecordUserContacts(ctx.UserID, contactList)
|
||||
|
||||
e.MessageId = cast.ToInt64(modelEmail.Id)
|
||||
e.MsgID = modelEmail.MsgID
|
||||
|
||||
async.New(ctx).Process(func(p any) {
|
||||
errMsg := ""
|
||||
err, sendErr := send.SendTriggered(ctx, e, "网页写信")
|
||||
|
||||
log.WithContext(ctx).Debugf("插件执行--SendAfter")
|
||||
|
||||
as2 := async.New(ctx)
|
||||
for _, hook := range hooks.Snapshot() {
|
||||
if hook == nil {
|
||||
continue
|
||||
}
|
||||
as2.WaitProcess(func(hk any) {
|
||||
hk.(framework.EmailHook).SendAfter(ctx, e, sendErr)
|
||||
}, hook)
|
||||
}
|
||||
as2.Wait()
|
||||
log.WithContext(ctx).Debugf("插件执行--SendAfter")
|
||||
|
||||
if err != nil {
|
||||
errMsg = err.Error()
|
||||
_ = db.Transaction(db.Instance, func(session *xorm.Session) error {
|
||||
if _, updateErr := session.Exec(db.WithContext(ctx, "update email set status = ?, error = ? where id = ?"), consts.EmailStatusFail, errMsg, modelEmail.Id); updateErr != nil {
|
||||
log.WithContext(ctx).Errorf("update email status failed: %+v", updateErr)
|
||||
return updateErr
|
||||
}
|
||||
if _, updateErr := session.Exec(db.WithContext(ctx, "update user_email set status = ? where email_id = ? and user_id = ?"), consts.EmailStatusFail, modelEmail.Id, ctx.UserID); updateErr != nil {
|
||||
log.WithContext(ctx).Errorf("update user_email status failed: %+v", updateErr)
|
||||
return updateErr
|
||||
}
|
||||
return nil
|
||||
})
|
||||
} else {
|
||||
_ = db.Transaction(db.Instance, func(session *xorm.Session) error {
|
||||
if _, updateErr := session.Exec(db.WithContext(ctx, "update email set status = ?, error = '' where id = ?"), consts.EmailStatusSent, modelEmail.Id); updateErr != nil {
|
||||
log.WithContext(ctx).Errorf("update email status failed: %+v", updateErr)
|
||||
return updateErr
|
||||
}
|
||||
if _, updateErr := session.Exec(db.WithContext(ctx, "update user_email set status = ? where email_id = ? and user_id = ?"), consts.EmailStatusSent, modelEmail.Id, ctx.UserID); updateErr != nil {
|
||||
log.WithContext(ctx).Errorf("update user_email status failed: %+v", updateErr)
|
||||
return updateErr
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
}, nil)
|
||||
|
||||
response.NewSuccessResponse(i18n.GetText(ctx.Lang, "succ")).FPrint(w)
|
||||
}
|
||||
|
||||
func persistOutgoingEmail(engine *xorm.Engine, userID int, email *models.Email) error {
|
||||
return db.Transaction(engine, func(session *xorm.Session) error {
|
||||
var saved models.Email
|
||||
err := db.Transaction(engine, func(session *xorm.Session) error {
|
||||
candidate := *email
|
||||
candidate.Id = 0
|
||||
candidate.Status = consts.EmailStatusDeliveryPending
|
||||
@@ -347,9 +295,16 @@ func persistOutgoingEmail(engine *xorm.Engine, userID int, email *models.Email)
|
||||
if _, err := session.Insert(&relation); err != nil {
|
||||
return err
|
||||
}
|
||||
*email = candidate
|
||||
if err := outbox.Enqueue(session, candidate); err != nil {
|
||||
return err
|
||||
}
|
||||
saved = candidate
|
||||
return nil
|
||||
})
|
||||
if err == nil {
|
||||
*email = saved
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func decodeAttachment(data string) (string, []byte, error) {
|
||||
|
||||
@@ -20,7 +20,7 @@ func TestSendTransactionalPersistenceConsistency(t *testing.T) {
|
||||
t.Fatalf("create test engine: %v", err)
|
||||
}
|
||||
engine.SetMaxOpenConns(1)
|
||||
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}); err != nil {
|
||||
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.OutboundDelivery{}); err != nil {
|
||||
t.Fatalf("sync test database: %v", err)
|
||||
}
|
||||
defer engine.Close()
|
||||
@@ -43,6 +43,7 @@ func TestSendTransactionalPersistenceConsistency(t *testing.T) {
|
||||
Status: consts.EmailStatusDeliveryPending,
|
||||
CreateTime: now,
|
||||
MsgID: "msg-123@example.com",
|
||||
To: `[{"EmailAddress":"recipient@example.com"}]`,
|
||||
}
|
||||
|
||||
err = persistOutgoingEmail(engine, ctx.UserID, &modelEmail)
|
||||
@@ -120,18 +121,18 @@ func TestOutboxExposesDeliveryStatus(t *testing.T) {
|
||||
}
|
||||
defer engine.Close()
|
||||
engine.SetMaxOpenConns(1)
|
||||
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.UserTrustedSender{}); err != nil {
|
||||
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.UserTrustedSender{}, &models.OutboundDelivery{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
previous := db.Instance
|
||||
db.Instance = engine
|
||||
defer func() { db.Instance = previous }()
|
||||
ctx := &context.Context{UserID: 1}
|
||||
email := models.Email{Subject: "pending", Type: consts.EmailTypeSend, Status: consts.EmailStatusSent}
|
||||
email := models.Email{Subject: "pending", Type: consts.EmailTypeSend, Status: consts.EmailStatusSent, To: `[{"EmailAddress":"recipient@example.com"}]`}
|
||||
if err := persistOutgoingEmail(engine, ctx.UserID, &email); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, status := range []int8{consts.EmailStatusDeliveryPending, consts.EmailStatusSent, consts.EmailStatusFail} {
|
||||
for _, status := range []int8{consts.EmailStatusDeliveryPending, consts.EmailStatusSent, consts.EmailStatusFail, consts.EmailStatusDeliveryUncertain} {
|
||||
if _, err := engine.ID(email.Id).Cols("status").Update(&models.Email{Status: status}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
@@ -150,3 +151,28 @@ func TestOutboxExposesDeliveryStatus(t *testing.T) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPersistOutgoingEmailRollsBackQueueFailure(t *testing.T) {
|
||||
engine, err := xorm.NewEngine("sqlite", ":memory:")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer engine.Close()
|
||||
engine.SetMaxOpenConns(1)
|
||||
if err := engine.Sync2(&models.Email{}, &models.UserEmail{}, &models.OutboundDelivery{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := engine.Exec("CREATE TRIGGER reject_queue BEFORE INSERT ON outbound_delivery BEGIN SELECT RAISE(ABORT, 'injected queue failure'); END"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
email := models.Email{To: `[{"EmailAddress":"recipient@example.com"}]`}
|
||||
if err := persistOutgoingEmail(engine, 1, &email); err == nil {
|
||||
t.Fatal("queue failure ignored")
|
||||
}
|
||||
for _, model := range []any{&models.Email{}, &models.UserEmail{}, &models.OutboundDelivery{}} {
|
||||
count, err := engine.Count(model)
|
||||
if err != nil || count != 0 || email.Id != 0 {
|
||||
t.Fatalf("rollback failed for %T: count=%d id=%d error=%v", model, count, email.Id, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
package migration
|
||||
|
||||
func outboundDeliveryStatements() map[Dialect][]string {
|
||||
return map[Dialect][]string{
|
||||
DialectSQLite: {
|
||||
`CREATE TABLE IF NOT EXISTS "outbound_delivery" ("id" INTEGER PRIMARY KEY AUTOINCREMENT, "email_id" INTEGER NOT NULL, "recipient" TEXT NOT NULL, "state" TEXT NOT NULL, "attempts" INTEGER NOT NULL DEFAULT 0, "next_attempt" BIGINT NOT NULL DEFAULT 0, "last_error" TEXT NOT NULL DEFAULT '')`,
|
||||
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_email" ON "outbound_delivery"("email_id")`,
|
||||
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_due" ON "outbound_delivery"("state", "next_attempt")`,
|
||||
},
|
||||
DialectMySQL: {
|
||||
"CREATE TABLE IF NOT EXISTS `outbound_delivery` (`id` BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, `email_id` BIGINT NOT NULL, `recipient` VARCHAR(320) NOT NULL, `state` VARCHAR(24) NOT NULL, `attempts` INT NOT NULL DEFAULT 0, `next_attempt` BIGINT NOT NULL DEFAULT 0, `last_error` TEXT NOT NULL, KEY `idx_outbound_delivery_email` (`email_id`), KEY `idx_outbound_delivery_due` (`state`, `next_attempt`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4",
|
||||
},
|
||||
DialectPostgres: {
|
||||
`CREATE TABLE IF NOT EXISTS "outbound_delivery" ("id" BIGSERIAL PRIMARY KEY, "email_id" BIGINT NOT NULL, "recipient" VARCHAR(320) NOT NULL, "state" VARCHAR(24) NOT NULL, "attempts" INTEGER NOT NULL DEFAULT 0, "next_attempt" BIGINT NOT NULL DEFAULT 0, "last_error" TEXT NOT NULL DEFAULT '')`,
|
||||
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_email" ON "outbound_delivery"("email_id")`,
|
||||
`CREATE INDEX IF NOT EXISTS "idx_outbound_delivery_due" ON "outbound_delivery"("state", "next_attempt")`,
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
package migration
|
||||
package migration
|
||||
|
||||
import (
|
||||
"regexp"
|
||||
@@ -32,6 +32,7 @@ func DefaultMigrations() []Migration {
|
||||
DefineCustom(20, "expand_protocol_credential_ciphertext", "expand_protocol_credential_ciphertext_v1", applyProtocolCredentialCiphertextSchema),
|
||||
DefineCustom(21, "expand_trusted_sender_blacklist", "expand_trusted_sender_blacklist_v1", applyTrustedSenderBlacklistSchema),
|
||||
DefineForDialects(22, "create_client_credentials", clientCredentialStatements()),
|
||||
DefineForDialects(23, "create_outbound_delivery", outboundDeliveryStatements()),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -296,6 +296,7 @@ func TestDefaultMigrationChecksumsAreImmutable(t *testing.T) {
|
||||
20: "e0bc01f4c2df742bc23c519c2a399cc1c3f341565dbed014509a8c63d68bf725",
|
||||
21: "ac1a0b3be90128c0e0512d2cec858f8cd7e70abc5ff4734d7113b9674f08dbb0",
|
||||
22: "1047cb22f5a32c8a09ba4ccedff8713a5225c14fdb98357db86a6e0723c30d8b",
|
||||
23: "5d80f2c2c583fc9a033fc320c0852c73bd6701ce6c8f12e8904deedfe0ba44b2",
|
||||
}
|
||||
migrations := DefaultMigrations()
|
||||
if len(migrations) != len(expected) {
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
package models
|
||||
|
||||
type OutboundDelivery struct {
|
||||
ID int64 `xorm:"id pk autoincr"`
|
||||
EmailID int `xorm:"email_id notnull index"`
|
||||
Recipient string `xorm:"varchar(320) notnull"`
|
||||
State string `xorm:"varchar(24) notnull"`
|
||||
Attempts int `xorm:"notnull"`
|
||||
NextAttempt int64 `xorm:"notnull"`
|
||||
LastError string `xorm:"text"`
|
||||
}
|
||||
|
||||
func (OutboundDelivery) TableName() string { return "outbound_delivery" }
|
||||
@@ -25,6 +25,7 @@ import (
|
||||
"git.pcux.cn/xuans/Smail/services/dbmigration"
|
||||
"git.pcux.cn/xuans/Smail/services/externalemail"
|
||||
"git.pcux.cn/xuans/Smail/services/logstore"
|
||||
"git.pcux.cn/xuans/Smail/services/outbox"
|
||||
pluginservice "git.pcux.cn/xuans/Smail/services/plugin"
|
||||
"git.pcux.cn/xuans/Smail/services/recovery"
|
||||
"git.pcux.cn/xuans/Smail/services/restart"
|
||||
@@ -47,6 +48,7 @@ var verificationRuntime *verification.Runtime
|
||||
var credentialService *credentials.Service
|
||||
var webAuthnRuntimeService *webauthnservice.Service
|
||||
var logRuntime *logstore.Runtime
|
||||
var outboxRuntime *outbox.Runtime
|
||||
|
||||
func startConfigManager() error {
|
||||
root := filepath.Join(config.ROOT_PATH, "config")
|
||||
@@ -215,6 +217,11 @@ func Init(serverVersion string) error {
|
||||
}()
|
||||
}
|
||||
hooks.Init(serverVersion)
|
||||
outboxRuntime, err = outbox.Start(db.Instance)
|
||||
if err != nil {
|
||||
stopServices()
|
||||
return fmt.Errorf("start persistent outbox: %w", err)
|
||||
}
|
||||
httpRun, httpsRun, err := http_server.PrepareWebServers()
|
||||
if err != nil {
|
||||
stopServices()
|
||||
@@ -294,6 +301,14 @@ func stopServices() error {
|
||||
http_server.HttpStop()
|
||||
pop3_server.Stop()
|
||||
imap_server.Stop()
|
||||
// 停止接收新请求后等待正在投递的任务写回,超时则保留数据库,避免提前关闭连接池。
|
||||
drainCtx, drainCancel := context.WithTimeout(context.Background(), 25*time.Second)
|
||||
err := outboxRuntime.Stop(drainCtx)
|
||||
drainCancel()
|
||||
if err != nil {
|
||||
return fmt.Errorf("outbox did not drain; database retained: %w", err)
|
||||
}
|
||||
outboxRuntime = nil
|
||||
hooks.Stop()
|
||||
// 先关闭业务入口,再撤下安全服务及会话清理器,避免新请求读取停止中的依赖。
|
||||
stopVerificationRuntime()
|
||||
|
||||
@@ -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")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
package send
|
||||
|
||||
import (
|
||||
stdcontext "context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/textproto"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.pcux.cn/xuans/Smail/utils/smtp"
|
||||
)
|
||||
|
||||
var errNullMX = errors.New("收件域名声明不接收邮件")
|
||||
|
||||
type mxLookup func(stdcontext.Context, string) ([]*net.MX, error)
|
||||
|
||||
func resolveMX(domain string, lookup mxLookup) ([]string, error) {
|
||||
ctx, cancel := stdcontext.WithTimeout(stdcontext.Background(), 10*time.Second)
|
||||
defer cancel()
|
||||
records, err := lookup(ctx, domain)
|
||||
if err != nil {
|
||||
var dnsErr *net.DNSError
|
||||
if !errors.As(err, &dnsErr) || !dnsErr.IsNotFound || dnsErr.IsTemporary || dnsErr.IsTimeout {
|
||||
return nil, fmt.Errorf("查询收件域名 MX 失败: %w", err)
|
||||
}
|
||||
// 无 MX 时使用域名自身的地址记录,不猜测 smtp 子域名。
|
||||
return []string{domain}, nil
|
||||
}
|
||||
if len(records) == 0 {
|
||||
return []string{domain}, nil
|
||||
}
|
||||
records = append([]*net.MX(nil), records...)
|
||||
for _, record := range records {
|
||||
if record == nil || record.Host == "" {
|
||||
return nil, errors.New("收件域名 MX 记录无效")
|
||||
}
|
||||
if record.Host == "." {
|
||||
return nil, errNullMX
|
||||
}
|
||||
}
|
||||
sort.SliceStable(records, func(i, j int) bool { return records[i].Pref < records[j].Pref })
|
||||
hosts := make([]string, 0, len(records))
|
||||
seen := make(map[string]bool)
|
||||
for _, record := range records {
|
||||
host := strings.ToLower(strings.TrimSuffix(record.Host, "."))
|
||||
if !seen[host] {
|
||||
hosts = append(hosts, host)
|
||||
seen[host] = true
|
||||
}
|
||||
}
|
||||
return hosts, nil
|
||||
}
|
||||
|
||||
func stopFallback(err error) bool {
|
||||
return smtp.IsDeliveryUncertain(err) || isCertificateVerificationError(err) || isPermanentSMTPResponse(err) || errors.Is(err, smtp.ErrUnsafeRemoteAddress)
|
||||
}
|
||||
|
||||
// deliverMX 只在确认本次未接收时切换安全通道,DATA 不确定结果不进入下一条路由。
|
||||
func deliverMX(hosts []string, attempt func(host, port string) error) error {
|
||||
var lastErr error
|
||||
for _, host := range hosts {
|
||||
for _, port := range []string{"25", "587", "465"} {
|
||||
lastErr = attempt(host, port)
|
||||
if lastErr == nil || stopFallback(lastErr) {
|
||||
return lastErr
|
||||
}
|
||||
}
|
||||
}
|
||||
if lastErr == nil {
|
||||
lastErr = errors.New("收件域名没有可用邮件服务器")
|
||||
}
|
||||
return lastErr
|
||||
}
|
||||
|
||||
// Retryable 仅允许有明确临时失败语义的结果进入持久队列重试。
|
||||
func Retryable(err error) bool {
|
||||
if err == nil || stopFallback(err) {
|
||||
return false
|
||||
}
|
||||
var response *textproto.Error
|
||||
if errors.As(err, &response) {
|
||||
return response.Code >= 400 && response.Code <= 499
|
||||
}
|
||||
var dnsErr *net.DNSError
|
||||
if errors.As(err, &dnsErr) {
|
||||
return dnsErr.IsTimeout || dnsErr.IsTemporary
|
||||
}
|
||||
var networkErr net.Error
|
||||
return errors.As(err, &networkErr)
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
package send
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/tls"
|
||||
"errors"
|
||||
"io"
|
||||
"net"
|
||||
"net/textproto"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"git.pcux.cn/xuans/Smail/utils/smtp"
|
||||
)
|
||||
|
||||
func TestResolveMX(t *testing.T) {
|
||||
for _, tt := range []struct {
|
||||
name string
|
||||
records []*net.MX
|
||||
err error
|
||||
want []string
|
||||
wantErr bool
|
||||
}{
|
||||
{name: "priority and duplicate", records: []*net.MX{{Host: "backup.example.", Pref: 20}, {Host: "primary.example.", Pref: 10}, {Host: "PRIMARY.example.", Pref: 30}}, want: []string{"primary.example", "backup.example"}},
|
||||
{name: "implicit MX", want: []string{"example.com"}},
|
||||
{name: "no MX record", err: &net.DNSError{IsNotFound: true}, want: []string{"example.com"}},
|
||||
{name: "temporary DNS", err: &net.DNSError{IsTemporary: true}, wantErr: true},
|
||||
{name: "timeout DNS", err: &net.DNSError{IsTimeout: true}, wantErr: true},
|
||||
{name: "null MX", records: []*net.MX{{Host: "."}}, wantErr: true},
|
||||
{name: "invalid MX", records: []*net.MX{nil}, wantErr: true},
|
||||
} {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
hosts, err := resolveMX("example.com", func(ctx context.Context, domain string) ([]*net.MX, error) {
|
||||
if _, ok := ctx.Deadline(); !ok || domain != "example.com" {
|
||||
t.Fatal("unbounded or wrong lookup")
|
||||
}
|
||||
return tt.records, tt.err
|
||||
})
|
||||
if (err != nil) != tt.wantErr || !reflect.DeepEqual(hosts, tt.want) {
|
||||
t.Fatalf("hosts=%v error=%v", hosts, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeliverMXFallbackAndStop(t *testing.T) {
|
||||
for _, tt := range []struct {
|
||||
name string
|
||||
err error
|
||||
calls int
|
||||
}{
|
||||
{"network fallback", &net.OpError{Op: "dial", Err: io.EOF}, 4},
|
||||
{"temporary refusal fallback", &textproto.Error{Code: 451, Msg: "later"}, 4},
|
||||
{"permanent refusal", &textproto.Error{Code: 550, Msg: "rejected"}, 1},
|
||||
{"certificate failure", &tls.CertificateVerificationError{Err: io.EOF}, 1},
|
||||
{"uncertain DATA", &smtp.DeliveryUncertainError{Cause: io.EOF}, 1},
|
||||
{"private MX", smtp.ErrUnsafeRemoteAddress, 1},
|
||||
} {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
var calls []string
|
||||
err := deliverMX([]string{"primary.example", "backup.example"}, func(host, port string) error {
|
||||
calls = append(calls, host+":"+port)
|
||||
if host == "backup.example" {
|
||||
return nil
|
||||
}
|
||||
return tt.err
|
||||
})
|
||||
if len(calls) != tt.calls {
|
||||
t.Fatalf("calls=%v", calls)
|
||||
}
|
||||
if tt.calls == 4 && err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if tt.calls == 1 && !errors.Is(err, tt.err) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestRetryable(t *testing.T) {
|
||||
for _, tt := range []struct {
|
||||
err error
|
||||
want bool
|
||||
}{
|
||||
{&textproto.Error{Code: 451}, true}, {&net.DNSError{IsTemporary: true}, true},
|
||||
{&net.DNSError{IsNotFound: true}, false}, {&textproto.Error{Code: 550}, false},
|
||||
{&smtp.DeliveryUncertainError{Cause: &net.DNSError{IsTimeout: true}}, false},
|
||||
{&tls.CertificateVerificationError{Err: io.EOF}, false}, {nil, false},
|
||||
} {
|
||||
if got := Retryable(tt.err); got != tt.want {
|
||||
t.Fatalf("Retryable(%v)=%v", tt.err, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
+51
-107
@@ -9,7 +9,6 @@ import (
|
||||
"git.pcux.cn/xuans/Smail/models"
|
||||
"git.pcux.cn/xuans/Smail/services/logstore"
|
||||
"git.pcux.cn/xuans/Smail/utils/array"
|
||||
"git.pcux.cn/xuans/Smail/utils/async"
|
||||
"git.pcux.cn/xuans/Smail/utils/consts"
|
||||
"git.pcux.cn/xuans/Smail/utils/context"
|
||||
"git.pcux.cn/xuans/Smail/utils/smtp"
|
||||
@@ -89,6 +88,23 @@ func Send(ctx *context.Context, e *parsemail.Email) (error, map[string]error) {
|
||||
|
||||
// SendTriggered 显式标记业务发起方,不从邮件主题或内容推断来源。
|
||||
func SendTriggered(ctx *context.Context, e *parsemail.Email, trigger string) (error, map[string]error) {
|
||||
return sendRecipients(ctx, e, nil, trigger)
|
||||
}
|
||||
|
||||
// SendRecipientTriggered 保留原邮件头,只向当前队列收件人发送 SMTP 信封。
|
||||
func SendRecipientTriggered(ctx *context.Context, e *parsemail.Email, recipient string) error {
|
||||
err, failures := sendRecipients(ctx, e, []*parsemail.User{{EmailAddress: recipient}}, "网页写信")
|
||||
if err != nil {
|
||||
for _, cause := range failures {
|
||||
if cause != nil {
|
||||
return cause
|
||||
}
|
||||
}
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func sendRecipients(ctx *context.Context, e *parsemail.Email, recipients []*parsemail.User, trigger string) (error, map[string]error) {
|
||||
_, fromDomain := e.From.GetDomainAccount()
|
||||
|
||||
b, err := e.BuildBytes(ctx, true)
|
||||
@@ -104,6 +120,9 @@ func SendTriggered(ctx *context.Context, e *parsemail.Email, trigger string) (er
|
||||
|
||||
var to []*parsemail.User
|
||||
to = append(append(append(to, e.To...), e.Cc...), e.Bcc...)
|
||||
if recipients != nil {
|
||||
to = recipients
|
||||
}
|
||||
|
||||
return doSend(ctx, fromDomain, b, to, e.From.EmailAddress, trigger)
|
||||
|
||||
@@ -176,8 +195,7 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
|
||||
invalidErrors := make(map[string]error)
|
||||
|
||||
// 按域名整理
|
||||
toByDomain := map[mxDomain][]*parsemail.User{}
|
||||
mxLookupErrors := map[mxDomain]error{}
|
||||
toByDomain := map[string][]*parsemail.User{}
|
||||
for _, s := range to {
|
||||
address, domain, addressErr := parseRecipientAddress(s)
|
||||
if addressErr != nil {
|
||||
@@ -189,41 +207,7 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
|
||||
log.WithContext(ctx).WithError(addressErr).Error("invalid recipient address")
|
||||
continue
|
||||
}
|
||||
args := []string{address, domain}
|
||||
if len(args) == 2 {
|
||||
if args[1] == consts.TEST_DOMAIN {
|
||||
// 测试使用
|
||||
address := mxDomain{
|
||||
domain: "localhost",
|
||||
mxHost: "127.0.0.1",
|
||||
localTest: true,
|
||||
}
|
||||
toByDomain[address] = append(toByDomain[address], s)
|
||||
} else {
|
||||
//查询dns mx记录
|
||||
mxInfo, lookupErr := net.LookupMX(args[1])
|
||||
address := mxDomain{
|
||||
domain: "smtp." + args[1],
|
||||
mxHost: "smtp." + args[1],
|
||||
}
|
||||
if lookupErr != nil {
|
||||
log.WithContext(ctx).Errorf("%s 域名mx记录查询失败,检查邮箱是否存在!", s.EmailAddress)
|
||||
}
|
||||
if len(mxInfo) > 0 {
|
||||
address = mxDomain{
|
||||
domain: args[1],
|
||||
mxHost: mxInfo[0].Host,
|
||||
}
|
||||
}
|
||||
if lookupErr != nil {
|
||||
mxLookupErrors[address] = lookupErr
|
||||
}
|
||||
toByDomain[address] = append(toByDomain[address], s)
|
||||
}
|
||||
} else {
|
||||
log.WithContext(ctx).Errorf("邮箱地址解析错误! %s", s)
|
||||
continue
|
||||
}
|
||||
toByDomain[domain] = append(toByDomain[domain], s)
|
||||
}
|
||||
|
||||
errEmailAddress := append([]string(nil), invalidAddresses...)
|
||||
@@ -234,14 +218,14 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
|
||||
errMap.Store(address, err)
|
||||
}
|
||||
|
||||
as := async.New(ctx)
|
||||
var workers sync.WaitGroup
|
||||
for domain, tos := range toByDomain {
|
||||
domain := domain
|
||||
tos := tos
|
||||
mxLookupErr := mxLookupErrors[domain]
|
||||
as.WaitProcess(func(p any) {
|
||||
workers.Add(1)
|
||||
go func() {
|
||||
defer workers.Done()
|
||||
recordFailure := func(err error) {
|
||||
err = deliveryFailureCause(mxLookupErr, err)
|
||||
log.WithContext(ctx).Errorf("%v 邮件投递失败%+v", tos, err)
|
||||
|
||||
errEmailAddressMu.Lock()
|
||||
@@ -250,11 +234,16 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
|
||||
}
|
||||
errEmailAddressMu.Unlock()
|
||||
|
||||
errMap.Store(domain.domain, err)
|
||||
errMap.Store(domain, err)
|
||||
}
|
||||
defer func() {
|
||||
if value := recover(); value != nil {
|
||||
recordFailure(&smtp.DeliveryUncertainError{Cause: fmt.Errorf("投递任务异常: %v", value)})
|
||||
}
|
||||
}()
|
||||
|
||||
if allowUnsafeSMTP(domain) {
|
||||
err := smtp.SendMailUnsafe("localhost", domain.mxHost+":25", nil, from, fromDomain, buildAddress(tos), data)
|
||||
if domain == consts.TEST_DOMAIN {
|
||||
err := smtp.SendMailUnsafe("localhost", "127.0.0.1:25", nil, from, fromDomain, buildAddress(tos), data)
|
||||
if err != nil {
|
||||
recordFailure(err)
|
||||
} else {
|
||||
@@ -263,71 +252,26 @@ func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemai
|
||||
return
|
||||
}
|
||||
|
||||
// 优先尝试25端口,starttls方式投递
|
||||
err := smtp.SendMail("", domain.mxHost+":25", nil, from, fromDomain, buildAddress(tos), data)
|
||||
if err == nil {
|
||||
hosts, err := resolveMX(domain, net.DefaultResolver.LookupMX)
|
||||
if err != nil {
|
||||
recordFailure(err)
|
||||
return
|
||||
}
|
||||
err = deliverMX(hosts, func(host, port string) error {
|
||||
address := net.JoinHostPort(host, port)
|
||||
if port == "465" {
|
||||
return smtp.SendMailWithTls(host, address, nil, from, fromDomain, buildAddress(tos), data)
|
||||
}
|
||||
return smtp.SendMail(host, address, nil, from, fromDomain, buildAddress(tos), data)
|
||||
})
|
||||
if err != nil {
|
||||
recordFailure(err)
|
||||
} else {
|
||||
accepted.Add(int64(len(tos)))
|
||||
return
|
||||
}
|
||||
if isCertificateVerificationError(err) {
|
||||
recordFailure(err)
|
||||
return
|
||||
}
|
||||
if isPermanentSMTPResponse(err) {
|
||||
recordFailure(err)
|
||||
return
|
||||
}
|
||||
log.WithContext(ctx).WithFields(log.Fields{
|
||||
"action": "SMTP 邮件投递",
|
||||
"result": "failure",
|
||||
"object": domain.mxHost + ":25",
|
||||
}).Infof("SMTP 25 端口 STARTTLS 投递失败: %s", err.Error())
|
||||
|
||||
// 587 使用 STARTTLS,只有 465 使用隐式 TLS。
|
||||
err = smtp.SendMail(strings.TrimSuffix(domain.mxHost, "."), domain.mxHost+":587", nil, from, fromDomain, buildAddress(tos), data)
|
||||
if err == nil {
|
||||
accepted.Add(int64(len(tos)))
|
||||
return
|
||||
}
|
||||
if isCertificateVerificationError(err) {
|
||||
recordFailure(err)
|
||||
return
|
||||
}
|
||||
if isPermanentSMTPResponse(err) {
|
||||
recordFailure(err)
|
||||
return
|
||||
}
|
||||
log.WithContext(ctx).WithFields(log.Fields{
|
||||
"action": "SMTP 邮件投递",
|
||||
"result": "failure",
|
||||
"object": domain.mxHost + ":587",
|
||||
}).Infof("SMTP 587 端口投递失败: %s", err.Error())
|
||||
|
||||
// 再次尝试465投递
|
||||
err = smtp.SendMailWithTls(strings.TrimSuffix(domain.mxHost, "."), domain.mxHost+":465", nil, from, fromDomain, buildAddress(tos), data)
|
||||
if err == nil {
|
||||
accepted.Add(int64(len(tos)))
|
||||
return
|
||||
}
|
||||
if isCertificateVerificationError(err) {
|
||||
recordFailure(err)
|
||||
return
|
||||
}
|
||||
if isPermanentSMTPResponse(err) {
|
||||
recordFailure(err)
|
||||
return
|
||||
}
|
||||
log.WithContext(ctx).WithFields(log.Fields{
|
||||
"action": "SMTP 邮件投递",
|
||||
"result": "failure",
|
||||
"object": domain.mxHost + ":465",
|
||||
}).Infof("SMTP 465 端口投递失败: %s", err.Error())
|
||||
|
||||
// 所有安全投递方式均失败后记录错误,不允许回退到明文连接。
|
||||
recordFailure(err)
|
||||
}, nil)
|
||||
}()
|
||||
}
|
||||
as.Wait()
|
||||
workers.Wait()
|
||||
|
||||
orgMap := map[string]error{}
|
||||
errMap.Range(func(key, value any) bool {
|
||||
|
||||
@@ -45,6 +45,22 @@ var EOFError = errors.New("EOF")
|
||||
var ErrUnsafeRemoteAddress = errors.New("smtp: remote address is not public")
|
||||
var ErrUnsafePlaintextTarget = errors.New("smtp: plaintext delivery is restricted to localhost")
|
||||
|
||||
// DeliveryUncertainError 表示 DATA 已开始,但未取得明确接收或拒绝响应,禁止自动重投。
|
||||
type DeliveryUncertainError struct {
|
||||
Cause error
|
||||
}
|
||||
|
||||
func (e *DeliveryUncertainError) Error() string {
|
||||
return "投递结果不确定,请核对收件结果后再操作: " + e.Cause.Error()
|
||||
}
|
||||
|
||||
func (e *DeliveryUncertainError) Unwrap() error { return e.Cause }
|
||||
|
||||
func IsDeliveryUncertain(err error) bool {
|
||||
var uncertain *DeliveryUncertainError
|
||||
return errors.As(err, &uncertain)
|
||||
}
|
||||
|
||||
const (
|
||||
outboundSMTPDialTimeout = 2 * time.Second
|
||||
outboundSMTPTLSHandshakeTimeout = 2 * time.Second
|
||||
@@ -554,10 +570,14 @@ func (c *Client) Data() (io.WriteCloser, error) {
|
||||
|
||||
func finishDelivery(c *Client, w io.WriteCloser, msg []byte) error {
|
||||
if _, err := w.Write(msg); err != nil {
|
||||
return err
|
||||
return &DeliveryUncertainError{Cause: err}
|
||||
}
|
||||
if err := w.Close(); err != nil {
|
||||
return err
|
||||
var rejection *textproto.Error
|
||||
if errors.As(err, &rejection) && rejection.Code >= 400 && rejection.Code <= 599 {
|
||||
return err
|
||||
}
|
||||
return &DeliveryUncertainError{Cause: err}
|
||||
}
|
||||
|
||||
// The final 250 response to DATA transfers responsibility for the message.
|
||||
|
||||
@@ -219,6 +219,10 @@ func startSMTPTransactionServer(t *testing.T, dataResponse string, holdWithoutQu
|
||||
done <- fmt.Errorf("message body was not received: %q", body)
|
||||
return
|
||||
}
|
||||
if dataResponse == "" {
|
||||
done <- nil
|
||||
return
|
||||
}
|
||||
if err := text.PrintfLine("%s", dataResponse); err != nil {
|
||||
done <- err
|
||||
return
|
||||
@@ -244,6 +248,17 @@ func startSMTPTransactionServer(t *testing.T, dataResponse string, holdWithoutQu
|
||||
return listener.Addr().String(), done
|
||||
}
|
||||
|
||||
func TestLostFinalDATAResponseIsUncertain(t *testing.T) {
|
||||
addr, done := startSMTPTransactionServer(t, "", false)
|
||||
err := SendMailUnsafe("localhost", addr, nil, "sender@example.com", "example.com", []string{"recipient@example.net"}, []byte("Subject: test\r\n\r\nbody\r\n"))
|
||||
if !IsDeliveryUncertain(err) {
|
||||
t.Fatalf("error=%v, want uncertain delivery", err)
|
||||
}
|
||||
if err := <-done; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func expectSMTPCommand(conn *textproto.Conn, prefix string) error {
|
||||
line, err := conn.ReadLine()
|
||||
if err != nil {
|
||||
|
||||
Reference in new issue
Block a user