ufo 5.0.6 → 6.0.1

data/lib/ufo/cli/ps.rb

@@ -0,0 +1,157 @@
+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
+
+      tasks = convert_to_task_objects(all_task_arns)
+      show_tasks(tasks)
+      show_errors(tasks)
+    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 show_tasks(tasks)
+      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_errors(tasks)
+      Errors.new(@options.merge(tasks: tasks)).show
+    end
+
+  private
+    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 convert_to_task_objects(task_arns)
+      task_arns.sort_by! { |t| t["task_arn"] }
+      task_arns.map { |t| Task.new(t) } # will have Task objects after this point
+    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

data/lib/ufo/cli/scale.rb

@@ -0,0 +1,76 @@
+class Ufo::CLI
+  class Scale < Base
+    delegate :service, :service?, :stack_resources, to: :info
+
+    def initialize(options={})
+      super
+      @desired = options[:desired]
+      @min = options[:min]
+      @max = options[:max]
+    end
+
+    def update
+      unless service?
+        logger.error "ERROR: Unable to find the #{service}.".color(:red)
+        logger.error "Are you sure you are trying to scale the right app?"
+        exit 1
+      end
+
+      unless @desired || @min || @max
+        logger.info <<~EOL
+          No --desired --min or --max options provided
+          Not taking any actions
+        EOL
+        return
+      end
+
+      logger.info "Configuring scaling settings for #{@stack_name}"
+      set_desired_count
+      set_autoscaling
+      warning
+    end
+
+    def set_desired_count
+      return unless @desired
+      ecs.update_service(
+        service: service.service_name,
+        cluster: @cluster,
+        desired_count: @desired
+      )
+      logger.info "Configured desired count to #{@desired}"
+    end
+
+    def set_autoscaling
+      return unless @min || @max
+      scalable_target = stack_resources.find do |r|
+        r.logical_resource_id == "ScalingTarget"
+      end
+      # service/dev/app1-web-dev-EcsService-Q0XkN6VtxGWv|ecs:service:DesiredCount|ecs
+      resource_id, scalable_dimension, service_namespace = scalable_target.physical_resource_id.split('|')
+      applicationautoscaling.register_scalable_target(
+        max_capacity: @max,
+        min_capacity: @min,
+        resource_id: resource_id,
+        scalable_dimension: scalable_dimension,
+        service_namespace: service_namespace,
+      )
+      logger.info "Configured autoscaling to min: #{@min} max: #{@max}"
+    end
+
+    def warning
+      return unless Ufo.config.scale.warning
+      logger.info <<~EOL
+        Note: The settings are temporary.
+        They can be overwritten in the next `ufo ship` deploy.
+        To make the settings permanent update your ufo config.
+
+        See: https://ufoships.com/docs/config/
+
+        You can also turn off this warning with
+
+            config.scaling.warning = false
+
+      EOL
+    end
+  end
+end

data/lib/ufo/cli/ship.rb

@@ -0,0 +1,28 @@
+class Ufo::CLI
+  class Ship < Base
+    include Ufo::Concerns
+
+    def run
+      are_you_sure?
+      build_task_definition
+      deploy.run
+      ps.run
+    end
+
+    def build_task_definition
+      return if @options[:rollback]
+      build.docker
+      build.task_definition
+    end
+
+  private
+    def are_you_sure?
+      message = "Will deploy stack #{@stack_name.color(:green)}"
+      if @options[:yes]
+        logger.info message
+      else
+        sure?(message)
+      end
+    end
+  end
+end

data/lib/ufo/cli/status.rb

@@ -0,0 +1,8 @@
+class Ufo::CLI
+  class Status < Base
+    def run
+      stack = Ufo::Cfn::Stack.new(@options)
+      stack.status.wait
+    end
+  end
+end

data/lib/ufo/cli/stop.rb

@@ -0,0 +1,49 @@
+class Ufo::CLI
+  class Stop < Base
+    def run
+      service = info.service
+      return unless service # brand new deploy
+
+      @deployments = service.deployments
+      if @deployments.size >= 1
+        stop(service.service_name)
+      end
+    end
+
+    def stop(service_name)
+      tasks = service_tasks(service_name)
+      show(tasks, preview: true) unless @options[:yes]
+      sure?
+      tasks.each do |task|
+        if @options[:stop_old_tasks]
+          next if task["task_definition_arn"] == latest_deployed_arn
+        end
+        logger.debug "stop task #{task["task_arn"]}"
+        meth = "stop_task"
+        ecs.stop_task(cluster: @cluster, task: task["task_arn"], reason: "stop by ufo")
+      end
+      logger.info "Stopping tasks"
+      show(tasks, preview: false) if @options[:yes]
+    end
+
+    def show(tasks, preview: true)
+      logger.info "Will stop the following tasks:" if preview
+      ps = Ps.new(@options)
+      ps.display_tasks(tasks)
+    end
+
+    # latest deployment task definition arn
+    def latest_deployed_arn
+      latest = @deployments.sort_by do |deployment|
+        Time.parse(deployment["created_at"].to_s)
+      end.last
+      latest["task_definition"]
+    end
+
+    def service_tasks(service_name)
+      all_task_arns = ecs.list_tasks(cluster: @cluster, service_name: service_name).task_arns
+      return [] if all_task_arns.empty?
+      ecs.describe_tasks(cluster: @cluster, tasks: all_task_arns).tasks
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
-module Ufo
-  class Tasks < Command
+class Ufo::CLI
+  class Tasks < Ufo::Command
     desc "build", "Build task definitions."
     long_desc Help.text("tasks:build")
     option :image_override, desc: "Override image in task definition for quick testing"

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

@@ -1,5 +1,5 @@
-module Ufo
-  class Upgrade < Command
+class Ufo::CLI
+  class Upgrade < Ufo::Command
     desc "v2to3", "Upgrade from version 2 to 3."
     def v2to3
       Upgrade3.new(options).run