listmonk/internal/messenger/emailer.go

168 lines
3.5 KiB
Go

package messenger
import (
"crypto/tls"
"fmt"
"math/rand"
"net/smtp"
"net/textproto"
"github.com/jaytaylor/html2text"
"github.com/knadh/smtppool"
)
const emName = "email"
// Server represents an SMTP server's credentials.
type Server struct {
Username string `json:"username"`
Password string `json:"password"`
AuthProtocol string `json:"auth_protocol"`
EmailFormat string `json:"email_format"`
TLSEnabled bool `json:"tls_enabled"`
TLSSkipVerify bool `json:"tls_skip_verify"`
EmailHeaders map[string]string `json:"email_headers"`
// Rest of the options are embedded directly from the smtppool lib.
// The JSON tag is for config unmarshal to work.
smtppool.Opt `json:",squash"`
pool *smtppool.Pool
}
// Emailer is the SMTP e-mail messenger.
type Emailer struct {
servers []*Server
}
// NewEmailer creates and returns an e-mail Messenger backend.
// It takes multiple SMTP configurations.
func NewEmailer(servers ...Server) (*Emailer, error) {
e := &Emailer{
servers: make([]*Server, 0, len(servers)),
}
for _, srv := range servers {
s := srv
var auth smtp.Auth
switch s.AuthProtocol {
case "cram":
auth = smtp.CRAMMD5Auth(s.Username, s.Password)
case "plain":
auth = smtp.PlainAuth("", s.Username, s.Password, s.Host)
case "login":
auth = &smtppool.LoginAuth{Username: s.Username, Password: s.Password}
case "", "none":
default:
return nil, fmt.Errorf("unknown SMTP auth type '%s'", s.AuthProtocol)
}
s.Opt.Auth = auth
// TLS config.
if s.TLSEnabled {
s.TLSConfig = &tls.Config{}
if s.TLSSkipVerify {
s.TLSConfig.InsecureSkipVerify = s.TLSSkipVerify
} else {
s.TLSConfig.ServerName = s.Host
}
}
pool, err := smtppool.New(s.Opt)
if err != nil {
return nil, err
}
s.pool = pool
e.servers = append(e.servers, &s)
}
return e, nil
}
// Name returns the Server's name.
func (e *Emailer) Name() string {
return emName
}
// Push pushes a message to the server.
func (e *Emailer) Push(m Message) error {
// If there are more than one SMTP servers, send to a random
// one from the list.
var (
ln = len(e.servers)
srv *Server
)
if ln > 1 {
srv = e.servers[rand.Intn(ln)]
} else {
srv = e.servers[0]
}
// Are there attachments?
var files []smtppool.Attachment
if m.Attachments != nil {
files = make([]smtppool.Attachment, 0, len(m.Attachments))
for _, f := range m.Attachments {
a := smtppool.Attachment{
Filename: f.Name,
Header: f.Header,
Content: make([]byte, len(f.Content)),
}
copy(a.Content, f.Content)
files = append(files, a)
}
}
mtext, err := html2text.FromString(string(m.Body),
html2text.Options{PrettyTables: true})
if err != nil {
return err
}
em := smtppool.Email{
From: m.From,
To: m.To,
Subject: m.Subject,
Attachments: files,
}
em.Headers = textproto.MIMEHeader{}
// Attach e-mail level headers.
if len(m.Headers) > 0 {
em.Headers = m.Headers
}
// Attach SMTP level headers.
if len(srv.EmailHeaders) > 0 {
for k, v := range srv.EmailHeaders {
em.Headers.Set(k, v)
}
}
switch srv.EmailFormat {
case "html":
em.HTML = m.Body
case "plain":
em.Text = []byte(mtext)
default:
em.HTML = m.Body
em.Text = []byte(mtext)
}
return srv.pool.Send(em)
}
// Flush flushes the message queue to the server.
func (e *Emailer) Flush() error {
return nil
}
// Close closes the SMTP pools.
func (e *Emailer) Close() error {
for _, s := range e.servers {
s.pool.Close()
}
return nil
}