ufo 5.0.5 → 6.0.0

data/lib/ufo/stack/context.rb

@@ -1,253 +0,0 @@
-class Ufo::Stack
-  class Context
-    extend Memoist
-    include Helper
-    include Ufo::Settings
-
-    attr_reader :stack_name
-    def initialize(options)
-      @options = options
-      @task_definition = options[:task_definition]
-      @service = options[:service]
-      # no need to adjust @cluster or @stack_name because it was adjusted in Stack#initialize
-      @cluster = options[:cluster].dup # Thor options are frozen, we thaw it because CustomProperties#substitute_variables does a sub!
-      @stack_name = options[:stack_name]
-
-      @stack = options[:stack]
-      @new_stack = !@stack
-    end
-
-    def scope
-      scope = Ufo::TemplateScope.new(Ufo::DSL::Helper.new, nil)
-      # Add additional variable to scope for CloudFormation template.
-      # Dirties the scope but needed.
-      vars = {
-        service: @service,
-        cluster: @cluster,
-        stack_name: @stack_name, # used in custom_properties
-        container: container,
-        # to reconstruct TaskDefinition in the CloudFormation template
-        task_definition: @task_definition,
-        rollback_definition_arn: @options[:rollback_definition_arn],
-        # elb options remember that their 'state'
-        create_elb: create_elb?, # helps set Ecs DependsOn
-        elb_type: elb_type,
-        subnet_mappings: subnet_mappings,
-        create_route53: create_elb? && has_dns_name?,
-        default_target_group_protocol: default_target_group_protocol,
-        default_listener_protocol: default_listener_protocol,
-        default_listener_ssl_protocol: default_listener_ssl_protocol,
-        create_listener_ssl: create_listener_ssl?,
-      }
-
-      scope.assign_instance_variables(vars)
-      scope
-    end
-    memoize :scope
-
-    def has_dns_name?
-      cfn.dig(:Dns, :Name) || cfn.dig(:dns, :name) # backwards compatiblity
-    end
-
-    def default_target_group_protocol
-      return 'TCP' if elb_type == 'network'
-      'HTTP'
-    end
-
-    def default_listener_protocol
-      port = cfn.dig(:Listener, :Port) || cfn.dig(:listener, :port) # backwards compatiblity
-      if elb_type == 'network'
-        port == 443 ? 'TLS' : 'TCP'
-      else
-        port == 443 ? 'HTTPS' : 'HTTP'
-      end
-    end
-
-    def default_listener_ssl_protocol
-      elb_type == 'network' ? 'TLS' : 'HTTPS'
-    end
-
-    # if the configuration is set to anything then enable it
-    def create_listener_ssl?
-      cfn.dig(:ListenerSsl, :Port) || cfn.dig(:listener_ssl, :port) # backwards compatiblity
-    end
-
-    def create_elb?
-      create_elb, _ = elb_options
-      create_elb == "true" # convert to boolean
-    end
-
-    # If --elb is not set at all and is nil, then it defaults to creating the load balancer if the ecs service has
-    # a container name "web".
-    #
-    # --elb '' - will not crete an elb
-    # --elb 'auto' - creates an elb
-    # --elb arn:... - will not create elb and use the existing target group
-    #
-    def elb_options
-      case @options[:elb]
-      when "auto", "true", "yes"
-        create_elb = "true"
-        elb_target_group = ""
-      when "false", "0", "no"
-        create_elb = "false"
-        elb_target_group = ""
-      when /^arn:aws:elasticloadbalancing.*targetgroup/
-        create_elb = "false"
-        elb_target_group = @options[:elb]
-      when "", nil
-        create_elb, elb_target_group = default_elb_options
-      else
-        puts "Invalid --elb option provided: #{@options[:elb].inspect}".color(:red)
-        puts "Exiting."
-        exit 1
-      end
-      [create_elb, elb_target_group]
-    end
-
-    def default_elb_options
-      # cannot use :use_previous_value because need to know the create_elb value to
-      # compile a template with the right DependsOn for the Ecs service
-      unless @new_stack
-        create_elb = get_parameter_value(@stack, "CreateElb")
-        elb_target_group = get_parameter_value(@stack, "ElbTargetGroup")
-        return [create_elb, elb_target_group]
-      end
-
-      # default is to create the load balancer is if container name is web
-      # and no --elb option is provided
-      create_elb = container[:name] == "web" ? "true" : "false"
-      elb_target_group = ""
-      [create_elb, elb_target_group]
-    end
-
-    def container
-      task_definition = Builder::Resources::TaskDefinition::Reconstructor.new(@task_definition, @options[:rollback]).reconstruct
-
-      container_def = task_definition["ContainerDefinitions"].first
-      requires_compatibilities = task_definition["RequiresCompatibilities"]
-      fargate = requires_compatibilities && requires_compatibilities == ["FARGATE"]
-      network_mode = task_definition["NetworkMode"]
-
-      mappings = container_def["PortMappings"] || []
-      unless mappings.empty?
-        port = mappings.first["ContainerPort"]
-      end
-
-      result =  {
-        name: container_def["Name"],
-        fargate: fargate,
-        network_mode: network_mode, # awsvpc, bridge, etc
-      }
-      result[:port] = port if port
-      result
-    end
-    memoize :container
-
-    def get_parameter_value(stack, key)
-      param = stack.parameters.find do |p|
-        p.parameter_key == key
-      end
-      param.parameter_value if param
-    end
-
-    def scheduling_strategy
-      unless @new_stack
-        scheduling_strategy = get_parameter_value(@stack, "EcsSchedulingStrategy")
-      end
-      scheduling_strategy || 'REPLICA' # defaults to REPLICA
-    end
-
-    def reset_empty_eip_ids?
-      # reset and remove eip allocation ids check
-      @options[:elb_eip_ids] && @options[:elb_eip_ids].detect { |x| [' ', 'empty'].include?(x) }
-    end
-
-    def subnet_mappings
-      return [] if reset_empty_eip_ids?
-
-      elb_eip_ids = normalize_elb_eip_ids
-      return build_subnet_mappings!(elb_eip_ids) unless elb_eip_ids.empty?
-
-      unless @new_stack
-        elb_eip_ids = get_parameter_value(@stack, "ElbEipIds").split(',')
-        build_subnet_mappings(elb_eip_ids)
-      end
-    end
-
-    def normalize_elb_eip_ids
-      elb_eip_ids = @options[:elb_eip_ids] || []
-      elb_eip_ids.uniq!
-      elb_eip_ids
-    end
-
-    # Returns string, used as CloudFormation parameter.
-    def elb_eip_ids
-      return '' if reset_empty_eip_ids?
-
-      elb_eip_ids = normalize_elb_eip_ids
-      return elb_eip_ids.join(',') unless elb_eip_ids.empty?
-
-      unless @new_stack
-        return get_parameter_value(@stack, "ElbEipIds")
-      end
-
-      ''
-    end
-
-    def build_subnet_mappings!(allocations)
-      unless allocations.size == network[:elb_subnets].size
-        puts "ERROR: The allocation_ids must match in length to the subnets.".color(:red)
-        puts "Please double check that .ufo/settings/network/#{settings.network_profile} has the same number of subnets as the eip allocation ids are you specifying."
-        subnets = network[:elb_subnets]
-        puts "Conigured subnets: #{subnets.inspect}"
-        puts "Specified allocation ids: #{allocations.inspect}"
-        exit 1
-      end
-
-      build_subnet_mappings(allocations)
-    end
-
-    def build_subnet_mappings(allocations)
-      mappings = []
-      allocations.sort.each_with_index do |allocation_id, i|
-        mappings << [allocation_id, network[:elb_subnets][i]]
-      end
-      mappings
-    end
-
-    def elb_type
-      # if option explicitly specified then change the elb type
-      return @options[:elb_type] if @options[:elb_type]
-      # user is trying to create a network load balancer if --elb-eip-ids is used
-      elb_eip_ids = normalize_elb_eip_ids
-      if !elb_eip_ids.empty?
-        return "network"
-      end
-
-      # if not explicitly set, new stack will defeault to application load balancer
-      if @new_stack # default for new stack
-        return "application"
-      end
-
-      # find existing load balancer for type
-      resp = cloudformation.describe_stack_resources(stack_name: @stack_name)
-      resources = resp.stack_resources
-      elb_resource = resources.find do |resource|
-        resource.logical_resource_id == "Elb"
-      end
-
-      # In the case when stack exists and there is no elb resource, the elb type
-      # doesnt really matter because the elb wont be created since the CreateElb
-      # parameter is set to false. The elb type only needs to be set for the
-      # template to validate.
-      return "application" unless elb_resource
-
-      resp = elb.describe_load_balancers(load_balancer_arns: [elb_resource.physical_resource_id])
-      load_balancer = resp.load_balancers.first
-      load_balancer.type
-    end
-    memoize :elb_type
-
-  end
-end

data/lib/ufo/stack/helper.rb

@@ -1,48 +0,0 @@
-class Ufo::Stack
-  module Helper
-    include Ufo::AwsService
-    include Ufo::Util
-    include Ufo::Settings
-    extend Memoist
-
-    def find_stack(stack_name)
-      resp = cloudformation.describe_stacks(stack_name: stack_name)
-      resp.stacks.first
-    rescue Aws::CloudFormation::Errors::ValidationError => e
-      # example: Stack with id demo-web does not exist
-      if e.message =~ /Stack with/ && e.message =~ /does not exist/
-        nil
-      else
-        raise
-      end
-    end
-
-    def adjust_stack_name(cluster, service)
-      if settings[:stack_naming].nil?
-        puts "WARN: In ufo v4.5 the UFO_ENV value gets appends to the end of the CloudFormation stack name.  This means a new stack gets created. You must upgrade to using the new stack and delete the old stack manually.  More info: https://ufoships.com/docs/upgrading/upgrade4.5/".color(:yellow)
-        puts "To get rid of this warning you can add `stack_naming: append_ufo_env` to your `.ufo/settings.yml config. New versions of ufo init do this automatically."
-        puts "Pausing for 20 seconds."
-        sleep 20
-      end
-
-      parts = case settings[:stack_naming]
-      when "prepend_cluster" # ufo v4.3 and below
-        [cluster, service, Ufo.env_extra] # legacy
-      when "append_env", "append_cluster" # ufo v4.5
-        # append_env will be removed in the next major version in favor of append_cluster to avoid confusion with
-        # append_ufo_env
-        [service, cluster, Ufo.env_extra]
-      when "append_nothing", "prepend_nothing"
-        [service, Ufo.env_extra]
-      else # new default. ufo v4.5 and above
-        [service, Ufo.env.to_s, Ufo.env_extra]
-      end
-      parts.reject {|x| x==''}.compact.join('-') # stack_name
-    end
-
-    def status
-      Status.new(@stack_name)
-    end
-    memoize :status
-  end
-end

data/lib/ufo/stack/template_body.rb

@@ -1,13 +0,0 @@
-class Ufo::Stack
-  class TemplateBody
-    def initialize(context)
-      @context = context
-    end
-
-    def build
-      builder = Builder.new(@context)
-      builder.build
-    end
-  end
-end
-

data/lib/ufo/stack.rb

@@ -1,213 +0,0 @@
-# CloudFormation status codes, full list:
-#   https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
-#
-#   CREATE_COMPLETE
-#   ROLLBACK_COMPLETE
-#   DELETE_COMPLETE
-#   UPDATE_COMPLETE
-#   UPDATE_ROLLBACK_COMPLETE
-#
-#   CREATE_FAILED
-#   DELETE_FAILED
-#   ROLLBACK_FAILED
-#   UPDATE_ROLLBACK_FAILED
-#
-#   CREATE_IN_PROGRESS
-#   DELETE_IN_PROGRESS
-#   REVIEW_IN_PROGRESS
-#   ROLLBACK_IN_PROGRESS
-#   UPDATE_COMPLETE_CLEANUP_IN_PROGRESS
-#   UPDATE_IN_PROGRESS
-#   UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS
-#   UPDATE_ROLLBACK_IN_PROGRESS
-#
-module Ufo
-  class Stack
-    extend Memoist
-    include Helper
-    include Ufo::Settings
-
-    def initialize(options)
-      @options = options
-      @task_definition = options[:task_definition]
-      @rollback = options[:rollback]
-      @service = options[:service]
-      @cluster = @options[:cluster] || default_cluster(@service)
-      @stack_name = adjust_stack_name(@cluster, options[:service])
-    end
-
-    def deploy
-      @stack = find_stack(@stack_name)
-      if @stack && rollback_complete?(@stack)
-        puts "Existing stack in ROLLBACK_COMPLETE state. Deleting stack before continuing."
-        cloudformation.delete_stack(stack_name: @stack_name)
-        status.wait
-        status.reset
-        @stack = nil # at this point stack has been deleted
-      end
-
-      exit_with_message(@stack) if @stack && !updatable?(@stack)
-
-      @stack ? perform(:update) : perform(:create)
-
-      stop_old_tasks if @options[:stop_old_task]
-
-      return unless @options[:wait]
-      status.wait
-
-      puts status.rollback_error_message if status.update_rollback?
-
-      status.success?
-    end
-
-    def perform(action)
-      puts "#{action[0..-2].capitalize}ing stack #{@stack_name.color(:green)}..."
-      # Example: cloudformation.send("update_stack", stack_options)
-      cloudformation.send("#{action}_stack", stack_options)
-    rescue Aws::CloudFormation::Errors::ValidationError => e
-      handle_stack_error(e)
-    end
-
-    def stack_options
-      save_template
-      if ENV['SAVE_TEMPLATE_EXIT']
-        puts "Template saved. Exiting."
-        exit 1
-      end
-      {
-        capabilities: ["CAPABILITY_IAM"],
-        notification_arns: notification_arns,
-        parameters: parameters,
-        stack_name: @stack_name,
-        template_body: template_body,
-      }
-    end
-
-    def notification_arns
-      settings[:notification_arns] || []
-    end
-
-    def parameters
-      create_elb, elb_target_group = context.elb_options
-
-      elb_subnets = network[:elb_subnets] && !network[:elb_subnets].empty? ?
-                    network[:elb_subnets] :
-                    network[:ecs_subnets]
-
-      params = {
-        Vpc: network[:vpc],
-        ElbSubnets: elb_subnets.join(','),
-        EcsSubnets: network[:ecs_subnets].join(','),
-
-        CreateElb: create_elb,
-        ElbTargetGroup: elb_target_group,
-        ElbEipIds: context.elb_eip_ids,
-
-        EcsDesiredCount: current_desired_count,
-        EcsSchedulingStrategy: scheduling_strategy,
-      }
-
-      params = Ufo::Utils::Squeezer.new(params).squeeze
-      params.map do |k,v|
-        if v == :use_previous_value
-          { parameter_key: k, use_previous_value: true }
-        else
-          { parameter_key: k, parameter_value: v }
-        end
-      end
-    end
-    memoize :parameters
-
-    # do not memoize template_body it can change for a rename retry
-    def template_body
-      TemplateBody.new(context).build
-    end
-    memoize :template_body
-
-    def context
-      o = @options.merge(
-        cluster: @cluster,
-        stack_name: @stack_name,
-        stack: @stack,
-      )
-      o[:rollback_definition_arn] = rollback_definition_arn if rollback_definition_arn
-      Context.new(o)
-    end
-    memoize :context
-
-    def scheduling_strategy
-      strategy = @options[:scheduling_strategy] || context.scheduling_strategy
-      strategy.upcase
-    end
-
-    def current_desired_count
-      # Cannot set ECS desired count when is scheduling_strategy DAEMON
-      return '' if scheduling_strategy == "DAEMON"
-
-      info = Info.new(@service, @options)
-      service = info.service
-      if service
-        service.desired_count.to_s
-      else
-        "1" # new service default
-      end
-    end
-
-    def rollback_definition_arn
-      return unless @rollback
-      resp = ecs.describe_task_definition(task_definition: @task_definition)
-      resp.task_definition.task_definition_arn
-    end
-    memoize :rollback_definition_arn
-
-    # Store template in tmp in case for debugging
-    def save_template
-      path = "/tmp/ufo/#{@stack_name}/stack.yml"
-      FileUtils.mkdir_p(File.dirname(path))
-      IO.write(path, template_body)
-      puts "Generated template saved at: #{path}"
-
-      path = "/tmp/ufo/#{@stack_name}/parameters.yml"
-      IO.write(path, JSON.pretty_generate(parameters))
-      puts "Generated parameters saved at: #{path}"
-    end
-
-    def exit_with_message(stack)
-      region = `aws configure get region`.strip rescue "us-east-1"
-      url = "https://console.aws.amazon.com/cloudformation/home?region=#{region}#/stacks"
-      puts "The stack is not in an updateable state: #{stack.stack_status.color(:yellow)}."
-      puts "Here's the CloudFormation url to check for more details #{url}"
-      exit 1
-    end
-
-    # Assume only first container_definition to get the container info.
-    # Stack:arn:aws:cloudformation:... is in ROLLBACK_COMPLETE state and can not be updated.
-    def handle_stack_error(e)
-      case e.message
-      when /state and can not be updated/
-        puts "The #{@stack_name} stack is in a state that cannot be updated. Deleted the stack and try again."
-        puts "ERROR: #{e.message}"
-        if message.include?('UPDATE_ROLLBACK_FAILED')
-          puts "You might be able to do a 'Continue Update Rollback' and skip some resources to get the stack back into a good state."
-        end
-        region = `aws configure get region`.strip rescue 'us-east-1'
-        url = "https://console.aws.amazon.com/cloudformation/home?region=#{region}"
-        puts "Here's the CloudFormation console url: #{url}"
-        exit 1
-      when /No updates are to be performed/
-        puts "There are no updates to be performed. Exiting.".color(:yellow)
-        exit 1
-      else
-        raise
-      end
-    end
-
-    def rollback_complete?(stack)
-      stack.stack_status == 'ROLLBACK_COMPLETE'
-    end
-
-    def updatable?(stack)
-      stack.stack_status =~ /_COMPLETE$/ || stack.stack_status == 'UPDATE_ROLLBACK_FAILED'
-    end
-  end
-end

data/lib/ufo/status.rb

@@ -1,56 +0,0 @@
-module Ufo
-  class Status < Base
-    # used for the ufo status command
-    def run
-      unless stack_exists?(@stack_name)
-        puts "The stack #{@stack_name.color(:green)} does not exist."
-        return
-      end
-
-      resp = cloudformation.describe_stacks(stack_name: @stack_name)
-      stack = resp.stacks.first
-
-      puts "The current status for the stack #{@stack_name.color(:green)} is #{stack.stack_status.color(:green)}"
-
-      status_poller = Stack::Status.new(@stack_name)
-
-      if stack.stack_status =~ /_IN_PROGRESS$/
-        puts "Stack events (tailing):"
-        # tail all events until done
-        status_poller.hide_time_took = true
-        status_poller.wait
-      else
-        puts "Stack events:"
-        # show the last events that was user initiated
-        status_poller.refresh_events
-        status_poller.show_events(true)
-      end
-    end
-
-    def stack_exists?(stack_name)
-      return true if ENV['TEST']
-      return false if @options[:noop]
-
-      exist = nil
-      begin
-        # When the stack does not exist an exception is raised. Example:
-        # Aws::CloudFormation::Errors::ValidationError: Stack with id blah does not exist
-        resp = cloudformation.describe_stacks(stack_name: stack_name)
-        exist = true
-      rescue Aws::CloudFormation::Errors::ValidationError => e
-        if e.message =~ /does not exist/
-          exist = false
-        elsif e.message.include?("'stackName' failed to satisfy constraint")
-          # Example of e.message when describe_stack with invalid stack name
-          # "1 validation error detected: Value 'instance_and_route53' at 'stackName' failed to satisfy constraint: Member must satisfy regular expression pattern: [a-zA-Z][-a-zA-Z0-9]*|arn:[-a-zA-Z0-9:/._+]*"
-          puts "Invalid stack name: #{stack_name}"
-          puts "Full error message: #{e.message}"
-          exit 1
-        else
-          raise # re-raise exception  because unsure what other errors can happen
-        end
-      end
-      exist
-    end
-  end
-end

data/lib/ufo/stop.rb

@@ -1,49 +0,0 @@
-module Ufo
-  class Stop < Base
-    def run
-      info = Info.new(@service, @options)
-      service = info.service
-      return unless service # brand new deploy
-
-      @deployments = service.deployments
-      if @deployments.size > 1
-        stop_old_tasks(service.service_name)
-      end
-    end
-
-    def stop_old_tasks(service_name)
-      # json = JSON.pretty_generate(deployments.map(&:to_h))
-      # IO.write("/tmp/deployments.json", json)
-      tasks = service_tasks(@cluster, service_name)
-      reason = "Ufo #{Ufo::VERSION} has deployed new code and stopping old tasks."
-      tasks.each do |task|
-        next if task["task_definition_arn"] == latest_deployed_arn
-        log "Stopping task #{task["task_arn"]}"
-        ecs.stop_task(cluster: @cluster, task: task["task_arn"], reason: reason)
-      end
-    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(cluster, 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
-
-    def log(text)
-      path = "#{Ufo.root}/.ufo/log/stop.log"
-      FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, 'a') do |f|
-        f.puts("#{Time.now} #{text}")
-      end
-      puts text unless @options[:mute]
-    end
-  end
-end