Mirrors/go-inbucket
1
0
Fork 0
mirror of https://github.com/jhillyerd/inbucket.git synced 2025-12-22 20:17:02 +00:00
Code Issues Releases Wiki Activity

extension: BeforeMessageStored event to rewrite envelope (#417)

Browse Source 
* extension: add InboundMessage type
* manager: fires BeforeMessageStored event
* manager: Reacts to BeforeMessageStored event response
* manager: Apply BeforeMessageStored response fields to message

Signed-off-by: James Hillyerd <james@hillyerd.com>
This commit is contained in:
James Hillyerd
2023-11-06 14:53:38 -08:00
committed by GitHub
parent 0cb62af074
commit 01fb161df8
11 changed files with 244 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
pkg/message/manager.go
View File

@@ -69,39 +69,73 @@ func (s *StoreManager) Deliver(
toaddr[i] = &torecip.Address
}
}
subject := header.Get("Subject")
now := time.Now()
tstamp := now.UTC().Format(recvdTimeFmt)
// Deliver to mailboxes.
for _, recip := range recipients {
if recip.ShouldStore() {
// Append recipient and timestamp to generated Recieved header.
recvd := fmt.Sprintf("%s for <%s>; %s\r\n", recvdHeader, recip.Address.Address, tstamp)
// Process inbound message through extensions.
mailboxes := make([]string, len(recipients))
toAddrs := make([]mail.Address, len(recipients))
for i, recip := range recipients {
mailboxes[i] = recip.Mailbox
toAddrs[i] = recip.Address
}
// Deliver message.
logger.Debug().Str("mailbox", recip.Mailbox).Msg("Delivering message")
delivery := &Delivery{
Meta: event.MessageMetadata{
Mailbox: recip.Mailbox,
From: fromaddr[0],
To: toaddr,
Date: now,
Subject: header.Get("Subject"),
},
Reader: io.MultiReader(strings.NewReader(recvd), bytes.NewReader(source)),
}
id, err := s.Store.AddMessage(delivery)
if err != nil {
logger.Error().Str("mailbox", recip.Mailbox).Err(err).Msg("Delivery failed")
return err
}
inbound := &event.InboundMessage{
Mailboxes: mailboxes,
From: *fromaddr[0],
To: toAddrs,
Subject: subject,
Size: int64(len(source)),
}
// Emit message stored event.
event := delivery.Meta
event.ID = id
s.ExtHost.Events.AfterMessageStored.Emit(&event)
extResult := s.ExtHost.Events.BeforeMessageStored.Emit(inbound)
if extResult == nil {
// Use address policy to determine deliverable mailboxes.
mailboxes = mailboxes[:0]
for _, recip := range recipients {
if recip.ShouldStore() {
mailboxes = append(mailboxes, recip.Mailbox)
}
}
inbound.Mailboxes = mailboxes
} else {
// Event response overrides destination mailboxes and address policy.
inbound = extResult
toaddr = make([]*mail.Address, len(inbound.To))
for i := range inbound.To {
toaddr[i] = &inbound.To[i]
}
}
// Deliver to mailboxes.
for _, mb := range inbound.Mailboxes {
// Append recipient and timestamp to generated Recieved header.
recvd := fmt.Sprintf("%s for <%s>; %s\r\n", recvdHeader, mb, tstamp)
// Deliver message.
logger.Debug().Str("mailbox", mb).Msg("Delivering message")
delivery := &Delivery{
Meta: event.MessageMetadata{
Mailbox: mb,
From: &inbound.From,
To: toaddr,
Date: now,
Subject: inbound.Subject,
},
Reader: io.MultiReader(strings.NewReader(recvd), bytes.NewReader(source)),
}
id, err := s.Store.AddMessage(delivery)
if err != nil {
logger.Error().Str("mailbox", mb).Err(err).Msg("Delivery failed")
return err
}
// Emit message stored event.
event := delivery.Meta
event.ID = id
s.ExtHost.Events.AfterMessageStored.Emit(&event)
}
return nil

168
pkg/message/manager_test.go
View File

@@ -1,10 +1,12 @@
package message_test
import (
"net/mail"
"testing"
"github.com/inbucket/inbucket/v3/pkg/config"
"github.com/inbucket/inbucket/v3/pkg/extension"
"github.com/inbucket/inbucket/v3/pkg/extension/event"
"github.com/inbucket/inbucket/v3/pkg/message"
"github.com/inbucket/inbucket/v3/pkg/policy"
"github.com/inbucket/inbucket/v3/pkg/test"
@@ -48,16 +50,140 @@ func TestDeliverRespectsRecipientPolicy(t *testing.T) {
t.Fatal(err)
}
// Expect empty mailbox for nostore domain.
assertMessageCount(t, sm, "u1@nostore.com", 0)
assertMessageCount(t, sm, "u2@example.com", 1)
}
func TestDeliverEmitsBeforeMessageStoredEvent(t *testing.T) {
sm, extHost := testStoreManager()
// Register function to receive event.
var got *event.InboundMessage
extHost.Events.BeforeMessageStored.AddListener(
"test",
func(msg event.InboundMessage) *event.InboundMessage {
got = &msg
return nil
})
// Deliver a message to trigger event.
origin, _ := sm.AddrPolicy.ParseOrigin("from@example.com")
recip1, _ := sm.AddrPolicy.NewRecipient("u1@example.com")
recip2, _ := sm.AddrPolicy.NewRecipient("u2@example.com")
if err := sm.Deliver(
origin,
[]*policy.Recipient{recip1, recip2},
"Received: xyz\n",
[]byte("From: from@example.com\nSubject: tsub\n\ntest email"),
); err != nil {
t.Fatal(err)
}
require.NotNil(t, got, "BeforeMessageStored listener did not receive InboundMessage")
assert.Equal(t, []string{"u1@example.com", "u2@example.com"}, got.Mailboxes, "Mailboxes not equal")
assert.Equal(t, mail.Address{Name: "", Address: "from@example.com"}, got.From, "From not equal")
assert.Equal(t, []mail.Address{
{Name: "", Address: "u1@example.com"},
{Name: "", Address: "u2@example.com"},
}, got.To, "To not equal")
assert.Equal(t, "tsub", got.Subject, "Subject not equal")
assert.Equal(t, int64(48), got.Size, "Size not equal")
}
func TestDeliverUsesBeforeMessageStoredEventResponseMailboxes(t *testing.T) {
sm, extHost := testStoreManager()
// Register function to receive event.
extHost.Events.BeforeMessageStored.AddListener(
"test",
func(msg event.InboundMessage) *event.InboundMessage {
// Listener rewrites destination mailboxes.
resp := msg
resp.Mailboxes = []string{"new1@example.com", "new2@nostore.com"}
return &resp
})
// Deliver a message to trigger event.
origin, _ := sm.AddrPolicy.ParseOrigin("from@example.com")
recip1, _ := sm.AddrPolicy.NewRecipient("u1@example.com")
recip2, _ := sm.AddrPolicy.NewRecipient("u2@example.com")
if err := sm.Deliver(
origin,
[]*policy.Recipient{recip1, recip2},
"Received: xyz\r\n",
[]byte("From: from@example.com\nSubject: tsub\n\ntest email"),
); err != nil {
t.Fatal(err)
}
// Expect messages in only the mailboxes in the event response, and for the DiscardDomains
// policy to be ignored.
assertMessageCount(t, sm, "u1@example.com", 0)
assertMessageCount(t, sm, "u2@example.com", 0)
assertMessageCount(t, sm, "new1@example.com", 1)
assertMessageCount(t, sm, "new2@nostore.com", 1)
}
func TestDeliverUsesBeforeMessageStoredEventResponseFields(t *testing.T) {
sm, extHost := testStoreManager()
// Register function to receive event.
extHost.Events.BeforeMessageStored.AddListener(
"test",
func(msg event.InboundMessage) *event.InboundMessage {
// Listener rewrites destination mailboxes.
msg.Subject = "event subj"
msg.From = mail.Address{Address: "from@event.com", Name: "From Event"}
// Changing To does not affect destination mailbox(es).
msg.To = []mail.Address{
{Address: "to@event.com", Name: "To Event"},
{Address: "to2@event.com", Name: "To 2 Event"},
}
// Size is read only, should have no effect.
msg.Size = 12345
return &msg
})
// Deliver a message to trigger event.
origin, _ := sm.AddrPolicy.ParseOrigin("from@example.com")
recip1, _ := sm.AddrPolicy.NewRecipient("u1@example.com")
if err := sm.Deliver(
origin,
[]*policy.Recipient{recip1},
"Received: xyz\r\n",
[]byte("From: from@example.com\nSubject: tsub\n\ntest email"),
); err != nil {
t.Fatal(err)
}
// Verify single message stored.
metadata, err := sm.GetMetadata("u1@example.com")
require.NoError(t, err)
require.Len(t, metadata, 1, "mailbox has incorrect # of messages")
got := metadata[0]
// Verify metadata fields were overridden by event response values.
assert.Equal(t, "event subj", got.Subject, "Subject didn't match")
assert.Equal(t, "from@event.com", got.From.Address, "From Address didn't match")
assert.Equal(t, "From Event", got.From.Name, "From Name didn't match")
require.Len(t, got.To, 2)
assert.Equal(t, "to@event.com", got.To[0].Address, "To Address didn't match")
assert.Equal(t, "To Event", got.To[0].Name, "To Name didn't match")
assert.Equal(t, "to2@event.com", got.To[1].Address, "To Address didn't match")
assert.Equal(t, "To 2 Event", got.To[1].Name, "To Name didn't match")
assert.NotEqual(t, 12345, got.Size, "Size is read only")
}
func TestDeliverEmitsAfterMessageStoredEvent(t *testing.T) {
sm, extHost := testStoreManager()
listener := extHost.Events.AfterMessageStored.AsyncTestListener("manager", 1)
// Attempt to deliver a message to generate event.
// Deliver a message to trigger event.
origin, _ := sm.AddrPolicy.ParseOrigin("from@example.com")
recip, _ := sm.AddrPolicy.NewRecipient("to@example.com")
if err := sm.Deliver(
@@ -75,6 +201,46 @@ func TestDeliverEmitsAfterMessageStoredEvent(t *testing.T) {
assertMessageCount(t, sm, "to@example.com", 1)
}
func TestDeliverBeforeAndAfterMessageStoredEvents(t *testing.T) {
sm, extHost := testStoreManager()
// Register function to receive Before event.
extHost.Events.BeforeMessageStored.AddListener(
"test",
func(msg event.InboundMessage) *event.InboundMessage {
// Listener rewrites destination mailboxes.
resp := msg
resp.Mailboxes = []string{"new1@example.com", "new2@example.com"}
return &resp
})
// After event listener.
listener := extHost.Events.AfterMessageStored.AsyncTestListener("manager", 2)
// Deliver a message to trigger events.
origin, _ := sm.AddrPolicy.ParseOrigin("from@example.com")
recip1, _ := sm.AddrPolicy.NewRecipient("u1@example.com")
recip2, _ := sm.AddrPolicy.NewRecipient("u2@example.com")
if err := sm.Deliver(
origin,
[]*policy.Recipient{recip1, recip2},
"Received: xyz\r\n",
[]byte("From: from@example.com\nSubject: tsub\n\ntest email"),
); err != nil {
t.Fatal(err)
}
// Confirm mailbox names overriden by Before were sent to After event. Order is
// not guaranteed.
got1, err := listener()
require.NoError(t, err)
got2, err := listener()
require.NoError(t, err)
got := []string{got1.Mailbox, got2.Mailbox}
assert.Contains(t, got, "new1@example.com")
assert.Contains(t, got, "new2@example.com")
}
// Returns an empty StoreManager and extension Host pair, configured for testing.
func testStoreManager() (*message.StoreManager, *extension.Host) {
extHost := extension.NewHost()