2022-02-12 13:34:04 -06:00
package parameter
import (
"context"
"database/sql"
"errors"
"github.com/google/uuid"
2022-07-18 19:39:24 +03:00
"golang.org/x/exp/slices"
2022-02-12 13:34:04 -06:00
"golang.org/x/xerrors"
2022-03-25 16:07:45 -05:00
"github.com/coder/coder/coderd/database"
2022-02-12 13:34:04 -06:00
)
// ComputeScope targets identifiers to pull parameters from.
type ComputeScope struct {
2022-06-02 00:44:53 +10:00
TemplateImportJobID uuid . UUID
TemplateID uuid . NullUUID
WorkspaceID uuid . NullUUID
AdditionalParameterValues [] database . ParameterValue
2022-02-12 13:34:04 -06:00
}
type ComputeOptions struct {
// HideRedisplayValues removes the value from parameters that
// come from schemas with RedisplayValue set to false.
HideRedisplayValues bool
}
// ComputedValue represents a computed parameter value.
type ComputedValue struct {
database . ParameterValue
SchemaID uuid . UUID `json:"schema_id"`
DefaultSourceValue bool `json:"default_source_value"`
2022-07-18 19:39:24 +03:00
index int32 // Track parameter schema index for sorting.
2022-02-12 13:34:04 -06:00
}
// 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 schemas provided.
func Compute ( ctx context . Context , db database . Store , scope ComputeScope , options * ComputeOptions ) ([] ComputedValue , error ) {
if options == nil {
options = & ComputeOptions {}
}
compute := & compute {
options : options ,
db : db ,
computedParameterByName : map [ string ] ComputedValue {},
parameterSchemasByName : map [ string ] database . ParameterSchema {},
}
// All parameters for the import job ID!
2022-04-06 12:42:40 -05:00
parameterSchemas , err := db . GetParameterSchemasByJobID ( ctx , scope . TemplateImportJobID )
2022-02-12 13:34:04 -06:00
if errors . Is ( err , sql . ErrNoRows ) {
err = nil
}
if err != nil {
2022-04-06 12:42:40 -05:00
return nil , xerrors . Errorf ( "get template parameters: %w" , err )
2022-02-12 13:34:04 -06:00
}
for _ , parameterSchema := range parameterSchemas {
compute . parameterSchemasByName [ parameterSchema . Name ] = parameterSchema
}
// Job parameters come second!
2022-06-17 12:22:28 -05:00
err = compute . injectScope ( ctx , database . ParameterValuesParams {
Scopes : [] database . ParameterScope { database . ParameterScopeImportJob },
ScopeIds : [] uuid . UUID { scope . TemplateImportJobID },
2022-02-12 13:34:04 -06:00
})
if err != nil {
return nil , err
}
2022-04-06 12:42:40 -05:00
// Default template parameter values come second!
2022-02-12 13:34:04 -06:00
for _ , parameterSchema := range parameterSchemas {
if parameterSchema . DefaultSourceScheme == database . ParameterSourceSchemeNone {
continue
}
if _ , ok := compute . computedParameterByName [ parameterSchema . Name ]; ok {
// We already have a value! No need to use the default.
continue
}
switch parameterSchema . DefaultSourceScheme {
case database . ParameterSourceSchemeData :
// Inject a default value scoped to the import job ID.
// This doesn't need to be inserted into the database,
// because it's a dynamic value associated with the schema.
err = compute . injectSingle ( database . ParameterValue {
ID : uuid . New (),
CreatedAt : database . Now (),
UpdatedAt : database . Now (),
SourceScheme : database . ParameterSourceSchemeData ,
Name : parameterSchema . Name ,
DestinationScheme : parameterSchema . DefaultDestinationScheme ,
SourceValue : parameterSchema . DefaultSourceValue ,
Scope : database . ParameterScopeImportJob ,
2022-04-06 12:42:40 -05:00
ScopeID : scope . TemplateImportJobID ,
2022-02-12 13:34:04 -06:00
}, true )
if err != nil {
return nil , xerrors . Errorf ( "insert default value: %w" , err )
}
default :
2022-04-06 12:42:40 -05:00
return nil , xerrors . Errorf ( "unsupported source scheme for template version parameter %q: %q" , parameterSchema . Name , string ( parameterSchema . DefaultSourceScheme ))
2022-02-12 13:34:04 -06:00
}
}
2022-04-06 12:42:40 -05:00
if scope . TemplateID . Valid {
// Template parameters come third!
2022-06-17 12:22:28 -05:00
err = compute . injectScope ( ctx , database . ParameterValuesParams {
Scopes : [] database . ParameterScope { database . ParameterScopeTemplate },
ScopeIds : [] uuid . UUID { scope . TemplateID . UUID },
2022-02-12 13:34:04 -06:00
})
if err != nil {
return nil , err
}
}
if scope . WorkspaceID . Valid {
// Workspace parameters come last!
2022-06-17 12:22:28 -05:00
err = compute . injectScope ( ctx , database . ParameterValuesParams {
Scopes : [] database . ParameterScope { database . ParameterScopeWorkspace },
ScopeIds : [] uuid . UUID { scope . WorkspaceID . UUID },
2022-02-12 13:34:04 -06:00
})
if err != nil {
return nil , err
}
}
2022-06-02 00:44:53 +10:00
// Finally, any additional parameter values declared in the input
for _ , v := range scope . AdditionalParameterValues {
err = compute . injectSingle ( v , false )
if err != nil {
return nil , xerrors . Errorf ( "inject single parameter value: %w" , err )
}
}
2022-02-12 13:34:04 -06:00
values := make ([] ComputedValue , 0 , len ( compute . computedParameterByName ))
for _ , value := range compute . computedParameterByName {
values = append ( values , value )
}
2022-07-18 19:39:24 +03:00
slices . SortFunc ( values , func ( a , b ComputedValue ) bool {
return a . index < b . index
})
2022-02-12 13:34:04 -06:00
return values , nil
}
type compute struct {
options * ComputeOptions
db database . Store
computedParameterByName map [ string ] ComputedValue
parameterSchemasByName map [ string ] database . ParameterSchema
}
// Validates and computes the value for parameters; setting the value on "parameterByName".
2022-06-17 12:22:28 -05:00
func ( c * compute ) injectScope ( ctx context . Context , scopeParams database . ParameterValuesParams ) error {
scopedParameters , err := c . db . ParameterValues ( ctx , scopeParams )
2022-02-12 13:34:04 -06:00
if errors . Is ( err , sql . ErrNoRows ) {
err = nil
}
if err != nil {
2022-06-17 12:22:28 -05:00
return xerrors . Errorf ( "get %s parameters: %w" , scopeParams . Scopes , err )
2022-02-12 13:34:04 -06:00
}
for _ , scopedParameter := range scopedParameters {
err = c . injectSingle ( scopedParameter , false )
if err != nil {
return xerrors . Errorf ( "inject single %q: %w" , scopedParameter . Name , err )
}
}
return nil
}
func ( c * compute ) injectSingle ( scopedParameter database . ParameterValue , defaultValue bool ) error {
parameterSchema , hasParameterSchema := c . parameterSchemasByName [ scopedParameter . Name ]
if ! hasParameterSchema {
2022-04-06 12:42:40 -05:00
// Don't inject parameters that aren't defined by the template.
2022-02-12 13:34:04 -06:00
return nil
}
_ , hasParameterValue := c . computedParameterByName [ scopedParameter . Name ]
if hasParameterValue {
if ! parameterSchema . AllowOverrideSource &&
2022-06-03 11:49:58 -07:00
// Workspaces cannot override anything on a template!
scopedParameter . Scope == database . ParameterScopeWorkspace {
2022-02-12 13:34:04 -06:00
return nil
}
}
switch scopedParameter . SourceScheme {
case database . ParameterSourceSchemeData :
value := ComputedValue {
ParameterValue : scopedParameter ,
SchemaID : parameterSchema . ID ,
DefaultSourceValue : defaultValue ,
2022-07-18 19:39:24 +03:00
index : parameterSchema . Index ,
2022-02-12 13:34:04 -06:00
}
if c . options . HideRedisplayValues && ! parameterSchema . RedisplayValue {
value . SourceValue = ""
}
c . computedParameterByName [ scopedParameter . Name ] = value
default :
return xerrors . Errorf ( "unsupported source scheme: %q" , string ( parameterSchema . DefaultSourceScheme ))
}
return nil
}