func (worker DeliveryWorker) Deliver(job *gobble.Job) {
var typedJob struct {
JobType string
}
err := job.Unmarshal(&typedJob)
if err != nil {
metrics.NewMetric("counter", map[string]interface{}{
"name": "notifications.worker.panic.json",
}).Log()
worker.deliveryFailureHandler.Handle(job, worker.logger)
return
}
switch typedJob.JobType {
case "campaign":
err := worker.strategyDeterminer.Determine(worker.database.Connection(), worker.uaaHost, *job)
if err != nil {
worker.deliveryFailureHandler.Handle(job, worker.logger)
}
case "v2":
var delivery Delivery
job.Unmarshal(&delivery)
err = worker.V2Workflow.Deliver(delivery, worker.logger)
if err != nil {
worker.deliveryFailureHandler.Handle(job, worker.logger)
status := StatusFailed
if job.ShouldRetry {
status = StatusRetry
}
worker.messageStatusUpdater.Update(worker.database.Connection(), delivery.MessageID, status, delivery.CampaignID, worker.logger)
}
default:
worker.V1Process.Deliver(job, worker.logger)
}
}
Message: "notifications.worker.smtp-connection-error",
LogLevel: int(lager.ERROR),
Data: map[string]interface{}{
"session": "1",
"error": "server timeout",
"recipient": "*****@*****.**",
"worker_id": float64(1234),
"message_id": "randomly-generated-guid",
"vcap_request_id": "some-request-id",
},
}))
})
It("updates the message status as unavailable", func() {
var jobDelivery postal.Delivery
err := job.Unmarshal(&jobDelivery)
if err != nil {
panic(err)
}
mailClient.ConnectCall.Returns.Error = errors.New("BOOM!")
messageID := jobDelivery.MessageID
v1Process.Deliver(job, logger)
Expect(messageStatusUpdater.UpdateCall.Receives.Connection).To(Equal(conn))
Expect(messageStatusUpdater.UpdateCall.Receives.MessageID).To(Equal(messageID))
Expect(messageStatusUpdater.UpdateCall.Receives.MessageStatus).To(Equal(postal.StatusUnavailable))
Expect(messageStatusUpdater.UpdateCall.Receives.Logger.SessionName()).To(Equal("notifications.worker"))
})
})
})
func (p V1Process) Deliver(job *gobble.Job, logger lager.Logger) error {
var delivery Delivery
err := job.Unmarshal(&delivery)
if err != nil {
metrics.NewMetric("counter", map[string]interface{}{
"name": "notifications.worker.panic.json",
}).Log()
p.deliveryFailureHandler.Handle(job, logger)
return nil
}
logger = logger.WithData(lager.Data{
"message_id": delivery.MessageID,
"vcap_request_id": delivery.VCAPRequestID,
})
if p.dbTrace {
p.database.TraceOn("", gorpCompatibleLogger{logger})
}
err = p.receiptsRepo.CreateReceipts(p.database.Connection(), []string{delivery.UserGUID}, delivery.ClientID, delivery.Options.KindID)
if err != nil {
p.deliveryFailureHandler.Handle(job, logger)
return nil
}
if delivery.Email == "" {
var token string
token, err = p.tokenLoader.Load(p.uaaHost)
if err != nil {
p.deliveryFailureHandler.Handle(job, logger)
return nil
}
users, err := p.userLoader.Load([]string{delivery.UserGUID}, token)
if err != nil || len(users) < 1 {
p.deliveryFailureHandler.Handle(job, logger)
return nil
}
emails := users[delivery.UserGUID].Emails
if len(emails) > 0 {
delivery.Email = emails[0]
}
}
logger = logger.WithData(lager.Data{
"recipient": delivery.Email,
})
if p.shouldDeliver(delivery, logger) {
status := p.deliver(delivery, logger)
if status != StatusDelivered {
p.deliveryFailureHandler.Handle(job, logger)
return nil
} else {
metrics.NewMetric("counter", map[string]interface{}{
"name": "notifications.worker.delivered",
}).Log()
}
} else {
metrics.NewMetric("counter", map[string]interface{}{
"name": "notifications.worker.unsubscribed",
}).Log()
}
return nil
}
func (d Determiner) Determine(conn services.ConnectionInterface, uaaHost string, job gobble.Job) error {
var campaignJob queue.CampaignJob
err := job.Unmarshal(&campaignJob)
if err != nil {
return err
}
var audience string
for key, _ := range campaignJob.Campaign.SendTo {
audience = key
}
params := notify.NotifyParams{
ReplyTo: campaignJob.Campaign.ReplyTo,
Subject: campaignJob.Campaign.Subject,
Text: campaignJob.Campaign.Text,
RawHTML: campaignJob.Campaign.HTML,
}
if audience == "email" {
params.To = campaignJob.Campaign.SendTo[audience]
}
params.FormatEmailAndExtractHTML()
strategy, err := d.findStrategy(audience)
if err != nil {
return err
}
var guid string
if audience != "email" {
guid = campaignJob.Campaign.SendTo[audience]
}
_, err = strategy.Dispatch(services.Dispatch{
JobType: "v2",
UAAHost: uaaHost,
GUID: guid,
Connection: conn,
TemplateID: campaignJob.Campaign.TemplateID,
CampaignID: campaignJob.Campaign.ID,
Client: services.DispatchClient{
ID: campaignJob.Campaign.ClientID,
},
Message: services.DispatchMessage{
To: params.To,
ReplyTo: params.ReplyTo,
Subject: params.Subject,
Text: params.Text,
HTML: services.HTML{
BodyContent: params.ParsedHTML.BodyContent,
BodyAttributes: params.ParsedHTML.BodyAttributes,
Head: params.ParsedHTML.Head,
Doctype: params.ParsedHTML.Doctype,
},
},
})
if err != nil {
return err
}
return nil
}
