HMS-5913: add package dates from RHEL lifecycle

Author: rverdile

pkg/cache/cache.go

@@ -28,6 +28,9 @@ type Cache interface {
 
 	GetRoadmapAppstreams(ctx context.Context) ([]byte, error)
 	SetRoadmapAppstreams(ctx context.Context, roadmapAppstreamsResponse []byte)
+
+	GetRoadmapRhelLifecycle(ctx context.Context) ([]byte, error)
+	SetRoadmapRhelLifecycle(ctx context.Context, rhelLifecyleResponse []byte)
 }
 
 func Initialize() Cache {

pkg/cache/cache_mock.go

@@ -64,3 +64,12 @@ func (c *noOpCache) GetRoadmapAppstreams(ctx context.Context) ([]byte, error) {
 // SetRoadmapAppstreams a NoOp version to store cached roadmap appstreams check
 func (c *noOpCache) SetRoadmapAppstreams(ctx context.Context, response []byte) {
 }
+
+// GetRoadmapAppstreams a NoOp version to fetch a cached roadmap rhel lifecycle check
+func (c *noOpCache) GetRoadmapRhelLifecycle(ctx context.Context) ([]byte, error) {
+	return nil, NotFound
+}
+
+// SetRoadmapAppstreams a NoOp version to store cached roadmap rhel lifecycle check
+func (c *noOpCache) SetRoadmapRhelLifecycle(ctx context.Context, response []byte) {
+}

pkg/cache/noop.go

@@ -61,6 +61,11 @@ func roadmapAppstreamsKey(ctx context.Context) string {
 	return fmt.Sprintf("roadmap-appstreams:%v", identity.Identity.OrgID)
 }
 
+func roadmapRhelLifecycleKey(ctx context.Context) string {
+	identity := identity.GetIdentity(ctx)
+	return fmt.Sprintf("roadmap-rhel-lifecycle:%v", identity.Identity.OrgID)
+}
+
 // GetAccessList uses the request context to read user information, and then tries to retrieve the role AccessList from the cache
 func (c *redisCache) GetAccessList(ctx context.Context) (rbac.AccessList, error) {
 	accessList := rbac.AccessList{}
@@ -187,6 +192,20 @@ func (c *redisCache) SetRoadmapAppstreams(ctx context.Context, response []byte)
 	c.client.Set(ctx, key, string(response), config.Get().Clients.Redis.Expiration.SubscriptionCheck)
 }
 
+func (c *redisCache) GetRoadmapRhelLifecycle(ctx context.Context) ([]byte, error) {
+	key := roadmapRhelLifecycleKey(ctx)
+	buf, err := c.get(ctx, key)
+	if err != nil {
+		return nil, fmt.Errorf("redis get error: %w", err)
+	}
+	return buf, nil
+}
+
+func (c *redisCache) SetRoadmapRhelLifecycle(ctx context.Context, response []byte) {
+	key := roadmapRhelLifecycleKey(ctx)
+	c.client.Set(ctx, key, string(response), config.Get().Clients.Redis.Expiration.SubscriptionCheck)
+}
+
 func (c *redisCache) get(ctx context.Context, key string) ([]byte, error) {
 	cmd := c.client.Get(ctx, key)
 	if errors.Is(cmd.Err(), redis.Nil) {

pkg/cache/redis.go

@@ -13,6 +13,8 @@ import (
 
 type RoadmapClient interface {
 	GetAppstreams(ctx context.Context) (AppstreamsResponse, int, error)
+	GetRhelLifecycle(ctx context.Context) (LifecycleResponse, int, error)
+	GetRhelLifecycleForLatestMajorVersions(ctx context.Context) (map[int]LifecycleEntity, error)
 }
 
 type roadmapClient struct {

pkg/clients/roadmap_client/client.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"time"
 
 	"github.com/content-services/content-sources-backend/pkg/api"
 	"github.com/content-services/content-sources-backend/pkg/cache"
@@ -35,6 +36,18 @@ type AppstreamEntity struct {
 	Impl      string `json:"impl"`
 }
 
+type LifecycleResponse struct {
+	Data []LifecycleEntity `json:"data"`
+}
+
+type LifecycleEntity struct {
+	Name  string `json:"name"`
+	Start string `json:"start"`
+	End   string `json:"end"`
+	Major int    `json:"major"`
+	Minor int    `json:"minor"`
+}
+
 func encodedIdentity(ctx context.Context) (string, error) {
 	id := identity.GetIdentity(ctx)
 	jsonIdentity, err := json.Marshal(id)
@@ -107,3 +120,89 @@ func (rc roadmapClient) GetAppstreams(ctx context.Context) (AppstreamsResponse,
 
 	return appStreamResp, statusCode, nil
 }
+
+func (rc roadmapClient) GetRhelLifecycle(ctx context.Context) (LifecycleResponse, int, error) {
+	statusCode := http.StatusInternalServerError
+	server := config.Get().Clients.Roadmap.Server
+	var err error
+	var lifecycleResponse LifecycleResponse
+	var body []byte
+
+	appstreams, err := rc.cache.GetRoadmapRhelLifecycle(ctx)
+	if err != nil && !errors.Is(err, cache.NotFound) {
+		log.Error().Err(err).Msg("GetAppstreams - error reading from cache")
+	}
+	if appstreams != nil {
+		err = json.Unmarshal(appstreams, &lifecycleResponse)
+		if err != nil {
+			return LifecycleResponse{}, statusCode, fmt.Errorf("error during unmarshal response body: %w", err)
+		}
+		return lifecycleResponse, http.StatusOK, nil
+	}
+
+	fullPath := server + "/lifecycle/rhel"
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, fullPath, nil)
+	if err != nil {
+		return LifecycleResponse{}, statusCode, fmt.Errorf("error building request: %w", err)
+	}
+
+	if config.Get().Clients.Roadmap.Username != "" && config.Get().Clients.Roadmap.Password != "" {
+		req.SetBasicAuth(config.Get().Clients.Roadmap.Username, config.Get().Clients.Roadmap.Password)
+	}
+
+	encodedXRHID, err := encodedIdentity(ctx)
+	if err != nil {
+		return LifecycleResponse{}, statusCode, fmt.Errorf("error getting encoded XRHID: %w", err)
+	}
+	req.Header.Set(api.IdentityHeader, encodedXRHID)
+
+	resp, err := rc.client.Do(req)
+	if resp != nil {
+		defer resp.Body.Close()
+
+		body, err = io.ReadAll(resp.Body)
+		if err != nil {
+			return LifecycleResponse{}, statusCode, fmt.Errorf("error reading response body: %w", err)
+		}
+		if resp.StatusCode != 0 {
+			statusCode = resp.StatusCode
+		}
+	}
+	if err != nil {
+		return LifecycleResponse{}, statusCode, fmt.Errorf("error sending request: %w", err)
+	}
+	if statusCode < 200 || statusCode >= 300 {
+		return LifecycleResponse{}, statusCode, fmt.Errorf("unexpected status code with body: %s", string(body))
+	}
+
+	rc.cache.SetRoadmapRhelLifecycle(ctx, body)
+
+	err = json.Unmarshal(body, &lifecycleResponse)
+	if err != nil {
+		return LifecycleResponse{}, statusCode, fmt.Errorf("error during unmarshal response body: %w", err)
+	}
+
+	return lifecycleResponse, statusCode, nil
+}
+
+func (rc roadmapClient) GetRhelLifecycleForLatestMajorVersions(ctx context.Context) (map[int]LifecycleEntity, error) {
+	lifecycleResp, _, err := rc.GetRhelLifecycle(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	currentDate := time.Now().UTC().Truncate(24 * time.Hour)
+	rhelEolMap := make(map[int]LifecycleEntity)
+	for _, item := range lifecycleResp.Data {
+		startDate, err := time.Parse("2006-01-02", item.Start)
+		if err != nil {
+			return nil, err
+		}
+		if startDate.Before(currentDate) || startDate.Equal(currentDate) {
+			if existing, found := rhelEolMap[item.Major]; !found || (item.Minor > existing.Minor) {
+				rhelEolMap[item.Major] = item
+			}
+		}
+	}
+	return rhelEolMap, nil
+}