ufo 5.0.7 → 6.0.0

data/lib/ufo/{logs.rb → cli/logs.rb}

@@ -1,14 +1,12 @@
 require "aws-logs"
 
-module Ufo
+class Ufo::CLI
   class Logs < Base
-    include AwsService
-
     delegate :service, to: :info
 
     def run
       log = find_log_group_name
-      puts "Showing logs for log group: #{log["awslogs-group"]} and stream prefix #{log["awslogs-stream-prefix"]}"
+      puts "Showing logs for stack: #{@stack_name} log group: #{log["awslogs-group"]} and stream prefix: #{log["awslogs-stream-prefix"]}"
       if log
         cloudwatch_tail(log)
       else
@@ -17,7 +15,12 @@ module Ufo
     end
 
     def find_log_group_name
-      resp = ecs.describe_task_definition(task_definition: info.service.task_definition)
+      unless info.service
+        logger.info "Cannot find ECS service for #{@stack_name}"
+        exit 1
+      end
+      task_definition = info.service.task_definition
+      resp = ecs.describe_task_definition(task_definition: task_definition)
 
       container_definitions = resp.task_definition.container_definitions
 
@@ -48,9 +51,13 @@ module Ufo
         follow: @options[:follow],
         format: @options[:format],
       }
-      o[:filter_pattern] = @options[:filter_pattern] if @options[:filter_pattern]
+      o[:filter_pattern] = filter_pattern
       cw_tail = AwsLogs::Tail.new(o)
       cw_tail.run
     end
+
+    def filter_pattern
+      @options[:filter_pattern] ? @options[:filter_pattern] : Ufo.config.logs.filter_pattern
+    end
   end
 end

data/lib/ufo/cli/new/concerns.rb

@@ -0,0 +1,16 @@
+class Ufo::CLI::New
+  module Concerns
+    extend ActiveSupport::Concern
+
+  private
+    def class_name
+      name.underscore.camelize
+    end
+
+    # Files should be named with underscores instead of dashes even though project name can contain a dash.
+    # This is because autoloading works with underscores in the filenames only.
+    def underscore_name
+      name.underscore
+    end
+  end
+end

data/lib/ufo/cli/new/helper.rb

@@ -0,0 +1,24 @@
+class Ufo::CLI::New
+  class Helper < Sequence
+    # required for name => underscore_name => .ufo/helpers/%underscore_name%_helper.rb.tt
+    argument :name, default: "custom"
+
+    def self.cli_options
+      [
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+      ]
+    end
+    cli_options.each do |args|
+      class_option(*args)
+    end
+
+    def set_source
+      set_template_source "helper"
+    end
+
+    def create_helper
+      logger.info "=> Creating #{name}_helper.rb"
+      directory ".", ".ufo/helpers"
+    end
+  end
+end

data/lib/ufo/cli/new/init.rb

@@ -0,0 +1,68 @@
+class Ufo::CLI::New
+  class Init < Sequence
+    def self.options
+      [
+        [:app, aliases: :a, desc: "App name.  If not specified, it's inferred from the folder name"],
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        # note: aliases: :r messes up Usage help: ufo init -h so not using it
+        [:repo, required: true, desc: "Docker repo to use. Example: ORG/REPO"],
+      ]
+    end
+    options.each { |o| class_option(*o) }
+
+    def set_source
+      set_template_source("init")
+      self.destination_root = '.'
+    end
+
+    def set_variables
+      @app = options[:app] || inferred_app
+      @repo = options[:repo]
+    end
+
+    def generate
+      puts "Generating .ufo structure"
+      directory "."
+    end
+
+    def update_gitignore
+      text =<<~EOL
+        .ufo/tmp
+        .ufo/log
+        .ufo/output
+        .secrets
+      EOL
+      if File.exist?(".gitignore")
+        append_to_file ".gitignore", text
+      else
+        create_file ".gitignore", text
+      end
+    end
+
+    def update_dockerignore
+      text = ".ufo\n"
+      if File.exist?(".dockerignore")
+        append_to_file ".dockerignore", text
+      else
+        create_file ".dockerignore", text
+      end
+    end
+
+    def create_dockefile
+      return if File.exist?("Dockerfile")
+      set_template_source("docker")
+      directory ".", "."
+    end
+
+    def user_message
+      puts "Starter .ufo files created"
+      puts <<~EOL
+        Congrats. You have successfully set up your project with ufo.
+        To deploy to ECS:
+
+            ufo ship
+
+      EOL
+    end
+  end
+end

data/lib/ufo/{sequence.rb → cli/new/sequence.rb}

@@ -1,18 +1,40 @@
 require 'fileutils'
 require 'thor'
 
-module Ufo
+class Ufo::CLI::New
   class Sequence < Thor::Group
+    include Concerns
     include Thor::Actions
+    include Ufo::Utils::Logging
 
     add_runtime_options! # force, pretend, quiet, skip options
       # https://github.com/erikhuda/thor/blob/master/lib/thor/actions.rb#L49
 
-    def self.source_paths
-      [File.expand_path("../../template", __FILE__)]
+  private
+    def self.set_template_source(folder)
+      path = File.expand_path("../../../templates/#{folder}", __dir__)
+      source_root path
+    end
+
+    def set_template_source(*paths)
+      paths = paths.flatten.map do |path|
+        File.expand_path("../../../templates/#{path}", __dir__)
+      end
+      set_template_paths(paths)
+    end
+
+    def set_template_paths(*paths)
+      paths.flatten!
+      # https://github.com/erikhuda/thor/blob/34df888d721ecaa8cf0cea97d51dc6c388002742/lib/thor/actions.rb#L128
+      instance_variable_set(:@source_paths, nil) # unset instance variable cache
+      # Using string with instance_eval because block doesnt have access to path at runtime.
+      instance_eval %{
+        def self.source_paths
+          #{paths.flatten.inspect}
+        end
+      }
     end
 
-  private
     def inferred_app
       File.basename(Dir.pwd)
     end

data/lib/ufo/cli/new.rb

@@ -0,0 +1,10 @@
+class Ufo::CLI
+  class New < Ufo::Command
+    desc "helper", "Generate helper file"
+    long_desc Help.text("new/helper")
+    Helper.cli_options.each do |args|
+      option(*args)
+    end
+    register(Helper, "helper", "helper", "Generate helper file")
+  end
+end

data/lib/ufo/cli/opts.rb

@@ -0,0 +1,35 @@
+class Ufo::CLI
+  class Opts
+    def initialize(cli)
+      @cli = cli
+    end
+
+    def yes
+      with_cli_scope do
+        option :yes, aliases: :y, type: :boolean, desc: "Bypass are you sure prompt"
+      end
+    end
+
+    def docker
+      with_cli_scope do
+        option :docker, type: :boolean, default: true, desc: "Skip docker build"
+      end
+    end
+
+    # Based on https://github.com/rails/thor/blob/ab3b5be455791f4efb79f0efb4f88cc6b59c8ccf/lib/thor/actions.rb#L48
+    def runtime_options
+      with_cli_scope do
+        option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
+                             :desc => "Overwrite files that already exist"
+
+        option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
+                            :desc => "Skip files that already exist"
+      end
+    end
+
+  private
+    def with_cli_scope(&block)
+      @cli.instance_eval(&block)
+    end
+  end
+end

data/lib/ufo/{ps → cli/ps}/task.rb

@@ -1,9 +1,7 @@
-class Ufo::Ps
+class Ufo::CLI::Ps
   class Task
     def self.header
-      header = %w[Id Name Release Started Status Notes]
-      header << "Container Instance" if extra_columns
-      header
+      %w[Task Name Release Started Status Notes]
     end
 
     def initialize(task)
@@ -12,7 +10,6 @@ class Ufo::Ps
 
     def to_a
       row = [id, name, release, started, status, notes]
-      row << container_instance_arn if extra_columns
       row
     end
 
@@ -21,9 +18,12 @@ class Ufo::Ps
     end
 
     def name
-      @task["overrides"]["container_overrides"].first["name"]
+      container_overrides = @task.dig("overrides", "container_overrides")
+      overrides = container_overrides.first # assume first is one we want
+      overrides["name"] if overrides # PENDING wont yet have info
     rescue NoMethodError
-      @task["containers"].first["name"]
+      container = @task["containers"].first
+      container["name"] if container # PENDING wont yet have info
     end
 
     def container_instance_arn
@@ -48,26 +48,32 @@ class Ufo::Ps
 
     # hide stopped tasks have been stopped for more than 5 minutes
     #  created_at=2018-07-05 21:52:13 -0700,
-     # started_at=2018-07-05 21:52:15 -0700,
-     # stopping_at=2018-07-05 22:03:44 -0700,
-     # stopped_at=2018-07-05 22:03:45 -0700,
+    #  started_at=2018-07-05 21:52:15 -0700,
+    #  stopping_at=2018-07-05 22:03:44 -0700,
+    #  stopped_at=2018-07-05 22:03:45 -0700,
     def hide?
       stopped_at = time(@task["stopped_at"])
-      status == "STOPPED" && stopped_at < Time.now - 60 * 5
+      time = Time.now - 60 * Ufo.config.ps.hide_age
+      status == "STOPPED" && stopped_at < time
     end
 
     def status
       @task["last_status"]
     end
 
+    # Grab all the reasons and surface to user.
+    # Even though will make the table output ugly, debugging info merits it.
+    #
+    #     ufo ps --format json
+    #
     def notes
       return unless @task["stopped_reason"]
-
-      if @task["stopped_reason"] =~ /Task failed ELB health checks/
-        "Failed ELB health check"
-      else
-        @task["stopped_reason"]
+      notes = []
+      notes << "Task Stopped Reason: #{@task["stopped_reason"]}."
+      @task.containers.each do |container|
+        notes << "Container #{container.name} reason: #{container.reason}" unless container.reason.blank?
       end
+      notes.join(" ")
     end
 
     # https://stackoverflow.com/questions/195740/how-do-you-do-relative-time-in-rails/195894
@@ -86,18 +92,5 @@ class Ufo::Ps
           start_time.strftime("%m/%d/%Y")
       end
     end
-
-    @@extra_columns = false
-    def self.extra_columns=(val)
-      @@extra_columns = val
-    end
-
-    def self.extra_columns
-      @@extra_columns
-    end
-
-    def extra_columns
-      self.class.extra_columns
-    end
   end
 end

data/lib/ufo/cli/ps.rb

@@ -0,0 +1,190 @@
+require 'text-table'
+require 'tty-screen'
+
+class Ufo::CLI
+  class Ps < Base
+    include Ufo::AwsServices
+    include Ufo::Concerns::Autoscaling
+    delegate :service, to: :info
+
+    def run
+      unless service
+        logger.info info.no_service_message
+        return
+      end
+
+      summary
+
+      if task_arns.empty?
+        logger.info "There are 0 running tasks."
+        return
+      end
+
+      all_task_arns = task_arns.each_slice(100).map do |arns|
+        resp = ecs.describe_tasks(tasks: arns, cluster: @cluster)
+        resp["tasks"]
+      end.flatten
+
+      display_tasks(all_task_arns)
+      display_scale_help
+      display_target_group_help
+    end
+
+    def summary
+      return unless Ufo.config.ps.summary
+
+      logger.info "Stack: #{@stack_name}"
+      logger.info "Service: #{service.service_name}"
+      logger.info "Status: #{service.status}" unless service.status == "ACTIVE" # not very useful when ACTIVE
+      logger.info "Tasks: #{tasks_counts}"
+      logger.info "Launch type: #{service.launch_type}" if service.launch_type
+      elb = info.load_balancer(service)
+      logger.info "#{elb.type.capitalize} ELB: #{elb.dns_name}" if elb
+      logger.info "Url: #{info.url}" if info.url
+    end
+
+    def tasks_counts
+      message = "Running: #{service.running_count} Desired: #{service.desired_count}"
+      if scalable_target
+        message += " Min: #{scalable_target.min_capacity} Max: #{scalable_target.max_capacity}"
+      end
+      message
+    end
+
+    def scalable_target
+      return unless autoscaling_enabled?
+      # Docs: https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/ApplicationAutoScaling/Client.html#describe_scalable_targets-instance_method
+      # ECS service - The resource type is service and the unique identifier is the cluster name and service name. Example: service/default/sample-webapp.
+      resource_id = "service/#{@cluster}/#{service.service_name}"
+      resp = applicationautoscaling.describe_scalable_targets(
+        service_namespace: "ecs",
+        resource_ids: [resource_id],
+      )
+      resp.scalable_targets.first # scalable_target
+    end
+
+    def display_target_group_help
+      events = service["events"][0..4]
+      return if events[0].message =~ /has reached a steady state/
+
+      # The error currently happens to be the 5th element.
+      #
+      # Example:
+      #  "(service XXX) (instance i-XXX) (port 32875) is unhealthy in (target-group arn:aws:elasticloadbalancing:us-east-1:111111111111:targetgroup/devel-Targe-1111111111111/1111111111111111) due to (reason Health checks failed with these codes: [400])">]
+      error_event = events.find do |e|
+        e.message =~ /is unhealthy in/ &&
+        e.message =~ /targetgroup/
+      end
+      return unless error_event
+
+      logger.error "There are targets in the target group reporting unhealthy.  This can cause containers to cycle. Here's the error:"
+      logger.error error_event.message.color(:red)
+      logger.error <<~EOL
+        Check out the ECS console and EC2 Load Balancer console for more info.
+        Sometimes they may not helpful :(
+        Docs that may help: https://ufoships.com/docs/debug/unhealthy-targets/
+      EOL
+    end
+
+    # If the running count less than the desired account yet, check the events
+    # and show a message with helpful debugging information.
+    def display_scale_help
+      return if service.running_count >= service.desired_count
+
+      events = service["events"][0..3] # only check most recent 4 messages
+      error_event = events.find do |e|
+        e.message =~ /was unable to place a task/
+      end
+      return unless error_event
+
+      logger.info "There is an issue scaling the #{@service.color(:green)} service to #{service.desired_count}.  Here's the error:"
+      logger.info error_event.message.color(:red)
+      if service.launch_type == "EC2"
+        logger.info "If AutoScaling is set up for the container instances, it can take a little time to add additional instances. You'll see this message until the capacity is added."
+      end
+    end
+
+    def display_tasks(raw_tasks)
+      raw_tasks.sort_by! { |t| t["task_arn"] }
+      tasks = raw_tasks.map { |t| Task.new(t) } # will have Task objects after this point
+      tasks = tasks.reject(&:hide?)
+      show_notes = show_notes(tasks)
+
+      format = determine_format(tasks)
+      o = @options.dup # Cant modify frozen Thor options
+      o[:format] ||= format
+
+      presenter = CliFormat::Presenter.new(o)
+      header = show_notes ? Task.header : Task.header[0..-2]
+      presenter.header = header
+      tasks.each do |task|
+        row = show_notes ? task.to_a : task.to_a[0..-2]
+        presenter.rows << row
+      end
+      presenter.show
+    end
+
+    def show_notes(tasks)
+      tasks.detect { |t| !t.notes.blank? }
+    end
+
+    # auto format will display in json if the output is to wide
+    # otherwise it defaults to table
+    def determine_format(tasks)
+      if Ufo.config.ps.format == "auto"
+        max = max_table_width(tasks)
+        max >= TTY::Screen.width ? "json" : "table"
+      else
+        Ufo.config.ps.format
+      end
+    end
+
+    def max_table_width(tasks)
+      max = 0
+      tasks.each do |row|
+        columns = row.to_a
+        width = columns.inject(0) do |total, column|
+          total += column.to_s.length
+        end
+        max = width if width >= max
+      end
+      padding = Task.header.size * 3 + 4
+      # max full column width. accounts for all the rows plus the padding from the table output
+      max + padding
+    end
+
+    def statuses
+      status = @options[:status] || "ALL" # can be nil when used from ship
+      status = status.upcase
+      valid_statuses = %w[RUNNING PENDING STOPPED]
+      all_statuses = valid_statuses + ["ALL"]
+      unless all_statuses.include?(status)
+        logger.error "Invalid status filter provided. Please provided one of the following:"
+        logger.error all_statuses.map(&:downcase).join(", ")
+        exit 1
+      end
+
+      status == "ALL" ? valid_statuses : [status]
+    end
+
+    def task_arns
+      threads, results = [], {}
+      statuses.each do |status|
+        threads << Thread.new do
+          options = {
+            service_name: service.service_name,
+            cluster: @cluster,
+            desired_status: status,
+          }
+          # Limit display of too many stopped tasks
+          options[:max_results] = 20 if status == "STOPPED"
+          resp = ecs.list_tasks(options)
+          results[status] = resp.task_arns
+        end
+      end
+      threads.map(&:join)
+      results.values.flatten.uniq
+    end
+    memoize :task_arns
+  end
+end

data/lib/ufo/{releases.rb → cli/releases.rb}

@@ -1,13 +1,13 @@
 require 'text-table'
 
-module Ufo
+class Ufo::CLI
   class Releases < Base
     def list
-      puts "Recent task definitions for this service:"
-      arns = task_definition_arns(@service)
+      logger.info "Latest task definitions for stack: #{@stack_name}"
+      arns = task_definition_arns(@task_definition.name)
       task_definitions = arns.map { |arn| arn.split('/').last }
       task_definitions.each do |name|
-        puts "  #{name}"
+        logger.info "    #{name}"
       end
     end
   end

data/lib/ufo/{rollback.rb → cli/rollback.rb}

@@ -1,11 +1,13 @@
-module Ufo
+class Ufo::CLI
   class Rollback < Base
-    def deploy
-      task_definition = normalize_version(@options[:version])
-      puts "Rolling back ECS service to task definition #{task_definition}"
+    include Ufo::Concerns
 
-      ship = Ship.new(@service, @options.merge(task_definition: task_definition, rollback: true))
-      ship.deploy
+    def deploy
+      are_you_sure?
+      rollback_task_definition = normalize_version(@options[:version])
+      logger.info "Rolling back ECS Service to task definition: #{rollback_task_definition}"
+      ship = Ship.new(@options.merge(rollback_task_definition: rollback_task_definition, rollback: true, yes: true))
+      ship.run
     end
 
     # normalizes the task definition
@@ -14,11 +16,11 @@ module Ufo
     #    demo-web:1 => demo-web:1
     def normalize_version(version)
       if version =~ /^\d+$/
-        "#{@service}:#{version}"
+        "#{@task_definition.name}:#{version}"
       elsif version.include?(':') && !version.include?(":ufo-")
         version
       else # assume git sha
-        # tongueroo/demo-ufo:ufo-2018-06-21T15-03-52-ac60240
+        # org/repo:ufo-2018-06-21T15-03-52-ac60240
         from_git_sha(version)
       end
     end
@@ -26,8 +28,8 @@ module Ufo
     def from_git_sha(sha)
       task_definition = nil
       max_items = 30
-      puts "Looking for task definition based on the git sha.  Searching most recent #{max_items} task definitions..."
-      arns = task_definition_arns(@service, max_items)
+      logger.info "Looking for task definition based on the git sha.  Searching most recent #{max_items} task definitions..."
+      arns = task_definition_arns(@task_definition.name, max_items)
       arns.each do |arn|
         resp = ecs.describe_task_definition(task_definition: arn)
         found = find_sha(resp.task_definition, sha)
@@ -39,9 +41,9 @@ module Ufo
         @final_newline
       end
 
-      puts '' if @final_newline
+      logger.info '' if @final_newline
       unless task_definition
-        puts "Unable to find a task definition with a image with: #{version}"
+        logger.info "Unable to find a task definition with a image with: #{version}"
       end
       task_definition
     end
@@ -50,5 +52,15 @@ module Ufo
       container = task_definition["container_definitions"].first # assume first
       container["image"].include?(sha)
     end
+
+  private
+    def are_you_sure?
+      message = "Will rollback to task definition version: #{@options[:version]}"
+      if @options[:yes]
+        logger.info message
+      else
+        sure?(message)
+      end
+    end
   end
 end