ufo 0.0.6

data/lib/ufo/dsl/outputter.rb

@@ -0,0 +1,40 @@
+module Ufo
+  class DSL
+    class Outputter
+      def initialize(name, erb_result, options={})
+        @name = name
+        @erb_result = erb_result
+        @options = options
+        @pretty = options[:pretty].nil? ? true : options[:pretty]
+      end
+
+      def write
+        output_path = "#{@options[:project_root]}/ufo/output"
+        FileUtils.rm_rf(output_path) if @options[:clean]
+        FileUtils.mkdir(output_path) unless File.exist?(output_path)
+
+        path = "#{output_path}/#{@name}.json"
+        puts "Generated task definition at: #{path}" unless @options[:quiet]
+        validate(@erb_result, path)
+        json = @pretty ?
+          JSON.pretty_generate(JSON.parse(@erb_result)) :
+          @erb_result
+        File.open(path, 'w') {|f| f.write(output_json(json)) }
+      end
+
+      def validate(json, path)
+        begin
+          JSON.parse(json)
+        rescue JSON::ParserError => e
+          puts "Invalid json.  Output written to #{path} for debugging".colorize(:red)
+          File.open(path, 'w') {|f| f.write(json) }
+          exit 1
+        end
+      end
+
+      def output_json(json)
+        @options[:pretty] ? JSON.pretty_generate(JSON.parse(json)) : json
+      end
+    end
+  end
+end

data/lib/ufo/dsl/task_definition.rb

@@ -0,0 +1,65 @@
+require "erb"
+require "json"
+
+module Ufo
+  class DSL
+    class TaskDefinition
+      attr_reader :task_definition_name
+      def initialize(dsl, task_definition_name, options={}, &block)
+        @dsl = dsl
+        @task_definition_name = task_definition_name
+        @block = block
+        @options = options
+        @project_root = @options[:project_root] || '.'
+      end
+
+      # delegate helper method back up to dsl
+      def helper
+        @dsl.helper
+      end
+
+      def build
+        instance_eval(&@block)
+        erb_template = IO.read(source_path)
+        ERB.new(erb_template).result(binding)
+      end
+
+      # at this point instance_eval has been called and source has possibly been called
+      def source(name)
+        @source = name
+      end
+
+      def variables(vars={})
+        vars.each do |var,value|
+          if instance_variable_defined?("@#{var}")
+            puts "WARNING: The instance variable @#{var} is already used internally with ufo.  Please name you variable another name!"
+          end
+          instance_variable_set("@#{var}", value)
+        end
+      end
+
+      def source_path
+        if @source # this means that source has been called
+          path = "#{@project_root}/ufo/templates/#{@source}.json.erb"
+          check_source_path(path)
+        else
+          # default source path
+          path = File.expand_path("../../templates/default.json.erb", __FILE__)
+          puts "#{task_definition_name} template definition using default template: #{path}" unless @options[:mute]
+        end
+        path
+      end
+
+      def check_source_path(path)
+        unless File.exist?(path)
+          friendly_path = path.sub("#{@project_root}/", '')
+          puts "ERROR: Could not find the #{friendly_path} template.  Are sure it exists?  Check where you called source in ufo/task_definitions.rb"
+          exit 1
+        else
+          puts "#{task_definition_name} template definition using project template: #{path}" unless @options[:mute]
+        end
+        path
+      end
+    end
+  end
+end

data/lib/ufo/ecr_auth.rb

@@ -0,0 +1,35 @@
+module Ufo
+  class EcrAuth
+    include AwsServices
+
+    def initialize(repo_domain)
+      @repo_domain = repo_domain
+    end
+
+    def update
+      auth_token = fetch_auth_token
+      if File.exist?(docker_config)
+        data = JSON.load(IO.read(docker_config))
+        data["auths"][@repo_domain] = {auth: auth_token}
+      else
+        data = {auths: {@repo_domain => {auth: auth_token}}}
+      end
+      ensure_dotdocker_exists
+      IO.write(docker_config, JSON.pretty_generate(data))
+    end
+
+    def fetch_auth_token
+      ecr.get_authorization_token.authorization_data.first.authorization_token
+    end
+
+    def docker_config
+      "#{ENV['HOME']}/.docker/config.json"
+    end
+
+    def ensure_dotdocker_exists
+      dirname = File.dirname(docker_config)
+      FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+    end
+
+  end
+end

data/lib/ufo/ecr_cleaner.rb

@@ -0,0 +1,66 @@
+require "json"
+
+# Can test:
+#
+#   ufo ship app-web --cluster prod --noop
+module Ufo
+  class EcrCleaner
+    include AwsServices
+    include Defaults
+
+    def initialize(docker_image_name, options={})
+      # docker_image_name does not containg the tag
+      # Example: 123456789.dkr.ecr.us-east-1.amazonaws.com/image
+      @docker_image_name = docker_image_name
+      @options = options
+      @keep = options[:ecr_keep] || settings.data["ecr_keep"]
+      @tag_prefix = options[:tag_prefix] || "ufo"
+    end
+
+    def cleanup
+      return false unless ecr_image?
+      return false unless @keep
+      update_auth_token
+      image_tags = fetch_image_tags
+      delete_tags = image_tags[@keep..-1] # ordered by most recent images first
+      delete_images(delete_tags)
+    end
+
+    def fetch_image_tags
+      ecr.list_images(repository_name: repo_name).
+        image_ids.
+        map { |image_id| image_id.image_tag }.
+        select { |image_tag| image_tag =~ Regexp.new("^#{@tag_prefix}-") }.
+        sort.reverse
+    end
+
+    def delete_images(tags)
+      return if tags.nil? || tags.empty?
+      unless @options[:mute]
+        puts "Keeping #{@keep} most recent ECR images."
+        puts "Deleting these ECR images:"
+        tag_list = tags.map { |t| "  #{repo_name}:#{t}" }
+        puts tag_list
+      end
+      image_ids = tags.map { |tag| {image_tag: tag} }
+      ecr.batch_delete_image(
+        repository_name: repo_name,
+        image_ids: image_ids) unless @options[:noop]
+    end
+
+    def update_auth_token
+      repo_domain = "https://#{@docker_image_name.split('/').first}"
+      auth = EcrAuth.new(repo_domain)
+      auth.update
+    end
+
+    def repo_name
+      # @docker_image_name example: 123456789.dkr.ecr.us-east-1.amazonaws.com/image
+      @docker_image_name.split('/').last
+    end
+
+    def ecr_image?
+      @docker_image_name =~ /\.amazonaws\.com/
+    end
+  end
+end

data/lib/ufo/execute.rb

@@ -0,0 +1,19 @@
+module Ufo
+  module Execute
+    def execute(command, local_options={})
+      command = "cd #{@project_root} && #{command}"
+      # local_options[:live] overrides the global @options[:noop]
+      if @options[:noop] && !local_options[:live]
+        say "NOOP: #{command}"
+        result = true # always success with no noop for specs
+      else
+        if local_options[:use_system]
+          result = system(command)
+        else
+          result = `#{command}`
+        end
+      end
+      result
+    end
+  end
+end

data/lib/ufo/init.rb

@@ -0,0 +1,83 @@
+require 'colorize'
+require 'erb'
+
+# quick test:
+# rm -rf ufo ; /Users/tung/src/tongueroo/ufo/bin/ufo init --cluster default2 --image tongueroo/ruby ; cat ufo/settings.yml
+module Ufo
+  class Init
+    def initialize(options = {})
+      @options = options
+      @project_root = options[:project_root] || '.'
+    end
+
+    def setup
+      puts "Setting up ufo project...".blue unless @options[:quiet]
+      source_root = File.expand_path("../../starter_project", __FILE__)
+      # https://ruby-doc.org/core-2.2.0/Dir.html
+      # use the File::FNM_DOTMATCH flag or something like "{*,.*}".
+      paths = Dir.glob("#{source_root}/**/{*,.*}").
+                select {|p| File.file?(p) }
+      paths.each do |src|
+        dest = src.gsub(%r{.*starter_project/},'')
+        dest = "#{@project_root}/#{dest}"
+
+        if File.exist?(dest) and !@options[:force]
+          puts "exists: #{dest}".yellow unless @options[:quiet]
+        else
+          dirname = File.dirname(dest)
+          FileUtils.mkdir_p(dirname) unless File.exist?(dirname)
+          if dest =~ /\.erb$/
+            FileUtils.cp(src, dest)
+          else
+            write_erb_result(src, dest)
+          end
+          puts "created: #{dest}".green unless @options[:quiet]
+        end
+      end
+      puts "Starter ufo files created.".blue
+      File.chmod(0755, "#{@project_root}/bin/deploy")
+      add_gitignore
+    end
+
+    def write_erb_result(src, dest)
+      source = IO.read(src)
+      b = ERBContext.new(@options).get_binding
+      output = ERB.new(source).result(b)
+      IO.write(dest, output)
+    end
+
+    def add_gitignore
+      gitignore_path = "#{@project_root}/.gitignore"
+      if File.exist?(gitignore_path)
+        ignores = IO.read(gitignore_path)
+        has_ignore = ignores.include?("ufo/output")
+        ignores << ufo_ignores unless has_ignore
+      else
+        ignores = ufo_ignores
+      end
+      IO.write(gitignore_path, ignores)
+    end
+
+    def ufo_ignores
+      ignores =<<-EOL
+/ufo/output
+/ufo/docker_image_name*.txt
+/ufo/version
+EOL
+    end
+
+  end
+end
+
+# http://stackoverflow.com/questions/1338960/ruby-templates-how-to-pass-variables-into-inlined-erb
+class ERBContext
+  def initialize(hash)
+    hash.each_pair do |key, value|
+      instance_variable_set('@' + key.to_s, value)
+    end
+  end
+
+  def get_binding
+    binding
+  end
+end

data/lib/ufo/pretty_time.rb

@@ -0,0 +1,14 @@
+module Ufo
+  module PrettyTime
+    # http://stackoverflow.com/questions/4175733/convert-duration-to-hoursminutesseconds-or-similar-in-rails-3-or-ruby
+    def pretty_time(total_seconds)
+      minutes = (total_seconds / 60) % 60
+      seconds = total_seconds % 60
+      if total_seconds < 60
+        "#{seconds.to_i}s"
+      else
+        "#{minutes.to_i}m #{seconds.to_i}s"
+      end
+    end
+  end
+end

data/lib/ufo/scale.rb

@@ -0,0 +1,34 @@
+module Ufo
+  class Scale
+    include Defaults
+    include AwsServices
+
+    def initialize(service, count, options={})
+      @service = service
+      @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 "Are you sure you are trying to scale the right service on the right cluster?"
+        exit
+      end
+      ecs.update_service(
+        service: @service,
+        cluster: @cluster,
+        desired_count: @count
+      )
+      puts "Scale #{@service} service in #{@cluster} 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
+end

data/lib/ufo/settings.rb

@@ -0,0 +1,33 @@
+require 'yaml'
+
+module Ufo
+  class Settings
+    def initialize(project_root='.')
+      @project_root = project_root
+    end
+
+    # 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 File.exist?(settings_path)
+        @data = YAML.load_file(settings_path)
+        @data = user_settings.merge(@data)
+      else
+        puts "ERROR: No settings file file at #{settings_path}"
+        puts "Please create a settings file via: ufo init"
+        exit 1
+      end
+    end
+
+    def user_settings
+      path = "#{ENV['HOME']}/.ufo/settings.yml"
+      File.exist?(path) ? YAML.load_file(path) : {}
+    end
+
+    def settings_path
+      "#{@project_root}/ufo/settings.yml"
+    end
+  end
+end

data/lib/ufo/ship.rb

@@ -0,0 +1,436 @@
+require 'colorize'
+
+module Ufo
+  # Creating this class pass so we can have a reference we do not have describe
+  # all services and look up service_name creating more API calls.
+  #
+  # Also this class allows us to pass one object around instead of both
+  # cluster_name and service_name.
+  module ECS
+    Service = Struct.new(:cluster_arn, :service_arn) do
+      def cluster_name
+        cluster_arn.split('/').last
+      end
+
+      def service_name
+        service_arn.split('/').last
+      end
+    end
+  end
+
+  class UfoError < RuntimeError; end
+  class ShipmentOverridden < UfoError; end
+
+  class Ship
+    include Defaults
+    include AwsServices
+    include PrettyTime
+
+    # service can be a pattern
+    def initialize(service, task_definition, options={})
+      @service = service
+      @task_definition = task_definition
+      @options = options
+      @project_root = options[:project_root] || '.'
+      @elb_prompt = @options[:elb_prompt].nil? ? true : @options[:elb_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]
+    end
+
+    # Find all the matching services on a cluster and update them.
+    # If no service is found at all, then create a service on the very first specified cluster
+    # only.
+    #
+    # If it looks like one service is passed in then it'll automatically create the service
+    # on the first cluster.
+
+    # If it looks like a regexp is passed in then it'll only update the services
+    # This is because regpex cannot be used to determined a list of service_names.
+    #
+    # Example:
+    #   No way to map: hi-.*-prod -> hi-web-prod hi-worker-prod hi-clock-prod
+    def deploy
+      puts "Shipping #{@service}...".green unless @options[:mute]
+
+      ensure_cluster_exist
+      process_single_service
+
+      puts "Software shipped!" unless @options[:mute]
+    end
+
+    # A single service name shouold had been passed and the service automatically
+    # gets created if it does not exist.
+    def process_single_service
+      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 process_multiple_services
+      puts "Multi services mode" unless @options[:mute]
+      services_to_deploy = []
+      find_all_ecs_services do |ecs_service|
+        if service_pattern_match?(ecs_service.service_name)
+          services_to_deploy << ecs_service
+        end
+      end
+
+      deployed_services = services_to_deploy.map do |ecs_service|
+        update_service(ecs_service)
+      end
+
+      wait_for_all_deployments(deployed_services) if @wait_for_deployment && !@options[:noop]
+      stop_old_tasks(deployed_services) 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)
+      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.
+      puts "@options[:stop_old_tasks] #{@options[:stop_old_tasks].inspect}"
+      puts "old_tasks.size #{old_tasks.size}"
+      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
+
+    # 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
+        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
+
+    def wait_for_all_deployments(deployed_services)
+      start_time = Time.now
+      threads = deployed_services.map do |deployed_service|
+        Thread.new do
+          # http://stackoverflow.com/questions/1383390/how-can-i-return-a-value-from-a-thread-in-ruby
+          Thread.current[:output] = wait_for_deployment(deployed_service, quiet=true)
+        end
+      end
+      threads.each { |t| t.join }
+      total_took = Time.now - start_time
+      puts ""
+      puts "Shipments for all #{deployed_service.size} services took a total of #{pretty_time(total_took).green}."
+      puts "Each deployment took:"
+      threads.each do |t|
+        service_name, took = t[:output]
+        puts "  #{service_name}: #{pretty_time(took)}"
+      end
+    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)
+    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
+      container = container_info(@task_definition)
+      target_group = create_service_prompt(container)
+
+      message = "#{@service} service created on #{@cluster} cluster"
+      if @options[:noop]
+        message = "NOOP #{message}"
+      else
+        options = {
+          cluster: @cluster,
+          service_name: @service,
+          desired_count: default_desired_count,
+          deployment_configuration: {
+            maximum_percent: default_maximum_percent,
+            minimum_healthy_percent: default_minimum_healthy_percent
+          },
+          task_definition: @task_definition
+        }
+        unless target_group.nil? || target_group.empty?
+          add_load_balancer!(container, options)
+        end
+        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
+    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
+        response = ecs.update_service(
+          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
+        )
+        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
+    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)
+      options.merge!(
+        role: "ecsServiceRole", # assumption that we're using the ecsServiceRole
+        load_balancers: [
+          {
+            container_name: container[:name],
+            container_port: container[:port],
+            target_group_arn: @options[: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 create_service_prompt(container)
+      return if @options[:noop]
+      return unless @elb_prompt
+      if container[:name] != "web" and @options[:target_group]
+        puts "WARNING: A --target-group #{@options[:target_group]} was provided but it will not be used because this not a web container.  Container name: #{container[:name].inspect}."
+      end
+      return unless container[:name] == 'web'
+      return @options[:target_group] if @options[:target_group]
+
+      puts "This service #{@service} does not yet exist in the #{@cluster} cluster.  This deploy will create it."
+      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)
+      task_definition_path = "ufo/output/#{task_definition}.json"
+      task_definition_full_path = "#{@project_root}/#{task_definition_path}"
+      unless File.exist?(task_definition_full_path)
+        puts "ERROR: Unable to find the task definition at #{task_definition_path}."
+        puts "Are you sure you have defined it in ufo/template_definitions.rb?"
+        exit
+      end
+      task_definition = JSON.load(IO.read(task_definition_full_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 service_exact_match?(service_name)
+      service_name == @service
+    end
+
+    # @service is changed to a pattern to be search with.
+    #
+    # Examples:
+    #   @service == "hi-.*-prod"
+    def service_pattern_match?(service_name)
+      service_patttern = Regexp.new(@service)
+      service_name =~ service_patttern
+    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 ECS::Service object
+    def find_all_ecs_services
+      ecs_services = []
+      service_arns.each do |service_arn|
+        ecs_service = ECS::Service.new(cluster_arn, service_arn)
+        yield(ecs_service) if block_given?
+        ecs_services << ecs_service
+      end
+      ecs_services
+    end
+
+    def service_arns
+      ecs.list_services(cluster: @cluster).service_arns
+    end
+
+    def cluster_arn
+      @cluster_arn ||= ecs_clusters.first.cluster_arn
+    end
+
+    def ensure_cluster_exist
+      cluster_exist = ecs_clusters.first
+      unless cluster_exist
+        message = "#{@cluster} cluster created."
+        if @options[:noop]
+          message = "NOOP #{message}"
+        else
+          ecs.create_cluster(cluster_name: @cluster)
+        end
+        puts message unless @options[:mute]
+      end
+    end
+
+    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