Skip to content

Commit c4644e1

Browse files
kylecarbskylecarbs
committed
Improve naming, abstract inject to consume scope
1 parent ace6248 commit c4644e1

File tree

1 file changed

+51
-68
lines changed

1 file changed

+51
-68
lines changed

‎coderd/projectparameter/projectparameter.go

Lines changed: 51 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -34,159 +34,142 @@ type Value struct {
3434
}
3535

3636
// Compute accepts a scope in which parameter values are sourced.
37-
// These sources are iterated in a hierarchial fashion to determine
38-
// the runtime parameter vaues for a project.
37+
// These sources are iterated in a hierarchical fashion to determine
38+
// the runtime parameter values for a project.
3939
func Compute(ctx context.Context, db database.Store, scope Scope) ([]Value, error) {
4040
compute := &compute{
41-
parameterByName: map[string]Value{},
42-
projectParameterByName: map[string]database.ProjectParameter{},
41+
db: db,
42+
computedParameterByName: map[string]Value{},
43+
projectHistoryParametersByName: map[string]database.ProjectParameter{},
4344
}
4445

4546
// All parameters for the project version!
4647
projectHistoryParameters, err := db.GetProjectParametersByHistoryID(ctx, scope.ProjectHistoryID)
4748
if errors.Is(err, sql.ErrNoRows) {
48-
// It's valid to have no parameters!
49+
// This occurs when the project history has defined
50+
// no parameters, so we have nothing to compute!
4951
return []Value{}, nil
5052
}
5153
if err != nil {
5254
return nil, xerrors.Errorf("get project parameters: %w", err)
5355
}
54-
for _, projectParameter := range projectHistoryParameters {
55-
compute.projectParameterByName[projectParameter.Name] = projectParameter
56+
for _, projectHistoryParameter := range projectHistoryParameters {
57+
compute.projectHistoryParametersByName[projectHistoryParameter.Name] = projectHistoryParameter
5658
}
5759

5860
// Organization parameters come first!
59-
organizationParameters, err := db.GetParameterValuesByScope(ctx, database.GetParameterValuesByScopeParams{
61+
err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
6062
Scope: database.ParameterScopeOrganization,
6163
ScopeID: scope.OrganizationID,
6264
})
63-
if errors.Is(err, sql.ErrNoRows) {
64-
err = nil
65-
}
6665
if err != nil {
67-
return nil, xerrors.Errorf("get organization parameters: %w", err)
68-
}
69-
err = compute.inject(organizationParameters)
70-
if err != nil {
71-
return nil, xerrors.Errorf("inject organization parameters: %w", err)
66+
return nil, err
7267
}
7368

7469
// Default project parameter values come second!
75-
for _, projectParameter := range projectHistoryParameters {
76-
if !projectParameter.DefaultSourceValue.Valid {
70+
for _, projectHistoryParameter := range projectHistoryParameters {
71+
if !projectHistoryParameter.DefaultSourceValue.Valid {
7772
continue
7873
}
79-
if !projectParameter.DefaultDestinationValue.Valid {
74+
if !projectHistoryParameter.DefaultDestinationValue.Valid {
8075
continue
8176
}
8277

83-
destinationScheme, err := convertDestinationScheme(projectParameter.DefaultDestinationScheme)
78+
destinationScheme, err := convertDestinationScheme(projectHistoryParameter.DefaultDestinationScheme)
8479
if err != nil {
85-
return nil, xerrors.Errorf("convert default destination scheme for project parameter %q: %w", projectParameter.Name, err)
80+
return nil, xerrors.Errorf("convert default destination scheme for project history parameter %q: %w", projectHistoryParameter.Name, err)
8681
}
8782

88-
switch projectParameter.DefaultSourceScheme {
83+
switch projectHistoryParameter.DefaultSourceScheme {
8984
case database.ParameterSourceSchemeData:
90-
compute.parameterByName[projectParameter.Name] = Value{
85+
compute.computedParameterByName[projectHistoryParameter.Name] = Value{
9186
Proto: &proto.ParameterValue{
9287
DestinationScheme: destinationScheme,
93-
Name: projectParameter.DefaultDestinationValue.String,
94-
Value: projectParameter.DefaultSourceValue.String,
88+
Name: projectHistoryParameter.DefaultDestinationValue.String,
89+
Value: projectHistoryParameter.DefaultSourceValue.String,
9590
},
9691
DefaultValue: true,
9792
Scope: database.ParameterScopeProject,
9893
ScopeID: scope.ProjectID.String(),
9994
}
10095
default:
101-
return nil, xerrors.Errorf("unsupported source scheme for project parameter %q: %q", projectParameter.Name, string(projectParameter.DefaultSourceScheme))
96+
return nil, xerrors.Errorf("unsupported source scheme for project history parameter %q: %q", projectHistoryParameter.Name, string(projectHistoryParameter.DefaultSourceScheme))
10297
}
10398
}
10499

105100
// Project parameters come third!
106-
projectParameters, err := db.GetParameterValuesByScope(ctx, database.GetParameterValuesByScopeParams{
101+
err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
107102
Scope: database.ParameterScopeProject,
108103
ScopeID: scope.ProjectID.String(),
109104
})
110-
if errors.Is(err, sql.ErrNoRows) {
111-
err = nil
112-
}
113-
if err != nil {
114-
return nil, xerrors.Errorf("get project parameters: %w", err)
115-
}
116-
err = compute.inject(projectParameters)
117105
if err != nil {
118-
return nil, xerrors.Errorf("inject project parameters: %w", err)
106+
return nil, err
119107
}
120108

121109
// User parameters come fourth!
122-
userParameters, err := db.GetParameterValuesByScope(ctx, database.GetParameterValuesByScopeParams{
110+
err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
123111
Scope: database.ParameterScopeUser,
124112
ScopeID: scope.UserID,
125113
})
126-
if errors.Is(err, sql.ErrNoRows) {
127-
err = nil
128-
}
129114
if err != nil {
130-
return nil, xerrors.Errorf("get user parameters: %w", err)
131-
}
132-
err = compute.inject(userParameters)
133-
if err != nil {
134-
return nil, xerrors.Errorf("inject user parameters: %w", err)
115+
return nil, err
135116
}
136117

137118
// Workspace parameters come last!
138-
workspaceParameters, err := db.GetParameterValuesByScope(ctx, database.GetParameterValuesByScopeParams{
119+
err = compute.inject(ctx, database.GetParameterValuesByScopeParams{
139120
Scope: database.ParameterScopeWorkspace,
140121
ScopeID: scope.WorkspaceID.String(),
141122
})
142-
if errors.Is(err, sql.ErrNoRows) {
143-
err = nil
144-
}
145-
if err != nil {
146-
return nil, xerrors.Errorf("get workspace parameters: %w", err)
147-
}
148-
err = compute.inject(workspaceParameters)
149123
if err != nil {
150-
return nil, xerrors.Errorf("inject workspace parameters: %w", err)
124+
return nil, err
151125
}
152126

153-
for _, projectParameter := range compute.projectParameterByName {
154-
if _, ok := compute.parameterByName[projectParameter.Name]; ok {
127+
for _, projectHistoryParameter := range compute.projectHistoryParametersByName {
128+
if _, ok := compute.computedParameterByName[projectHistoryParameter.Name]; ok {
155129
continue
156130
}
157131
return nil, NoValueError{
158-
ParameterID: projectParameter.ID,
159-
ParameterName: projectParameter.Name,
132+
ParameterID: projectHistoryParameter.ID,
133+
ParameterName: projectHistoryParameter.Name,
160134
}
161135
}
162136

163-
values := make([]Value, 0, len(compute.parameterByName))
164-
for _, value := range compute.parameterByName {
137+
values := make([]Value, 0, len(compute.computedParameterByName))
138+
for _, value := range compute.computedParameterByName {
165139
values = append(values, value)
166140
}
167141
return values, nil
168142
}
169143

170144
type compute struct {
171-
parameterByName map[string]Value
172-
projectParameterByName map[string]database.ProjectParameter
145+
db database.Store
146+
computedParameterByName map[string]Value
147+
projectHistoryParametersByName map[string]database.ProjectParameter
173148
}
174149

175150
// Validates and computes the value for parameters; setting the value on "parameterByName".
176-
func (c *compute) inject(scopedParameters []database.ParameterValue) error {
151+
func (c *compute) inject(ctx context.Context, scopeParams database.GetParameterValuesByScopeParams) error {
152+
scopedParameters, err := c.db.GetParameterValuesByScope(ctx, scopeParams)
153+
if errors.Is(err, sql.ErrNoRows) {
154+
err = nil
155+
}
156+
if err != nil {
157+
return xerrors.Errorf("get %s parameters: %w", scopeParams.Scope, err)
158+
}
159+
177160
for _, scopedParameter := range scopedParameters {
178-
projectParameter, hasProjectParameter := c.projectParameterByName[scopedParameter.Name]
179-
if !hasProjectParameter {
161+
projectHistoryParameter, hasProjectHistoryParameter := c.projectHistoryParametersByName[scopedParameter.Name]
162+
if !hasProjectHistoryParameter {
180163
// Don't inject parameters that aren't defined by the project.
181164
continue
182165
}
183166

184-
_, hasExistingParameter := c.parameterByName[scopedParameter.Name]
167+
_, hasExistingParameter := c.computedParameterByName[scopedParameter.Name]
185168
if hasExistingParameter {
186169
// If a parameter already exists, check if this variable can override it.
187170
// Injection hierarchy is the responsibility of the caller. This check ensures
188171
// project parameters cannot be overridden if already set.
189-
if !projectParameter.AllowOverrideSource && scopedParameter.Scope != database.ParameterScopeProject {
172+
if !projectHistoryParameter.AllowOverrideSource && scopedParameter.Scope != database.ParameterScopeProject {
190173
continue
191174
}
192175
}
@@ -198,15 +181,15 @@ func (c *compute) inject(scopedParameters []database.ParameterValue) error {
198181

199182
switch scopedParameter.SourceScheme {
200183
case database.ParameterSourceSchemeData:
201-
c.parameterByName[projectParameter.Name] = Value{
184+
c.computedParameterByName[projectHistoryParameter.Name] = Value{
202185
Proto: &proto.ParameterValue{
203186
DestinationScheme: destinationScheme,
204187
Name: scopedParameter.SourceValue,
205188
Value: scopedParameter.DestinationValue,
206189
},
207190
}
208191
default:
209-
return xerrors.Errorf("unsupported source scheme: %q", string(projectParameter.DefaultSourceScheme))
192+
return xerrors.Errorf("unsupported source scheme: %q", string(projectHistoryParameter.DefaultSourceScheme))
210193
}
211194
}
212195
return nil

0 commit comments

Comments
 (0)