Class: Highlander::Dsl::SubcomponentParamValueResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/highlander.dsl.component.rb

Class Method Summary collapse

Class Method Details

.resolveComponentParamValue(component, sub_component, param) ⇒ Object 



158
159
160
161
162
163
164
165
 
# File 'lib/highlander.dsl.component.rb', line 158

def self.resolveComponentParamValue(component, sub_component, param)
  # check component config for param value
  # TODO
  # check stack config for param value
  # TODO
  # return default value
  return "'#{param.default_value}'"
end

.resolveMappingParamValue(component, sub_component, param) ⇒ Object 



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/highlander.dsl.component.rb', line 167

def self.resolveMappingParamValue(component, sub_component, param)

  # determine map name

  provider = nil

  mappings_name = param.mapName
  actual_map_name = mappings_name

  key_name = nil

  # priority 0: stack-level parameter of map name
  stack_param_mapname = component.parameters.param_list.find { |p| p.name == mappings_name }
  unless stack_param_mapname.nil?
    key_name = "Ref('#{mappings_name}')"
  end

  # priority 1 mapping provider keyName - used as lowest priority
  if key_name.nil?
    provider = mappings_provider(mappings_name)
    if ((not provider.nil?) and (provider.respond_to?('getDefaultKey')))
      key_name = provider.getDefaultKey
    end
  end

  # priority 2: dsl defined key name
  if key_name.nil?
    key_name = param.mapKey
    # could still be nil after this line
  end

  value =  mapping_value(component: component,
      provider_name: mappings_name,
      value_name: param.mapAttribute,
      key_name: key_name
  )

  if value.nil?
    return "'#{param.default_value}'" unless param.default_value.empty?
    return "''"
  end

  return value


  return value
end

.resolveOutputParamValue(component, sub_component, param) ⇒ Object 



215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/highlander.dsl.component.rb', line 215

def self.resolveOutputParamValue(component, sub_component, param)
  component_name = param.component
  resource_name = nil
  if not sub_component.export_config.nil?
    if sub_component.export_config.key? component_name
      resource_name = sub_component.export_config[component_name]
    end
  end

  if resource_name.nil?
    # find by component
    resource = component.components.find { |c| c.name == component_name }
    resource_name = resource.name unless resource.nil?
    if resource_name.nil?
      resource = component.components.find { |c| c.template == component_name }
      resource_name = resource.name unless resource.nil?
    end
  end

  if resource_name.nil?
    raise "#{sub_component.name}.Params.#{param.name}: Failed to resolve OutputParam '#{param.name}' with source '#{component_name}'. Component not found!"
  end

  return "FnGetAtt('#{resource_name}','Outputs.#{param.name}')"
end

.resolveStackParamValue(component, sub_component, param) ⇒ Object 



153
154
155
156
 
# File 'lib/highlander.dsl.component.rb', line 153

def self.resolveStackParamValue(component, sub_component, param)
  param_name = param.is_global ? param.name : "#{sub_component.name}#{param.name}"
  return "Ref('#{param_name}')"
end

.resolveValue(component, sub_component, param) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/highlander.dsl.component.rb', line 131

def self.resolveValue(component, sub_component, param)

  puts("Resolving parameter #{component.name} -> #{sub_component.name}.#{param.name}")

  # check if there are values defined on component itself
  if sub_component.param_values.key?(param.name)
    return Highlander::Helper.parameter_cfndsl_value(sub_component.param_values[param.name])
  end

  if param.class == Highlander::Dsl::StackParam
    return self.resolveStackParamValue(component, sub_component, param)
  elsif param.class == Highlander::Dsl::ComponentParam
    return self.resolveComponentParamValue(component, sub_component, param)
  elsif param.class == Highlander::Dsl::MappingParam
    return self.resolveMappingParamValue(component, sub_component, param)
  elsif param.class == Highlander::Dsl::OutputParam
    return self.resolveOutputParamValue(component, sub_component, param)
  else
    raise "#{param.class} not resolvable to parameter value"
  end
end