Merge pull request #3725 from ActiveState/CP-1087

Allow configuration of notifications URL

Author: MDrakos

cmd/state-svc/internal/notifications/notifications.go

@@ -11,7 +11,6 @@ import (
 	"github.com/ActiveState/cli/internal/config"
 	"github.com/ActiveState/cli/internal/constants"
 	"github.com/ActiveState/cli/internal/errs"
-	"github.com/ActiveState/cli/internal/fileutils"
 	"github.com/ActiveState/cli/internal/graph"
 	"github.com/ActiveState/cli/internal/httputil"
 	"github.com/ActiveState/cli/internal/logging"
@@ -21,8 +20,14 @@ import (
 	auth "github.com/ActiveState/cli/pkg/platform/authentication"
 	"github.com/ActiveState/cli/pkg/sysinfo"
 	"github.com/blang/semver"
+
+	configMediator "github.com/ActiveState/cli/internal/mediators/config"
 )
 
+func init() {
+	configMediator.RegisterOption(constants.NotificationsURLConfig, configMediator.String, "")
+}
+
 const ConfigKeyLastReport = "notifications.last_reported"
 
 type Notifications struct {
@@ -48,11 +53,11 @@ func New(cfg *config.Instance, auth *auth.Auth) (*Notifications, error) {
 		defer func() {
 			panics.LogAndPanic(recover(), debug.Stack())
 		}()
-		resp, err := fetch()
+		resp, err := fetch(cfg)
 		return resp, err
 	})
 
-	return &Notifications{
+	notifications := &Notifications{
 		baseParams: &ConditionParams{
 			OS:           sysinfo.OS().String(),
 			OSVersion:    NewVersionFromSysinfo(osVersion),
@@ -62,7 +67,20 @@ func New(cfg *config.Instance, auth *auth.Auth) (*Notifications, error) {
 		cfg:  cfg,
 		auth: auth,
 		poll: poll,
-	}, nil
+	}
+
+	configMediator.AddListener(constants.NotificationsURLConfig, func() {
+		notifications.poll.Close()
+		notifications.poll = poller.New(10*time.Minute, func() (interface{}, error) {
+			defer func() {
+				panics.LogAndPanic(recover(), debug.Stack())
+			}()
+			resp, err := fetch(cfg)
+			return resp, err
+		})
+	})
+
+	return notifications, nil
 }
 
 func (m *Notifications) Close() error {
@@ -168,8 +186,7 @@ func check(params *ConditionParams, notifications []*graph.NotificationInfo, las
 		// Check if message is within date range
 		inRange, err := notificationInDateRange(notification, baseTime)
 		if err != nil {
-			logging.Warning("Could not check if notification %s is in date range: %v", notification.ID, err)
-			continue
+			return nil, errs.Wrap(err, "Could not check if notification %s is in date range", notification.ID)
 		}
 		if !inRange {
 			logging.Debug("Skipping notification %s as it is outside of its date range", notification.ID)
@@ -198,17 +215,36 @@ func check(params *ConditionParams, notifications []*graph.NotificationInfo, las
 	return filteredNotifications, nil
 }
 
-func fetch() ([]*graph.NotificationInfo, error) {
+func fetch(cfg *config.Instance) ([]*graph.NotificationInfo, error) {
 	var body []byte
 	var err error
 
-	if v := os.Getenv(constants.NotificationsOverrideEnvVarName); v != "" {
-		body, err = fileutils.ReadFile(v)
+	var (
+		notificationsURL string
+
+		envURL    = os.Getenv(constants.NotificationsOverrideEnvVarName)
+		configURL = cfg.GetString(constants.NotificationsURLConfig)
+	)
+
+	switch {
+	case envURL != "":
+		notificationsURL = envURL
+	case configURL != "":
+		notificationsURL = configURL
+	default:
+		notificationsURL = constants.NotificationsInfoURL
+	}
+
+	logging.Debug("Fetching notifications from %s", notificationsURL)
+	// Check if this is a local file path (when using environment override)
+	if envURL != "" {
+		body, err = os.ReadFile(notificationsURL)
 		if err != nil {
-			return nil, errs.Wrap(err, "Could not read notifications override file")
+			return nil, errs.Wrap(err, "Could not read notifications file")
 		}
 	} else {
-		body, err = httputil.Get(constants.NotificationsInfoURL)
+		// Use HTTP client for remote URLs
+		body, err = httputil.Get(notificationsURL)
 		if err != nil {
 			return nil, errs.Wrap(err, "Could not fetch notifications information")
 		}

cmd/state/main.go

@@ -97,6 +97,7 @@ func main() {
 	// Configuration options
 	// This should only be used if the config option is not exclusive to one package.
 	configMediator.RegisterOption(constants.OptinBuildscriptsConfig, configMediator.Bool, false)
+	configMediator.RegisterOption(constants.NotificationsURLConfig, configMediator.String, "")
 
 	// Set up our output formatter/writer
 	outFlags := parseOutputFlags(os.Args)

internal/constants/constants.go

@@ -418,6 +418,9 @@ const AnalyticsPixelOverrideConfig = "report.analytics.endpoint"
 // UpdateEndpointConfig is the config key used to determine the update endpoint to use
 const UpdateEndpointConfig = "update.endpoint"
 
+// NotificationsURLConfig is the config key used to determine the notifications url to use
+const NotificationsURLConfig = "notifications.endpoint"
+
 // APIHostConfig is the config key used to determine the api host
 const APIHostConfig = "api.host"
 

internal/testhelpers/e2e/session.go

@@ -66,7 +66,6 @@ type Session struct {
 	ignoreLogErrors bool
 	cfg             *config.Instance
 	cache           keyCache
-	cfg             *config.Instance
 }
 
 type keyCache map[string]string

test/integration/notification_int_test.go

@@ -2,6 +2,9 @@ package integration
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
@@ -269,6 +272,91 @@ func (suite *NotificationIntegrationTestSuite) TestNotification_Basic_InterruptE
 	ts.IgnoreLogErrors()
 }
 
+func (suite *NotificationIntegrationTestSuite) TestNotificationEndpoint_SetBeforeInvocation() {
+	suite.OnlyRunForTags(tagsuite.Notifications)
+
+	ts := e2e.New(suite.T(), false)
+	defer ts.Close()
+
+	notificationsURL := "https://test.example.com/notifications"
+	ts.SetConfig(constants.NotificationsURLConfig, notificationsURL)
+	suite.Assert().Equal(ts.GetConfig(constants.NotificationsURLConfig), notificationsURL)
+
+	cp := ts.Spawn("--version")
+	cp.ExpectExitCode(0)
+
+	foundConfigURL := false
+	foundDefaultURL := false
+	logDir := filepath.Join(ts.Dirs.Config, "logs")
+	files, err := os.ReadDir(logDir)
+	suite.Require().NoError(err)
+	for _, file := range files {
+		if strings.Contains(file.Name(), "state-svc") {
+			logPath := filepath.Join(logDir, file.Name())
+			contents := string(fileutils.ReadFileUnsafe(logPath))
+			if strings.Contains(contents, "test.example.com") {
+				foundConfigURL = true
+			}
+			if strings.Contains(contents, "state-tool.s3.amazonaws.com") {
+				foundDefaultURL = true
+			}
+		}
+	}
+	suite.Assert().True(foundConfigURL, "Log file should contain the configured notifications endpoint '%s'", notificationsURL)
+	suite.Assert().False(foundDefaultURL, "Log file should not contain the default notifications endpoint '%s'", constants.NotificationsInfoURL)
+
+	// Clean up - remove the config setting
+	cp = ts.Spawn("config", "set", constants.NotificationsURLConfig, "")
+	cp.Expect("Successfully")
+	cp.ExpectExitCode(0)
+}
+
+func (suite *NotificationIntegrationTestSuite) TestNotificationEndpoint() {
+	suite.OnlyRunForTags(tagsuite.Notifications)
+
+	ts := e2e.New(suite.T(), false)
+	defer ts.Close()
+
+	msgFile, err := fileutils.WriteTempFileToDir(ts.Dirs.Work, "messages.json", []byte(`[{
+		"ID": "config-test",
+		"Message": "This is a [NOTICE]config test[/RESET] notification"
+	}]`), 0755)
+	suite.Require().NoError(err)
+
+	notificationsURL := "https://test.example.com/notifications"
+	cp := ts.Spawn("config", "set", constants.NotificationsURLConfig, notificationsURL)
+	cp.Expect("Successfully set config key")
+	cp.ExpectExitCode(0)
+
+	cp = ts.SpawnWithOpts(
+		e2e.OptArgs("--version"),
+		e2e.OptAppendEnv(constants.NotificationsOverrideEnvVarName+"="+msgFile),
+		e2e.OptAppendEnv("VERBOSE=true"),
+	)
+	cp.ExpectExitCode(0)
+
+	correctHostFound := false
+	incorrectHostFound := false
+	for _, path := range ts.LogFiles() {
+		contents := string(fileutils.ReadFileUnsafe(path))
+		if strings.Contains(contents, notificationsURL) {
+			correctHostFound = true
+			break
+		}
+		if strings.Contains(contents, constants.NotificationsInfoURL) {
+			incorrectHostFound = true
+			break
+		}
+	}
+	suite.Assert().True(correctHostFound, "Log file should contain the configured notifications endpoint 'example.com'")
+	suite.Assert().False(incorrectHostFound, "Log file should not contain the default notifications endpoint 'state-tool.s3.amazonaws.com'")
+
+	// Clean up - remove the config setting
+	cp = ts.Spawn("config", "set", constants.NotificationsURLConfig, "")
+	cp.Expect("Successfully")
+	cp.ExpectExitCode(0)
+}
+
 func TestNotificationIntegrationTestSuite(t *testing.T) {
 	suite.Run(t, new(NotificationIntegrationTestSuite))
 }