[release-4.14] MGMT-16517: Add Env Var Deployment Type & Set ABI

cmd/main.go

@@ -398,6 +398,10 @@ func main() {
 	failOnError(autoMigrationWithLeader(autoMigrationLeader, db, log), "Failed auto migration process")
 
 	Options.UploaderConfig.AssistedServiceVersion = versions.GetRevision()
+	Options.UploaderConfig.Versions = Options.Versions
+	if Options.GeneratorConfig.InstallInvoker == "agent-installer" {
+		Options.UploaderConfig.DeploymentType = "ABI"
+	}
 	uploadClient := uploader.NewClient(&Options.UploaderConfig, db, log, ocpClient)
 
 	hostApi := host.NewManager(log.WithField("pkg", "host-state"), db, notificationStream, eventsHandler, hwValidator,

deploy/assisted-service.yaml

@@ -44,6 +44,8 @@ spec:
               value: "ai-kafka-0.ai-kafka-headless.assisted-installer.svc.cluster.local:9092"
             - name: KAFKA_EVENT_STREAM_TOPIC
               value: "events-stream"
+            - name: DEPLOYMENT_TYPE
+              value: "SaaS"
             - name: DB_HOST
               valueFrom:
                 secretKeyRef:

deploy/podman/configmap-disconnected.yml

@@ -12,6 +12,7 @@ data:
   DB_PORT: "5432"
   DB_USER: admin
   DEPLOY_TARGET: onprem
+  DEPLOYMENT_TYPE: "Podman"
   DISK_ENCRYPTION_SUPPORT: "true"
   DUMMY_IGNITION: "false"
   ENABLE_SINGLE_NODE_DNSMASQ: "true"

deploy/podman/configmap.yml

@@ -12,6 +12,7 @@ data:
   DB_PORT: "5432"
   DB_USER: admin
   DEPLOY_TARGET: onprem
+  DEPLOYMENT_TYPE: "Podman"
   DISK_ENCRYPTION_SUPPORT: "true"
   DUMMY_IGNITION: "false"
   ENABLE_SINGLE_NODE_DNSMASQ: "true"

deploy/podman/configmap_tls.yml

@@ -16,6 +16,7 @@ data:
   DB_PORT: "5432"
   DB_USER: admin
   DEPLOY_TARGET: onprem
+  DEPLOYMENT_TYPE: "Podman"
   DISK_ENCRYPTION_SUPPORT: "true"
   DUMMY_IGNITION: "false"
   ENABLE_SINGLE_NODE_DNSMASQ: "true"

internal/uploader/events_uploader.go

@@ -17,6 +17,7 @@ import (
 	"github.com/openshift/assisted-service/internal/cluster/validations"
 	"github.com/openshift/assisted-service/internal/common"
 	eventsapi "github.com/openshift/assisted-service/internal/events/api"
+	"github.com/openshift/assisted-service/internal/versions"
 	"github.com/openshift/assisted-service/models"
 	"github.com/openshift/assisted-service/pkg/k8sclient"
 	"github.com/pkg/errors"
@@ -39,7 +40,7 @@ func (e *eventsUploader) UploadEvents(ctx context.Context, cluster *common.Clust
 	if err != nil {
 		return errors.Wrapf(err, "failed to get pull secret to upload event data for cluster %s", cluster.ID)
 	}
-	buffer, err := prepareFiles(ctx, e.db, cluster, eventsHandler, pullSecret)
+	buffer, err := prepareFiles(ctx, e.db, cluster, eventsHandler, pullSecret, e.Config)
 	if err != nil {
 		return errors.Wrapf(err, "failed to prepare files to upload for cluster %s", cluster.ID)
 	}
@@ -118,7 +119,8 @@ func (e *eventsUploader) sendRequest(req *http.Request) error {
 	return nil
 }
 
-func prepareFiles(ctx context.Context, db *gorm.DB, cluster *common.Cluster, eventsHandler eventsapi.Handler, pullSecret *validations.PullSecretCreds) (*bytes.Buffer, error) {
+func prepareFiles(ctx context.Context, db *gorm.DB, cluster *common.Cluster, eventsHandler eventsapi.Handler, pullSecret *validations.PullSecretCreds,
+	config Config) (*bytes.Buffer, error) {
 	buffer := &bytes.Buffer{}
 	gz := gzip.NewWriter(buffer)
 	tw := tar.NewWriter(gz)
@@ -148,6 +150,14 @@ func prepareFiles(ctx context.Context, db *gorm.DB, cluster *common.Cluster, eve
 		return nil, errors.Errorf("no event data files created for cluster %s", cluster.ID)
 	}
 
+	// Add versions file to bundle
+	if versionsJson, err := json.Marshal(versions.GetModelVersions(config.Versions)); err == nil {
+		addFile(tw, versionsJson, fmt.Sprintf("%s/versions.json", *cluster.ID)) //nolint:errcheck // errors adding this file shouldn't prevent the data from being sent
+	}
+
+	// Add metadata file to bundle
+	metadataFile(tw, cluster.ID, config)
+
 	// produce tar
 	if err := tw.Close(); err != nil {
 		return nil, errors.Wrap(err, "failed closing tar file")
@@ -159,6 +169,17 @@ func prepareFiles(ctx context.Context, db *gorm.DB, cluster *common.Cluster, eve
 	return buffer, nil
 }
 
+func metadataFile(tw *tar.Writer, clusterID *strfmt.UUID, config Config) {
+	metadata := versions.GetModelVersions(config.Versions)
+	metadata["deployment-type"] = config.DeploymentType
+	metadata["deployment-version"] = config.DeploymentVersion
+	metadata["git-ref"] = config.AssistedServiceVersion
+
+	if metadataJson, err := json.Marshal(metadata); err == nil {
+		addFile(tw, metadataJson, fmt.Sprintf("%s/metadata.json", *clusterID)) //nolint:errcheck // errors adding this file shouldn't prevent the data from being sent
+	}
+}
+
 func eventsFile(ctx context.Context, clusterID *strfmt.UUID, eventsHandler eventsapi.Handler, tw *tar.Writer) error {
 	if eventsHandler == nil {
 		return errors.Errorf("failed to get events for cluster %s, events handler is nil", clusterID)

internal/uploader/events_uploader_test.go

@@ -27,6 +27,7 @@ import (
 	"github.com/openshift/assisted-service/internal/events"
 	eventsapi "github.com/openshift/assisted-service/internal/events/api"
 	"github.com/openshift/assisted-service/internal/events/eventstest"
+	"github.com/openshift/assisted-service/internal/versions"
 	"github.com/openshift/assisted-service/models"
 	"github.com/openshift/assisted-service/pkg/k8sclient"
 	"github.com/pkg/errors"
@@ -150,15 +151,17 @@ var _ = Describe("prepareBody", func() {
 
 var _ = Describe("prepareFiles", func() {
 	var (
-		ctrl       *gomock.Controller
-		ctx        context.Context
-		db         *gorm.DB
-		dbName     string
-		token      string
-		clusterID  strfmt.UUID
-		mockEvents *eventsapi.MockHandler
-		hostID     strfmt.UUID
-		infraEnvID strfmt.UUID
+		ctrl           *gomock.Controller
+		ctx            context.Context
+		db             *gorm.DB
+		dbName         string
+		token          string
+		clusterID      strfmt.UUID
+		mockEvents     *eventsapi.MockHandler
+		hostID         strfmt.UUID
+		infraEnvID     strfmt.UUID
+		cfg            Config
+		serviceVersion versions.Versions
 	)
 
 	BeforeEach(func() {
@@ -170,6 +173,16 @@ var _ = Describe("prepareFiles", func() {
 		infraEnvID = strfmt.UUID(uuid.New().String())
 		hostID = strfmt.UUID(uuid.New().String())
 		token = base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", username, "thePassword")))
+		serviceVersion = versions.Versions{
+			SelfVersion:     "self-version",
+			AgentDockerImg:  "agent-image",
+			InstallerImage:  "installer-image",
+			ControllerImage: "controller-image",
+			ReleaseTag:      "v1.2.3",
+		}
+		cfg = Config{
+			Versions: serviceVersion,
+		}
 	})
 
 	AfterEach(func() {
@@ -182,21 +195,25 @@ var _ = Describe("prepareFiles", func() {
 
 		cluster := createTestObjects(db, &clusterID, &hostID, &infraEnvID)
 		pullSecret := validations.PullSecretCreds{AuthRaw: token, Email: fmt.Sprintf("testemail@%s", emailDomain), Username: username}
-		buf, err := prepareFiles(ctx, db, cluster, mockEvents, &pullSecret)
+		buf, err := prepareFiles(ctx, db, cluster, mockEvents, &pullSecret, cfg)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(buf.Bytes()).NotTo(BeEmpty())
 		testFiles := map[string]*testFile{
 			"cluster":  {expected: true},
 			"infraenv": {expected: true},
 			"hosts":    {expected: true},
 			"events":   {expected: true},
+			"versions": {expected: true},
+			"metadata": {expected: true},
 		}
 
 		readtgzFiles(testFiles, clusterID, buf.Bytes())
 		checkHostsFile(db, testFiles["hosts"], clusterID)
 		checkClusterFile(db, testFiles["cluster"], clusterID, username, emailDomain)
 		checkInfraEnvFile(db, testFiles["infraenv"], infraEnvID)
 		checkEventsFile(testFiles["events"], []string{}, 0)
+		checkVersionsFile(testFiles["versions"], serviceVersion)
+		checkMetadataFile(testFiles["metadata"], cfg)
 	})
 	It("prepares only the event data for the current cluster", func() {
 		clusterID2 := strfmt.UUID(uuid.New().String())
@@ -206,63 +223,75 @@ var _ = Describe("prepareFiles", func() {
 		cluster := createTestObjects(db, &clusterID, &hostID, &infraEnvID)
 		createTestObjects(db, &clusterID2, nil, nil)
 		pullSecret := validations.PullSecretCreds{AuthRaw: token, Email: fmt.Sprintf("testemail@%s", emailDomain), Username: username}
-		buf, err := prepareFiles(ctx, db, cluster, eventsHandler, &pullSecret)
+		buf, err := prepareFiles(ctx, db, cluster, eventsHandler, &pullSecret, cfg)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(buf.Bytes()).NotTo(BeEmpty())
 		testFiles := map[string]*testFile{
 			"cluster":  {expected: true},
 			"infraenv": {expected: true},
 			"hosts":    {expected: true},
 			"events":   {expected: true},
+			"versions": {expected: true},
+			"metadata": {expected: true},
 		}
 
 		readtgzFiles(testFiles, clusterID, buf.Bytes())
 		checkHostsFile(db, testFiles["hosts"], clusterID)
 		checkClusterFile(db, testFiles["cluster"], clusterID, username, emailDomain)
 		checkInfraEnvFile(db, testFiles["infraenv"], infraEnvID)
 		checkEventsFile(testFiles["events"], []string{models.ClusterStatusAddingHosts}, 1)
+		checkVersionsFile(testFiles["versions"], serviceVersion)
+		checkMetadataFile(testFiles["metadata"], cfg)
 	})
 	It("prepares only the cluster, host, and event data when missing infraEnv ID", func() {
 		mockEvents.EXPECT().V2GetEvents(
 			ctx, common.GetDefaultV2GetEventsParams(&clusterID, nil, nil, models.EventCategoryMetrics, models.EventCategoryUser)).Return(&common.V2GetEventsResponse{}, nil).Times(1)
 
 		cluster := createTestObjects(db, &clusterID, &hostID, nil)
 		pullSecret := validations.PullSecretCreds{AuthRaw: token, Email: fmt.Sprintf("testemail@%s", emailDomain), Username: username}
-		buf, err := prepareFiles(ctx, db, cluster, mockEvents, &pullSecret)
+		buf, err := prepareFiles(ctx, db, cluster, mockEvents, &pullSecret, cfg)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(buf.Bytes()).NotTo(BeEmpty())
 		testFiles := map[string]*testFile{
 			"cluster":  {expected: true},
 			"infraenv": {expected: false},
 			"hosts":    {expected: true},
 			"events":   {expected: true},
+			"versions": {expected: true},
+			"metadata": {expected: true},
 		}
 
 		readtgzFiles(testFiles, clusterID, buf.Bytes())
 		checkHostsFile(db, testFiles["hosts"], clusterID)
 		checkClusterFile(db, testFiles["cluster"], clusterID, username, emailDomain)
 		checkInfraEnvFile(db, testFiles["infraenv"], infraEnvID)
 		checkEventsFile(testFiles["events"], []string{}, 0)
+		checkVersionsFile(testFiles["versions"], serviceVersion)
+		checkMetadataFile(testFiles["metadata"], cfg)
 	})
 	It("fails to prepare files when there is no data", func() {
 		mockEvents.EXPECT().V2GetEvents(ctx, common.GetDefaultV2GetEventsParams(nil, nil, nil, models.EventCategoryMetrics, models.EventCategoryUser)).Return(
 			nil, errors.New("no events found")).Times(1)
 		pullSecret := validations.PullSecretCreds{AuthRaw: token, Email: fmt.Sprintf("testemail@%s", emailDomain)}
-		buf, err := prepareFiles(ctx, db, &common.Cluster{}, mockEvents, &pullSecret)
+		buf, err := prepareFiles(ctx, db, &common.Cluster{}, mockEvents, &pullSecret, cfg)
 		Expect(err).To(HaveOccurred())
 		Expect(buf).To(BeNil())
 		testFiles := map[string]*testFile{
 			"cluster":  {expected: false},
 			"infraenv": {expected: false},
 			"hosts":    {expected: false},
 			"events":   {expected: false},
+			"versions": {expected: false},
+			"metadata": {expected: false},
 		}
 
 		readtgzFiles(testFiles, clusterID, nil)
 		checkHostsFile(db, testFiles["hosts"], clusterID)
 		checkClusterFile(db, testFiles["cluster"], clusterID, username, emailDomain)
 		checkInfraEnvFile(db, testFiles["infraenv"], infraEnvID)
 		checkEventsFile(testFiles["events"], []string{}, 0)
+		checkVersionsFile(testFiles["versions"], serviceVersion)
+		checkMetadataFile(testFiles["metadata"], cfg)
 	})
 })
 
@@ -284,6 +313,7 @@ var _ = Describe("UploadEvents", func() {
 		uploader         *eventsUploader
 		dataUploadServer func([]string, int, map[string]*testFile) http.HandlerFunc
 		mockEvents       *eventsapi.MockHandler
+		servicesVersion  versions.Versions
 	)
 
 	BeforeEach(func() {
@@ -296,7 +326,17 @@ var _ = Describe("UploadEvents", func() {
 		infraEnvID = strfmt.UUID(uuid.New().String())
 		hostID = strfmt.UUID(uuid.New().String())
 		token = base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", username, "thePassword")))
-
+		servicesVersion = versions.Versions{
+			SelfVersion:     "self-version",
+			AgentDockerImg:  "agent-image",
+			InstallerImage:  "installer-image",
+			ControllerImage: "controller-image",
+			ReleaseTag:      "v1.2.3",
+		}
+		cfg := Config{
+			AssistedServiceVersion: serviceVersion,
+			Versions:               servicesVersion,
+		}
 		dataUploadServer = func(expectedEvents []string, expectedNumberOfEvents int, testFiles map[string]*testFile) http.HandlerFunc {
 			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 				Expect(r.Method).To(Equal(http.MethodPost))
@@ -320,17 +360,17 @@ var _ = Describe("UploadEvents", func() {
 					checkInfraEnvFile(db, testFiles["infraenv"], infraEnvID)
 					checkHostsFile(db, testFiles["hosts"], clusterID)
 					checkEventsFile(testFiles["events"], expectedEvents, expectedNumberOfEvents)
+					checkVersionsFile(testFiles["versions"], servicesVersion)
+					checkMetadataFile(testFiles["metadata"], cfg)
 				}
 			})
 		}
-		cfg := &Config{
-			AssistedServiceVersion: serviceVersion,
-		}
+
 		uploader = &eventsUploader{
 			db:     db,
 			log:    common.GetTestLog(),
 			client: mockK8sClient,
-			Config: *cfg,
+			Config: cfg,
 		}
 	})
 	AfterEach(func() {
@@ -355,9 +395,12 @@ var _ = Describe("UploadEvents", func() {
 			"hosts":    {expected: true},
 			"infraenv": {expected: true},
 			"events":   {expected: true},
+			"versions": {expected: true},
+			"metadata": {expected: true},
 		}
 		server := httptest.NewServer(dataUploadServer([]string{models.ClusterStatusAddingHosts}, 1, testFiles))
 		uploader.Config.DataUploadEndpoint = fmt.Sprintf("%s/%s", server.URL, "upload/test")
+		uploader.Config.Versions = servicesVersion
 
 		cluster := createTestObjects(db, &clusterID, &hostID, &infraEnvID)
 		err := uploader.UploadEvents(ctx, cluster, mockEvents)
@@ -460,6 +503,10 @@ func readFiles(tr *tar.Reader, testFiles map[string]*testFile, clusterID strfmt.
 			fileName = "cluster"
 		case fmt.Sprintf("%s/events.json", clusterID):
 			fileName = "events"
+		case fmt.Sprintf("%s/versions.json", clusterID):
+			fileName = "versions"
+		case fmt.Sprintf("%s/metadata.json", clusterID):
+			fileName = "metadata"
 		}
 		if fileName != "" {
 			fileContents, err := io.ReadAll(tr)
@@ -554,3 +601,25 @@ func checkEventsFile(eventsFile *testFile, expectedEvents []string, expectedNumb
 		}
 	}
 }
+
+func checkVersionsFile(versionsFile *testFile, expectedVersions versions.Versions) {
+	Expect(versionsFile.expected).To(Equal(versionsFile.exists))
+	if versionsFile.expected {
+		var serviceVersion models.Versions
+		Expect(json.Unmarshal(versionsFile.contents, &serviceVersion)).ShouldNot(HaveOccurred())
+		Expect(serviceVersion).To(BeEquivalentTo(versions.GetModelVersions(expectedVersions)))
+	}
+}
+
+func checkMetadataFile(metadataFile *testFile, cfg Config) {
+	Expect(metadataFile.expected).To(Equal(metadataFile.exists))
+	if metadataFile.expected {
+		var metadataContents models.Versions
+		Expect(json.Unmarshal(metadataFile.contents, &metadataContents)).ShouldNot(HaveOccurred())
+		expectedMetadata := versions.GetModelVersions(cfg.Versions)
+		expectedMetadata["deployment-type"] = cfg.DeploymentType
+		expectedMetadata["deployment-version"] = cfg.DeploymentVersion
+		expectedMetadata["git-ref"] = cfg.AssistedServiceVersion
+		Expect(metadataContents).To(BeEquivalentTo(expectedMetadata))
+	}
+}

internal/uploader/uploader.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/openshift/assisted-service/internal/common"
 	eventsapi "github.com/openshift/assisted-service/internal/events/api"
+	"github.com/openshift/assisted-service/internal/versions"
 	"github.com/openshift/assisted-service/pkg/k8sclient"
 	"github.com/sirupsen/logrus"
 	"gorm.io/gorm"
@@ -17,7 +18,10 @@ type Client interface {
 }
 
 type Config struct {
+	Versions               versions.Versions
 	DataUploadEndpoint     string `envconfig:"DATA_UPLOAD_ENDPOINT" default:"https://console.redhat.com/api/ingress/v1/upload"`
+	DeploymentType         string `envconfig:"DEPLOYMENT_TYPE" default:""`
+	DeploymentVersion      string `envconfig:"DEPLOYMENT_VERSION" default:""`
 	AssistedServiceVersion string
 	EnableDataCollection   bool `envconfig:"ENABLE_DATA_COLLECTION" default:"true"`
 }

openshift/template.yaml

@@ -195,6 +195,8 @@ parameters:
 - name: ENABLE_DATA_COLLECTION
   value: "false"
   required: false
+- name: DEPLOYMENT_TYPE
+  value: "SaaS"
 - name: INSTALLER_CACHE_CAPACITY
   value: "6442450944"
   required: false
@@ -457,6 +459,8 @@ objects:
                 value: ${ENABLE_REJECT_UNKNOWN_FIELDS}
               - name: ENABLE_DATA_COLLECTION
                 value: ${ENABLE_DATA_COLLECTION}
+              - name: DEPLOYMENT_TYPE
+                value: ${DEPLOYMENT_TYPE}
               - name: INSTALLER_CACHE_CAPACITY
                 value: ${INSTALLER_CACHE_CAPACITY}
               - name: ENABLE_OKD_SUPPORT