POR-1440 setup app templates for preview envs (#3702)

api/server/handlers/porter_app/create_app_template.go

@@ -0,0 +1,150 @@
+package porter_app
+
+import (
+	"net/http"
+
+	"github.com/google/uuid"
+	"github.com/porter-dev/porter/api/server/handlers"
+	"github.com/porter-dev/porter/api/server/shared"
+	"github.com/porter-dev/porter/api/server/shared/apierrors"
+	"github.com/porter-dev/porter/api/server/shared/config"
+	"github.com/porter-dev/porter/api/server/shared/requestutils"
+	"github.com/porter-dev/porter/api/types"
+	"github.com/porter-dev/porter/internal/models"
+	"github.com/porter-dev/porter/internal/telemetry"
+)
+
+// CreateAppTemplateHandler is the handler for the /app-template endpoint
+type CreateAppTemplateHandler struct {
+	handlers.PorterHandlerReadWriter
+}
+
+// NewCreateAppTemplateHandler handles POST requests to the endpoint /app-template
+func NewCreateAppTemplateHandler(
+	config *config.Config,
+	decoderValidator shared.RequestDecoderValidator,
+	writer shared.ResultWriter,
+) *CreateAppTemplateHandler {
+	return &CreateAppTemplateHandler{
+		PorterHandlerReadWriter: handlers.NewDefaultPorterHandler(config, decoderValidator, writer),
+	}
+}
+
+// CreateAppTemplateRequest is the request object for the /app-template POST endpoint
+type CreateAppTemplateRequest struct {
+	B64AppProto string `json:"b64_app_proto"`
+}
+
+// CreateAppTemplateResponse is the response object for the /app-template POST endpoint
+type CreateAppTemplateResponse struct {
+	AppTemplateID string `json:"app_template_id"`
+}
+
+// ServeHTTP creates or updates an app template for a given porter app
+func (c *CreateAppTemplateHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx, span := telemetry.NewSpan(r.Context(), "serve-create-app-template")
+	defer span.End()
+
+	project, _ := ctx.Value(types.ProjectScope).(*models.Project)
+
+	if !project.GetFeatureFlag(models.ValidateApplyV2, c.Config().LaunchDarklyClient) {
+		err := telemetry.Error(ctx, span, nil, "project does not have validate apply v2 enabled")
+		c.HandleAPIError(w, r, apierrors.NewErrForbidden(err))
+		return
+	}
+
+	appName, reqErr := requestutils.GetURLParamString(r, types.URLParamPorterAppName)
+	if reqErr != nil {
+		e := telemetry.Error(ctx, span, reqErr, "error parsing stack name from url")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(e, http.StatusBadRequest))
+		return
+	}
+
+	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "app-name", Value: appName})
+
+	request := &CreateAppTemplateRequest{}
+	if ok := c.DecodeAndValidate(w, r, request); !ok {
+		err := telemetry.Error(ctx, span, nil, "error decoding request")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+	if request.B64AppProto == "" {
+		err := telemetry.Error(ctx, span, nil, "b64 app proto is empty")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+
+	porterApps, err := c.Repo().PorterApp().ReadPorterAppsByProjectIDAndName(project.ID, appName)
+	if err != nil {
+		err := telemetry.Error(ctx, span, err, "error getting porter app from repo")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+	if len(porterApps) == 0 {
+		err := telemetry.Error(ctx, span, err, "no porter apps returned")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+	if len(porterApps) > 1 {
+		err := telemetry.Error(ctx, span, err, "multiple porter apps returned; unable to determine which one to use")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+
+	if porterApps[0].ID == 0 {
+		err := telemetry.Error(ctx, span, err, "porter app id is missing")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+
+	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "porter-app-id", Value: porterApps[0].ID})
+
+	var appTemplate *models.AppTemplate
+
+	existingAppTemplate, err := c.Repo().AppTemplate().AppTemplateByPorterAppID(
+		project.ID,
+		porterApps[0].ID,
+	)
+	if err != nil {
+		err := telemetry.Error(ctx, span, err, "error checking for existing app template")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+
+	if existingAppTemplate.ID != uuid.Nil {
+		appTemplate = existingAppTemplate
+		telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "update-app-template", Value: true})
+	}
+	if appTemplate == nil {
+		appTemplate = &models.AppTemplate{
+			ProjectID:   int(project.ID),
+			PorterAppID: int(porterApps[0].ID),
+			Base64App:   request.B64AppProto,
+		}
+		telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "update-app-template", Value: false})
+	}
+
+	updatedAppTemplate, err := c.Repo().AppTemplate().CreateAppTemplate(appTemplate)
+	if err != nil {
+		err := telemetry.Error(ctx, span, err, "error creating app template")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+
+	if updatedAppTemplate == nil {
+		err := telemetry.Error(ctx, span, err, "updated app template is nil")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+	if updatedAppTemplate.ID == uuid.Nil {
+		err := telemetry.Error(ctx, span, err, "updated app template id is nil")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+
+	res := &CreateAppTemplateResponse{
+		AppTemplateID: updatedAppTemplate.ID.String(),
+	}
+
+	c.WriteResult(w, r, res)
+}

api/server/handlers/porter_app/get_app_template.go

@@ -0,0 +1,108 @@
+package porter_app
+
+import (
+	"net/http"
+
+	"github.com/google/uuid"
+	"github.com/porter-dev/porter/api/server/handlers"
+	"github.com/porter-dev/porter/api/server/shared"
+	"github.com/porter-dev/porter/api/server/shared/apierrors"
+	"github.com/porter-dev/porter/api/server/shared/config"
+	"github.com/porter-dev/porter/api/server/shared/requestutils"
+	"github.com/porter-dev/porter/api/types"
+	"github.com/porter-dev/porter/internal/models"
+	"github.com/porter-dev/porter/internal/telemetry"
+)
+
+// GetAppTemplateHandler is the handler for the /app-template endpoint
+type GetAppTemplateHandler struct {
+	handlers.PorterHandlerReadWriter
+}
+
+// NewGetAppTemplateHandler handles GET requests to the endpoint /apps/{porter_app_name}/app-template
+func NewGetAppTemplateHandler(
+	config *config.Config,
+	decoderValidator shared.RequestDecoderValidator,
+	writer shared.ResultWriter,
+) *GetAppTemplateHandler {
+	return &GetAppTemplateHandler{
+		PorterHandlerReadWriter: handlers.NewDefaultPorterHandler(config, decoderValidator, writer),
+	}
+}
+
+// GetAppTemplateResponse is the response object for the /apps/{porter_app_name}/app-template GET endpoint
+type GetAppTemplateResponse struct {
+	TemplateB64AppProto string `json:"template_b64_app_proto"`
+}
+
+// ServeHTTP creates or updates an app template for a given porter app
+func (c *GetAppTemplateHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx, span := telemetry.NewSpan(r.Context(), "serve-get-app-template")
+	defer span.End()
+
+	project, _ := ctx.Value(types.ProjectScope).(*models.Project)
+
+	if !project.GetFeatureFlag(models.ValidateApplyV2, c.Config().LaunchDarklyClient) {
+		err := telemetry.Error(ctx, span, nil, "project does not have validate apply v2 enabled")
+		c.HandleAPIError(w, r, apierrors.NewErrForbidden(err))
+		return
+	}
+
+	appName, reqErr := requestutils.GetURLParamString(r, types.URLParamPorterAppName)
+	if reqErr != nil {
+		e := telemetry.Error(ctx, span, reqErr, "error parsing stack name from url")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(e, http.StatusBadRequest))
+		return
+	}
+
+	telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "app-name", Value: appName})
+
+	porterApps, err := c.Repo().PorterApp().ReadPorterAppsByProjectIDAndName(project.ID, appName)
+	if err != nil {
+		err := telemetry.Error(ctx, span, err, "error getting porter app from repo")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+	if len(porterApps) == 0 {
+		err := telemetry.Error(ctx, span, err, "no porter apps returned")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+	if len(porterApps) > 1 {
+		err := telemetry.Error(ctx, span, err, "multiple porter apps returned; unable to determine which one to use")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
+		return
+	}
+
+	if porterApps[0].ID == 0 {
+		err := telemetry.Error(ctx, span, err, "porter app id is missing")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+
+	appTemplate, err := c.Repo().AppTemplate().AppTemplateByPorterAppID(
+		project.ID,
+		porterApps[0].ID,
+	)
+	if err != nil {
+		err := telemetry.Error(ctx, span, err, "error checking for existing app template")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+	if appTemplate == nil {
+		err := telemetry.Error(ctx, span, err, "no app template found")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusNotFound))
+		return
+	}
+	if appTemplate.ID == uuid.Nil {
+		err := telemetry.Error(ctx, span, err, "app template id is missing")
+		c.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
+		return
+	}
+
+	res := &GetAppTemplateResponse{
+		TemplateB64AppProto: appTemplate.Base64App,
+	}
+
+	c.WriteResult(w, r, res)
+}

api/server/router/porter_app.go

@@ -1241,5 +1241,63 @@ func getPorterAppRoutes(
 		Router:   r,
 	})
 
+	// GET /api/projects/{project_id}/clusters/{cluster_id}/apps/{porter_app_name}/app-templates -> porter_app.NewGetAppTemplateHandler
+	getAppTemplateEndpoint := factory.NewAPIEndpoint(
+		&types.APIRequestMetadata{
+			Verb:   types.APIVerbGet,
+			Method: types.HTTPVerbGet,
+			Path: &types.Path{
+				Parent:       basePath,
+				RelativePath: fmt.Sprintf("%s/{%s}/templates", relPathV2, types.URLParamPorterAppName),
+			},
+			Scopes: []types.PermissionScope{
+				types.UserScope,
+				types.ProjectScope,
+				types.ClusterScope,
+			},
+		},
+	)
+
+	getAppTemplateHandler := porter_app.NewGetAppTemplateHandler(
+		config,
+		factory.GetDecoderValidator(),
+		factory.GetResultWriter(),
+	)
+
+	routes = append(routes, &router.Route{
+		Endpoint: getAppTemplateEndpoint,
+		Handler:  getAppTemplateHandler,
+		Router:   r,
+	})
+
+	// POST /api/projects/{project_id}/clusters/{cluster_id}/apps/{porter_app_name}/app-templates -> porter_app.NewCreateAppTemplateHandler
+	createAppTemplateEndpoint := factory.NewAPIEndpoint(
+		&types.APIRequestMetadata{
+			Verb:   types.APIVerbCreate,
+			Method: types.HTTPVerbPost,
+			Path: &types.Path{
+				Parent:       basePath,
+				RelativePath: fmt.Sprintf("%s/{%s}/templates", relPathV2, types.URLParamPorterAppName),
+			},
+			Scopes: []types.PermissionScope{
+				types.UserScope,
+				types.ProjectScope,
+				types.ClusterScope,
+			},
+		},
+	)
+
+	createAppTemplateHandler := porter_app.NewCreateAppTemplateHandler(
+		config,
+		factory.GetDecoderValidator(),
+		factory.GetResultWriter(),
+	)
+
+	routes = append(routes, &router.Route{
+		Endpoint: createAppTemplateEndpoint,
+		Handler:  createAppTemplateHandler,
+		Router:   r,
+	})
+
 	return routes, newPath
 }

internal/models/app_template.go

@@ -0,0 +1,23 @@
+package models
+
+import (
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+// AppTemplate represents a partial spec of a porter app that hydrates the first revision of an app
+type AppTemplate struct {
+	gorm.Model
+
+	// ID is a UUID for the AppRevision
+	ID uuid.UUID `gorm:"type:uuid;primaryKey" json:"id"`
+
+	// Base64App is the PorterApp as json encoded in base64
+	Base64App string `json:"base64_app"`
+
+	// ProjectID is the ID of the project that the template belongs to.
+	ProjectID int `json:"project_id"`
+
+	// PorterAppID is the ID of the PorterApp that the template belongs to.
+	PorterAppID int `json:"porter_app_id"`
+}

internal/repository/app_template.go

@@ -0,0 +1,13 @@
+package repository
+
+import (
+	"github.com/porter-dev/porter/internal/models"
+)
+
+// AppTemplateRepository represents the set of queries on the AppTemplate model
+type AppTemplateRepository interface {
+	// AppTemplateByPorterAppID finds an app template by its porter app id
+	AppTemplateByPorterAppID(projectID, appID uint) (*models.AppTemplate, error)
+	// CreateAppTemplate creates a new app template
+	CreateAppTemplate(appTemplate *models.AppTemplate) (*models.AppTemplate, error)
+}

internal/repository/gorm/app_template.go

@@ -0,0 +1,65 @@
+package gorm
+
+import (
+	"errors"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/porter-dev/porter/internal/models"
+	"github.com/porter-dev/porter/internal/repository"
+	"gorm.io/gorm"
+)
+
+// AppTemplateRepository uses gorm.DB for querying the database
+type AppTemplateRepository struct {
+	db *gorm.DB
+}
+
+// NewAppTemplateRepository returns a AppTemplateRepository which uses
+// gorm.DB for querying the database
+func NewAppTemplateRepository(db *gorm.DB) repository.AppTemplateRepository {
+	return &AppTemplateRepository{db}
+}
+
+// AppTemplateByPorterAppID finds an app template by its porter app id
+func (repo *AppTemplateRepository) AppTemplateByPorterAppID(projectID uint, appID uint) (*models.AppTemplate, error) {
+	appTemplate := &models.AppTemplate{}
+
+	if err := repo.db.Where("project_id = ? AND porter_app_id = ?", projectID, appID).Limit(1).Find(&appTemplate).Error; err != nil {
+		return nil, err
+	}
+
+	return appTemplate, nil
+}
+
+// CreateAppTemplate creates a new app template
+func (repo *AppTemplateRepository) CreateAppTemplate(appTemplate *models.AppTemplate) (*models.AppTemplate, error) {
+	if appTemplate == nil {
+		return nil, errors.New("app template is nil")
+	}
+	if appTemplate.Base64App == "" {
+		return nil, errors.New("app template base64 app is empty")
+	}
+	if appTemplate.ProjectID == 0 {
+		return nil, errors.New("app template project id is empty")
+	}
+	if appTemplate.PorterAppID == 0 {
+		return nil, errors.New("app template porter app id is empty")
+	}
+
+	if appTemplate.ID == uuid.Nil {
+		appTemplate.ID = uuid.New()
+	}
+	if appTemplate.CreatedAt.IsZero() {
+		appTemplate.CreatedAt = time.Now().UTC()
+	}
+	if appTemplate.UpdatedAt.IsZero() {
+		appTemplate.UpdatedAt = time.Now().UTC()
+	}
+
+	if err := repo.db.Create(appTemplate).Error; err != nil {
+		return nil, err
+	}
+
+	return appTemplate, nil
+}

internal/repository/gorm/migrate.go

@@ -64,6 +64,7 @@ func AutoMigrate(db *gorm.DB, debug bool) error {
 		&models.PorterAppEvent{},
 		&models.AppRevision{},
 		&models.DeploymentTarget{},
+		&models.AppTemplate{},
 		&ints.KubeIntegration{},
 		&ints.BasicIntegration{},
 		&ints.OIDCIntegration{},

internal/repository/gorm/repository.go

@@ -54,6 +54,7 @@ type GormRepository struct {
 	porterApp                 repository.PorterAppRepository
 	porterAppEvent            repository.PorterAppEventRepository
 	deploymentTarget          repository.DeploymentTargetRepository
+	appTemplate               repository.AppTemplateRepository
 }
 
 func (t *GormRepository) User() repository.UserRepository {
@@ -245,6 +246,11 @@ func (t *GormRepository) DeploymentTarget() repository.DeploymentTargetRepositor
 	return t.deploymentTarget
 }
 
+// AppTemplate returns the AppTemplateRepository interface implemented by gorm
+func (t *GormRepository) AppTemplate() repository.AppTemplateRepository {
+	return t.appTemplate
+}
+
 // NewRepository returns a Repository which persists users in memory
 // and accepts a parameter that can trigger read/write errors
 func NewRepository(db *gorm.DB, key *[32]byte, storageBackend credentials.CredentialStorage) repository.Repository {
@@ -296,5 +302,6 @@ func NewRepository(db *gorm.DB, key *[32]byte, storageBackend credentials.Creden
 		porterApp:                 NewPorterAppRepository(db),
 		porterAppEvent:            NewPorterAppEventRepository(db),
 		deploymentTarget:          NewDeploymentTargetRepository(db),
+		appTemplate:               NewAppTemplateRepository(db),
 	}
 }

internal/repository/repository.go

@@ -48,4 +48,5 @@ type Repository interface {
 	PorterApp() PorterAppRepository
 	PorterAppEvent() PorterAppEventRepository
 	DeploymentTarget() DeploymentTargetRepository
+	AppTemplate() AppTemplateRepository
 }

internal/repository/test/app_template.go

@@ -0,0 +1,28 @@
+package test
+
+import (
+	"errors"
+
+	"github.com/porter-dev/porter/internal/models"
+	"github.com/porter-dev/porter/internal/repository"
+)
+
+// AppTemplateRepository is a test repository that implements repository.AppTemplateRepository
+type AppTemplateRepository struct {
+	canQuery bool
+}
+
+// NewAppTemplateRepository returns the test AppTemplateRepository
+func NewAppTemplateRepository() repository.AppTemplateRepository {
+	return &AppTemplateRepository{canQuery: false}
+}
+
+// AppTemplateByPorterAppID finds an app template by its porter app id
+func (repo *AppTemplateRepository) AppTemplateByPorterAppID(projectID uint, appID uint) (*models.AppTemplate, error) {
+	return nil, errors.New("cannot read database")
+}
+
+// CreateAppTemplate creates a new app template
+func (repo *AppTemplateRepository) CreateAppTemplate(appTemplate *models.AppTemplate) (*models.AppTemplate, error) {
+	return nil, errors.New("cannot write database")
+}

internal/repository/test/repository.go

@@ -52,6 +52,7 @@ type TestRepository struct {
 	porterApp                 repository.PorterAppRepository
 	porterAppEvent            repository.PorterAppEventRepository
 	deploymentTarget          repository.DeploymentTargetRepository
+	appTemplate               repository.AppTemplateRepository
 }
 
 func (t *TestRepository) User() repository.UserRepository {
@@ -243,6 +244,11 @@ func (t *TestRepository) DeploymentTarget() repository.DeploymentTargetRepositor
 	return t.deploymentTarget
 }
 
+// AppTemplate returns a test AppTemplateRepository
+func (t *TestRepository) AppTemplate() repository.AppTemplateRepository {
+	return t.appTemplate
+}
+
 // NewRepository returns a Repository which persists users in memory
 // and accepts a parameter that can trigger read/write errors
 func NewRepository(canQuery bool, failingMethods ...string) repository.Repository {
@@ -294,5 +300,6 @@ func NewRepository(canQuery bool, failingMethods ...string) repository.Repositor
 		porterApp:                 NewPorterAppRepository(canQuery, failingMethods...),
 		porterAppEvent:            NewPorterAppEventRepository(canQuery),
 		deploymentTarget:          NewDeploymentTargetRepository(),
+		appTemplate:               NewAppTemplateRepository(),
 	}
 }