Merge pull request #2333 from porter-dev/staging

Metrics fixes + more instance types -> production

api/client/registry.go

@@ -27,7 +27,7 @@ func (c *Client) CreateRegistry(
 	return resp, err
 }
 
-// CreateRegistry creates a new registry integration
+// CreateHelmRepo creates a new helm repo in the project
 func (c *Client) CreateHelmRepo(
 	ctx context.Context,
 	projectID uint,
@@ -47,6 +47,40 @@ func (c *Client) CreateHelmRepo(
 	return resp, err
 }
 
+// ListHelmRepos list helm repos in the project
+func (c *Client) ListHelmRepos(
+	ctx context.Context,
+	projectID uint,
+) ([]*types.HelmRepo, error) {
+	var resp []*types.HelmRepo
+
+	err := c.getRequest(
+		fmt.Sprintf(
+			"/projects/%d/helmrepos",
+			projectID,
+		),
+		nil,
+		&resp,
+	)
+
+	return resp, err
+}
+
+// DeleteHelmRepo deletes a helm repo from the project
+func (c *Client) DeleteHelmRepo(
+	ctx context.Context,
+	projectID, helmRepoID uint,
+) error {
+	return c.deleteRequest(
+		fmt.Sprintf(
+			"/projects/%d/helmrepos/%d",
+			projectID, helmRepoID,
+		),
+		nil,
+		nil,
+	)
+}
+
 // ListRegistries returns a list of registries for a project
 func (c *Client) ListRegistries(
 	ctx context.Context,

api/server/handlers/helmrepo/delete.go

@@ -0,0 +1,78 @@
+package helmrepo
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	"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"
+	"gorm.io/gorm"
+)
+
+type HelmRepoDeleteHandler struct {
+	handlers.PorterHandlerReadWriter
+}
+
+func NewHelmRepoDeleteHandler(
+	config *config.Config,
+	decoderValidator shared.RequestDecoderValidator,
+	writer shared.ResultWriter,
+) *HelmRepoDeleteHandler {
+	return &HelmRepoDeleteHandler{
+		PorterHandlerReadWriter: handlers.NewDefaultPorterHandler(config, decoderValidator, writer),
+	}
+}
+
+func (p *HelmRepoDeleteHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	proj, _ := r.Context().Value(types.ProjectScope).(*models.Project)
+
+	helmRepoID, reqErr := requestutils.GetURLParamUint(r, "helm_repo_id")
+
+	if reqErr != nil {
+		p.HandleAPIError(w, r, reqErr)
+		return
+	}
+
+	helmRepo, err := p.Repo().HelmRepo().ReadHelmRepo(proj.ID, helmRepoID)
+
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			p.HandleAPIError(w, r, apierrors.NewErrNotFound(fmt.Errorf("no such helm repo")))
+			return
+		}
+
+		p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+		return
+	}
+
+	if helmRepo.BasicAuthIntegrationID != 0 {
+		basicAuthInt, err := p.Repo().BasicIntegration().ReadBasicIntegration(proj.ID, helmRepo.BasicAuthIntegrationID)
+
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+			return
+		} else if err == nil {
+			_, err = p.Repo().BasicIntegration().DeleteBasicIntegration(basicAuthInt)
+
+			if err != nil {
+				p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+				return
+			}
+		}
+	}
+
+	err = p.Repo().HelmRepo().DeleteHelmRepo(helmRepo)
+
+	if err != nil {
+		p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+		return
+	}
+
+	p.WriteResult(w, r, helmRepo.ToHelmRepoType())
+}

api/server/handlers/infra/forms.go

@@ -396,6 +396,10 @@ tabs:
           value: t3.xlarge
         - label: t3.2xlarge
           value: t3.2xlarge
+        - label: c6i.large
+          value: c6i.large
+        - label: c6i.xlarge
+          value: c6i.xlarge
         - label: c6i.2xlarge
           value: c6i.2xlarge
     - type: string-input

api/server/router/helm_repo.go

@@ -81,6 +81,35 @@ func getHelmRepoRoutes(
 		Router:   r,
 	})
 
+	// DELETE /api/projects/{project_id}/helmrepos/{helm_repo_id} -> registry.NewHelmRepoDeleteHandler
+	deleteEndpoint := factory.NewAPIEndpoint(
+		&types.APIRequestMetadata{
+			Verb:   types.APIVerbDelete,
+			Method: types.HTTPVerbDelete,
+			Path: &types.Path{
+				Parent:       basePath,
+				RelativePath: relPath,
+			},
+			Scopes: []types.PermissionScope{
+				types.UserScope,
+				types.ProjectScope,
+				types.HelmRepoScope,
+			},
+		},
+	)
+
+	deleteHandler := helmrepo.NewHelmRepoDeleteHandler(
+		config,
+		factory.GetDecoderValidator(),
+		factory.GetResultWriter(),
+	)
+
+	routes = append(routes, &router.Route{
+		Endpoint: deleteEndpoint,
+		Handler:  deleteHandler,
+		Router:   r,
+	})
+
 	//  GET /api/projects/{project_id}/helmrepos/{helm_repo_id}/charts -> helmrepo.NewChartListHandler
 	hrListEndpoint := factory.NewAPIEndpoint(
 		&types.APIRequestMetadata{

cli/cmd/delete.go

@@ -85,6 +85,21 @@ var deleteAddonsCmd = &cobra.Command{
 	},
 }
 
+// deleteHelmCmd represents the "porter delete helm" subcommand
+var deleteHelmCmd = &cobra.Command{
+	Use:     "helm",
+	Aliases: []string{"helmrepo", "helmrepos"},
+	Short:   "Deletes an existing helm repo",
+	Args:    cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		err := checkLoginAndRun(args, deleteHelm)
+
+		if err != nil {
+			os.Exit(1)
+		}
+	},
+}
+
 func init() {
 	deleteCmd.PersistentFlags().StringVar(
 		&namespace,
@@ -96,6 +111,7 @@ func init() {
 	deleteCmd.AddCommand(deleteAppsCmd)
 	deleteCmd.AddCommand(deleteJobsCmd)
 	deleteCmd.AddCommand(deleteAddonsCmd)
+	deleteCmd.AddCommand(deleteHelmCmd)
 
 	rootCmd.AddCommand(deleteCmd)
 }
@@ -221,3 +237,36 @@ func deleteAddon(_ *types.GetAuthenticatedUserResponse, client *api.Client, args
 
 	return nil
 }
+
+func deleteHelm(_ *types.GetAuthenticatedUserResponse, client *api.Client, args []string) error {
+	name := args[0]
+
+	resp, err := client.ListHelmRepos(context.Background(), cliConf.Project)
+
+	if err != nil {
+		return err
+	}
+
+	var repo *types.HelmRepo
+
+	for _, r := range resp {
+		if r.Name == name {
+			repo = r
+			break
+		}
+	}
+
+	if repo == nil {
+		return fmt.Errorf("no helm repo found with name: %s", name)
+	}
+
+	color.New(color.FgBlue).Printf("Deleting helm repo: %s\n", name)
+
+	err = client.DeleteHelmRepo(context.Background(), cliConf.Project, repo.ID)
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

cli/cmd/run.go

@@ -33,6 +33,9 @@ import (
 
 var namespace string
 var verbose bool
+var existingPod bool
+var nonInteractive bool
+var containerName string
 
 // runCmd represents the "porter run" base command when called
 // without any subcommands
@@ -63,8 +66,6 @@ var cleanupCmd = &cobra.Command{
 	},
 }
 
-var existingPod bool
-
 func init() {
 	rootCmd.AddCommand(runCmd)
 
@@ -91,12 +92,31 @@ func init() {
 		"whether to print verbose output",
 	)
 
+	runCmd.PersistentFlags().BoolVar(
+		&nonInteractive,
+		"non-interactive",
+		false,
+		"whether to run in non-interactive mode",
+	)
+
+	runCmd.PersistentFlags().StringVarP(
+		&containerName,
+		"container",
+		"c",
+		"",
+		"name of the container inside pod to run the command in",
+	)
+
 	runCmd.AddCommand(cleanupCmd)
 }
 
 func run(_ *types.GetAuthenticatedUserResponse, client *api.Client, args []string) error {
 	color.New(color.FgGreen).Println("Running", strings.Join(args[1:], " "), "for release", args[0])
 
+	if nonInteractive {
+		color.New(color.FgBlue).Println("Using non-interactive mode. The first available pod will be used to run the command.")
+	}
+
 	podsSimple, err := getPods(client, namespace, args[0])
 
 	if err != nil {
@@ -108,7 +128,7 @@ func run(_ *types.GetAuthenticatedUserResponse, client *api.Client, args []strin
 
 	if len(podsSimple) == 0 {
 		return fmt.Errorf("At least one pod must exist in this deployment.")
-	} else if len(podsSimple) == 1 || !existingPod {
+	} else if nonInteractive || len(podsSimple) == 1 || !existingPod {
 		selectedPod = podsSimple[0]
 	} else {
 		podNames := make([]string, 0)
@@ -133,12 +153,35 @@ func run(_ *types.GetAuthenticatedUserResponse, client *api.Client, args []strin
 
 	var selectedContainerName string
 
-	// if the selected pod has multiple container, spawn selector
 	if len(selectedPod.ContainerNames) == 0 {
-		return fmt.Errorf("At least one pod must exist in this deployment.")
+		return fmt.Errorf("At least one container must exist in the selected pod.")
 	} else if len(selectedPod.ContainerNames) == 1 {
+		if containerName != "" && containerName != selectedPod.ContainerNames[0] {
+			return fmt.Errorf("provided container %s does not exist in pod %s", containerName, selectedPod.Name)
+		}
+
 		selectedContainerName = selectedPod.ContainerNames[0]
-	} else {
+	}
+
+	if containerName != "" && selectedContainerName == "" {
+		// check if provided container name exists in the pod
+		for _, name := range selectedPod.ContainerNames {
+			if name == containerName {
+				selectedContainerName = name
+				break
+			}
+		}
+
+		if selectedContainerName == "" {
+			return fmt.Errorf("provided container %s does not exist in pod %s", containerName, selectedPod.Name)
+		}
+	}
+
+	if selectedContainerName == "" {
+		if nonInteractive {
+			return fmt.Errorf("container name must be specified using the --container flag when using non-interactive mode")
+		}
+
 		selectedContainer, err := utils.PromptSelect("Select the container:", selectedPod.ContainerNames)
 
 		if err != nil {

internal/kubernetes/prometheus/metrics.go

@@ -301,7 +301,7 @@ func getSelectionRegex(kind, name string) (string, error) {
 
 	switch strings.ToLower(kind) {
 	case "deployment":
-		suffix = "[a-z0-9]+"
+		suffix = "[a-z0-9]+(-[a-z0-9]+)*"
 	case "statefulset":
 		suffix = "[0-9]+"
 	case "job":

internal/repository/gorm/auth.go

@@ -304,6 +304,33 @@ func (repo *BasicIntegrationRepository) ListBasicIntegrationsByProjectID(
 	return basics, nil
 }
 
+// DeleteBasicIntegration deletes an existing basic auth mechanism
+func (repo *BasicIntegrationRepository) DeleteBasicIntegration(
+	am *ints.BasicIntegration,
+) (*ints.BasicIntegration, error) {
+	project := &models.Project{}
+
+	if err := repo.db.Where("id = ?", am.ProjectID).First(&project).Error; err != nil {
+		return nil, err
+	}
+
+	assoc := repo.db.Model(&project).Association("BasicIntegrations")
+
+	if assoc.Error != nil {
+		return nil, assoc.Error
+	}
+
+	if err := assoc.Delete(am); err != nil {
+		return nil, err
+	}
+
+	if err := repo.db.Delete(am).Error; err != nil {
+		return nil, err
+	}
+
+	return am, nil
+}
+
 // EncryptBasicIntegrationData will encrypt the basic integration data before
 // writing to the DB
 func (repo *BasicIntegrationRepository) EncryptBasicIntegrationData(

internal/repository/integrations.go

@@ -18,6 +18,7 @@ type BasicIntegrationRepository interface {
 	CreateBasicIntegration(am *ints.BasicIntegration) (*ints.BasicIntegration, error)
 	ReadBasicIntegration(projectID, id uint) (*ints.BasicIntegration, error)
 	ListBasicIntegrationsByProjectID(projectID uint) ([]*ints.BasicIntegration, error)
+	DeleteBasicIntegration(am *ints.BasicIntegration) (*ints.BasicIntegration, error)
 }
 
 // OIDCIntegrationRepository represents the set of queries on the OIDC auth

internal/repository/test/auth.go

@@ -137,6 +137,27 @@ func (repo *BasicIntegrationRepository) ListBasicIntegrationsByProjectID(
 	return res, nil
 }
 
+// DeleteBasicIntegration deletes a basic integration
+func (repo *BasicIntegrationRepository) DeleteBasicIntegration(
+	am *ints.BasicIntegration,
+) (*ints.BasicIntegration, error) {
+	if !repo.canQuery {
+		return nil, errors.New("Cannot read from database")
+	}
+
+	var newInts []*ints.BasicIntegration
+
+	for _, basicInt := range repo.basicIntegrations {
+		if basicInt.ID != am.ID {
+			newInts = append(newInts, basicInt)
+		}
+	}
+
+	repo.basicIntegrations = newInts
+
+	return am, nil
+}
+
 // OIDCIntegrationRepository implements repository.OIDCIntegrationRepository
 type OIDCIntegrationRepository struct {
 	canQuery         bool