ufo 3.5.7 → 4.0.0

data/lib/ufo/releases.rb

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

data/lib/ufo/rollback.rb

@@ -0,0 +1,53 @@
+module Ufo
+  class Rollback < Base
+    def deploy
+      task_definition = normalize_version(@options[:version])
+      puts "Rolling back ECS service to task definition #{task_definition}"
+      ship = Ship.new(@service, @options.merge(task_definition: task_definition))
+      ship.deploy
+    end
+
+    # normalizes the task definition
+    # if user passes in:
+    #    1 => demo-web:1
+    #    demo-web:1 => demo-web:1
+    def normalize_version(version)
+      if version =~ /^\d+$/
+        "#{@service}:#{version}"
+      elsif version.include?(':') && !version.include?(":ufo-")
+        version
+      else # assume git sha
+        # tongueroo/demo-ufo:ufo-2018-06-21T15-03-52-ac60240
+        from_git_sha(version)
+      end
+    end
+
+    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)
+      arns.each do |arn|
+        resp = ecs.describe_task_definition(task_definition: arn)
+        found = find_sha(resp.task_definition, sha)
+        if found
+          task_definition = arn.split('/').last
+          break
+        end
+        print '.'
+        @final_newline
+      end
+
+      puts '' if @final_newline
+      unless task_definition
+        puts "Unable to find a task definition with a image with: #{version}"
+      end
+      task_definition
+    end
+
+    def find_sha(task_definition, sha)
+      container = task_definition["container_definitions"].first # assume first
+      container["image"].include?(sha)
+    end
+  end
+end

data/lib/ufo/scale.rb

@@ -1,33 +1,27 @@
 module Ufo
-  class Scale
-    include Util
-    include AwsService
+  class Scale < Base
+    delegate :service, to: :info
 
     def initialize(service, count, options={})
-      @service = service
+      super(service, options)
       @count = count
-      @options = options
-      @cluster = @options[:cluster] || default_cluster
     end
 
     def update
       unless service_exists?
-        puts "Unable to find the #{@service} service on #{@cluster} cluster."
+        puts "Unable to find the #{@pretty_service_name.colorize(:green)} service on the #{@cluster.colorize(:green)} cluster."
         puts "Are you sure you are trying to scale the right service on the right cluster?"
         exit
       end
       ecs.update_service(
-        service: @service,
+        service: service.service_name,
         cluster: @cluster,
         desired_count: @count
       )
-      puts "Scale #{@service} service in #{@cluster} cluster to #{@count}" unless @options[:mute]
+      puts "Scale #{@pretty_service_name.colorize(:green)} service in #{@cluster.colorize(:green)} cluster to #{@count}" unless @options[:mute]
     end
 
     def service_exists?
-      cluster = ecs.describe_clusters(clusters: [@cluster]).clusters.first
-      return false unless cluster
-      service = ecs.describe_services(services: [@service], cluster: @cluster).services.first
       !!service
     end
   end

data/lib/ufo/sequence.rb

@@ -6,11 +6,18 @@ module Ufo
   class Sequence < Thor::Group
     include Thor::Actions
 
+    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__)]
     end
 
   private
+    def inferred_app
+      File.basename(Dir.pwd)
+    end
+
     def get_execution_role_arn_input
       return @execution_role_arn if @execution_role_arn
 

data/lib/ufo/setting.rb

@@ -2,6 +2,9 @@ require 'yaml'
 
 module Ufo
   class Setting
+    extend Memoist
+    autoload :Profile, "ufo/setting/profile"
+
     def initialize(check_ufo_project=true)
       @check_ufo_project = check_ufo_project
     end
@@ -9,12 +12,8 @@ module Ufo
     # data contains the settings.yml config.  The order or precedence for settings
     # is the project ufo/settings.yml and then the ~/.ufo/settings.yml.
     def data
-      return @data if @data
-
       if @check_ufo_project && !File.exist?(project_settings_path)
-        puts "ERROR: No settings file at #{project_settings_path}.  Are you sure you are in a project with ufo setup?"
-        puts "If you want to set up ufo for this prjoect, please create a settings file via: ufo init"
-        exit 1
+        Ufo.check_ufo_project!
       end
 
       # project based settings files
@@ -28,8 +27,10 @@ module Ufo
 
       all_envs = default.deep_merge(user.deep_merge(project))
       all_envs = merge_base(all_envs)
-      @@data = all_envs[Ufo.env] || all_envs["base"] || {}
+      data = all_envs[Ufo.env] || all_envs["base"] || {}
+      data.deep_symbolize_keys
     end
+    memoize :data
 
   private
     def load_file(path)

data/lib/ufo/setting/profile.rb

@@ -0,0 +1,24 @@
+class Ufo::Setting
+  class Profile
+    extend Memoist
+
+    def initialize(type, profile='default')
+      @type = type.to_s # cfn or network
+      @profile = profile
+    end
+
+    def data
+      path = "#{Ufo.root}/.ufo/settings/#{@type}/#{@profile}.yml"
+      unless File.exist?(path)
+        puts "#{@type.camelize} profile #{path} not found. Please double check that it exists."
+        exit 1
+      end
+
+      text = RenderMePretty.result(path)
+      # puts "text:".colorize(:cyan)
+      # puts text
+      YAML.load(text).deep_symbolize_keys
+    end
+    memoize :data
+  end
+end

data/lib/ufo/ship.rb

@@ -3,23 +3,16 @@ require 'colorize'
 module Ufo
   class UfoError < RuntimeError; end
   class ShipmentOverridden < UfoError; end
+  autoload :KillTask, 'ufo/ship/kill_task'
 
-  class Ship
-    include AwsService
-    include Util
-
-    def initialize(service, task_definition, options={})
-      @service = service
-      @task_definition = task_definition
-      @options = options
-      @target_group_prompt = @options[:target_group_prompt].nil? ? true : @options[:target_group_prompt]
-      @cluster = @options[:cluster] || default_cluster
-      @wait_for_deployment = @options[:wait].nil? ? true : @options[:wait]
-      @stop_old_tasks = @options[:stop_old_tasks].nil? ? false : @options[:stop_old_tasks]
+  class Ship < Base
+    def initialize(service, options={})
+      super
+      @task_definition = options[:task_definition]
     end
 
     def deploy
-      message = "Shipping #{@service}..."
+      message = "Deploying #{@service}..."
       unless @options[:mute]
         if @options[:noop]
           puts "NOOP: #{message}"
@@ -31,180 +24,45 @@ module Ufo
 
       ensure_log_group_exist
       ensure_cluster_exist
-      process_deployment
-
-      puts "Software shipped!" unless @options[:mute]
-    end
+      stop_old_tasks if @options[:stop_old_tasks]
+      success = deploy_stack
 
-    def ensure_log_group_exist
-      LogGroup.new(@task_definition, @options).create
-    end
-
-    def process_deployment
-      ecs_service = find_ecs_service
-      deployed_service = if ecs_service
-                           # update all existing service
-                           update_service(ecs_service)
-                         else
-                           # create service on the first cluster
-                           create_service
-                         end
-
-      wait_for_deployment(deployed_service) if @wait_for_deployment && !@options[:noop]
-      stop_old_task(deployed_service) if @stop_old_tasks
-    end
-
-    def service_tasks(cluster, service)
-      all_task_arns = ecs.list_tasks(cluster: cluster, service_name: service).task_arns
-      return [] if all_task_arns.empty?
-      ecs.describe_tasks(cluster: cluster, tasks: all_task_arns).tasks
-    end
-
-    def old_task?(deployed_task_definition_arn, task_definition_arn)
-      puts "deployed_task_definition_arn: #{deployed_task_definition_arn.inspect}"
-      puts "task_definition_arn: #{task_definition_arn.inspect}"
-      deployed_version = deployed_task_definition_arn.split(':').last.to_i
-      version = task_definition_arn.split(':').last.to_i
-      puts "deployed_version #{deployed_version.inspect}"
-      puts "version #{version.inspect}"
-      is_old = version < deployed_version
-      puts "is_old #{is_old.inspect}"
-      is_old
-    end
-
-    def stop_old_tasks(services)
-      services.each do |service|
-        stop_old_task(service)
+      return if @options[:mute] || !@options[:wait]
+      if success
+        puts "Software shipped!"
+      else
+        puts "Software fail to ship."
       end
     end
 
-    # aws ecs list-tasks --cluster prod-hi --service-name gr-web-prod
-    # aws ecs describe-tasks --tasks arn:aws:ecs:us-east-1:467446852200:task/09038fd2-f989-4903-a8c6-1bc41761f93f --cluster prod-hi
-    def stop_old_task(deployed_service)
-      deployed_task_definition_arn = deployed_service.task_definition
-      puts "deployed_task_definition_arn #{deployed_task_definition_arn.inspect}"
-
-      # cannot use @serivce because of multiple mode
-      all_tasks = service_tasks(@cluster, deployed_service.service_name)
-      old_tasks = all_tasks.select do |task|
-        old_task?(deployed_task_definition_arn, task.task_definition_arn)
-      end
-
-      reason = "Ufo #{Ufo::VERSION} has deployed new code and waited until the newer code is running."
-      puts reason
-      # Stopping old tasks after we have confirmed that the new task definition has the same
-      # number of desired_count and running_count speeds up clean up and ensure that we
-      # dont have any stale code being served.  It seems to take a long time for the
-      # ELB to drain the register container otherwise. This might cut off some requests but
-      # providing this as an option that can be turned of beause I've seen deploys go way too
-      # slow.
-      old_tasks.each do |task|
-        puts "stopping task.task_definition_arn #{task.task_definition_arn.inspect}"
-        ecs.stop_task(cluster: @cluster, task: task.task_arn, reason: reason)
-      end if @options[:stop_old_tasks]
-    end
+    # Start a thread that will poll for ecs deployments and kill of tasks
+    # in old deployments.
+    # This must be done in a thread because the stack update process is blocking.
+    def stop_old_tasks
+      # only works when deployment is blocking
+      return unless @options[:wait]
 
-    # service is the returned object from aws-sdk not the @service which is just a String.
-    # Returns [service_name, time_took]
-    def wait_for_deployment(deployed_service, quiet=false)
-      start_time = Time.now
-      deployed_task_name = task_name(deployed_service.task_definition)
-      puts "Waiting for deployment of task definition #{deployed_task_name.green} to complete" unless quiet
-      begin
-        until deployment_complete(deployed_service)
-          print '.'
-          sleep 5
+      Thread.new do
+        stop = Ufo::Stop.new(@service, @options.merge(mute: true))
+        while true
+          stop.log "checking for old tasks and waiting for 10 seconds"
+          stop.run
+          sleep 10
         end
-      rescue ShipmentOverridden => e
-        puts "This deployed was overridden by another deploy"
-        puts e.message
       end
-      puts '' unless quiet
-      took = Time.now - start_time
-      puts "Time waiting for ECS deployment: #{pretty_time(took).green}." unless quiet
-      [deployed_service.service_name, took]
     end
 
-    # used for polling
-    # must pass in a service and cannot use @service for the case of multi_services mode
-    def find_updated_service(service)
-      ecs.describe_services(services: [service.service_name], cluster: @cluster).services.first
-    end
-
-    # aws ecs describe-services --services hi-web-prod --cluster prod-hi
-    # Passing in the service because we need to capture the deployed task_definition
-    # that was actually deployed.   We use it to pull the describe_services
-    # until all the paramters we expect upon a completed deployment are updated.
-    #
-    def deployment_complete(deployed_service)
-      deployed_task_definition = deployed_service.task_definition # want the stale task_definition out of the wa
-      service = find_updated_service(deployed_service) # polling
-      deployment = service.deployments.first
-      # Edge case when another deploy superseds this deploy in this case break out of this loop
-      deployed_task_version = task_version(deployed_task_definition)
-      current_task_version = task_version(service.task_definition)
-      if current_task_version > deployed_task_version
-        raise ShipmentOverridden.new("deployed_task_version was #{deployed_task_version} but task_version is now #{current_task_version}")
-      end
-
-      (deployment.task_definition == deployed_task_definition &&
-       deployment.desired_count == deployment.running_count)
+    def ensure_log_group_exist
+      LogGroup.new(@task_definition, @options).create
     end
 
-    # $ aws ecs create-service --generate-cli-skeleton
-    # {
-    #     "cluster": "",
-    #     "serviceName": "",
-    #     "taskDefinition": "",
-    #     "desiredCount": 0,
-    #     "loadBalancers": [
-    #         {
-    #             "targetGroupArn": "",
-    #             "containerName": "",
-    #             "containerPort": 0
-    #         }
-    #     ],
-    #     "role": "",
-    #     "clientToken": "",
-    #     "deploymentConfiguration": {
-    #         "maximumPercent": 0,
-    #         "minimumHealthyPercent": 0
-    #     }
-    # }
-    #
-    # If the service needs to be created it will get created with some default settings.
-    # When does a normal deploy where an update happens only the only thing that ufo
-    # will update is the task_definition.  The other settings should normally be updated with
-    # the ECS console.  `ufo scale` will allow you to updated the desired_count from the
-    # CLI though.
-    def create_service
-      puts "This service #{@service.colorize(:green)} does not yet exist in the #{@cluster.colorize(:green)} cluster.  This deploy will create it."
-      container = container_info(@task_definition)
-      target_group = target_group_prompt(container)
-
-      message = "#{@service} service created on #{@cluster} cluster"
-      if @options[:noop]
-        message = "NOOP #{message}"
-      else
-        options = {
-          cluster: @cluster,
-          service_name: @service,
-          task_definition: @task_definition
-        }
-        options = options.merge(default_params[:create_service])
-        unless target_group.nil? || target_group.empty?
-          add_load_balancer!(container, options, target_group)
-        end
-
-        puts "Creating ECS service with params:"
-        display_params(options)
-        show_aws_cli_command(:create, options)
-        response = ecs.create_service(options)
-        service = response.service # must set service here since this might never be called if @wait_for_deployment is false
-      end
-
-      puts message unless @options[:mute]
-      service
+    def deploy_stack
+      options = @options.merge(
+        service: @service,
+        task_definition: @task_definition,
+      )
+      stack = Stack.new(options)
+      stack.deploy
     end
 
     def show_aws_cli_command(action, params)
@@ -224,143 +82,6 @@ module Ufo
       puts "  aws ecs #{action}-service --cli-input-json #{file_path}".colorize(:green)
     end
 
-    # $ aws ecs update-service --generate-cli-skeleton
-    # {
-    #     "cluster": "",
-    #     "service": "",
-    #     "taskDefinition": "",
-    #     "desiredCount": 0,
-    #     "deploymentConfiguration": {
-    #         "maximumPercent": 0,
-    #         "minimumHealthyPercent": 0
-    #     }
-    # }
-    # Only thing we want to change is the task-definition
-    def update_service(ecs_service)
-      message = "#{ecs_service.service_name} service updated on #{ecs_service.cluster_name} cluster with task #{@task_definition}"
-      if @options[:noop]
-        message = "NOOP #{message}"
-      else
-        params = {
-          cluster: ecs_service.cluster_arn, # can use the cluster name also since it is unique
-          service: ecs_service.service_arn, # can use the service name also since it is unique
-          task_definition: @task_definition
-        }
-        params = params.merge(default_params[:update_service] || {})
-        puts "Updating ECS service with params:"
-        display_params(params)
-        show_aws_cli_command(:update, params)
-
-        unless @options[:noop]
-          response = ecs.update_service(params)
-          service = response.service # must set service here since this might never be called if @wait_for_deployment is false
-        end
-      end
-
-      puts message unless @options[:mute]
-      service
-    end
-
-    # Only support Application Load Balancer
-    # Think there is an AWS bug that complains about not having the LB
-    # name but you cannot pass both a LB Name and a Target Group.
-    def add_load_balancer!(container, options, target_group)
-      options.merge!(
-        load_balancers: [
-          {
-            container_name: container[:name],
-            container_port: container[:port],
-            target_group_arn: target_group,
-          }
-        ]
-      )
-    end
-
-    # Returns the target_group.
-    # Will only allow an target_group and the service to use a load balancer
-    # if the container name is "web".
-    def target_group_prompt(container)
-      return if @options[:noop]
-      # If a target_group is provided at the CLI return it right away.
-      return @options[:target_group] if @options[:target_group]
-      # Allows skipping the target group prompt.
-      return unless @target_group_prompt
-
-      # If the container name is web then it is assume that this is a web service that
-      # needs a target group/elb.
-      return unless container[:name] == 'web'
-
-      puts "Would you like this service to be associated with an Application Load Balancer?"
-      puts "If yes, please provide the Application Load Balancer Target Group ARN."
-      puts "If no, simply press enter."
-      print "Target Group ARN: "
-
-      arn = $stdin.gets.strip
-      until arn == '' or validate_target_group(arn)
-        puts "You have provided an invalid Application Load Balancer Target Group ARN: #{arn}."
-        puts "It should be in the form: arn:aws:elasticloadbalancing:us-east-1:123456789:targetgroup/target-name/2378947392743"
-        puts "Please try again or skip adding a Target Group by just pressing enter."
-        print "Target Group ARN: "
-        arn = $stdin.gets.strip
-      end
-      arn
-    end
-
-    def validate_target_group(arn)
-      elb.describe_target_groups(target_group_arns: [arn])
-      true
-    rescue Aws::ElasticLoadBalancingV2::Errors::ValidationError
-      false
-    end
-
-    # assume only 1 container_definition
-    # assume only 1 port mapping in that container_defintion
-    def container_info(task_definition)
-      Ufo.check_task_definition!(task_definition)
-      task_definition_path = ".ufo/output/#{task_definition}.json"
-      task_definition = JSON.load(IO.read(task_definition_path))
-      container_def = task_definition["containerDefinitions"].first
-      mappings = container_def["portMappings"]
-      if mappings
-        map = mappings.first
-        port = map["containerPort"]
-      end
-      {
-        name: container_def["name"],
-        port: port
-      }
-    end
-
-    def find_ecs_service
-      find_all_ecs_services.find { |ecs_service| ecs_service.service_name == @service }
-    end
-
-    # find all services on a cluster
-    # yields Ufo::ECS::Service object
-    def find_all_ecs_services
-      ecs_services = []
-      service_arns.each do |service_arn|
-        ecs_service = Ufo::ECS::Service.new(cluster_arn, service_arn)
-        yield(ecs_service) if block_given?
-        ecs_services << ecs_service
-      end
-      ecs_services
-    end
-
-    def service_arns
-      services = ecs.list_services(cluster: @cluster)
-      list_service_arns = services.service_arns
-      while services.next_token != nil
-        services = ecs.list_services(cluster: @cluster, next_token: services.next_token)
-        list_service_arns += services.service_arns
-      end
-      list_service_arns
-    end
-
-    def cluster_arn
-      @cluster_arn ||= ecs_clusters.first.cluster_arn
-    end
-
     def ensure_cluster_exist
       cluster = ecs_clusters.first
       unless cluster && cluster.status == "ACTIVE"
@@ -369,7 +90,7 @@ module Ufo
           message = "NOOP #{message}"
         else
           ecs.create_cluster(cluster_name: @cluster)
-          # TODO: Aad Waiter logic, sometimes the cluster does not exist by the time
+          # TODO: Add Waiter logic, sometimes the cluster does not exist by the time
           # we create the service
         end
 
@@ -380,17 +101,5 @@ module Ufo
     def ecs_clusters
       ecs.describe_clusters(clusters: [@cluster]).clusters
     end
-
-    def task_name(task_definition)
-      # "arn:aws:ecs:us-east-1:123456789:task-definition/hi-web-prod:72"
-      #   ->
-      # "task-definition/hi-web-prod:72"
-      task_definition.split('/').last
-    end
-
-    def task_version(task_definition)
-      # "task-definition/hi-web-prod:72" -> 72
-      task_name(task_definition).split(':').last.to_i
-    end
   end
 end