lono 6.1.11 → 7.0.0

data/lib/lono/script/base.rb

@@ -1,14 +1,5 @@
 class Lono::Script
-  class Base
+  class Base < Lono::AbstractBase
     SCRIPTS_INFO_PATH = "#{Lono.config.output_path}/data/scripts_info.txt"
-    include Lono::Blueprint::Root
-
-    def initialize(blueprint, options={})
-      @blueprint, @options = blueprint, options
-      @template = @options[:template] || @blueprint
-      Lono::ProjectChecker.check
-      set_blueprint_root(@blueprint)
-      Lono::ProjectChecker.empty_templates
-    end
   end
 end

data/lib/lono/script/upload.rb

@@ -3,6 +3,7 @@ require "filesize"
 class Lono::Script
   class Upload < Base
     include Lono::AwsServices
+    include Lono::Utils::PrettyTime
 
     def run
       Lono::ProjectChecker.check
@@ -18,7 +19,7 @@ class Lono::Script
       start_time = Time.now
       obj.upload_file(tarball_path)
       time_took = pretty_time(Time.now-start_time).color(:green)
-      puts "Time to upload code to s3: #{time_took}"
+      puts "Time took to upload code to s3: #{time_took}"
     end
 
     def filesize
@@ -50,16 +51,5 @@ class Lono::Script
     def tarball_path
       IO.read(SCRIPTS_INFO_PATH).strip
     end
-
-    # http://stackoverflow.com/questions/4175733/convert-duration-to-hoursminutesseconds-or-similar-in-rails-3-or-ruby
-    def pretty_time(total_seconds)
-      minutes = (total_seconds / 60) % 60
-      seconds = total_seconds % 60
-      if total_seconds < 60
-        "#{seconds.to_i}s"
-      else
-        "#{minutes.to_i}m #{seconds.to_i}s"
-      end
-    end
   end
 end

data/lib/lono/seed.rb

@@ -1,18 +1,9 @@
 module Lono
-  class Seed
-    include Lono::Blueprint::Root
-    include Lono::Conventions
-
-    def initialize(blueprint, options={})
-      @blueprint, @options = blueprint, options
-      set_blueprint_root(@blueprint)
-      @template, @param = template_param_convention(options)
-    end
-
+  class Seed < AbstractBase
     def create
       puts "Creating starter config files for #{@blueprint}"
       configs_class = load_configs_class # ::Configs or Lono::Seed::Base
-      configs = configs_class.new(@blueprint, @options)
+      configs = configs_class.new(@options)
       # The Configs class implements: variables
       configs.run # setup the instance variables
     end

data/lib/lono/seed/base.rb

@@ -12,27 +12,23 @@ require "yaml"
 # Note there is no params method to hook. The Base class handles params well.
 #
 class Lono::Seed
-  class Base
-    include Lono::Blueprint::Root
+  class Base < Lono::AbstractBase
     include Lono::AwsServices
-    include Lono::Conventions
     include ServiceRole
 
     # What's needed for a Thor::Group or "Sequence"
     # Gives us Thor::Actions commands like create_file
     include Thor::Actions
     include Thor::Base
+    # Override Thor::Base initialize
+    def initialize(options={})
+      reinitialize(options)
+    end
 
     extend Memoist
 
-    # attr_reader :options
-    def initialize(blueprint, options)
-      @blueprint, @options = blueprint, options
-      @template, @param = template_param_convention(options)
-    end
-
     def run
-      check_dsl_type!
+      generate_template
       setup
       self.destination_root = Dir.pwd # Thor::Actions require destination_root to be set
       create_params
@@ -40,74 +36,71 @@ class Lono::Seed
       finish
     end
 
-    def create_params
-      return unless params
-
-      # Only supporting the main blueprint for now
-      path = "#{Lono.config.templates_path}/#{@blueprint}.rb"
-      if File.exist?(path)
-        create_param_file(path)
-      end
-
-      # TODO: detect and write multiple templates to different paths
-      # with_each_template do |path|
-      #   create_param_file(path)
-      # end
+    def generate_template
+      Lono::Template::Generator.new(@options).run
     end
 
-    def params
-      true
+    def create_params
+      return unless params
+      create_param_file
     end
 
-    def create_param_file(app_template_path)
-      parameters = parameters(app_template_path)
-
-      lines = []
-      required = required(parameters)
-      lines << "# Required parameters:" unless required.empty?
-      required.each do |name, data|
-        example = description_example(data["Description"])
-        lines << "#{name}=#{example}"
-      end
-      optional = optional(parameters)
-      lines << "# Optional parameters:" unless optional.empty?
-      optional.each do |name, data|
-        value = default_value(data)
-        lines << "# #{name}=#{value}"
-      end
-
-      if lines.empty?
+    def create_param_file
+      @output_template = Lono::Output::Template.new(@blueprint, @template)
+      if @output_template.parameters.empty?
         puts "Template has no parameters."
         return
       end
 
-      content = lines.join("\n") + "\n"
+      # Generate by parameter group first
+      lines, shown = [], []
+      @output_template.parameter_groups.each do |label, parameters|
+        lines << "# Parameter Group: #{label}"
+        parameters.each do |name|
+          lines << parameter_line(name)
+          shown << name
+        end
+        lines << ""
+      end if @output_template.parameter_groups
+
+      # Then generate the rest
+      @output_template.parameters.each do |name, data|
+        lines << parameter_line(name) unless shown.include?(name)
+      end
+
+      content = lines.join("\n")
       dest_path = "configs/#{@blueprint}/params/#{Lono.env}.txt" # only support environment level parameters for now
       create_file(dest_path, content) # Thor::Action
     end
 
-    def create_variables
-      return unless variables
-      dest_path = "configs/#{@blueprint}/variables/#{Lono.env}.rb"
-      create_file(dest_path, variables) # Thor::Action
+    def parameter_line(name)
+      data = @output_template.parameters[name]
+      example = description_example(data["Description"])
+      if data["Default"].nil?
+        line = "#{name}=#{example} # (required)"
+      else
+        default = data["Default"]
+        line = "# #{name}=#{default}"
+        line = "#{line} # #{example}" if example
+      end
+      line
     end
 
-    def check_dsl_type!
-      dsl_type = template_type == 'dsl'
-      unless dsl_type
-        puts "Detected template_type: #{template_type}"
-        puts "lono seed only supports dsl template types currently."
-        exit 1
-      end
+    def description_example(description)
+      return unless description
+      md = description.match(/(Example|IE): (.*)/)
+      return unless md
+      md[2]
     end
 
-    def template_type
-      blueprint_root = find_blueprint_root(@blueprint)
-      meta_config = "#{blueprint_root}/.meta/config.yml"
-      return false unless File.exist?(meta_config)
+    def params
+      true
+    end
 
-      meta = YAML.load_file(meta_config)
-      meta['template_type']
+    def create_variables
+      return unless variables
+      dest_path = "configs/#{@blueprint}/variables/#{Lono.env}.rb"
+      create_file(dest_path, variables) # Thor::Action
     end
 
     def setup; end
@@ -118,53 +111,5 @@ class Lono::Seed
     def variables
       false
     end
-
-    def write(path, content)
-      FileUtils.mkdir_p(File.dirname(path))
-      IO.write(path, content)
-    end
-
-    def description_example(description)
-      default = ''
-      return default unless description
-      md = description.match(/(Example|IE): (.*)/)
-      return default unless md
-      md[2]
-    end
-
-    def default_value(data)
-      value = data["Default"]
-      # Dont use !blank? since there can be false optional values
-      # Also dont use .empty? since value can be an Integer
-      if value.nil? || value == ''
-        description_example(data["Description"])
-      else
-        value
-      end
-    end
-
-    def parameters(app_template_path)
-      builder = Lono::Template::Dsl::Builder.new(app_template_path, @blueprint, quiet: false)
-      template = builder.template
-      template["Parameters"] || []
-    end
-    memoize :parameters
-
-    def required(parameters)
-      parameters.select { |logical_id, p| p["Default"].nil? } # allow for false
-    end
-
-    def optional(parameters)
-      parameters.select { |logical_id, p| !p["Default"].nil? } # allow for false
-    end
-
-  private
-    def with_each_template
-      paths = Dir.glob("#{Lono.config.templates_path}/**/*.rb")
-      files = paths.select{ |e| File.file?(e) }
-      files.each do |path|
-        yield(path)
-      end
-    end
   end
-end
+end

data/lib/lono/sets.rb

@@ -0,0 +1,38 @@
+module Lono
+  class Sets < Command
+    opts = Opts.new(self)
+
+    desc "deploy STACK_SET", "Deploy CloudFormation stack set."
+    long_desc Help.text("sets/deploy")
+    opts.deploy
+    def deploy(stack)
+      Deploy.new(options.merge(stack: stack)).run
+    end
+
+    desc "status STACK_SET", "Show current status of stack set."
+    long_desc Help.text("sets/status")
+    def status(stack)
+      status = Status.new(@options.merge(stack: stack, delay_for_threads: false))
+      success = status.show
+      exit 3 unless success
+    end
+
+    desc "delete STACK_SET", "Delete CloudFormation stack set."
+    long_desc Lono::Help.text("sets/delete")
+    option :sure, type: :boolean, desc: "Skips are you sure prompt"
+    def delete(stack)
+      Delete.new(options.merge(stack: stack)).run
+    end
+
+    desc "list", "List CloudFormation stack sets."
+    long_desc Lono::Help.text("sets/list")
+    option :status, default: "active", desc: "active, all or deleted"
+    def list
+      List.new(options).run
+    end
+
+    desc "instances SUBCOMMAND", "instances subcommands"
+    long_desc Help.text("sets/instances")
+    subcommand "instances", Instances
+  end
+end

data/lib/lono/sets/base.rb

@@ -0,0 +1,45 @@
+class Lono::Sets
+  class Base < Lono::Cfn::Base
+    def run
+      generate_all
+      save
+    end
+
+    def exit_unless_updatable!
+      return true if ENV['LONO_ENV']
+      return false if @options[:noop]
+
+      status = Status.new(@options) # using status for completed?
+      return if status.stack_instances.empty?
+      completed = status.completed?(status.stack_set_status)
+      unless completed
+        puts "Cannot update stack set because #{@stack} is not in an updatable state.  Stack set status: #{status.stack_set_status}".color(:red)
+        quit(1)
+      end
+    end
+
+    def build_options
+      parameters = generate_all
+      options = {
+        stack_set_name: @stack,
+        parameters: parameters,
+        capabilities: capabilities, # ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"]
+      }
+      options[:tags] = tags unless tags.empty?
+      options[:operation_preferences] = operation_preferences unless operation_preferences.empty?
+      options.reject! {|k, v| v.nil? }
+      set_template_url!(options)
+      options
+    end
+
+    def operation_preferences
+      o = {}
+      o[:failure_tolerance_count] = @options[:failure_tolerance_count]
+      o[:failure_tolerance_percentage] = @options[:failure_tolerance_percentage]
+      o[:max_concurrent_count] = @options[:max_concurrent_count]
+      o[:max_concurrent_percentage] = @options[:max_concurrent_percentage]
+      o.reject! {|k, v| v.nil? }
+      o
+    end
+  end
+end

data/lib/lono/sets/create.rb

@@ -0,0 +1,30 @@
+class Lono::Sets
+  class Create < Base
+    def save
+      message = "Creating #{@stack.color(:green)} stack set."
+      if @options[:noop]
+        puts "NOOP #{message}"
+        return
+      end
+
+      if stack_set_exists?(@stack)
+        puts "Cannot create #{@stack.color(:green)} stack set because it already exists.".color(:red)
+        return
+      end
+
+      unless File.exist?(template_path)
+        puts "Cannot create #{@stack.color(:green)} template not found: #{template_path}."
+        return
+      end
+
+      options = build_options
+      show_options(options, "cfn.create_stack_set")
+
+      sure?("Are you sure you want to create the #{@stack} stack set?")
+
+      cfn.create_stack_set(options) # resp.stack_set_id => String. There is no resp.operation_id
+      puts message unless @options[:mute]
+      true # There is no resp.operation_id
+    end
+  end
+end

data/lib/lono/sets/delete.rb

@@ -0,0 +1,47 @@
+class Lono::Sets
+  class Delete
+    include Lono::AwsServices
+    include Lono::Sets::Summarize
+    include Lono::Utils::Sure
+
+    def initialize(options={})
+      @options = options
+      @stack = options.delete(:stack)
+    end
+
+    def run
+      message = "Deleting #{@stack} stack set."
+      if @options[:noop]
+        puts "NOOP #{message}"
+      else
+        sure?("Are you sure you want to delete the #{@stack} stack set?", "Be sure that it emptied of stack instances first.")
+
+        if stack_set_exists?(@stack)
+          cfn.delete_stack_set(stack_set_name: @stack) # resp is an Empty structure, so much get operation_id from status
+          puts message
+        else
+          puts "#{@stack.inspect} stack set does not exist".color(:red)
+          return
+        end
+      end
+
+      return true if @options[:noop] || !@options[:wait]
+
+      status = Status.new(@options)
+      success = status.wait
+      operation_id = status.operation_id # getting operation_id from status because cfn.delete_stack_set resp is an Empty structure
+      summarize(operation_id)
+      exit 1 unless success
+
+    rescue Aws::CloudFormation::Errors::StackSetNotEmptyException => e
+      puts "ERROR: #{e.class}: #{e.message}".color(:red)
+      puts <<~EOL
+        The stack set must be empty before deleting. Cannot delete stack set until all stack instances are first
+        deleted. If you want to delete all stack instances you can use:
+
+            lono sets instances delete #{@stack} --all
+
+      EOL
+    end
+  end
+end

data/lib/lono/sets/deploy.rb

@@ -0,0 +1,11 @@
+class Lono::Sets
+  class Deploy < Base
+    def run
+      if stack_set_exists?(@stack)
+        Update.new(@options).run
+      else
+        Create.new(@options).run
+      end
+    end
+  end
+end