forger 1.5.0

data/lib/forger/create/params.rb

@@ -0,0 +1,106 @@
+class Forger::Create
+  class Params < Forger::Base
+    # deep_symbolize_keys is ran at the very end only.
+    # up until that point we're dealing with String keys.
+    def generate
+      cleanup
+      params = Forger::Profile.new(@options).load
+      decorate_params(params)
+      normalize_launch_template(params).deep_symbolize_keys
+    end
+
+    def decorate_params(params)
+      upsert_name_tag!(params)
+      replace_runtime_options!(params)
+      params
+    end
+
+    # Expose a list of runtime params that are convenient. Try to limit the
+    # number of options from the cli to keep tool simple. Most options can
+    # be easily control through profile files. The runtime options that are
+    # very convenient to have at the CLI are modified here.
+    def replace_runtime_options!(params)
+      params["image_id"] = @options[:source_ami_id] if @options[:source_ami_id]
+      params
+    end
+
+    def cleanup
+      FileUtils.rm_f("#{Forger.root}/tmp/user-data.txt")
+    end
+
+    # Adds instance ec2 tag if not already provided
+    def upsert_name_tag!(params)
+      specs = params["tag_specifications"] || []
+
+      # insert an empty spec placeholder if one not found
+      spec = specs.find do |s|
+        s["resource_type"] == "instance"
+      end
+      unless spec
+        spec = {
+            "resource_type" => "instance",
+            "tags" => []
+          }
+        specs << spec
+      end
+      # guaranteed there's a tag_specifications with resource_type instance at this point
+
+      tags = spec["tags"] || []
+
+      unless tags.map { |t| t["key"] }.include?("Name")
+        tags << { "key" => "Name", "value" => @name }
+      end
+
+      specs = specs.map do |s|
+        # replace the name tag value
+        if s["resource_type"] == "instance"
+          {
+            "resource_type" => "instance",
+            "tags" => tags
+          }
+        else
+          s
+        end
+      end
+
+      params["tag_specifications"] = specs
+      params
+    end
+
+    # Allow adding launch template as a simple string.
+    #
+    # Standard structure:
+    # {
+    #   launch_template: { launch_template_name: "TestLaunchTemplate" },
+    # }
+    #
+    # Simple string:
+    # {
+    #   launch_template: "TestLaunchTemplate",
+    # }
+    #
+    # When launch_template is a simple String it will get transformed to the
+    # standard structure.
+    def normalize_launch_template(params)
+      if params["launch_template"].is_a?(String)
+        launch_template_identifier = params["launch_template"]
+        launch_template = if launch_template_identifier =~ /^lt-/
+            { "launch_template_id" => launch_template_identifier }
+          else
+            { "launch_template_name" => launch_template_identifier }
+          end
+        params["launch_template"] = launch_template
+      end
+      params
+    end
+
+    # Hard coded sensible defaults.
+    # Can be overridden easily with profiles
+    def defaults
+      {
+        max_count: 1,
+        min_count: 1,
+      }
+    end
+  end
+end

data/lib/forger/dotenv.rb

@@ -0,0 +1,30 @@
+require 'dotenv'
+require 'pathname'
+
+class Forger::Dotenv
+  class << self
+    def load!
+      ::Dotenv.load(*dotenv_files)
+    end
+
+    # dotenv files will load the following files, starting from the bottom. The first value set (or those already defined in the environment) take precedence:
+
+    # - `.env` - The Original®
+    # - `.env.development`, `.env.test`, `.env.production` - Environment-specific settings.
+    # - `.env.local` - Local overrides. This file is loaded for all environments _except_ `test`.
+    # - `.env.development.local`, `.env.test.local`, `.env.production.local` - Local overrides of environment-specific settings.
+    #
+    def dotenv_files
+      [
+        root.join(".env.#{Forger.env}.local"),
+        (root.join(".env.local") unless Forger.env == "test"),
+        root.join(".env.#{Forger.env}"),
+        root.join(".env")
+      ].compact
+    end
+
+    def root
+      Forger.root || Pathname.new(ENV["AWS_EC2_ROOT"] || Dir.pwd)
+    end
+  end
+end

data/lib/forger/help.rb

@@ -0,0 +1,9 @@
+module Forger::Help
+  class << self
+    def text(namespaced_command)
+      path = namespaced_command.to_s.gsub(':','/')
+      path = File.expand_path("../help/#{path}.md", __FILE__)
+      IO.read(path) if File.exist?(path)
+    end
+  end
+end

data/lib/forger/help/ami.md

@@ -0,0 +1,13 @@
+Examples:
+
+    $ forger ami myrubyami --profile ruby --noop
+
+Launches an EC2 instance to create an AMI.  An AMI creation script is appended to the end of the user-data script. The AMI creation script calls `aws ec2 create-image` and causes the instance to reboot at the end.
+
+It is useful to include to timestamp as a part of the AMI name with the date command.
+
+    $ forger ami ruby-2.5.0_$(date "+%Y-%m-%d-%H-%M") --profile ruby --noop
+
+The instance also automatically gets terminated and cleaned up by a termination script appended to user-data.
+
+It is recommended to use the `set -e` option in your user-data script so that if the script fails, the AMI creation script is never reached and the instance is left behind so you can debug.

data/lib/forger/help/clean/ami.md

@@ -0,0 +1,22 @@
+Examples:
+
+    $ forger clean ami 'base-amazonlinux2*'
+    $ forger clean ami 'base-ubuntu*' --keep 5
+    $ forger clean ami 'base-ubuntu*' --noop # dry-run
+
+Deletes old AMIs using the provided name as the base portion of the AMI name to search for.
+
+Let's say you have these images:
+
+    base-ubuntu_2018-03-25-04-20
+    base-ubuntu_2018-03-25-03-39
+    base-ubuntu_2018-03-25-02-57
+    base-ubuntu_2018-03-25-02-47
+    base-ubuntu_2018-03-25-02-43
+    base-ubuntu_2018-03-23-00-15
+
+Running:
+
+    $ forger clean ami 'base-ubuntu*'
+
+Would delete all images and keep the 2 most recent AMIs.  The default `--keep` value is 2.  Make sure to surround the query pattern with a single quote to prevent shell glob expansion.

data/lib/forger/help/compile.md

@@ -0,0 +1,5 @@
+Examples:
+
+    $ forger compile
+
+Compiles app/scripts and app/user-data files to the tmp folder. Useful for inspection.

data/lib/forger/help/completion.md

@@ -0,0 +1,22 @@
+Example:
+
+    forger completion
+
+Prints words for TAB auto-completion.
+
+Examples:
+
+    forger completion
+    forger completion hello
+    forger completion hello name
+
+To enable, TAB auto-completion add the following to your profile:
+
+    eval $(forger completion_script)
+
+Auto-completion example usage:
+
+    forger [TAB]
+    forger hello [TAB]
+    forger hello name [TAB]
+    forger hello name --[TAB]

data/lib/forger/help/completion_script.md

@@ -0,0 +1,3 @@
+To use, add the following to your `~/.bashrc` or `~/.profile`
+
+    eval $(forger completion_script)

data/lib/forger/help/create.md

@@ -0,0 +1,7 @@
+Examples:
+
+    $ forger create my-instance
+
+To see the snippet of code that gets added to the user-data script you can use the `--noop` option and then view the generated tmp/user-data.txt.
+
+    $ forger create myscript --noop

data/lib/forger/help/upload.md

@@ -0,0 +1,10 @@
+Examples:
+
+    $ forger upload
+
+Compiles the app/scripts and app/user-data files to the tmp folder. Then uploads the files to an s3 bucket that is configured in config/settings.yml.  Example s3_folder setting:
+
+```yaml
+development:
+  s3_folder: my-bucket/folder # enables auto sync to s3
+```

data/lib/forger/help/wait/ami.md

@@ -0,0 +1,12 @@
+Examples:
+
+    $ forger wait ami ruby-2.5.0_2018-03-24-17-07
+    $ forger wait ami ami-b0138dc8
+
+Polls the AMI with the given AMI name or id until AMI is found and available.
+
+### Timeout
+
+Command times out after 30 mins by default.  You can control the timeout with the `--timeout` flag.  The timeout is specified in seconds.
+
+    $ forger wait ami --id ami-b0138dc8 --timeout 3600

data/lib/forger/hook.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+module Forger
+  class Hook
+    def initialize(options={})
+      @options = options
+    end
+
+    def run(name)
+      return if @options[:noop]
+      return unless hooks[name]
+      command = hooks[name]
+      puts "Running hook #{name}: #{command}"
+      sh(command)
+    end
+
+    def hooks
+      hooks_path = "#{Forger.root}/config/hooks.yml"
+      data = File.exist?(hooks_path) ? YAML.load_file(hooks_path) : {}
+      data ? data : {} # in case the file is empty
+    end
+
+    def sh(command)
+      puts "=> #{command}".colorize(:cyan)
+      success = system(command)
+      abort("Command failed") unless success
+    end
+
+    def self.run(name, options={})
+      Hook.new(options).run(name.to_s)
+    end
+  end
+end

data/lib/forger/profile.rb

@@ -0,0 +1,64 @@
+module Forger
+  class Profile < Base
+    include Forger::Template
+
+    def load
+      return @profile_params if @profile_params
+
+      check!
+
+      file = profile_file(profile_name)
+      @profile_params = load_profile(file)
+    end
+
+    def check!
+      file = profile_file(profile_name)
+      return if File.exist?(file)
+
+      puts "Unable to find a #{file.colorize(:green)} profile file."
+      puts "Please double check that it exists or that you specified the right profile.".colorize(:red)
+      exit 1
+    end
+
+    def load_profile(file)
+      return {} unless File.exist?(file)
+
+      puts "Using profile: #{file}".colorize(:green)
+      text = RenderMePretty.result(file, context: context)
+      begin
+        data = YAML.load(text)
+      rescue Psych::SyntaxError => e
+        tmp_file = file.sub("profiles", "tmp")
+        IO.write(tmp_file, text)
+        puts "There was an error evaluating in your yaml file #{file}".colorize(:red)
+        puts "The evaludated yaml file has been saved at #{tmp_file} for debugging."
+        puts "ERROR: #{e.message}"
+        exit 1
+      end
+      data ? data : {} # in case the file is empty
+      data.has_key?("run_instances") ? data["run_instances"] : data
+    end
+
+    # Determines a valid profile_name. Falls back to default
+    def profile_name
+      # allow user to specify the path also
+      if @options[:profile] && File.exist?(@options[:profile])
+        filename_profile = File.basename(@options[:profile], '.yml')
+      end
+
+      name = derandomize(@name)
+      if File.exist?(profile_file(name))
+        name_profile = name
+      end
+
+      filename_profile ||
+      @options[:profile] ||
+      name_profile || # conventional profile is the name of the ec2 instance
+      "default"
+    end
+
+    def profile_file(name)
+      "#{Forger.root}/profiles/#{name}.yml"
+    end
+  end
+end

data/lib/forger/script.rb

@@ -0,0 +1,46 @@
+module Forger
+  class Script
+    autoload :Compile, "forger/script/compile"
+    autoload :Compress, "forger/script/compress"
+    autoload :Upload, "forger/script/upload"
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def add_to_user_data!(user_data)
+      user_data
+    end
+
+    def auto_terminate_after_timeout
+      load_template("auto_terminate_after_timeout.sh")
+    end
+
+    def auto_terminate
+      # set variables for the template
+      @ami_name = @options[:ami_name]
+      load_template("auto_terminate.sh")
+    end
+
+    def cloudwatch
+      load_template("cloudwatch.sh")
+    end
+
+    def create_ami
+      # set variables for the template
+      @ami_name = @options[:ami_name]
+      @region = `aws configure get region`.strip rescue 'us-east-1'
+      load_template("ami_creation.sh")
+    end
+
+    def extract_forger_scripts
+      load_template("extract_forger_scripts.sh")
+    end
+
+  private
+    def load_template(name)
+      template = IO.read(File.expand_path("script/templates/#{name}", File.dirname(__FILE__)))
+      text = ERB.new(template, nil, "-").result(binding)
+    end
+  end
+end

data/lib/forger/script/compile.rb

@@ -0,0 +1,40 @@
+require 'fileutils'
+
+# Class for forger compile command
+class Forger::Script
+  class Compile < Forger::Base
+    include Forger::Template
+
+    # used in upload
+    def compile_scripts
+      clean
+      compile_folder("scripts")
+    end
+
+    # use in compile cli command
+    def compile_all
+      clean
+      compile_folder("scripts")
+      layout_path = context.layout_path(@options[:layout])
+      compile_folder("user-data", layout_path)
+    end
+
+    def compile_folder(folder, layout_path=false)
+      puts "Compiling app/#{folder} to tmp/app/#{folder}.".colorize(:green)
+      Dir.glob("#{Forger.root}/app/#{folder}/**/*").each do |path|
+        next if File.directory?(path)
+        next if path.include?("layouts")
+
+        result = RenderMePretty.result(path, layout: layout_path, context: context)
+        tmp_path = path.sub(%r{.*/app/}, "#{BUILD_ROOT}/app/")
+        puts "  #{tmp_path}" if @options[:verbose]
+        FileUtils.mkdir_p(File.dirname(tmp_path))
+        IO.write(tmp_path, result)
+      end
+    end
+
+    def clean
+      FileUtils.rm_rf("#{BUILD_ROOT}/app")
+    end
+  end
+end