Esempio n. 1
0
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)
	}
}
Esempio n. 2
0
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
}
Esempio n. 3
0
			ClientID: "some-client",
			UserGUID: userGUID,
			Options: postal.Options{
				Subject:    "the subject",
				Text:       "body content",
				ReplyTo:    "*****@*****.**",
				KindID:     "some-kind",
				TemplateID: "some-template-id",
			},
			MessageID:     messageID,
			VCAPRequestID: "some-request-id",
		}
	})

	Describe("Deliver", func() {
		var job *gobble.Job

		BeforeEach(func() {
			j := gobble.NewJob(delivery)
			job = &j
		})

		It("logs the email address of the recipient", func() {
			v1Process.Deliver(job, logger)

			lines, err := parseLogLines(buffer.Bytes())
			Expect(err).NotTo(HaveOccurred())

			Expect(lines).To(ContainElement(logLine{
				Source:   "notifications",
				Message:  "notifications.worker.delivery-start",
		})

		It("can be halted", func() {
			go func() {
				worker.Halt()
			}()

			Eventually(func() bool {
				worker.Work()
				return true
			}).Should(BeTrue())
		})
	})

	Describe("Deliver", func() {
		var job *gobble.Job
		BeforeEach(func() {
			j := gobble.NewJob(delivery)
			job = &j
		})

		Context("when the job is not a campaign, and not a v2 delivery", func() {
			It("should hand the job to the v1 workflow", func() {
				worker.Deliver(job)

				Expect(v1Workflow.DeliverCall.Receives.Job).To(Equal(job))
				Expect(v1Workflow.DeliverCall.Receives.Logger).ToNot(BeNil())
			})
		})

		Context("when the job is a campaign", func() {
Esempio n. 5
0
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
}