lono 6.1.11 → 7.0.0

data/lib/lono/cfn/rollback.rb

@@ -3,15 +3,15 @@ class Lono::Cfn
     extend Memoist
     include Lono::AwsServices
 
-    def initialize(stack_name)
-      @stack_name = stack_name
+    def initialize(stack)
+      @stack = stack
     end
 
     def delete_stack
-      stack = find_stack(@stack_name)
+      stack = find_stack(@stack)
       if stack && rollback_complete?(stack)
         puts "Existing stack in ROLLBACK_COMPLETE state. Deleting stack before continuing."
-        cfn.delete_stack(stack_name: @stack_name)
+        cfn.delete_stack(stack_name: @stack)
         status.wait
         status.reset
         true
@@ -19,7 +19,7 @@ class Lono::Cfn
     end
 
     def status
-      Lono::Cfn::Status.new(@stack_name)
+      Lono::Cfn::Status.new(@stack)
     end
     memoize :status
   end

data/lib/lono/cfn/status.rb

@@ -1,14 +1,4 @@
 class Lono::Cfn
   class Status < CfnStatus
-    include Util
-
-    def initialize(stack_name, options={})
-      super
-      @stack_name = switch_current(stack_name)
-    end
-
-    def switch_current(stack_name)
-      Lono::Cfn::Current.name!(stack_name)
-    end
   end
 end

data/lib/lono/cfn/update.rb

@@ -1,13 +1,9 @@
 class Lono::Cfn
   class Update < Base
-    # save_stack is the interface method
-    def save_stack(params)
-      update_stack(params)
-    end
-
+    # save is the interface method
     # aws cloudformation update-stack --stack-name prod-hi-123456789 --parameters file://output/params/prod-hi-123456789.json --template-body file://output/prod-hi.json
-    def update_stack(params)
-      message = "Updating #{@stack_name} stack"
+    def save(parameters)
+      message = "Updating #{@stack} stack"
       if @options[:noop]
         puts "NOOP #{message}"
         return
@@ -15,60 +11,59 @@ class Lono::Cfn
 
       deleted = delete_rollback_stack
       if deleted
-        Create.new(@stack_name, @options).create_stack(params)
+        Create.new(@options).save(parameters)
         return
       end
 
-      unless stack_exists?(@stack_name)
-        puts "Cannot update a stack because the #{@stack_name} does not exists."
+      unless stack_exists?(@stack)
+        puts "Cannot update a stack because the #{@stack} does not exists."
         return
       end
-      exit_unless_updatable!(stack_status(@stack_name))
+      exit_unless_updatable!
 
       options = @options.merge(mute_params: true, mute_using: true, keep: true)
       # create new copy of preview when update_stack is called because of IAM retry logic
-      changeset_preview = Lono::Cfn::Preview::Changeset.new(@stack_name, options)
+      changeset_preview = Lono::Cfn::Preview::Changeset.new(options)
 
-      error = nil
       param_preview.run if @options[:param_preview]
       codediff_preview.run if @options[:codediff_preview]
       changeset_preview.run if @options[:changeset_preview]
-      are_you_sure?(@stack_name, :update)
+      sure?("Are you sure you want to update the #{@stack} stack?")
 
       if @options[:change_set] # defaults to this
         message << " via change set: #{changeset_preview.change_set_name}"
         changeset_preview.execute_change_set
       else
-        standard_update(params)
+        standard_update(parameters)
       end
-      puts message unless @options[:mute] || error
+      puts message unless @options[:mute]
     end
 
-    def standard_update(params)
-      params = {
-        stack_name: @stack_name,
-        parameters: params,
+    def standard_update(parameters)
+      options = {
+        stack_name: @stack,
+        parameters: parameters,
         capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
         disable_rollback: !@options[:rollback],
       }
-      params[:tags] = tags unless tags.empty?
-      set_template_body!(params)
-      show_parameters(params, "cfn.update_stack")
+      options[:tags] = tags unless tags.empty?
+      set_template_url!(options)
+      show_options(options, "cfn.update_stack")
       begin
-        cfn.update_stack(params)
+        cfn.update_stack(options)
       rescue Aws::CloudFormation::Errors::ValidationError => e
-        puts "ERROR: #{e.message}".red
+        puts "ERROR: #{e.message}".color(:red)
         false
       end
     end
 
     def codediff_preview
-      Lono::Cfn::Preview::Codediff.new(@stack_name, @options.merge(mute_params: true, mute_using: true))
+      Lono::Cfn::Preview::Codediff.new(@options.merge(mute_params: true, mute_using: true))
     end
     memoize :codediff_preview
 
     def param_preview
-      Lono::Cfn::Preview::Param.new(@stack_name, @options)
+      Lono::Cfn::Preview::Param.new(@options)
     end
     memoize :param_preview
   end

data/lib/lono/clean.rb

@@ -2,13 +2,13 @@ require "fileutils"
 
 class Lono::Clean
   attr_reader :options
-  def initialize(options)
+  def initialize(options={})
     @options = options
   end
 
   def run
-    puts "Cleaning up"
-    puts "Removing output/ folder"
+    puts "Clean: removing output/ and tmp/ folder"
     FileUtils.rm_rf("#{Lono.config.output_path}")
+    FileUtils.rm_rf("#{Lono.root}/tmp")
   end
 end

data/lib/lono/cli.rb

@@ -1,6 +1,7 @@
 module Lono
   class CLI < Command
     include Thor::Actions # for add_runtime_options
+    opts = Opts.new(self)
 
     long_desc Help.text(:new)
     New.cli_options.each do |args|
@@ -8,58 +9,71 @@ module Lono
     end
     register(New, "new", "new NAME", "Generates new lono project.")
 
-    desc "blueprints", "Lists project blueprints"
+    desc "blueprints", "Lists blueprints"
     long_desc Help.text(:blueprints)
     def blueprints
-      Blueprint::List.available
+      Finder::Blueprint.list
     end
 
-    desc "generate", "Generate both CloudFormation templates and parameters files."
+    desc "configsets [BLUEPRINT]", "Lists configsets"
+    long_desc Help.text(:configsets)
+    opts.source
+    opts.stack
+    def configsets(blueprint=nil)
+      Configset::List.new(options.merge(blueprint: blueprint)).run
+    end
+
+    desc "generate BLUEPRINT", "Generate both CloudFormation templates and parameters files."
     long_desc Help.text(:generate)
-    option :clean, type: :boolean, default: false, desc: "remove all output files before generating"
     option :quiet, type: :boolean, desc: "silence the output"
-    option :stack, desc: "stack name. defaults to blueprint name."
-    def generate(blueprint=nil)
-      Blueprint::Find.one_or_all(blueprint).each do |b|
-        Script::Build.new(b, options).run
-        Template::Generator.new(b, options).run
-        Param::Generator.new(b, options).generate
-      end
+    opts.clean
+    opts.source
+    opts.stack
+    opts.template
+    def generate(blueprint)
+      o = options.merge(blueprint: blueprint)
+      Script::Build.new(o).run
+      Template::Generator.new(o).run
+      Param::Generator.new(o).generate
     end
 
     desc "user_data NAME", "Generates user_data script for debugging."
     long_desc Help.text(:user_data)
-    option :clean, type: :boolean, default: true, desc: "remove all output/user_data files before generating"
+    opts.clean
     def user_data(blueprint, name)
       Script::Build.new(blueprint, options).run
       UserData.new(blueprint, options.merge(name: name)).generate
     end
 
-    desc "summary BLUEPRINT TEMPLATE", "Prints summary of CloudFormation templates."
+    desc "summary BLUEPRINT", "Prints summary of CloudFormation templates."
     long_desc Help.text("summary")
-    def summary(blueprint=nil, template=nil)
-      Lono::Inspector::Summary.new(blueprint, template, options).run
+    opts.source
+    opts.template
+    def summary(blueprint)
+      Lono::Inspector::Summary.new(options.merge(blueprint: blueprint)).run
     end
 
     desc "xgraph STACK", "Graphs dependencies tree of CloudFormation template resources."
     long_desc Help.text("xgraph")
     option :display, type: :string, desc: "graph or text", default: "graph"
     option :noop, type: :boolean, desc: "noop mode"
-    def xgraph(blueprint, template=nil)
-      template ||= blueprint
-      Lono::Inspector::Graph.new(blueprint, template, options).run
+    opts.source
+    opts.template
+    def xgraph(blueprint)
+      Lono::Inspector::Graph.new(options.merge(blueprint: blueprint)).run
     end
 
     desc "seed BLUEPRINT", "Generates starter configs for a blueprint."
     long_desc Help.text("seed")
     option :param, desc: "override convention and specify the param file to use"
-    option :template, desc: "override convention and specify the template file to use"
+    opts.source
+    opts.template
     add_runtime_options! # Thor::Action options like --force
     def seed(blueprint)
-      Seed.new(blueprint, options).create
+      Seed.new(options.merge(blueprint: blueprint)).create
     end
 
-    desc "app_files BLUEPRINT", "Builds app files"
+    desc "app_files BLUEPRINT", "Builds app files", hide: true
     long_desc Help.text("app_files")
     add_runtime_options! # Thor::Action options like --force
     def app_files(blueprint)
@@ -71,6 +85,12 @@ module Lono
       Clean.new(options).run
     end
 
+    desc "upgrade", "Upgrade lono"
+    long_desc Help.text("upgrade")
+    def upgrade
+      Upgrade.new(options).run
+    end
+
     desc "completion *PARAMS", "Prints words for auto-completion."
     long_desc Help.text("completion")
     def completion(*params)
@@ -86,35 +106,50 @@ module Lono
     desc "version", "Prints version"
     def version
       puts "Lono: #{VERSION}"
-      puts "Lono Pro Addon: #{Lono.pro_version}"
     end
 
-    desc "template SUBCOMMAND", "template subcommands"
-    long_desc Help.text(:template)
-    subcommand "template", Template
+    desc "blueprint SUBCOMMAND", "blueprint subcommands"
+    long_desc Help.text(:blueprint)
+    subcommand "blueprint", Blueprint
 
     desc "cfn SUBCOMMAND", "cfn subcommands"
     long_desc Help.text(:cfn)
     subcommand "cfn", Cfn
 
+    desc "code SUBCOMMAND", "code subcommands"
+    long_desc Help.text(:code)
+    subcommand "code", Code
+
+    desc "configset SUBCOMMAND", "configset subcommands"
+    long_desc Help.text(:configset)
+    subcommand "configset", Configset
+
     desc "param SUBCOMMAND", "param subcommands"
     long_desc Help.text(:param)
     subcommand "param", Param
 
-    desc "script SUBCOMMAND", "script subcommands"
-    long_desc Help.text(:script)
-    subcommand "script", Script
+    desc "pro SUBCOMMAND", "pro subcommands"
+    long_desc Help.text(:pro)
+    subcommand "pro", Pro
 
-    desc "upgrade SUBCOMMAND", "upgrade subcommands"
-    long_desc Help.text(:upgrade)
-    subcommand "upgrade", Upgrade
+    desc "registration SUBCOMMAND", "registration subcommands"
+    long_desc Help.text(:registration)
+    subcommand "registration", Registration
 
     desc "s3 SUBCOMMAND", "s3 subcommands"
     long_desc Help.text(:s3)
     subcommand "s3", S3
 
-    desc "blueprint SUBCOMMAND", "blueprint subcommands"
-    long_desc Help.text(:blueprint)
-    subcommand "blueprint", Blueprint
+    desc "script SUBCOMMAND", "script subcommands"
+    long_desc Help.text(:script)
+    subcommand "script", Script
+
+    desc "sets SUBCOMMAND", "sets subcommands"
+    long_desc Help.text(:sets)
+    subcommand "sets", Sets
+
+    desc "template SUBCOMMAND", "template subcommands"
+    long_desc Help.text(:template)
+    subcommand "template", Template
   end
 end

data/lib/lono/code.rb

@@ -0,0 +1,22 @@
+module Lono
+  class Code < Lono::Command
+    desc "import SOURCE", "Imports CloudFormation template and converts it to Ruby code."
+    long_desc Help.text("code/import")
+    option :blueprint, default: nil, desc: "final blueprint name"
+    option :casing, default: "as-is", desc: "Controls casing of logical ids. IE: as-is, camelcase or underscore"
+    option :summary, default: true, type: :boolean, desc: "provide template summary after import"
+    option :template, default: nil, desc: "final template name of downloaded template without extension"
+    option :template_name_casing, default: "dasherize", desc: "camelcase or dasherize the template name"
+    option :type, default: "dsl", desc: "import as a DSL or ERB template"
+    def import(source)
+      Importer.new(options.merge(source: source)).run
+    end
+
+    desc "convert SOURCE", "Converts snippet of JSON or YAML CloudFormation templates to Ruby code."
+    long_desc Help.text("code/convert")
+    option :casing, default: "as-is", desc: "Controls casing of logical ids. IE: as-is, camelcase or underscore"
+    def convert(source)
+      Importer::Converter.new(options.merge(source: source)).run
+    end
+  end
+end

data/lib/lono/command.rb

@@ -91,6 +91,13 @@ module Lono
       def website
         "http://lono.cloud"
       end
+
+      # https://github.com/erikhuda/thor/issues/244
+      # Deprecation warning: Thor exit with status 0 on errors. To keep this behavior, you must define `exit_on_failure?` in `Lono::CLI`
+      # You can silence deprecations warning by setting the environment variable THOR_SILENCE_DEPRECATION.
+      def exit_on_failure?
+        true
+      end
     end
   end
 end

data/lib/lono/config_location.rb

@@ -1,16 +1,11 @@
 module Lono
-  class ConfigLocation
+  class ConfigLocation < AbstractBase
     extend Memoist
-    include Lono::Conventions
 
     def initialize(config, options={}, env=Lono.env, root=Lono.root)
+      super(options)
       # config can be params or variables
-      @config, @options, @root, @env = config, options, root, env
-
-      @stack = options[:stack]
-      @blueprint = options[:blueprint] || @stack
-      @template, @param = template_param_convention(options)
-
+      @config, @options, @env, @root = config, options, env, root
       @requested = determine_requested
     end
 
@@ -73,14 +68,12 @@ module Lono
     def determine_requested
       # param is usually set from the convention. when set from convention stack name takes higher precedence
       config_key = @config.singularize.to_sym # param or variable
-      @options[config_key] || @options[:config] || @options[:stack]
+      @options[config_key] || @options[:config] || @stack
     end
 
     def requested_file(path)
-      # List of paths to consider from initial path provided
-      paths = @config == "params" ?
-                [path, "#{path}.txt", "#{path}.sh"] :
-                [path, "#{path}.rb"]
+      # List of paths to consider from initial path provided. Combine params and variables possible paths for simplicity.
+      paths = [path, "#{path}.txt", "#{path}.sh", "#{path}.rb"].compact
       paths.find { |p| File.file?(p) }
     end
     memoize :requested_file

data/lib/lono/configset.rb

@@ -0,0 +1,9 @@
+module Lono
+  class Configset < Command
+    long_desc Help.text("configset/new")
+    New.cli_options.each do |args|
+      option(*args)
+    end
+    register(New, "new", "new NAME", "Generates new lono configset.")
+  end
+end

data/lib/lono/configset/combiner.rb

@@ -0,0 +1,128 @@
+require "yaml"
+
+class Lono::Configset
+  class Combiner
+    def initialize(cfn, options={})
+      @cfn, @options = cfn, options
+
+      @sets = []
+      @map = {} # stores resource logical id => metadata cfn-init
+    end
+
+    def metadata_map
+      return {} unless additional_configsets?
+
+      existing_configsets.each do |data|
+        add(data[:registry], data[:metdata_configset])
+      end
+
+      Register::Blueprint.configsets.each do |registry|
+        loader = Lono::Blueprint::Configset::Loader.new(registry, @options)
+        add(registry, loader.metdata_configset)
+      end
+      Register::Project.configsets.each do |registry|
+        loader = Loader.new(registry, @options)
+        add(registry, loader.metdata_configset)
+      end
+
+      combine
+      Register::Blueprint.clear! # in case of lono generate for all templates
+      Register::Project.clear! # in case of lono generate for all templates
+      @map
+    end
+
+    def add(registry, metadata)
+      @sets << [registry, metadata.dup]
+    end
+
+    def additional_configsets?
+      !Register::Blueprint.configsets.empty? || !Register::Project.configsets.empty?
+    end
+
+    # Normalized/convert cfn template to mimic the registry format
+    def existing_configsets
+      configsets = []
+      @cfn["Resources"].each do |logical_id, attributes|
+        init = attributes.dig("Metadata", "AWS::CloudFormation::Init")
+
+        next unless init
+
+        data = {
+          registry: Lono::Configset::Registry.new(["#{logical_id}OriginalConfigset"], resource: logical_id),
+          metdata_configset: attributes["Metadata"]
+        }
+        configsets << data
+      end
+      configsets
+    end
+
+    def combine
+      # Remove duplicate configsets. Can happen if same configset is in blueprint and project.
+      # Ugly because of the sets structure.
+      @sets.uniq! do |array|
+        registry, _ = array
+        registry.name
+      end
+
+      metadata_map = {}
+
+      @sets.each_with_index do |array, i|
+        padded_i = "%03d" % i
+        registry, metadata = array
+        name, resource = registry.name, registry.resource
+
+        metadata_map[resource] ||= {"AWS::CloudFormation::Init" => {"configSets" => {}}}
+        configSets = metadata_map[resource]["AWS::CloudFormation::Init"]["configSets"]
+
+        configSets["default"] ||= []
+        configSets["default"] << {"ConfigSet" => name}
+
+        validate_structure!(name, metadata)
+        init = metadata["AWS::CloudFormation::Init"]
+
+        if init.key?("configSets")
+          cs = init.delete("configSets") # Only support configSets with simple Array of Strings
+          validate_simple!(registry, cs)
+          configSets[name] = cs["default"].map {|c| "#{padded_i}_#{c}" }
+          init.transform_keys! { |c| "#{padded_i}_#{c}" }
+        else # simple config
+          config_key = "#{padded_i}_single_generated"
+          configSets[name] = [config_key]
+          init = {config_key => init["config"]}
+        end
+
+        metadata_map[resource]["AWS::CloudFormation::Init"].merge!(init)
+        @map[resource] = metadata_map[resource]
+      end
+      @map
+    end
+
+    def validate_structure!(name, metadata)
+      return if metadata.is_a?(Hash) && metadata.key?("AWS::CloudFormation::Init")
+
+      puts "ERROR: The #{name} configset does not appear to have a AWS::CloudFormation::Init key".color(:red)
+      puts "Please double check the #{name} configset.yml structure"
+      exit 1
+    end
+
+    def validate_simple!(registry, cs)
+      has_complex_type = cs["default"].detect { |s| !s.is_a?(String) }
+      if has_complex_type
+        message =<<~EOL
+          ERROR: The configset #{registry.name} has a configSets property with a complex type.
+          configSets:
+
+              #{cs}
+
+          lono configsets only supports combining configSets with an Array of Strings.
+        EOL
+        if ENV['LONO_TEST']
+          raise message
+        else
+          puts message.color(:red)
+          exit 1
+        end
+      end
+    end
+  end
+end