support v1 endpoints (#4081)

api/server/handlers/porter_app/create.go

@@ -8,6 +8,13 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
+	"time"
+
+	"github.com/porter-dev/api-contracts/generated/go/porter/v1/porterv1connect"
+
+	"connectrpc.com/connect"
+
+	porterv1 "github.com/porter-dev/api-contracts/generated/go/porter/v1"
 
 	"github.com/google/uuid"
 	"github.com/porter-dev/porter/internal/kubernetes"
@@ -54,12 +61,6 @@ func (c *CreatePorterAppHandler) ServeHTTP(w http.ResponseWriter, r *http.Reques
 	ctx, span := telemetry.NewSpan(r.Context(), "serve-create-porter-app")
 	defer span.End()
 
-	if project.GetFeatureFlag(models.ValidateApplyV2, c.Config().LaunchDarklyClient) {
-		err := telemetry.Error(ctx, span, nil, "unable to update app: please upgrade the CLI and try again")
-		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusForbidden))
-		return
-	}
-
 	request := &types.CreatePorterAppRequest{}
 	if ok := c.DecodeAndValidate(w, r, request); !ok {
 		err := telemetry.Error(ctx, span, nil, "error decoding request")
@@ -73,6 +74,72 @@ func (c *CreatePorterAppHandler) ServeHTTP(w http.ResponseWriter, r *http.Reques
 		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
 		return
 	}
+
+	// TODO (POR-2170): Deprecate this entire endpoint in favor of v2 endpoints
+	if project.GetFeatureFlag(models.ValidateApplyV2, c.Config().LaunchDarklyClient) {
+		porterApp, err := c.Repo().PorterApp().ReadPorterAppByName(cluster.ID, appName)
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "porter app not found in cluster")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+			return
+		}
+
+		appInstance, err := appInstanceFromAppName(ctx, appInstanceFromAppNameInput{
+			ProjectID: project.ID,
+			ClusterID: cluster.ID,
+			AppName:   appName,
+			CCPClient: c.Config().ClusterControlPlaneClient,
+		})
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error getting deployment target id from app name")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		updateAppImageReq := connect.NewRequest(&porterv1.UpdateAppImageRequest{
+			ProjectId:     int64(project.ID),
+			AppName:       appName,
+			RepositoryUrl: request.ImageInfo.Repository,
+			Tag:           request.ImageInfo.Tag,
+			DeploymentTargetIdentifier: &porterv1.DeploymentTargetIdentifier{
+				Id: appInstance.DeploymentTargetId,
+			},
+		})
+
+		appImageResp, err := c.Config().ClusterControlPlaneClient.UpdateAppImage(ctx, updateAppImageReq)
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error updating app image")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		if appImageResp == nil || appImageResp.Msg == nil {
+			err := telemetry.Error(ctx, span, errors.New("app image response is nil"), "error updating app image")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		revisionNumber, err := pollForRevisionNumber(ctx, pollForRevisionNumberInput{
+			ProjectID:  project.ID,
+			RevisionID: appImageResp.Msg.RevisionId,
+			CCPClient:  c.Config().ClusterControlPlaneClient,
+		})
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error polling for revision number")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		c.WriteResult(w, r, &types.PorterApp{
+			ID:                 porterApp.ID,
+			ProjectID:          project.ID,
+			ClusterID:          cluster.ID,
+			Name:               appName,
+			HelmRevisionNumber: revisionNumber,
+		})
+		return
+	}
+
 	namespace := utils.NamespaceFromPorterAppName(appName)
 	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "application-name", Value: appName})
 
@@ -513,6 +580,43 @@ func (c *CreatePorterAppHandler) ServeHTTP(w http.ResponseWriter, r *http.Reques
 	}
 }
 
+type pollForRevisionNumberInput struct {
+	ProjectID  uint
+	RevisionID string
+	CCPClient  porterv1connect.ClusterControlPlaneServiceClient
+}
+
+func pollForRevisionNumber(ctx context.Context, input pollForRevisionNumberInput) (int, error) {
+	ctx, span := telemetry.NewSpan(ctx, "poll-for-revision-number")
+	defer span.End()
+
+	startTime := time.Now().UTC()
+
+	for {
+		if time.Now().UTC().After(startTime.Add(2 * time.Minute)) {
+			return 0, telemetry.Error(ctx, span, nil, "timed out waiting for revision number")
+		}
+
+		appRevisionResp, err := input.CCPClient.GetAppRevision(ctx, connect.NewRequest(&porterv1.GetAppRevisionRequest{
+			ProjectId:     int64(input.ProjectID),
+			AppRevisionId: input.RevisionID,
+		}))
+		if err != nil {
+			return 0, telemetry.Error(ctx, span, err, "error getting app revision")
+		}
+
+		if appRevisionResp == nil || appRevisionResp.Msg == nil || appRevisionResp.Msg.AppRevision == nil {
+			return 0, telemetry.Error(ctx, span, err, "app revision resp is nil")
+		}
+
+		if appRevisionResp.Msg.AppRevision.RevisionNumber != 0 {
+			return int(appRevisionResp.Msg.AppRevision.RevisionNumber), nil
+		}
+
+		time.Sleep(2 * time.Second)
+	}
+}
+
 // createOldPorterAppDeployEvent creates an event for use in the activity feed
 // TODO: remove this method and all call-sites if this span no longer exists in telemetry for 4 consecutive weeks
 func createOldPorterAppDeployEvent(ctx context.Context, status types.PorterAppEventStatus, appID uint, revision int, tag string, repo repository.PorterAppEventRepository) (*models.PorterAppEvent, error) {

api/server/handlers/porter_app/helm_release.go

@@ -1,7 +1,17 @@
 package porter_app
 
 import (
+	"context"
+	"fmt"
 	"net/http"
+	"strings"
+
+	"github.com/porter-dev/api-contracts/generated/go/porter/v1/porterv1connect"
+
+	"github.com/stefanmcshane/helm/pkg/release"
+
+	"connectrpc.com/connect"
+	porterv1 "github.com/porter-dev/api-contracts/generated/go/porter/v1"
 
 	"github.com/porter-dev/porter/api/server/authz"
 	"github.com/porter-dev/porter/api/server/handlers"
@@ -32,11 +42,17 @@ func NewPorterAppHelmReleaseGetHandler(
 
 func (c *PorterAppHelmReleaseGetHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
+	project, _ := ctx.Value(types.ProjectScope).(*models.Project)
 	cluster, _ := ctx.Value(types.ClusterScope).(*models.Cluster)
 
 	ctx, span := telemetry.NewSpan(ctx, "serve-get-porter-app-helm-release")
 	defer span.End()
 
+	telemetry.WithAttributes(span,
+		telemetry.AttributeKV{Key: "project-id", Value: project.ID},
+		telemetry.AttributeKV{Key: "cluster-id", Value: cluster.ID},
+	)
+
 	appName, reqErr := requestutils.GetURLParamString(r, types.URLParamPorterAppName)
 	if reqErr != nil {
 		err := telemetry.Error(ctx, span, reqErr, "error getting stack name from url")
@@ -53,6 +69,86 @@ func (c *PorterAppHelmReleaseGetHandler) ServeHTTP(w http.ResponseWriter, r *htt
 	}
 	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "version", Value: version})
 
+	// TODO (POR-2170): Deprecate this entire endpoint in favor of v2 endpoints
+	if project.GetFeatureFlag(models.ValidateApplyV2, c.Config().LaunchDarklyClient) {
+		appInstance, err := appInstanceFromAppName(ctx, appInstanceFromAppNameInput{
+			ProjectID: project.ID,
+			ClusterID: cluster.ID,
+			AppName:   appName,
+			CCPClient: c.Config().ClusterControlPlaneClient,
+		})
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error getting deployment target id from app name")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		// TODO (POR-2170): remove this database call once endpoint is deprecated
+		revision, err := c.Repo().AppRevision().AppRevisionByInstanceIDAndRevisionNumber(project.ID, appInstance.Id, version)
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error getting app revision by instance id and revision number")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		if revision == nil {
+			err := telemetry.Error(ctx, span, err, "app revision is nil")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		appRevisionRequest := connect.NewRequest(&porterv1.GetAppRevisionRequest{
+			ProjectId:     int64(project.ID),
+			AppRevisionId: revision.ID.String(),
+		})
+
+		getAppRevisionResp, err := c.Config().ClusterControlPlaneClient.GetAppRevision(ctx, appRevisionRequest)
+		if err != nil {
+			err := telemetry.Error(ctx, span, err, "error getting current app revision from cluster control plane client")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		if getAppRevisionResp.Msg == nil || getAppRevisionResp.Msg.AppRevision == nil {
+			err := telemetry.Error(ctx, span, err, "app revision is nil")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		appRevision := getAppRevisionResp.Msg.AppRevision
+
+		if appRevision.App == nil || appRevision.App.Image == nil {
+			err := telemetry.Error(ctx, span, err, "app revision app or image is nil")
+			c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+			return
+		}
+
+		res := &types.Release{
+			Release: &release.Release{
+				Name:  "",
+				Info:  nil,
+				Chart: nil,
+				Config: map[string]interface{}{
+					"global": map[string]interface{}{
+						"image": map[string]interface{}{
+							"tag": appRevision.App.Image.Tag,
+						},
+					},
+				},
+				Manifest:  "",
+				Hooks:     nil,
+				Version:   int(appRevision.RevisionNumber),
+				Namespace: "",
+				Labels:    nil,
+			},
+			PorterRelease: nil,
+			Form:          nil,
+		}
+
+		c.WriteResult(w, r, res)
+		return
+	}
+
 	namespace := utils.NamespaceFromPorterAppName(appName)
 	helmAgent, err := c.GetHelmAgent(ctx, r, cluster, namespace)
 	if err != nil {
@@ -73,3 +169,99 @@ func (c *PorterAppHelmReleaseGetHandler) ServeHTTP(w http.ResponseWriter, r *htt
 
 	c.WriteResult(w, r, res)
 }
+
+type appInstanceFromAppNameInput struct {
+	ProjectID uint
+	ClusterID uint
+	AppName   string
+	CCPClient porterv1connect.ClusterControlPlaneServiceClient
+}
+
+// appInstanceFromAppName makes a best-effort attempt to find the app instance for an app name
+// It does this by getting all deployment targets in the cluster, then getting all app instances in the project,
+// then filtering the app instances by app name and non-preview deployment targets. If there is only one matching
+// app instance, then the instance is returned. Otherwise, an error is returned.
+func appInstanceFromAppName(ctx context.Context, input appInstanceFromAppNameInput) (*porterv1.AppInstance, error) {
+	ctx, span := telemetry.NewSpan(ctx, "app-instance-from-app-name")
+	defer span.End()
+
+	var appInstance *porterv1.AppInstance
+
+	telemetry.WithAttributes(span,
+		telemetry.AttributeKV{Key: "project-id", Value: input.ProjectID},
+		telemetry.AttributeKV{Key: "cluster-id", Value: input.ClusterID},
+		telemetry.AttributeKV{Key: "app-name", Value: input.AppName},
+	)
+
+	listDeploymentTargetsReq := connect.NewRequest(&porterv1.DeploymentTargetsRequest{
+		ProjectId: int64(input.ProjectID),
+		ClusterId: int64(input.ClusterID),
+	})
+	listDeploymentTargetsResp, err := input.CCPClient.DeploymentTargets(ctx, listDeploymentTargetsReq)
+	if err != nil {
+		return appInstance, telemetry.Error(ctx, span, err, "error getting deployment targets from cluster control plane client")
+	}
+
+	if listDeploymentTargetsResp.Msg == nil || listDeploymentTargetsResp.Msg.DeploymentTargets == nil {
+		return appInstance, telemetry.Error(ctx, span, nil, "deployment targets response is nil")
+	}
+
+	deploymentTargetSet := map[string]*porterv1.DeploymentTarget{}
+	for _, deploymentTarget := range listDeploymentTargetsResp.Msg.DeploymentTargets {
+		deploymentTargetSet[deploymentTarget.Id] = deploymentTarget
+	}
+
+	listAppInstancesReq := connect.NewRequest(&porterv1.ListAppInstancesRequest{
+		ProjectId: int64(input.ProjectID),
+	})
+	listAppInstancesResp, err := input.CCPClient.ListAppInstances(ctx, listAppInstancesReq)
+	if err != nil {
+		return appInstance, telemetry.Error(ctx, span, err, "error getting app instances from cluster control plane client")
+	}
+
+	if listAppInstancesResp.Msg == nil || listAppInstancesResp.Msg.AppInstances == nil {
+		return appInstance, telemetry.Error(ctx, span, nil, "app instances response is nil")
+	}
+
+	var matchingAppInstances []*porterv1.AppInstance
+
+	for _, instance := range listAppInstancesResp.Msg.AppInstances {
+		if instance == nil {
+			continue
+		}
+		if instance.Name == input.AppName {
+			if deploymentTargetSet[instance.DeploymentTargetId] == nil {
+				continue
+			}
+			if deploymentTargetSet[instance.DeploymentTargetId].IsPreview {
+				continue
+			}
+			matchingAppInstances = append(matchingAppInstances, instance)
+		}
+	}
+
+	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "len-app-instances", Value: len(matchingAppInstances)})
+
+	printInstances := func([]*porterv1.AppInstance) string {
+		var stringInstances []string
+		for _, appInstance := range matchingAppInstances {
+			stringInstances = append(stringInstances, appInstance.String())
+		}
+		return fmt.Sprintf("[%s]", strings.Join(stringInstances, ","))
+	}
+
+	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "app-instances", Value: printInstances(matchingAppInstances)})
+
+	if len(matchingAppInstances) == 0 {
+		return appInstance, telemetry.Error(ctx, span, nil, "no matching app instances found")
+	}
+
+	if len(matchingAppInstances) > 1 {
+		return appInstance, telemetry.Error(ctx, span, nil, "multiple matching app instances found")
+	}
+
+	matchingDeploymentTarget := deploymentTargetSet[matchingAppInstances[0].DeploymentTargetId]
+	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "matching-deployment-target", Value: matchingDeploymentTarget.String()})
+
+	return matchingAppInstances[0], nil
+}

api/server/handlers/porter_app/latest_app_revisions.go

@@ -148,10 +148,16 @@ func (c *LatestAppRevisionsHandler) ServeHTTP(w http.ResponseWriter, r *http.Req
 			deploymentTargets[encodedRevision.DeploymentTarget.ID] = deploymentTarget
 		}
 
+		// TODO: move this filtering to CCP
 		if request.IgnorePreviewApps && deploymentTarget.IsPreview {
 			continue
 		}
 
+		// TODO: move this filtering to CCP
+		if cluster.ID != uint(deploymentTarget.ClusterId) {
+			continue
+		}
+
 		encodedRevision.DeploymentTarget.Name = deploymentTarget.Name
 
 		res.AppRevisions = append(res.AppRevisions, LatestRevisionWithSource{

internal/repository/app_revision.go

@@ -0,0 +1,11 @@
+package repository
+
+import (
+	"github.com/porter-dev/porter/internal/models"
+)
+
+// AppRevisionRepository represents the set of queries on the AppRevision model
+type AppRevisionRepository interface {
+	// AppRevisionByInstanceIDAndRevisionNumber finds an app revision by revision number
+	AppRevisionByInstanceIDAndRevisionNumber(projectID uint, appInstanceId string, revisionNumber uint) (*models.AppRevision, error)
+}

internal/repository/gorm/app_revision.go

@@ -0,0 +1,29 @@
+package gorm
+
+import (
+	"github.com/porter-dev/porter/internal/models"
+	"github.com/porter-dev/porter/internal/repository"
+	"gorm.io/gorm"
+)
+
+// AppRevisionRepository uses gorm.DB for querying the database
+type AppRevisionRepository struct {
+	db *gorm.DB
+}
+
+// NewAppRevisionRepository returns a AppRevisionRepository which uses
+// gorm.DB for querying the database
+func NewAppRevisionRepository(db *gorm.DB) repository.AppRevisionRepository {
+	return &AppRevisionRepository{db}
+}
+
+// AppRevisionByInstanceIDAndRevisionNumber finds an app revision by revision number
+func (repo *AppRevisionRepository) AppRevisionByInstanceIDAndRevisionNumber(projectID uint, instanceId string, revisionNumber uint) (*models.AppRevision, error) {
+	AppRevision := &models.AppRevision{}
+
+	if err := repo.db.Where("project_id = ? AND app_instance_id = ? AND revision_number = ?", projectID, instanceId, revisionNumber).Limit(1).Find(&AppRevision).Error; err != nil {
+		return nil, err
+	}
+
+	return AppRevision, nil
+}

internal/repository/gorm/repository.go

@@ -54,6 +54,7 @@ type GormRepository struct {
 	porterApp                 repository.PorterAppRepository
 	porterAppEvent            repository.PorterAppEventRepository
 	deploymentTarget          repository.DeploymentTargetRepository
+	appRevision               repository.AppRevisionRepository
 	appTemplate               repository.AppTemplateRepository
 	githubWebhook             repository.GithubWebhookRepository
 }
@@ -247,6 +248,11 @@ func (t *GormRepository) DeploymentTarget() repository.DeploymentTargetRepositor
 	return t.deploymentTarget
 }
 
+// AppRevision returns the AppRevisionRepository interface implemented by gorm
+func (t *GormRepository) AppRevision() repository.AppRevisionRepository {
+	return t.appRevision
+}
+
 // AppTemplate returns the AppTemplateRepository interface implemented by gorm
 func (t *GormRepository) AppTemplate() repository.AppTemplateRepository {
 	return t.appTemplate
@@ -308,6 +314,7 @@ func NewRepository(db *gorm.DB, key *[32]byte, storageBackend credentials.Creden
 		porterApp:                 NewPorterAppRepository(db),
 		porterAppEvent:            NewPorterAppEventRepository(db),
 		deploymentTarget:          NewDeploymentTargetRepository(db),
+		appRevision:               NewAppRevisionRepository(db),
 		appTemplate:               NewAppTemplateRepository(db),
 		githubWebhook:             NewGithubWebhookRepository(db),
 	}

internal/repository/repository.go

@@ -48,6 +48,7 @@ type Repository interface {
 	PorterApp() PorterAppRepository
 	PorterAppEvent() PorterAppEventRepository
 	DeploymentTarget() DeploymentTargetRepository
+	AppRevision() AppRevisionRepository
 	AppTemplate() AppTemplateRepository
 	GithubWebhook() GithubWebhookRepository
 }

internal/repository/test/app_revision.go

@@ -0,0 +1,23 @@
+package test
+
+import (
+	"errors"
+
+	"github.com/porter-dev/porter/internal/models"
+	"github.com/porter-dev/porter/internal/repository"
+)
+
+// AppRevisionRepository is a test repository that implements repository.AppRevisionRepository
+type AppRevisionRepository struct {
+	canQuery bool
+}
+
+// NewAppRevisionRepository returns the test AppRevisionRepository
+func NewAppRevisionRepository() repository.AppRevisionRepository {
+	return &AppRevisionRepository{canQuery: false}
+}
+
+// AppRevisionByInstanceIDAndRevisionNumber finds an app revision by revision number
+func (repo *AppRevisionRepository) AppRevisionByInstanceIDAndRevisionNumber(projectID uint, appInstanceId string, revisionNumber uint) (*models.AppRevision, error) {
+	return nil, errors.New("cannot read database")
+}

internal/repository/test/repository.go

@@ -52,6 +52,7 @@ type TestRepository struct {
 	porterApp                 repository.PorterAppRepository
 	porterAppEvent            repository.PorterAppEventRepository
 	deploymentTarget          repository.DeploymentTargetRepository
+	appRevision               repository.AppRevisionRepository
 	appTemplate               repository.AppTemplateRepository
 	githubWebhook             repository.GithubWebhookRepository
 }
@@ -245,6 +246,11 @@ func (t *TestRepository) DeploymentTarget() repository.DeploymentTargetRepositor
 	return t.deploymentTarget
 }
 
+// AppRevision returns a test AppRevisionRepository
+func (t *TestRepository) AppRevision() repository.AppRevisionRepository {
+	return t.appRevision
+}
+
 // AppTemplate returns a test AppTemplateRepository
 func (t *TestRepository) AppTemplate() repository.AppTemplateRepository {
 	return t.appTemplate
@@ -306,6 +312,7 @@ func NewRepository(canQuery bool, failingMethods ...string) repository.Repositor
 		porterApp:                 NewPorterAppRepository(canQuery, failingMethods...),
 		porterAppEvent:            NewPorterAppEventRepository(canQuery),
 		deploymentTarget:          NewDeploymentTargetRepository(),
+		appRevision:               NewAppRevisionRepository(),
 		appTemplate:               NewAppTemplateRepository(),
 		githubWebhook:             NewGithubWebhookRepository(),
 	}