forger 1.5.0

data/lib/forger/completer.rb

@@ -0,0 +1,161 @@
+=begin
+Code Explanation:
+
+There are 3 types of things to auto-complete:
+
+  1. command: the command itself
+  2. parameters: command parameters.
+  3. options: command options
+
+Here's an example:
+
+  mycli hello name --from me
+
+  * command: hello
+  * parameters: name
+  * option: --from
+
+When command parameters are done processing, the remaining completion words will be options.  We can tell that the command params are completed based on the method arity.
+
+## Arity
+
+For example, say you had a method for a CLI command with the following form:
+
+  ufo scale service count --cluster development
+
+It's equivalent ruby method:
+
+  scale(service, count) = has an arity of 2
+
+So typing:
+
+  ufo scale service count [TAB] # there are 3 parameters including the "scale" command according to Thor's CLI processing.
+
+So the completion should only show options, something like this:
+
+  --noop --verbose --cluster
+
+## Splat Arguments
+
+When the ruby method has a splat argument, it's arity is negative.  Here are some example methods and their arities.
+
+   ship(service) = 1
+   scale(service, count) = 2
+   ships(*services) = -1
+   foo(example, *rest) = -2
+
+Fortunately, negative and positive arity values are processed the same way. So we take simply take the absolute value of the arity and process it the same.
+
+Here are some test cases, hit TAB after typing the command:
+
+  forger completion
+  forger completion hello
+  forger completion hello name
+  forger completion hello name --
+  forger completion hello name --noop
+
+  forger completion
+  forger completion sub:goodbye
+  forger completion sub:goodbye name
+
+## Subcommands and Thor::Group Registered Commands
+
+Sometimes the commands are not simple thor commands but are subcommands or Thor::Group commands. A good specific example is the ufo tool.
+
+  * regular command: ufo ship
+  * subcommand: ufo docker
+  * Thor::Group command: ufo init
+
+Auto-completion accounts for each of these type of commands.
+=end
+module Forger
+  class Completer
+    autoload :Script, 'forger/completer/script'
+
+    def initialize(command_class, *params)
+      @params = params
+      @current_command = @params[0]
+      @command_class = command_class # CLI initiall
+    end
+
+    def run
+      if subcommand?(@current_command)
+        subcommand_class = @command_class.subcommand_classes[@current_command]
+        @params.shift # destructive
+        Completer.new(subcommand_class, *@params).run # recursively use subcommand
+        return
+      end
+
+      # full command has been found!
+      unless found?(@current_command)
+        puts all_commands
+        return
+      end
+
+      # will only get to here if command aws found (above)
+      arity = @command_class.instance_method(@current_command).arity.abs
+      if @params.size > arity or thor_group_command?
+        puts options_completion
+      else
+        puts params_completion
+      end
+    end
+
+    def subcommand?(command)
+      @command_class.subcommands.include?(command)
+    end
+
+    # hacky way to detect that command is a registered Thor::Group command
+    def thor_group_command?
+      command_params(raw=true) == [[:rest, :args]]
+    end
+
+    def found?(command)
+      public_methods = @command_class.public_instance_methods(false)
+      command && public_methods.include?(command.to_sym)
+    end
+
+    # all top-level commands
+    def all_commands
+      commands = @command_class.all_commands.reject do |k,v|
+        v.is_a?(Thor::HiddenCommand)
+      end
+      commands.keys
+    end
+
+    def command_params(raw=false)
+      params = @command_class.instance_method(@current_command).parameters
+      # Example:
+      # >> Sub.instance_method(:goodbye).parameters
+      # => [[:req, :name]]
+      # >>
+      raw ? params : params.map!(&:last)
+    end
+
+    def params_completion
+      offset = @params.size - 1
+      offset_params = command_params[offset..-1]
+      command_params[offset..-1].first
+    end
+
+    def options_completion
+      used = ARGV.select { |a| a.include?('--') } # so we can remove used options
+
+      method_options = @command_class.all_commands[@current_command].options.keys
+      class_options = @command_class.class_options.keys
+
+      all_options = method_options + class_options + ['help']
+
+      all_options.map! { |o| "--#{o.to_s.gsub('_','-')}" }
+      filtered_options = all_options - used
+      filtered_options.uniq
+    end
+
+    # Useful for debugging. Using puts messes up completion.
+    def log(msg)
+      File.open("/tmp/complete.log", "a") do |file|
+        file.puts(msg)
+      end
+    end
+  end
+end

data/lib/forger/completer/script.rb

@@ -0,0 +1,6 @@
+class Forger::Completer::Script
+  def self.generate
+    bash_script = File.expand_path("script.sh", File.dirname(__FILE__))
+    puts "source #{bash_script}"
+  end
+end

data/lib/forger/completer/script.sh

@@ -0,0 +1,10 @@
+_forger() {
+  COMPREPLY=()
+  local word="${COMP_WORDS[COMP_CWORD]}"
+  local words=("${COMP_WORDS[@]}")
+  unset words[0]
+  local completion=$(forger completion ${words[@]})
+  COMPREPLY=( $(compgen -W "$completion" -- "$word") )
+}
+
+complete -F _forger forger

data/lib/forger/config.rb

@@ -0,0 +1,20 @@
+require 'yaml'
+
+module Forger
+  class Config < Base
+    def initialize(options={})
+      super
+      @path = options[:path] || "#{Forger.root}/config/#{Forger.env}.yml"
+    end
+
+    @@data = nil
+    def data
+      return @@data if @@data
+      @@data = YAML.load_file(@path)
+    rescue Errno::ENOENT => e
+      puts e.message
+      puts "The #{@path} does not exist. Please double check that it exists."
+      exit
+    end
+  end
+end

data/lib/forger/core.rb

@@ -0,0 +1,51 @@
+require 'pathname'
+require 'yaml'
+
+module Forger
+  module Core
+    @@config = nil
+    def config
+      @@config ||= Config.new.data
+    end
+
+    def settings
+      Setting.new.data
+    end
+
+    def root
+      path = ENV['AWS_EC2_ROOT'] || '.'
+      Pathname.new(path)
+    end
+
+    def validate_in_project!
+      unless File.exist?("#{root}/profiles")
+        puts "Could not find a profiles folder in the current directory.  It does not look like you are running this command within a forger project.  Please confirm that you are in a forger project and try again.".colorize(:red)
+        exit
+      end
+    end
+
+    @@env = nil
+    def env
+      return @@env if @@env
+      env = env_from_profile(ENV['AWS_PROFILE']) || 'development'
+      env = ENV['AWS_EC2_ENV'] if ENV['AWS_EC2_ENV'] # highest precedence
+      @@env = env
+    end
+
+    private
+    # Do not use the Setting class to load the profile because it can cause an
+    # infinite loop then if we decide to use Forger.env from within settings class.
+    def env_from_profile(aws_profile)
+      settings_path = "#{Forger.root}/config/settings.yml"
+      return unless File.exist?(settings_path)
+
+      data = YAML.load_file(settings_path)
+      env = data.find do |_env, setting|
+        setting ||= {}
+        profiles = setting['aws_profiles']
+        profiles && profiles.include?(aws_profile)
+      end
+      env.first if env
+    end
+  end
+end

data/lib/forger/create.rb

@@ -0,0 +1,155 @@
+require 'yaml'
+require 'active_support/core_ext/hash'
+
+module Forger
+  class Create < Base
+    autoload :Params, "forger/create/params"
+    autoload :ErrorMessages, "forger/create/error_messages"
+
+    include AwsService
+    include ErrorMessages
+
+    def run
+      Profile.new(@options).check!
+
+      Hook.run(:before_run_instances, @options)
+      sync_scripts_to_s3
+
+      puts "Creating EC2 instance #{@name.colorize(:green)}"
+      display_ec2_info
+      if @options[:noop]
+        puts "NOOP mode enabled. EC2 instance not created."
+        return
+      end
+      resp = run_instances(params)
+      instance_id = resp.instances.first.instance_id
+      display_spot_info(instance_id)
+      puts "EC2 instance #{@name} created: #{instance_id} 🎉"
+      puts "Visit https://console.aws.amazon.com/ec2/home to check on the status"
+      display_cloudwatch_info(instance_id)
+    end
+
+    def run_instances(params)
+      ec2.run_instances(params)
+    rescue Aws::EC2::Errors::ServiceError => e
+      handle_ec2_service_error!(e)
+    end
+
+    # Configured by config/settings.yml.
+    # Example: config/settings.yml:
+    #
+    #   development:
+    #     s3_folder: my-bucket/folder
+    def sync_scripts_to_s3
+      if Forger.settings["s3_folder"]
+        Script::Upload.new(@options).run
+      end
+    end
+
+    # params are main derived from profile files
+    def params
+      @params ||= Params.new(@options).generate
+    end
+
+    def display_spot_info(instance_id)
+      resp = ec2.describe_instances(instance_ids: [instance_id])
+      spot_id = resp.reservations.first.instances.first.spot_instance_request_id
+      return unless spot_id
+
+      puts "Spot instance request id: #{spot_id}"
+    end
+
+    def display_ec2_info
+      puts "Using the following parameters:"
+      pretty_display(params)
+
+      display_launch_template
+    end
+
+    def display_launch_template
+      launch_template = params[:launch_template]
+      return unless launch_template
+
+      resp = ec2.describe_launch_template_versions(
+        launch_template_id: launch_template[:launch_template_id],
+        launch_template_name: launch_template[:launch_template_name],
+      )
+      versions = resp.launch_template_versions
+      launch_template_data = {} # combined launch_template_data
+      versions.sort_by { |v| v[:version_number] }.each do |v|
+        launch_template_data.merge!(v[:launch_template_data])
+      end
+      puts "launch template data (versions combined):"
+      pretty_display(launch_template_data)
+    rescue Aws::EC2::Errors::InvalidLaunchTemplateNameNotFoundException => e
+      puts "ERROR: The specified launched template #{launch_template.inspect} was not found."
+      puts "Please double check that it exists."
+      exit
+    end
+
+    def display_cloudwatch_info(instance_id)
+      return unless @options[:cloudwatch]
+
+      region = get_region
+      stream = "#{instance_id}/var/log/cloud-init-output.log"
+      url = "https://#{region}.console.aws.amazon.com/cloudwatch/home?region=#{region}#logEventViewer:group=ec2;stream=#{stream}"
+      cw_init_log = "cw tail -f ec2 #{stream}"
+      puts "To view instance's cloudwatch logs visit:"
+      puts "  #{url}"
+
+      puts "  #{cw_init_log}" if ENV['AWS_EC2_CW']
+      if ENV['AWS_EC2_CW'] && @options[:auto_terminate]
+        cw_terminate_log = "cw tail -f ec2 #{instance_id}/var/log/auto-terminate.log"
+        puts "  #{cw_terminate_log}"
+      end
+
+      puts "Note: It takes a little time for the instance to launch and report logs."
+
+      paste_command = ENV['AWS_EC2_CW'] ? cw_init_log : url
+      add_to_clipboard(paste_command)
+    end
+
+    def add_to_clipboard(text)
+      return unless RUBY_PLATFORM =~ /darwin/
+      return unless system("type pbcopy > /dev/null")
+
+      system(%[echo "#{text}" | pbcopy])
+      puts "Pro tip: The CloudWatch Console Link has been added to your copy-and-paste clipboard."
+    end
+
+    def get_region
+      # Highest precedence: AWS_EC2_REGION env variable. Only really used here.
+      if ENV['AWS_EC2_REGION']
+        return ENV['AWS_EC2_REGION']
+      end
+
+      # Pretty high in precedence: AWS_PROFILE and ~/.aws/config and
+      aws_found = system("type aws > /dev/null")
+      if aws_found
+        region = `aws configure get region`.strip
+        return region
+      end
+
+      # Assumes instance same region as the calling ec2 instance.
+      # It is possible for curl not to be installed.
+      curl_found = system("type curl > /dev/null")
+      if curl_found
+        region = `curl --connect-timeout 3  -s 169.254.169.254/latest/meta-data/placement/availability-zone | sed s'/.$//'`
+        return region unless region == ''
+      end
+
+      return 'us-east-1' # fallback default
+    end
+
+    def pretty_display(data)
+      data = data.deep_stringify_keys
+
+      if data["user_data"]
+        message = "base64-encoded: cat tmp/user-data.txt to view"
+        data["user_data"] = message
+      end
+
+      puts YAML.dump(data)
+    end
+  end
+end

data/lib/forger/create/error_messages.rb

@@ -0,0 +1,58 @@
+require "active_support/core_ext/string"
+
+class Forger::Create
+  module ErrorMessages
+    def handle_ec2_service_error!(exception)
+      meth = map_exception_to_method(exception)
+      if respond_to?(meth)
+        message = send(meth) # custom specific error message
+        message = print_error_message(exception, message)
+      else
+        # generic error message
+        print_error_message(exception, <<-EOL)
+There was an error with the parameters used for the run_instance method.
+EOL
+      end
+    end
+
+    # Examples:
+    #   Aws::EC2::Errors::InvalidGroupNotFound => invalid_group_not_found!
+    #   Aws::EC2::Errors::InvalidParameterCombination => invalid_parameter_combination!
+    def map_exception_to_method(exception)
+      class_name = File.basename(exception.class.to_s).sub(/.*::/,'')
+      class_name.underscore # method_name
+    end
+
+    def print_error_message(exception, message)
+      puts "ERROR: Unable to launch the instance.".colorize(:red)
+      puts message
+      puts exception.message
+      puts "For the full internal backtrace re-run the command with DEBUG=1"
+      puts exception.backtrace if ENV['DEBUG']
+      exit 1
+    end
+
+    #######################################################
+    # specific messages with a little more info for more common error cases below:
+    def invalid_group_not_found
+      <<-EOL
+The security group passed in does not exit.
+Please double check that security group exists in the VPC.
+EOL
+    end
+
+    def invalid_parameter_combination
+      <<-EOL
+The parameters passed to the run_instances method were invalid.
+Please double check that the parameters are all valid.
+EOL
+    end
+
+    def invalid_subnet_id_not_found
+      <<-EOL
+The provided subnets ids were were not found.
+Please double check that the subnets exists.
+EOL
+    end
+  end
+end