Class: Lono::Param::Generator

Inherits:
AbstractBase show all
Defined in:
lib/lono/param/generator.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from AbstractBase

#initialize, #reinitialize, #template_path

Methods included from Blueprint::Root

#find_blueprint_root, #set_blueprint_root

Constructor Details

This class inherits a constructor from Lono::AbstractBase

Instance Attribute Details

#base_path ⇒ Object (readonly)

set when generate is called



3
4
5
 
# File 'lib/lono/param/generator.rb', line 3

def base_path
  @base_path
end

#env_path ⇒ Object (readonly)

set when generate is called



3
4
5
 
# File 'lib/lono/param/generator.rb', line 3

def env_path
  @env_path
end

Instance Method Details

#config_locations ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/lono/param/generator.rb', line 36

def config_locations
  @base_path = lookup_config_location("base")
  @env_path = lookup_config_location(Lono.env)

  if ENV['LONO_DEBUG_PARAM']
    puts "LONO_DEBUG_PARAM enabled"
    puts "  @base_path #{@base_path.inspect}"
    puts "  @env_path #{@env_path.inspect}"
  end

  [@base_path, @env_path]
end

#context ⇒ Object

Context for ERB rendering. This is where we control what references get passed to the ERB rendering.



108
109
110
 
# File 'lib/lono/param/generator.rb', line 108

def context
  @context ||= Lono::Template::Context.new(@options)
end

#convert_to_cfn_format(contents, casing = :underscore) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/lono/param/generator.rb', line 123

def convert_to_cfn_format(contents, casing=:underscore)
  lines = parse_contents(contents)

  # First use a Hash structure so that overlay env files will override
  # the base param file.
  data = {}
  lines.each do |line|
    key,value = line.strip.split("=").map {|x| x.strip}
    data[key] = value
  end

  # Now build up the aws json format for parameters
  params = []
  data.each do |key,value|
    param = if value == "use_previous_value" || value == "UsePreviousValue"
              {
                "ParameterKey": key,
                "UsePreviousValue": true
              }
            elsif value
              {
                "ParameterKey": key,
                "ParameterValue": value
              }
            end
    if param
      param = param.to_snake_keys if casing == :underscore
      params << param
    end
  end
  params
end

#generate ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/lono/param/generator.rb', line 5

def generate
  puts "Generating parameter files for blueprint #{@blueprint.color(:green)}:"

  @base_path, @env_path = config_locations

  return {} unless @base_path || @env_path

  # useful option for lono cfn, since some templates dont require params
  return {} if @options[:allow_not_exists] && !params_exist?

  if params_exist?
    contents = process_erb
    data = convert_to_cfn_format(contents)
    camel_data = convert_to_cfn_format(contents, :camel)
    json = JSON.pretty_generate(camel_data)
    write_output(json)
    unless @options[:mute]
      short_output_path = output_path.sub("#{Lono.root}/","")
      puts "  #{short_output_path}"
    end
  else
    puts "#{@base_path} or #{@env_path} could not be found?  Are you sure it exist?"
    exit 1
  end
  data
end

#lookup_config_location(env) ⇒ Object 



49
50
51
52
 
# File 'lib/lono/param/generator.rb', line 49

def lookup_config_location(env)
  location = Lono::ConfigLocation.new("params", @options, env)
  env == "base" ? location.lookup_base : location.lookup
end

#output_path ⇒ Object 



156
157
158
159
160
161
162
163
164
165
 
# File 'lib/lono/param/generator.rb', line 156

def output_path
  output = Lono.config.output_path.sub("#{Lono.root}/","")
  path = if @base_path && !@env_path
           # Handle case when base config exist but the env config does not
           @base_path.sub("configs", output).sub("base", Lono.env)
         else
           @env_path.sub("configs", output)
         end
  path.sub(/\.txt$/,'.json')
end

#parameters ⇒ Object 



32
33
34
 
# File 'lib/lono/param/generator.rb', line 32

def parameters
  generate
end

#params_exist? ⇒ Boolean

Checks both base and source path for existing of the param file. Example:

params/base/mystack.txt - base path
params/production/mystack.txt - source path

Returns:

  • (Boolean) 


67
68
69
70
 
# File 'lib/lono/param/generator.rb', line 67

def params_exist?
  @base_path && File.exist?(@base_path) ||
  @env_path && File.exist?(@env_path)
end

#parse_contents(contents) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
 
# File 'lib/lono/param/generator.rb', line 112

def parse_contents(contents)
  lines = contents.split("\n")
  # remove comment at the end of the line
  lines.map! { |l| l.sub(/#.*/,'').strip }
  # filter out commented lines
  lines = lines.reject { |l| l =~ /(^|\s)#/i }
  # filter out empty lines
  lines = lines.reject { |l| l.strip.empty? }
  lines
end

#process_erb ⇒ Object

Reads both the base source and env source and overlay the two Example 1:

params/base/mystack.txt - base path
params/production/mystack.txt - env path

the base/mystack.txt gets combined with the prod/mystack.txt
it produces a final prod/mystack.txt

Example 2:

params/base/mystack.txt - base path

the base/mystack.txt is used to produced a prod/mystack.txt

Example 3:

params/production/mystack.txt - env path

the prod/mystack.txt is used to produced a prod/mystack.txt



89
90
91
92
93
94
95
96
97
 
# File 'lib/lono/param/generator.rb', line 89

def process_erb
  contents = []
  contents << render_erb(@base_path)
  contents << render_erb(@env_path)
  result = contents.compact.join("\n")
  # puts "process_erb result".color(:yellow)
  # puts result
  result
end

#puts_param_message(type) ⇒ Object 



54
55
56
57
58
59
60
61
 
# File 'lib/lono/param/generator.rb', line 54

def puts_param_message(type)
  path = send("#{type}_path")
  return unless path
  if param_file?(path)
    pretty_path = path.sub("#{Lono.root}/",'')
    puts "Using param for #{type}: #{pretty_path}".color(:yellow)
  end
end

#render_erb(path) ⇒ Object 



99
100
101
102
103
104
 
# File 'lib/lono/param/generator.rb', line 99

def render_erb(path)
  return unless path
  if File.exist?(path)
    RenderMePretty.result(path, context: context)
  end
end

#write_output(json) ⇒ Object 



167
168
169
170
171
 
# File 'lib/lono/param/generator.rb', line 167

def write_output(json)
  dir = File.dirname(output_path)
  FileUtils.mkdir_p(dir)
  IO.write(output_path, json)
end