consolidate care partner alerts pusher configs

The tasks service and data service can both push alerts for care
partners. This change consolidates that configuration into one set of
environment variables loaded via the alerts package.

I wish that alerts didn't need to know about envconfig, but at least
for the moment it's the only way to consolidate the information about
the configuration into a single re-usable struct.

Naming of the pusher in both services is prefixed with "alerts" to
communicate that this pusher is configured for care partner alerts.

BACK-2559

Author: ewollesen

alerts/pusher.go

@@ -0,0 +1,78 @@
+package alerts
+
+import (
+	"context"
+
+	"github.com/kelseyhightower/envconfig"
+
+	"github.com/tidepool-org/platform/devicetokens"
+	"github.com/tidepool-org/platform/errors"
+	"github.com/tidepool-org/platform/push"
+)
+
+// Pusher is a service-agnostic interface for sending push notifications.
+type Pusher interface {
+	// Push a notification to a device.
+	Push(context.Context, *devicetokens.DeviceToken, *push.Notification) error
+}
+
+// ToPushNotification converts Notification to push.Notification.
+func ToPushNotification(notification *Notification) *push.Notification {
+	return &push.Notification{
+		Message: notification.Message,
+	}
+}
+
+type cpaPusherEnvconfig struct {
+	// SigningKey is the raw token signing key received from Apple (.p8 file containing
+	// PEM-encoded private key)
+	//
+	// https://developer.apple.com/documentation/usernotifications/sending-notification-requests-to-apns
+	SigningKey []byte `envconfig:"TIDEPOOL_CARE_PARTNER_ALERTS_APNS_SIGNING_KEY" required:"true"`
+	KeyID      string `envconfig:"TIDEPOOL_CARE_PARTNER_ALERTS_APNS_KEY_ID" required:"true"`
+	BundleID   string `envconfig:"TIDEPOOL_CARE_PARTNER_ALERTS_APNS_BUNDLE_ID" required:"true"`
+	TeamID     string `envconfig:"TIDEPOOL_CARE_PARTNER_ALERTS_APNS_TEAM_ID" required:"true"`
+}
+
+// NewPusher handles the loading of care partner configuration for push notifications.
+func NewPusher() (*push.APNSPusher, error) {
+	config, err := loadPusherViaEnvconfig()
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to care partner pusher config")
+	}
+
+	client, err := push.NewAPNS2Client(config.SigningKey, config.KeyID, config.TeamID)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create care partner pusher client")
+	}
+
+	return push.NewAPNSPusher(client, config.BundleID), nil
+}
+
+func loadPusherViaEnvconfig() (*cpaPusherEnvconfig, error) {
+	c := &cpaPusherEnvconfig{}
+	if err := envconfig.Process("", c); err != nil {
+		return nil, errors.Wrap(err, "Unable to process APNs pusher config")
+	}
+
+	// envconfig's "required" tag won't error on values that are defined but empty, so
+	// manually check
+
+	if len(c.SigningKey) == 0 {
+		return nil, errors.New("Unable to build APNSPusherConfig: APNs signing key is blank")
+	}
+
+	if c.BundleID == "" {
+		return nil, errors.New("Unable to build APNSPusherConfig: bundleID is blank")
+	}
+
+	if c.KeyID == "" {
+		return nil, errors.New("Unable to build APNSPusherConfig: keyID is blank")
+	}
+
+	if c.TeamID == "" {
+		return nil, errors.New("Unable to build APNSPusherConfig: teamID is blank")
+	}
+
+	return c, nil
+}

alerts/pusher_test.go

@@ -0,0 +1,75 @@
+package alerts
+
+import (
+	"os"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("APNSPusher", func() {
+	Describe("NewAPNSPusherFromEnv", func() {
+		It("succeeds", func() {
+			configureEnvconfig()
+			pusher, err := NewPusher()
+			Expect(err).To(Succeed())
+			Expect(pusher).ToNot(Equal(nil))
+		})
+	})
+})
+
+var _ = Describe("LoadAPNSPusherConfigFromEnv", func() {
+	BeforeEach(func() {
+		configureEnvconfig()
+	})
+
+	It("errors if key data is empty or blank", func() {
+		GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_SIGNING_KEY", "")
+		_, err := NewPusher()
+		Expect(err).To(MatchError(ContainSubstring("APNs signing key is blank")))
+
+		os.Unsetenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_SIGNING_KEY")
+		_, err = NewPusher()
+		Expect(err).To(MatchError(ContainSubstring("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_SIGNING_KEY missing value")))
+	})
+
+	It("errors if key data is invalid", func() {
+		GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_SIGNING_KEY", "invalid")
+		_, err := NewPusher()
+		Expect(err).To(MatchError(ContainSubstring("AuthKey must be a valid .p8 PEM file")))
+	})
+
+	It("errors if bundleID is blank", func() {
+		GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_BUNDLE_ID", "")
+		_, err := NewPusher()
+		Expect(err).To(MatchError(ContainSubstring("bundleID is blank")))
+	})
+
+	It("errors if teamID is blank", func() {
+		GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_TEAM_ID", "")
+		_, err := NewPusher()
+		Expect(err).To(MatchError(ContainSubstring("teamID is blank")))
+	})
+
+	It("errors if keyID is blank", func() {
+		GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_KEY_ID", "")
+		_, err := NewPusher()
+		Expect(err).To(MatchError(ContainSubstring("keyID is blank")))
+	})
+})
+
+func configureEnvconfig() {
+	GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_SIGNING_KEY", string(validTestKey))
+	GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_KEY_ID", "key")
+	GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_TEAM_ID", "team")
+	GinkgoT().Setenv("TIDEPOOL_CARE_PARTNER_ALERTS_APNS_BUNDLE_ID", "bundle")
+}
+
+// validTestKey is a random private key for testing
+var validTestKey = []byte(`-----BEGIN PRIVATE KEY-----
+MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDDNrXT9ZRWPUAAg38Qi
+Z553y7sGqOgMxUCG36eCIcRCy1QiTJBgGDxIhWvkE8Sx4N6hZANiAATrsRyRXLa0
+Tgczq8tmFomMP212HdkPF3gFEl/CkqGHUodR2EdZBW1zVcmuLjIN4zvqVVXMJm/U
+eHZz9xAZ95y3irAfkMuOD/Bw88UYvhKnipOHBeS8BwqyfFQ+NRB6xYU=
+-----END PRIVATE KEY-----
+`)

alerts/tasks.go

@@ -6,12 +6,10 @@ import (
 	"time"
 
 	"github.com/tidepool-org/platform/auth"
-	"github.com/tidepool-org/platform/devicetokens"
 	"github.com/tidepool-org/platform/errors"
 	"github.com/tidepool-org/platform/log"
 	"github.com/tidepool-org/platform/permission"
 	"github.com/tidepool-org/platform/pointer"
-	"github.com/tidepool-org/platform/push"
 	"github.com/tidepool-org/platform/task"
 )
 
@@ -202,16 +200,3 @@ func (r *CarePartnerRunner) pushNotifications(ctx context.Context,
 		}
 	}
 }
-
-// Pusher is a service-agnostic interface for sending push notifications.
-type Pusher interface {
-	// Push a notification to a device.
-	Push(context.Context, *devicetokens.DeviceToken, *push.Notification) error
-}
-
-// ToPushNotification converts Notification to push.Notification.
-func ToPushNotification(notification *Notification) *push.Notification {
-	return &push.Notification{
-		Message: notification.Message,
-	}
-}

data/service/service/standard.go

@@ -6,7 +6,6 @@ import (
 	"time"
 
 	"github.com/IBM/sarama"
-	"github.com/kelseyhightower/envconfig"
 
 	eventsCommon "github.com/tidepool-org/go-common/events"
 
@@ -47,7 +46,7 @@ type Standard struct {
 	dataClient                *Client
 	clinicsClient             *clinics.Client
 	dataSourceClient          *dataSourceServiceClient.Client
-	pusher                    dataEvents.Pusher
+	alertsPusher              dataEvents.Pusher
 	userEventsHandler         events.Runner
 	alertsEventsHandler       events.Runner
 	api                       *api.Standard
@@ -95,7 +94,7 @@ func (s *Standard) Initialize(provider application.Provider) error {
 	if err := s.initializeSaramaLogger(); err != nil {
 		return err
 	}
-	if err := s.initializePusher(); err != nil {
+	if err := s.initializeAlertsPusher(); err != nil {
 		return err
 	}
 	if err := s.initializeUserEventsHandler(); err != nil {
@@ -451,27 +450,15 @@ func (s *Standard) initializeSaramaLogger() error {
 	return nil
 }
 
-func (s *Standard) initializePusher() error {
+func (s *Standard) initializeAlertsPusher() error {
 	var err error
-
-	apns2Config := &struct {
-		SigningKey []byte `envconfig:"TIDEPOOL_DATA_SERVICE_PUSHER_APNS_SIGNING_KEY"`
-		KeyID      string `envconfig:"TIDEPOOL_DATA_SERVICE_PUSHER_APNS_KEY_ID"`
-		BundleID   string `envconfig:"TIDEPOOL_DATA_SERVICE_PUSHER_APNS_BUNDLE_ID"`
-		TeamID     string `envconfig:"TIDEPOOL_DATA_SERVICE_PUSHER_APNS_TEAM_ID"`
-	}{}
-	if err := envconfig.Process("", apns2Config); err != nil {
-		return errors.Wrap(err, "Unable to process APNs pusher config")
-	}
-
 	var pusher dataEvents.Pusher
-	pusher, err = push.NewAPNSPusherFromKeyData(apns2Config.SigningKey, apns2Config.KeyID,
-		apns2Config.TeamID, apns2Config.BundleID)
+	pusher, err = alerts.NewPusher()
 	if err != nil {
-		s.Logger().WithError(err).Warn("falling back to logging of push notifications")
+		s.Logger().WithError(err).Warn("falling back to logging of alerts push notifications")
 		pusher = push.NewLogPusher(s.Logger())
 	}
-	s.pusher = pusher
+	s.alertsPusher = pusher
 
 	return nil
 }
@@ -508,7 +495,7 @@ func (s *Standard) initializeAlertsEventsHandler() error {
 		DeviceTokens:       s.AuthClient(),
 		Logger:             s.Logger(),
 		Permissions:        s.PermissionClient(),
-		Pusher:             s.pusher,
+		Pusher:             s.alertsPusher,
 		LastCommunications: dataEvents.NewLastCommunicationRecorder(lastCommunicationsRepo),
 		TokensProvider:     s.AuthClient(),
 	}

push/push.go

@@ -34,53 +34,14 @@ type APNSPusher struct {
 	clientMu sync.Mutex
 }
 
-// NewAPNSPusher creates a Pusher for sending device notifications via Apple's
-// APNs.
+// NewAPNSPusher creates an APNSPusher for sending device notifications via Apple's APNs.
 func NewAPNSPusher(client APNS2Client, bundleID string) *APNSPusher {
 	return &APNSPusher{
 		BundleID: bundleID,
 		client:   client,
 	}
 }
 
-// NewAPNSPusherFromKeyData creates an APNSPusher for sending device
-// notifications via Apple's APNs.
-//
-// The signingKey is the raw token signing key received from Apple (.p8 file
-// containing PEM-encoded private key), along with its respective team id, key
-// id, and application bundle id.
-//
-// https://developer.apple.com/documentation/usernotifications/sending-notification-requests-to-apns
-func NewAPNSPusherFromKeyData(signingKey []byte, keyID, teamID, bundleID string) (*APNSPusher, error) {
-	if len(signingKey) == 0 {
-		return nil, errors.New("Unable to build APNSPusher: APNs signing key is blank")
-	}
-
-	if bundleID == "" {
-		return nil, errors.New("Unable to build APNSPusher: bundleID is blank")
-	}
-
-	if keyID == "" {
-		return nil, errors.New("Unable to build APNSPusher: keyID is blank")
-	}
-
-	if teamID == "" {
-		return nil, errors.New("Unable to build APNSPusher: teamID is blank")
-	}
-
-	authKey, err := token.AuthKeyFromBytes(signingKey)
-	if err != nil {
-		return nil, err
-	}
-	token := &token.Token{
-		AuthKey: authKey,
-		KeyID:   keyID,
-		TeamID:  teamID,
-	}
-	client := &apns2Client{Client: apns2.NewTokenClient(token)}
-	return NewAPNSPusher(client, bundleID), nil
-}
-
 func (p *APNSPusher) Push(ctx context.Context, deviceToken *devicetokens.DeviceToken,
 	notification *Notification) error {
 
@@ -146,6 +107,19 @@ type apns2Client struct {
 	*apns2.Client
 }
 
+func NewAPNS2Client(signingKey []byte, keyID, teamID string) (*apns2Client, error) {
+	authKey, err := token.AuthKeyFromBytes(signingKey)
+	if err != nil {
+		return nil, err
+	}
+	token := &token.Token{
+		AuthKey: authKey,
+		KeyID:   keyID,
+		TeamID:  teamID,
+	}
+	return &apns2Client{apns2.NewTokenClient(token)}, nil
+}
+
 func (c apns2Client) Development() APNS2Client {
 	d := c.Client.Development()
 	return &apns2Client{Client: d}

push/push_test.go

@@ -49,50 +49,6 @@ func testDeps() (context.Context, *APNSPusher, *pushTestDeps) {
 }
 
 var _ = Describe("APNSPusher", func() {
-	Describe("NewAPNSPusherFromKeyData", func() {
-		It("errors if key data is empty or blank", func() {
-			_, err := NewAPNSPusherFromKeyData([]byte(""), "key", "team", "bundle")
-			Expect(err).To(MatchError(ContainSubstring("APNs signing key is blank")))
-
-			_, err = NewAPNSPusherFromKeyData(nil, "key", "team", "bundle")
-			Expect(err).To(MatchError(ContainSubstring("APNs signing key is blank")))
-		})
-
-		It("errors if key data is invalid", func() {
-			_, err := NewAPNSPusherFromKeyData([]byte("foo"), "key", "team", "bundle")
-			Expect(err).To(MatchError(ContainSubstring("AuthKey must be a valid .p8 PEM file")))
-		})
-
-		It("errors if bundleID is blank", func() {
-			_, err := NewAPNSPusherFromKeyData([]byte("hi"), "key", "team", "")
-			Expect(err).To(MatchError(ContainSubstring("bundleID is blank")))
-		})
-
-		It("errors if teamID is blank", func() {
-			_, err := NewAPNSPusherFromKeyData([]byte("hi"), "key", "", "bundle")
-			Expect(err).To(MatchError(ContainSubstring("teamID is blank")))
-		})
-
-		It("errors if keyID is blank", func() {
-			_, err := NewAPNSPusherFromKeyData([]byte("hi"), "", "team", "bundle")
-			Expect(err).To(MatchError(ContainSubstring("keyID is blank")))
-		})
-
-		It("succeeds", func() {
-			// random private key for testing
-			data := []byte(`-----BEGIN PRIVATE KEY-----
-MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDDNrXT9ZRWPUAAg38Qi
-Z553y7sGqOgMxUCG36eCIcRCy1QiTJBgGDxIhWvkE8Sx4N6hZANiAATrsRyRXLa0
-Tgczq8tmFomMP212HdkPF3gFEl/CkqGHUodR2EdZBW1zVcmuLjIN4zvqVVXMJm/U
-eHZz9xAZ95y3irAfkMuOD/Bw88UYvhKnipOHBeS8BwqyfFQ+NRB6xYU=
------END PRIVATE KEY-----
-`)
-			pusher, err := NewAPNSPusherFromKeyData(data, "key", "team", "bundle")
-			Expect(err).To(Succeed())
-			Expect(pusher).ToNot(Equal(nil))
-		})
-	})
-
 	Describe("Push", func() {
 		It("requires an Apple token", func() {
 			ctx, pusher, deps := testDeps()