coder · Emyrk · Jun 17, 2022 · Jun 14, 2022 · Jun 15, 2022 · Jun 15, 2022
diff --git a/cli/parameterslist.go b/cli/parameterslist.go
@@ -46,15 +46,15 @@ func parameterList() *cobra.Command {
 				}
 				scopeID = template.ID
 
-			case codersdk.ParameterScopeImportJob, "template_version":
-				scope = string(codersdk.ParameterScopeImportJob)
+			case codersdk.ParameterImportJob, "template_version":
+				scope = string(codersdk.ParameterImportJob)
 				scopeID, err = uuid.Parse(name)
 				if err != nil {
 					return xerrors.Errorf("%q must be a uuid for this scope type", name)
 				}
 			default:
 				return xerrors.Errorf("%q is an unsupported scope, use %v", scope, []codersdk.ParameterScope{
-					codersdk.ParameterWorkspace, codersdk.ParameterTemplate, codersdk.ParameterScopeImportJob,
+					codersdk.ParameterWorkspace, codersdk.ParameterTemplate, codersdk.ParameterImportJob,
 				})
 			}
 

diff --git a/cli/templatecreate.go b/cli/templatecreate.go
@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/briandowns/spinner"
+	"github.com/google/uuid"
 	"github.com/spf13/cobra"
 	"golang.org/x/xerrors"
 
@@ -82,7 +83,13 @@ func templateCreate() *cobra.Command {
 			}
 			spin.Stop()
 
-			job, parameters, err := createValidTemplateVersion(cmd, client, organization, database.ProvisionerType(provisioner), resp.Hash, parameterFile)
+			job, parameters, err := createValidTemplateVersion(cmd, createValidTemplateVersionArgs{
+				Client:        client,
+				Organization:  organization,
+				Provisioner:   database.ProvisionerType(provisioner),
+				FileHash:      resp.Hash,
+				ParameterFile: parameterFile,
+			})
 			if err != nil {
 				return err
 			}
@@ -133,13 +140,26 @@ func templateCreate() *cobra.Command {
 	return cmd
 }
 
-func createValidTemplateVersion(cmd *cobra.Command, client *codersdk.Client, organization codersdk.Organization, provisioner database.ProvisionerType, hash string, parameterFile string, parameters ...codersdk.CreateParameterRequest) (*codersdk.TemplateVersion, []codersdk.CreateParameterRequest, error) {
+type createValidTemplateVersionArgs struct {
+	Client        *codersdk.Client
+	Organization  codersdk.Organization
+	Provisioner   database.ProvisionerType
+	FileHash      string
+	ParameterFile string
+	// TemplateID is only required if updating a template's active version.
+	TemplateID uuid.UUID
+}
+
+func createValidTemplateVersion(cmd *cobra.Command, args createValidTemplateVersionArgs, parameters ...codersdk.CreateParameterRequest) (*codersdk.TemplateVersion, []codersdk.CreateParameterRequest, error) {
 	before := time.Now()
-	version, err := client.CreateTemplateVersion(cmd.Context(), organization.ID, codersdk.CreateTemplateVersionRequest{
+	client := args.Client
+
+	version, err := client.CreateTemplateVersion(cmd.Context(), args.Organization.ID, codersdk.CreateTemplateVersionRequest{
 		StorageMethod:   codersdk.ProvisionerStorageMethodFile,
-		StorageSource:   hash,
-		Provisioner:     codersdk.ProvisionerType(provisioner),
+		StorageSource:   args.FileHash,
+		Provisioner:     codersdk.ProvisionerType(args.Provisioner),
 		ParameterValues: parameters,
+		TemplateID:      args.TemplateID,
 	})
 	if err != nil {
 		return nil, nil, err
@@ -175,11 +195,37 @@ func createValidTemplateVersion(cmd *cobra.Command, client *codersdk.Client, org
 		return nil, nil, err
 	}
 
+	// lastParameterValues are pulled from the current active template version if
+	// templateID is provided. This allows pulling params from the last
+	// version if we are updating template versions.
+	lastParameterValues := make(map[string]codersdk.Parameter)
+	if args.TemplateID != uuid.Nil {
+		template, err := client.Template(cmd.Context(), args.TemplateID)
+		if err != nil {
+			return nil, nil, xerrors.Errorf("Fetch template: %w", err)
+		}
+
+		activeVersion, err := client.TemplateVersion(cmd.Context(), template.ActiveVersionID)
+		if err != nil {
+			return nil, nil, xerrors.Errorf("Fetch current active template version: %w", err)
+		}
+
+		// We don't want to compute the params, we only want to copy from this scope
+		values, err := client.Parameters(cmd.Context(), codersdk.ParameterImportJob, activeVersion.Job.ID)
+		if err != nil {
+			return nil, nil, xerrors.Errorf("Fetch previous version parameters: %w", err)
+		}
+		for _, value := range values {
+			lastParameterValues[value.Name] = value
+		}
+	}
+
 	if provisionerd.IsMissingParameterError(version.Job.Error) {
 		valuesBySchemaID := map[string]codersdk.TemplateVersionParameter{}
 		for _, parameterValue := range parameterValues {
 			valuesBySchemaID[parameterValue.SchemaID.String()] = parameterValue
 		}
+
 		sort.Slice(parameterSchemas, func(i, j int) bool {
 			return parameterSchemas[i].Name < parameterSchemas[j].Name
 		})
@@ -195,14 +241,20 @@ func createValidTemplateVersion(cmd *cobra.Command, client *codersdk.Client, org
 
 		// parameterMapFromFile can be nil if parameter file is not specified
 		var parameterMapFromFile map[string]string
-		if parameterFile != "" {
+		if args.ParameterFile != "" {
 			_, _ = fmt.Fprintln(cmd.OutOrStdout(), cliui.Styles.Paragraph.Render("Attempting to read the variables from the parameter file.")+"\r\n")
-			parameterMapFromFile, err = createParameterMapFromFile(parameterFile)
+			parameterMapFromFile, err = createParameterMapFromFile(args.ParameterFile)
 			if err != nil {
 				return nil, nil, err
 			}
 		}
 		for _, parameterSchema := range missingSchemas {
+			if inherit, ok := lastParameterValues[parameterSchema.Name]; ok {
+				parameters = append(parameters, codersdk.CreateParameterRequest{
+					CopyFromParameter: inherit.ID,
+				})
+				continue
+			}
 			parameterValue, err := getParameterValueFromMapOrInput(cmd, parameterMapFromFile, parameterSchema)
 			if err != nil {
 				return nil, nil, err
@@ -218,7 +270,7 @@ func createValidTemplateVersion(cmd *cobra.Command, client *codersdk.Client, org
 
 		// This recursion is only 1 level deep in practice.
 		// The first pass populates the missing parameters, so it does not enter this `if` block again.
-		return createValidTemplateVersion(cmd, client, organization, provisioner, hash, parameterFile, parameters...)
+		return createValidTemplateVersion(cmd, args, parameters...)
 	}
 
 	if version.Job.Status != codersdk.ProvisionerJobSucceeded {

diff --git a/cli/templateupdate.go b/cli/templateupdate.go
@@ -10,14 +10,16 @@ import (
 	"golang.org/x/xerrors"
 
 	"github.com/coder/coder/cli/cliui"
+	"github.com/coder/coder/coderd/database"
 	"github.com/coder/coder/codersdk"
 	"github.com/coder/coder/provisionersdk"
 )
 
 func templateUpdate() *cobra.Command {
 	var (
-		directory   string
-		provisioner string
+		directory     string
+		provisioner   string
+		parameterFile string
 	)
 
 	cmd := &cobra.Command{
@@ -64,42 +66,72 @@ func templateUpdate() *cobra.Command {
 			}
 			spin.Stop()
 
-			before := time.Now()
-			templateVersion, err := client.CreateTemplateVersion(cmd.Context(), organization.ID, codersdk.CreateTemplateVersionRequest{
+			job, _, err := createValidTemplateVersion(cmd, createValidTemplateVersionArgs{
+				Client:        client,
+				Organization:  organization,
+				Provisioner:   database.ProvisionerType(provisioner),
+				FileHash:      resp.Hash,
+				ParameterFile: parameterFile,
 				TemplateID:    template.ID,
-				StorageMethod: codersdk.ProvisionerStorageMethodFile,
-				StorageSource: resp.Hash,
-				Provisioner:   codersdk.ProvisionerType(provisioner),
 			})
 			if err != nil {
 				return err
 			}
-			logs, err := client.TemplateVersionLogsAfter(cmd.Context(), templateVersion.ID, before)
-			if err != nil {
-				return err
-			}
-			for {
-				log, ok := <-logs
-				if !ok {
-					break
-				}
-				_, _ = fmt.Printf("%s (%s): %s\n", provisioner, log.Level, log.Output)
+
+			if job.Job.Status != codersdk.ProvisionerJobSucceeded {
+				return xerrors.Errorf("job failed: %s", job.Job.Status)
 			}
-			templateVersion, err = client.TemplateVersion(cmd.Context(), templateVersion.ID)
+
+			_, err = cliui.Prompt(cmd, cliui.PromptOptions{
+				Text:      "Confirm create?",
+				IsConfirm: true,
+			})
 			if err != nil {
 				return err
 			}
 
-			if templateVersion.Job.Status != codersdk.ProvisionerJobSucceeded {
-				return xerrors.Errorf("job failed: %s", templateVersion.Job.Error)
-			}
-
 			err = client.UpdateActiveTemplateVersion(cmd.Context(), template.ID, codersdk.UpdateActiveTemplateVersion{
-				ID: templateVersion.ID,
+				ID: job.ID,
 			})
 			if err != nil {
 				return err
 			}
+
+			// templateVersion, err := client.CreateTemplateVersion(cmd.Context(), organization.ID, codersdk.CreateTemplateVersionRequest{
+			//	TemplateID:    template.ID,
+			//	StorageMethod: codersdk.ProvisionerStorageMethodFile,
+			//	StorageSource: resp.Hash,
+			//	Provisioner:   codersdk.ProvisionerType(provisioner),
+			//})
+			//if err != nil {
+			//	return xerrors.Errorf("create template: %w", err)
+			//}
+			//logs, err := client.TemplateVersionLogsAfter(cmd.Context(), templateVersion.ID, before)
+			//if err != nil {
+			//	return err
+			//}
+			//for {
+			//	log, ok := <-logs
+			//	if !ok {
+			//		break
+			//	}
+			//	_, _ = fmt.Printf("%s (%s): %s\n", provisioner, log.Level, log.Output)
+			//}
+			//templateVersion, err = client.TemplateVersion(cmd.Context(), templateVersion.ID)
+			//if err != nil {
+			//	return err
+			//}
+			//
+			//if templateVersion.Job.Status != codersdk.ProvisionerJobSucceeded {
+			//	return xerrors.Errorf("job failed: %s", templateVersion.Job.Error)
+			//}
+			//
+			//err = client.UpdateActiveTemplateVersion(cmd.Context(), template.ID, codersdk.UpdateActiveTemplateVersion{
+			//	ID: templateVersion.ID,
+			//})
+			//if err != nil {
+			//	return err
+			//}
 			_, _ = fmt.Printf("Updated version!\n")
 			return nil
 		},
@@ -108,6 +140,7 @@ func templateUpdate() *cobra.Command {
 	currentDirectory, _ := os.Getwd()
 	cmd.Flags().StringVarP(&directory, "directory", "d", currentDirectory, "Specify the directory to create from")
 	cmd.Flags().StringVarP(&provisioner, "test.provisioner", "", "terraform", "Customize the provisioner backend")
+	cmd.Flags().StringVarP(&parameterFile, "parameter-file", "", "", "Specify a file path with parameter values.")
 	cliui.AllowSkipPrompt(cmd)
 	// This is for testing!
 	err := cmd.Flags().MarkHidden("test.provisioner")

diff --git a/coderd/database/databasefake/databasefake.go b/coderd/database/databasefake/databasefake.go
@@ -101,6 +101,19 @@ func (q *fakeQuerier) AcquireProvisionerJob(_ context.Context, arg database.Acqu
 	return database.ProvisionerJob{}, sql.ErrNoRows
 }
 
+func (q *fakeQuerier) ParameterValue(_ context.Context, id uuid.UUID) (database.ParameterValue, error) {
+	q.mutex.Lock()
+	defer q.mutex.Unlock()
+
+	for _, parameterValue := range q.parameterValues {
+		if parameterValue.ID.String() != id.String() {
+			continue
+		}
+		return parameterValue, nil
+	}
+	return database.ParameterValue{}, sql.ErrNoRows
+}
+
 func (q *fakeQuerier) DeleteParameterValueByID(_ context.Context, id uuid.UUID) error {
 	q.mutex.Lock()
 	defer q.mutex.Unlock()
@@ -703,17 +716,26 @@ func (q *fakeQuerier) GetOrganizationsByUserID(_ context.Context, userID uuid.UU
 	return organizations, nil
 }
 
-func (q *fakeQuerier) GetParameterValuesByScope(_ context.Context, arg database.GetParameterValuesByScopeParams) ([]database.ParameterValue, error) {
+func (q *fakeQuerier) ParameterValues(_ context.Context, arg database.ParameterValuesParams) ([]database.ParameterValue, error) {
 	q.mutex.RLock()
 	defer q.mutex.RUnlock()
 
 	parameterValues := make([]database.ParameterValue, 0)
 	for _, parameterValue := range q.parameterValues {
-		if parameterValue.Scope != arg.Scope {
+		if arg.Scope != "" && parameterValue.Scope != arg.Scope {
 			continue
 		}
-		if parameterValue.ScopeID != arg.ScopeID {
-			continue
+
+		if len(arg.ScopeIds) > 0 {
+			if !contains(arg.ScopeIds, parameterValue.ScopeID) {
+				continue
+			}
+		}
+
+		if len(arg.Ids) > 0 {
+			if !contains(arg.Ids, parameterValue.ID) {
+				continue
+			}
 		}
 		parameterValues = append(parameterValues, parameterValue)
 	}
@@ -1966,3 +1988,12 @@ func (q *fakeQuerier) InsertAuditLog(_ context.Context, arg database.InsertAudit
 
 	return alog, nil
 }
+
+func contains[T comparable](haystack []T, needle T) bool {
+	for _, hay := range haystack {
+		if needle == hay {
+			return true
+		}
+	}
+	return false
+}
diff --git a/coderd/database/querier.go b/coderd/database/querier.go