Per sending domain API keys, only supports sendgrid for now (#8)

Author: joeledstrom

cmd/mmailerd/mmailerd.go

@@ -22,6 +22,7 @@ import (
 	"github.com/labstack/echo-contrib/prometheus"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
+	"github.com/modfin/henry/slicez"
 	"github.com/modfin/mmailer"
 	"github.com/modfin/mmailer/internal/config"
 	"github.com/modfin/mmailer/internal/logger"
@@ -202,6 +203,23 @@ func loadServices() {
 		retry = mmailer.RetryNone
 	}
 
+	domainApiKeys := make(map[string][]mmailer.ServiceApiKey)
+
+	for _, k := range config.Get().ServiceDomainApiKeys {
+		parts := strings.Split(k, ":")
+		if len(parts) != 3 {
+			logger.Warn(fmt.Sprintf("couldn't parse row of SERVICE_DOMAIN_API_KEYS, '%s'", k))
+		}
+		key := mmailer.ServiceApiKey{
+			Service: strings.ToLower(parts[0]),
+			ApiKey: mmailer.ApiKey{
+				Domain: strings.ToLower(parts[1]),
+				Key:    parts[2],
+			},
+		}
+		domainApiKeys[key.Service] = append(domainApiKeys[key.Service], key)
+	}
+
 	var services []mmailer.Service
 	logger.Info("Services:")
 	var weighted = strategyName == "weighted"
@@ -235,7 +253,8 @@ func loadServices() {
 
 		posthookUrl := fmt.Sprintf("%s/posthook?key=%s&service=%s", config.Get().PublicURL, config.Get().PosthookKey, strings.ToLower(parts[0]))
 
-		switch strings.ToLower(parts[0]) {
+		service := strings.ToLower(parts[0])
+		switch service {
 		case "mailjet":
 			if len(parts) != 3 {
 				logger.Warn(fmt.Sprintf("mailjet api string is not valid, %s", s))
@@ -252,12 +271,30 @@ func loadServices() {
 			logger.Info(fmt.Sprintf(" - Mandrill: add the following posthook url %s", posthookUrl))
 			services = append(services, decorate(mandrill.New(parts[1])))
 		case "sendgrid":
-			if len(parts) != 2 {
+			if len(parts) < 1 || len(parts) > 2 {
 				logger.Warn("sendgrid api string is not valid,", s)
 				continue
 			}
+			apiKeys := slicez.Map(domainApiKeys[service], func(k mmailer.ServiceApiKey) mmailer.ApiKey {
+				return k.ApiKey
+			})
+			if len(parts) == 2 {
+				apiKeys = append(apiKeys, mmailer.ApiKey{
+					Domain: mmailer.ApiKeyAnyDomain,
+					Key:    parts[1],
+				})
+				logger.Info(" - Sendgrid: key enabled: AnyDomain")
+			}
+			for _, k := range domainApiKeys[service] {
+				logger.Info(fmt.Sprintf(" - Sendgrid: key enabled: %s", k.Domain))
+			}
+			if len(apiKeys) == 0 {
+				logger.Warn(" - Sendgrid: disabled, no api keys provided")
+				continue
+			}
+
 			logger.Info(fmt.Sprintf(" - Sendgrid: add the following posthook url %s", posthookUrl))
-			services = append(services, decorate(sendgrid.New(parts[1])))
+			services = append(services, decorate(sendgrid.New(apiKeys)))
 		case "brev":
 			brev, err := brev.New(parts[1:], posthookUrl)
 			if err != nil {

internal/config/config.go

@@ -1,11 +1,12 @@
 package config
 
 import (
+	"strings"
+	"sync"
+
 	"github.com/caarlos0/env/v6"
 	"github.com/modfin/henry/slicez"
 	"github.com/modfin/mmailer/internal/logger"
-	"strings"
-	"sync"
 )
 
 type AppConfig struct {
@@ -19,8 +20,9 @@ type AppConfig struct {
 
 	FromDomainOverride string `env:"FROM_DOMAIN_OVERRIDE"`
 
-	Services            []string `env:"SERVICES" envSeparator:"\n"`
-	ServiceIpPoolConfig []string `env:"SERVICE_IP_POOL_CONFIG" envSeparator:"\n"`
+	Services             []string `env:"SERVICES" envSeparator:"\n"`
+	ServiceIpPoolConfig  []string `env:"SERVICE_IP_POOL_CONFIG" envSeparator:"\n"`
+	ServiceDomainApiKeys []string `env:"SERVICE_DOMAIN_API_KEYS" envSeparator:"\n"`
 
 	RetryStrategy  string `env:"RETRY_STRATEGY"`
 	SelectStrategy string `env:"SELECT_STRATEGY"`

internal/svc/retry.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+
 	"github.com/modfin/mmailer"
 )
 

mmailer.go

@@ -4,11 +4,13 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/modfin/mmailer/internal/logger"
 	"io/ioutil"
 	"net/http"
 	"strings"
 	"time"
+
+	"github.com/modfin/henry/slicez"
+	"github.com/modfin/mmailer/internal/logger"
 )
 
 type Facade struct {
@@ -26,7 +28,12 @@ func New(selecting SelectStrategy, retry RetryStrategy, services ...Service) *Fa
 }
 
 func (f *Facade) Send(ctx context.Context, email Email, preferredService string) (res []Response, err error) {
-	if len(f.Services) == 0 {
+
+	services := slicez.Filter(f.Services, func(s Service) bool {
+		return s.CanSend(email)
+	})
+
+	if len(services) == 0 {
 		return nil, errors.New("facade no services to use")
 	}
 
@@ -35,7 +42,7 @@ func (f *Facade) Send(ctx context.Context, email Email, preferredService string)
 	// If service is specified
 	if len(preferredService) > 0 {
 		preferredService = strings.ToLower(preferredService)
-		for _, s := range f.Services {
+		for _, s := range services {
 			if s.Name() == preferredService {
 				service = s
 				break
@@ -49,7 +56,7 @@ func (f *Facade) Send(ctx context.Context, email Email, preferredService string)
 		if strategy == nil {
 			strategy = SelectRandom
 		}
-		service = strategy(f.Services)
+		service = strategy(services)
 	}
 
 	if service == nil {
@@ -63,7 +70,7 @@ func (f *Facade) Send(ctx context.Context, email Email, preferredService string)
 
 	ctx = logger.AddToLogContext(ctx, "service", service.Name())
 	logger.InfoCtx(ctx, fmt.Sprintf("Sending mail to %v through %s at [%v]", email.To, service.Name(), time.Now().String()))
-	return retry(ctx, service, email, f.Services)
+	return retry(ctx, service, email, services)
 }
 
 func (f *Facade) UnmarshalPosthook(r *http.Request) (res []Posthook, err error) {

service.go

@@ -2,10 +2,49 @@ package mmailer
 
 import (
 	"context"
+	"net/mail"
+	"strings"
+
+	"github.com/modfin/henry/slicez"
 )
 
 type Service interface {
 	Name() string
+	CanSend(email Email) bool
 	Send(ctx context.Context, email Email) (res []Response, err error)
 	UnmarshalPosthook(body []byte) ([]Posthook, error)
 }
+
+type ServiceApiKey struct {
+	Service string
+	ApiKey
+}
+
+type ApiKey struct {
+	Domain string
+	Key    string
+}
+
+const ApiKeyAnyDomain = ""
+
+func KeyByEmailDomain(apiKeys []ApiKey, emailFrom string) (ApiKey, bool) {
+	domain := ""
+	if from, err := mail.ParseAddress(emailFrom); err == nil {
+		parts := strings.Split(from.Address, "@")
+		if len(parts) == 2 {
+			d := strings.ToLower(strings.TrimSpace(parts[1]))
+			if d != "" {
+				domain = d
+			}
+		}
+	}
+	domainKey, ok := slicez.Find(apiKeys, func(e ApiKey) bool {
+		return domain != "" && e.Domain == domain
+	})
+	if ok {
+		return domainKey, true
+	}
+	return slicez.Find(apiKeys, func(e ApiKey) bool {
+		return e.Domain == ApiKeyAnyDomain
+	})
+}

services/brev/brev.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+
 	"github.com/modfin/brev"
 	"github.com/modfin/mmailer"
 	"github.com/modfin/mmailer/internal/logger"
@@ -57,6 +58,10 @@ func (b *Brev) Name() string {
 	return "brev"
 }
 
+func (*Brev) CanSend(email mmailer.Email) bool {
+	return true // per domain keys not implemented
+}
+
 func (b *Brev) Send(ctx context.Context, m mmailer.Email) (res []mmailer.Response, err error) {
 	if b.client == nil {
 		return nil, errors.New("brev: cant send, missing client")

services/generic/generic.go

@@ -5,15 +5,16 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
+	"net/smtp"
+	"net/url"
+	"os"
+	"strings"
+
 	"github.com/google/uuid"
 	"github.com/modfin/mmailer"
 	"github.com/modfin/mmailer/internal/logger"
 	"github.com/modfin/mmailer/internal/smtpx"
 	"github.com/modfin/mmailer/services"
-	"net/smtp"
-	"net/url"
-	"os"
-	"strings"
 )
 
 // make generic implement mmailer.Service interface by implementing Name and Send methods
@@ -36,6 +37,10 @@ func (g *Generic) Name() string {
 	return fmt.Sprintf("Generic smtp %s", g.smtpUrl.Host)
 }
 
+func (g *Generic) CanSend(email mmailer.Email) bool {
+	return true // per domain keys not implemented
+}
+
 func (g *Generic) Send(ctx context.Context, email mmailer.Email) (res []mmailer.Response, err error) {
 	message := smtpx.NewMessage()
 	for k, v := range email.Headers {

services/mailjet/mailjet.go

@@ -4,10 +4,11 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"strings"
+
 	mj "github.com/mailjet/mailjet-apiv3-go/v3"
 	"github.com/modfin/mmailer"
 	"github.com/modfin/mmailer/services"
-	"strings"
 )
 
 type Mailjet struct {
@@ -71,6 +72,10 @@ func (m *Mailjet) Name() string {
 	return "mailjet"
 }
 
+func (*Mailjet) CanSend(email mmailer.Email) bool {
+	return true // per domain keys not implemented
+}
+
 func (m *Mailjet) Send(_ context.Context, email mmailer.Email) (res []mmailer.Response, err error) {
 	message := mj.InfoMessagesV31{
 		Headers: map[string]interface{}{},

services/mandrill/mandrill.go

@@ -4,13 +4,14 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/keighl/mandrill"
-	"github.com/modfin/mmailer"
-	"github.com/modfin/mmailer/services"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
+
+	"github.com/keighl/mandrill"
+	"github.com/modfin/mmailer"
+	"github.com/modfin/mmailer/services"
 )
 
 type Mandrill struct {
@@ -37,6 +38,10 @@ func (m *Mandrill) Name() string {
 	return "mandrill"
 }
 
+func (*Mandrill) CanSend(email mmailer.Email) bool {
+	return true // per domain keys not implemented
+}
+
 func (m *Mandrill) Send(_ context.Context, email mmailer.Email) (res []mmailer.Response, err error) {
 	message := &mandrill.Message{}
 

services/sendgrid/sendgrid.go

@@ -3,6 +3,7 @@ package sendgrid
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"strings"
 
@@ -16,25 +17,34 @@ import (
 )
 
 type Sendgrid struct {
-	apiKey string
-	confer services.Configurer[*mail.SGMailV3]
+	apiKeys []mmailer.ApiKey
+	confer  services.Configurer[*mail.SGMailV3]
 }
 
-func (m *Sendgrid) newClient() *sendgrid.Client {
-	return sendgrid.NewSendClient(m.apiKey)
+func (m *Sendgrid) newClient(addr string) (*sendgrid.Client, error) {
+	k, ok := mmailer.KeyByEmailDomain(m.apiKeys, addr)
+	if !ok {
+		return nil, errors.New("sendgrid: no api key found for " + addr)
+	}
+	return sendgrid.NewSendClient(k.Key), nil
 }
 
-func New(apiKey string) *Sendgrid {
+func New(apiKeys []mmailer.ApiKey) *Sendgrid {
 	return &Sendgrid{
-		apiKey: apiKey,
-		confer: SendgridConfigurer{},
+		apiKeys: apiKeys,
+		confer:  SendgridConfigurer{},
 	}
 }
 
 func (m *Sendgrid) Name() string {
 	return "sendgrid"
 }
 
+func (m *Sendgrid) CanSend(email mmailer.Email) bool {
+	_, ok := mmailer.KeyByEmailDomain(m.apiKeys, email.From.Email)
+	return ok
+}
+
 func (m *Sendgrid) Send(_ context.Context, email mmailer.Email) (res []mmailer.Response, err error) {
 	from := mail.NewEmail(email.From.Name, email.From.Email)
 
@@ -78,8 +88,11 @@ func (m *Sendgrid) Send(_ context.Context, email mmailer.Email) (res []mmailer.R
 			Address: a.Email,
 		})
 	}
-
-	response, err := m.newClient().Send(message)
+	client, err := m.newClient(email.From.Email)
+	if err != nil {
+		return nil, err
+	}
+	response, err := client.Send(message)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %s", m.Name(), err)
 	}