coder · kylecarbs · Jan 29, 2022 · Jan 29, 2022 · Jan 29, 2022 · Jan 29, 2022
diff --git a/.github/workflows/coder.yaml b/.github/workflows/coder.yaml
@@ -10,8 +10,7 @@ on:
 
   pull_request:
     branches:
-      - main
-      - "release/*"
+      - "*"
 
   workflow_dispatch:
 

diff --git a/coderd/projectparameter/projectparameter.go b/coderd/projectparameter/projectparameter.go
@@ -0,0 +1,217 @@
+package projectparameter
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+	"golang.org/x/xerrors"
+
+	"github.com/coder/coder/database"
+	"github.com/coder/coder/provisionersdk/proto"
+)
+
+// Scope targets identifiers to pull parameters from.
+type Scope struct {
+	OrganizationID     string
+	ProjectID          uuid.UUID
+	ProjectHistoryID   uuid.UUID
+	UserID             string
+	WorkspaceID        uuid.UUID
+	WorkspaceHistoryID uuid.UUID
+}
+
+// Value represents a computed parameter.
+type Value struct {
+	Proto *proto.ParameterValue
+	// DefaultValue is whether a default value for the scope
+	// was consumed. This can only be true for projects.
+	DefaultValue bool
+	Scope        database.ParameterScope
+	ScopeID      string
+}
+
+// Compute accepts a scope in which parameter values are sourced.
+// These sources are iterated in a hierarchical fashion to determine
+// the runtime parameter values for a project.
+func Compute(ctx context.Context, db database.Store, scope Scope) ([]Value, error) {
+	compute := &compute{
+		db:                             db,
+		computedParameterByName:        map[string]Value{},
+		projectHistoryParametersByName: map[string]database.ProjectParameter{},
+	}
+
+	// All parameters for the project version!
+	projectHistoryParameters, err := db.GetProjectParametersByHistoryID(ctx, scope.ProjectHistoryID)
+	if errors.Is(err, sql.ErrNoRows) {
+		// This occurs when the project history has defined
+		// no parameters, so we have nothing to compute!
+		return []Value{}, nil
+	}
+	if err != nil {
+		return nil, xerrors.Errorf("get project parameters: %w", err)
+	}
+	for _, projectHistoryParameter := range projectHistoryParameters {
+		compute.projectHistoryParametersByName[projectHistoryParameter.Name] = projectHistoryParameter
+	}
+
+	// Organization parameters come first!
+	err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
+		Scope:   database.ParameterScopeOrganization,
+		ScopeID: scope.OrganizationID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Default project parameter values come second!
+	for _, projectHistoryParameter := range projectHistoryParameters {
+		if !projectHistoryParameter.DefaultSourceValue.Valid {
+			continue
+		}
+		if !projectHistoryParameter.DefaultDestinationValue.Valid {
+			continue
+		}
+
+		destinationScheme, err := convertDestinationScheme(projectHistoryParameter.DefaultDestinationScheme)
+		if err != nil {
+			return nil, xerrors.Errorf("convert default destination scheme for project history parameter %q: %w", projectHistoryParameter.Name, err)
+		}
+
+		switch projectHistoryParameter.DefaultSourceScheme {
+		case database.ParameterSourceSchemeData:
+			compute.computedParameterByName[projectHistoryParameter.Name] = Value{
+				Proto: &proto.ParameterValue{
+					DestinationScheme: destinationScheme,
+					Name:              projectHistoryParameter.DefaultDestinationValue.String,
+					Value:             projectHistoryParameter.DefaultSourceValue.String,
+				},
+				DefaultValue: true,
+				Scope:        database.ParameterScopeProject,
+				ScopeID:      scope.ProjectID.String(),
+			}
+		default:
+			return nil, xerrors.Errorf("unsupported source scheme for project history parameter %q: %q", projectHistoryParameter.Name, string(projectHistoryParameter.DefaultSourceScheme))
+		}
+	}
+
+	// Project parameters come third!
+	err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
+		Scope:   database.ParameterScopeProject,
+		ScopeID: scope.ProjectID.String(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// User parameters come fourth!
+	err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
+		Scope:   database.ParameterScopeUser,
+		ScopeID: scope.UserID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Workspace parameters come last!
+	err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
+		Scope:   database.ParameterScopeWorkspace,
+		ScopeID: scope.WorkspaceID.String(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	for _, projectHistoryParameter := range compute.projectHistoryParametersByName {
+		if _, ok := compute.computedParameterByName[projectHistoryParameter.Name]; ok {
+			continue
+		}
+		return nil, NoValueError{
+			ParameterID:   projectHistoryParameter.ID,
+			ParameterName: projectHistoryParameter.Name,
+		}
+	}
+
+	values := make([]Value, 0, len(compute.computedParameterByName))
+	for _, value := range compute.computedParameterByName {
+		values = append(values, value)
+	}
+	return values, nil
+}
+
+type compute struct {
+	db                             database.Store
+	computedParameterByName        map[string]Value
+	projectHistoryParametersByName map[string]database.ProjectParameter
+}
+
+// Validates and computes the value for parameters; setting the value on "parameterByName".
+func (c *compute) inject(ctx context.Context, scopeParams database.GetParameterValuesByScopeParams) error {
+	scopedParameters, err := c.db.GetParameterValuesByScope(ctx, scopeParams)
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		return xerrors.Errorf("get %s parameters: %w", scopeParams.Scope, err)
+	}
+
+	for _, scopedParameter := range scopedParameters {
+		projectHistoryParameter, hasProjectHistoryParameter := c.projectHistoryParametersByName[scopedParameter.Name]
+		if !hasProjectHistoryParameter {
+			// Don't inject parameters that aren't defined by the project.
+			continue
+		}
+
+		_, hasExistingParameter := c.computedParameterByName[scopedParameter.Name]
+		if hasExistingParameter {
+			// If a parameter already exists, check if this variable can override it.
+			// Injection hierarchy is the responsibility of the caller. This check ensures
+			// project parameters cannot be overridden if already set.
+			if !projectHistoryParameter.AllowOverrideSource && scopedParameter.Scope != database.ParameterScopeProject {
+				continue
+			}
+		}
+
+		destinationScheme, err := convertDestinationScheme(scopedParameter.DestinationScheme)
+		if err != nil {
+			return xerrors.Errorf("convert destination scheme: %w", err)
+		}
+
+		switch scopedParameter.SourceScheme {
+		case database.ParameterSourceSchemeData:
+			c.computedParameterByName[projectHistoryParameter.Name] = Value{
+				Proto: &proto.ParameterValue{
+					DestinationScheme: destinationScheme,
+					Name:              scopedParameter.SourceValue,
+					Value:             scopedParameter.DestinationValue,
+				},
+			}
+		default:
+			return xerrors.Errorf("unsupported source scheme: %q", string(projectHistoryParameter.DefaultSourceScheme))
+		}
+	}
+	return nil
+}
+
+// Converts the database destination scheme to the protobuf version.
+func convertDestinationScheme(scheme database.ParameterDestinationScheme) (proto.ParameterDestination_Scheme, error) {
+	switch scheme {
+	case database.ParameterDestinationSchemeEnvironmentVariable:
+		return proto.ParameterDestination_ENVIRONMENT_VARIABLE, nil
+	case database.ParameterDestinationSchemeProvisionerVariable:
+		return proto.ParameterDestination_PROVISIONER_VARIABLE, nil
+	default:
+		return 0, xerrors.Errorf("unsupported destination scheme: %q", scheme)
+	}
+}
+
+type NoValueError struct {
+	ParameterID   uuid.UUID
+	ParameterName string
+}
+
+func (e NoValueError) Error() string {
+	return fmt.Sprintf("no value for parameter %q found", e.ParameterName)
+}