More wiring

coder · mtojek · Feb 17, 2023 · Feb 9, 2023 · Feb 9, 2023 · Feb 9, 2023
commit e4ee7f93ccff9e96e56899823f49384fe2c6eaac
diff --git a/coderd/provisionerdserver/provisionerdserver.go b/coderd/provisionerdserver/provisionerdserver.go
@@ -385,9 +385,22 @@ func (server *Server) UpdateJob(ctx context.Context, request *proto.UpdateJobReq
 			return nil, xerrors.Errorf("get template version by job id: %w", err)
 		}
 
+		var variableValues []*sdkproto.VariableValue
 		for _, templateVariable := range request.TemplateVariables {
 			server.Logger.Info(ctx, "insert template variable", slog.F("template_version_id", templateVersion.ID), slog.F("template_variable", templateVariable))
 
+			var value = templateVariable.DefaultValue
+			for _, v := range request.VariableValues {
+				if v.Name == templateVariable.Name {
+					value = v.Value
+					variableValues = append(variableValues, &sdkproto.VariableValue{
+						Name:  v.Name,
+						Value: v.Value,
+					})
+					break
+				}
+			}
+
 			_, err = server.Database.InsertTemplateVersionVariable(ctx, database.InsertTemplateVersionVariableParams{
 				TemplateVersionID: templateVersion.ID,
 				Name:              templateVariable.Name,
@@ -396,12 +409,17 @@ func (server *Server) UpdateJob(ctx context.Context, request *proto.UpdateJobReq
 				DefaultValue:      templateVariable.DefaultValue,
 				Required:          templateVariable.Required,
 				Sensitive:         templateVariable.Sensitive,
-				// FIXME value
+				Value:             value,
 			})
 			if err != nil {
 				return nil, xerrors.Errorf("insert parameter schema: %w", err)
 			}
 		}
+
+		return &proto.UpdateJobResponse{
+			Canceled:       job.CanceledAt.Valid,
+			VariableValues: variableValues,
+		}, nil
 	}
 
 	if len(request.ParameterSchemas) > 0 {
@@ -1216,7 +1234,8 @@ func auditActionFromTransition(transition database.WorkspaceTransition) database
 }
 
 type TemplateVersionImportJob struct {
-	TemplateVersionID uuid.UUID `json:"template_version_id"`
+	TemplateVersionID uuid.UUID                `json:"template_version_id"`
+	VariableValues    []codersdk.VariableValue `json:"variable_values"`
 }
 
 // WorkspaceProvisionJob is the payload for the "workspace_provision" job type.

diff --git a/coderd/templateversions.go b/coderd/templateversions.go
@@ -1311,6 +1311,7 @@ func (api *API) postTemplateVersionsByOrganization(rw http.ResponseWriter, r *ht
 		templateVersionID := uuid.New()
 		jobInput, err := json.Marshal(provisionerdserver.TemplateVersionImportJob{
 			TemplateVersionID: templateVersionID,
+			VariableValues:    req.VariableValues,
 		})
 		if err != nil {
 			return xerrors.Errorf("marshal job input: %w", err)

diff --git a/codersdk/organizations.go b/codersdk/organizations.go
@@ -54,6 +54,13 @@ type CreateTemplateVersionRequest struct {
 	// ParameterValues allows for additional parameters to be provided
 	// during the dry-run provision stage.
 	ParameterValues []CreateParameterRequest `json:"parameter_values,omitempty"`
+
+	VariableValues []VariableValue `json:"variable_values,omitempty"`
+}
+
+type VariableValue struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
 }
 
 // CreateTemplateRequest provides options when creating a template.

diff --git a/provisioner/terraform/provision.go b/provisioner/terraform/provision.go
@@ -139,7 +139,7 @@ func (s *server) Provision(stream proto.DRPCProvisioner_ProvisionStream) error {
 	}
 	s.logger.Debug(ctx, "ran initialization")
 
-	env, err := provisionEnv(config, request.GetPlan().GetParameterValues(), request.GetPlan().GetRichParameterValues())
+	env, err := provisionEnv(config, request.GetPlan().GetParameterValues(), request.GetPlan().GetVariableValues(), request.GetPlan().GetRichParameterValues())
 	if err != nil {
 		return err
 	}
@@ -205,7 +205,7 @@ func planVars(plan *proto.Provision_Plan) ([]string, error) {
 	return vars, nil
 }
 
-func provisionEnv(config *proto.Provision_Config, params []*proto.ParameterValue, richParams []*proto.RichParameterValue) ([]string, error) {
+func provisionEnv(config *proto.Provision_Config, params []*proto.ParameterValue, variableValues []*proto.VariableValue, richParams []*proto.RichParameterValue) ([]string, error) {
 	env := safeEnviron()
 	env = append(env,
 		"CODER_AGENT_URL="+config.Metadata.CoderUrl,
@@ -229,6 +229,9 @@ func provisionEnv(config *proto.Provision_Config, params []*proto.ParameterValue
 			return nil, xerrors.Errorf("unsupported parameter type %q for %q", param.DestinationScheme, param.Name)
 		}
 	}
+	for _, variable := range variableValues {
+		env = append(env, fmt.Sprintf("%s=%s", variable.Name, variable.Value))
+	}
 	for _, param := range richParams {
 		env = append(env, provider.ParameterEnvironmentVariable(param.Name)+"="+param.Value)
 	}

diff --git a/provisionerd/proto/provisionerd.pb.go b/provisionerd/proto/provisionerd.pb.go
diff --git a/provisionerd/proto/provisionerd.proto b/provisionerd/proto/provisionerd.proto
@@ -21,6 +21,7 @@ message AcquiredJob {
     }
     message TemplateImport {
         provisioner.Provision.Metadata metadata = 1;
+		repeated provisioner.VariableValue variable_values = 2;
     }
     message TemplateDryRun {
         repeated provisioner.ParameterValue parameter_values = 1;
@@ -100,14 +101,16 @@ message UpdateJobRequest {
     repeated Log logs = 2;
     repeated provisioner.ParameterSchema parameter_schemas = 3;
     repeated provisioner.TemplateVariable template_variables = 4;
-    bytes readme = 5;
+	repeated provisioner.VariableValue variable_values = 5;
+    bytes readme = 6;
 }
 
 message UpdateJobResponse {
     bool canceled = 1;
     // If parameter schemas are sent, the job will respond
     // with resolved parameter values.
     repeated provisioner.ParameterValue parameter_values = 2;
+	repeated provisioner.VariableValue variable_values = 5;
 }
 
 message CommitQuotaRequest {

diff --git a/provisionerd/proto/provisionerd_drpc.pb.go b/provisionerd/proto/provisionerd_drpc.pb.go
diff --git a/provisionerd/runner/runner.go b/provisionerd/runner/runner.go
@@ -416,7 +416,9 @@ func (r *Runner) do(ctx context.Context) (*proto.CompletedJob, *proto.FailedJob)
 	}
 	switch jobType := r.job.Type.(type) {
 	case *proto.AcquiredJob_TemplateImport_:
-		r.logger.Debug(context.Background(), "acquired job is template import")
+		r.logger.Info(context.Background(), "acquired job is template import",
+			slog.F("variable_values", jobType.TemplateImport.VariableValues), // FIXME to be redacted
+		)
 
 		failedJob := r.runReadmeParse(ctx)
 		if failedJob != nil {
@@ -542,10 +544,14 @@ func (r *Runner) runTemplateImport(ctx context.Context) (*proto.CompletedJob, *p
 	if err != nil {
 		return nil, r.failedJobf("run parse: %s", err)
 	}
+
+	// Once Terraform template variables are parsed, the runner can pass variables
+	// to store in database and filter valid ones.
 	updateResponse, err := r.update(ctx, &proto.UpdateJobRequest{
 		JobId:             r.job.JobId,
 		ParameterSchemas:  parameterSchemas,
 		TemplateVariables: templateVariables,
+		VariableValues:    r.job.GetTemplateImport().GetVariableValues(),
 	})
 	if err != nil {
 		return nil, r.failedJobf("update job: %s", err)
@@ -569,7 +575,7 @@ func (r *Runner) runTemplateImport(ctx context.Context) (*proto.CompletedJob, *p
 		Stage:     "Detecting persistent resources",
 		CreatedAt: time.Now().UnixMilli(),
 	})
-	startResources, parameters, err := r.runTemplateImportProvision(ctx, updateResponse.ParameterValues, &sdkproto.Provision_Metadata{
+	startResources, parameters, err := r.runTemplateImportProvision(ctx, updateResponse.ParameterValues, updateResponse.VariableValues, &sdkproto.Provision_Metadata{
 		CoderUrl:            r.job.GetTemplateImport().Metadata.CoderUrl,
 		WorkspaceTransition: sdkproto.WorkspaceTransition_START,
 	})
@@ -584,7 +590,7 @@ func (r *Runner) runTemplateImport(ctx context.Context) (*proto.CompletedJob, *p
 		Stage:     "Detecting ephemeral resources",
 		CreatedAt: time.Now().UnixMilli(),
 	})
-	stopResources, _, err := r.runTemplateImportProvision(ctx, updateResponse.ParameterValues, &sdkproto.Provision_Metadata{
+	stopResources, _, err := r.runTemplateImportProvision(ctx, updateResponse.ParameterValues, updateResponse.VariableValues, &sdkproto.Provision_Metadata{
 		CoderUrl:            r.job.GetTemplateImport().Metadata.CoderUrl,
 		WorkspaceTransition: sdkproto.WorkspaceTransition_STOP,
 	})
@@ -652,13 +658,13 @@ func (r *Runner) runTemplateImportParse(ctx context.Context) ([]*sdkproto.Parame
 // Performs a dry-run provision when importing a template.
 // This is used to detect resources that would be provisioned for a workspace in various states.
 // It doesn't define values for rich parameters as they're unknown during template import.
-func (r *Runner) runTemplateImportProvision(ctx context.Context, values []*sdkproto.ParameterValue, metadata *sdkproto.Provision_Metadata) ([]*sdkproto.Resource, []*sdkproto.RichParameter, error) {
-	return r.runTemplateImportProvisionWithRichParameters(ctx, values, nil, metadata)
+func (r *Runner) runTemplateImportProvision(ctx context.Context, values []*sdkproto.ParameterValue, variableValues []*sdkproto.VariableValue, metadata *sdkproto.Provision_Metadata) ([]*sdkproto.Resource, []*sdkproto.RichParameter, error) {
+	return r.runTemplateImportProvisionWithRichParameters(ctx, values, variableValues, nil, metadata)
 }
 
 // Performs a dry-run provision with provided rich parameters.
 // This is used to detect resources that would be provisioned for a workspace in various states.
-func (r *Runner) runTemplateImportProvisionWithRichParameters(ctx context.Context, values []*sdkproto.ParameterValue, richParameterValues []*sdkproto.RichParameterValue, metadata *sdkproto.Provision_Metadata) ([]*sdkproto.Resource, []*sdkproto.RichParameter, error) {
+func (r *Runner) runTemplateImportProvisionWithRichParameters(ctx context.Context, values []*sdkproto.ParameterValue, variableValues []*sdkproto.VariableValue, richParameterValues []*sdkproto.RichParameterValue, metadata *sdkproto.Provision_Metadata) ([]*sdkproto.Resource, []*sdkproto.RichParameter, error) {
 	ctx, span := r.startTrace(ctx, tracing.FuncName())
 	defer span.End()
 
@@ -697,6 +703,7 @@ func (r *Runner) runTemplateImportProvisionWithRichParameters(ctx context.Contex
 				},
 				ParameterValues:     values,
 				RichParameterValues: richParameterValues,
+				VariableValues:      variableValues,
 			},
 		},
 	})
@@ -785,6 +792,7 @@ func (r *Runner) runTemplateDryRun(ctx context.Context) (*proto.CompletedJob, *p
 	// Run the template import provision task since it's already a dry run.
 	resources, _, err := r.runTemplateImportProvisionWithRichParameters(ctx,
 		r.job.GetTemplateDryRun().GetParameterValues(),
+		nil, // FIXME variable values
 		r.job.GetTemplateDryRun().GetRichParameterValues(),
 		metadata,
 	)