ufo 5.0.5 → 6.0.0

data/lib/ufo/cfn/base.rb

@@ -0,0 +1,7 @@
+module Ufo::Cfn
+  class Base < Ufo::CLI::Base
+    extend Memoist
+    include Ufo::AwsServices
+    include Ufo::Concerns # info
+  end
+end

data/lib/ufo/cfn/deploy.rb

@@ -0,0 +1,54 @@
+module Ufo::Cfn
+  class Deploy < Base
+    def run
+      ensure_log_group_exist
+      ensure_cluster_exist
+      stop_old_tasks
+      stack = Stack.new(@options)
+      success = stack.deploy
+
+      return unless @options[:wait]
+      if success
+        puts "Software shipped!"
+      else
+        puts "Software fail to ship."
+        exit 1
+      end
+    end
+
+    def ensure_cluster_exist
+      return unless Ufo.config.ecs.create_cluster
+
+      cluster = ecs_clusters.first
+      exist = cluster && cluster.status == "ACTIVE"
+      return if exist
+
+      ecs.create_cluster(cluster_name: @cluster)
+      logger.info "#{@cluster} cluster created."
+    end
+
+    def ecs_clusters
+      ecs.describe_clusters(clusters: [@cluster]).clusters
+    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
+      return unless @options[:stop_old_tasks]
+      return unless @options[:wait] # only works when deployment is blocking
+
+      Thread.new do
+        stop = Ufo::Stop.new(@options.merge(mute: true))
+        while true
+          stop.log "checking for old tasks and waiting for 10 seconds"
+          stop.run
+          sleep 10
+        end
+      end
+    end
+
+    def ensure_log_group_exist
+      Ufo::LogGroup.new(@options).create
+    end
+  end
+end

data/lib/ufo/{stack → cfn/stack}/builder/base.rb

@@ -1,23 +1,9 @@
-class Ufo::Stack::Builder
-  class Base
-    include Ufo::Settings
-
-    def initialize
-      copy_instance_variables
-    end
-
-    # Copy the instance variables from TemplateScope Stack Builder classes
-    def copy_instance_variables
-      context = Ufo::Stack::Builder.context
-      scope = context.scope
-      scope.instance_variables.each do |var|
-        val = scope.instance_variable_get(var)
-        instance_variable_set(var, val)
-      end
-    end
-
-    def self.build
-      new.build
+class Ufo::Cfn::Stack::Builder
+  class Base < Ufo::Cfn::Base
+    attr_reader :vars
+    def initialize(options={})
+      super
+      @vars = options[:vars]
     end
 
     # type: elb or ecs
@@ -30,8 +16,7 @@ class Ufo::Stack::Builder
     # So we will not assign security groups at all for case of workers with no security groups at all.
     #
     def security_groups(type)
-      settings_key = "#{type}_security_groups".to_sym
-      group_ids = Ufo::Setting::SecurityGroups.new(@service, settings_key).load
+      group_ids = Ufo.config.vpc.security_groups[type] || []
       # no security groups at all
       return if !managed_security_groups? && group_ids.blank?
 
@@ -47,8 +32,12 @@ class Ufo::Stack::Builder
     end
 
     def managed_security_groups?
-      managed = settings[:managed_security_groups]
+      managed = Ufo.config.vpc.security_groups.managed
       managed.nil? ? true : managed
     end
+
+    def self.build(options={})
+      new(options).build
+    end
   end
 end

data/lib/ufo/cfn/stack/builder/conditions.rb

@@ -0,0 +1,25 @@
+class Ufo::Cfn::Stack::Builder
+  class Conditions < Base
+    def build
+      text =<<~EOL
+        CreateElbIsTrue:
+          Fn::Equals:
+          - Ref: CreateElb
+          - true
+        ElbTargetGroupIsBlank:
+          Fn::Equals:
+          - Ref: ElbTargetGroup
+          - ''
+        CreateTargetGroupIsTrue:
+          Fn::And:
+          - Condition: CreateElbIsTrue
+          - Condition: ElbTargetGroupIsBlank
+        EcsDesiredCountIsBlank:
+          Fn::Equals:
+          - Ref: EcsDesiredCount
+          - ''
+      EOL
+      Ufo::Yaml.load(text)
+    end
+  end
+end

data/lib/ufo/{stack → cfn/stack}/builder/outputs.rb

@@ -1,4 +1,4 @@
-class Ufo::Stack::Builder
+class Ufo::Cfn::Stack::Builder
   class Outputs < Base
     def build
       outputs = {
@@ -11,7 +11,7 @@ class Ufo::Stack::Builder
         }
       }
 
-      if @create_route53
+      if vars[:create_route53]
         outputs[:Route53Dns] = {
           Description: "Route53 Dns",
           Value: {Ref: "Dns"},

data/lib/ufo/cfn/stack/builder/parameters.rb

@@ -0,0 +1,34 @@
+class Ufo::Cfn::Stack::Builder
+  class Parameters < Base
+    def build
+      yaml =<<~EOL
+        Vpc:
+          Description: Existing vpc id
+          Type: AWS::EC2::VPC::Id
+        ElbSubnets:
+          Description: Existing subnet ids for ELB
+          Type: List<AWS::EC2::Subnet::Id>
+        EcsSubnets:
+          Description: Existing subnet ids for ECS
+          Type: List<AWS::EC2::Subnet::Id>
+        ElbTargetGroup:
+          Description: Existing target group
+          Type: String
+          Default: ''
+        CreateElb:
+          Description: Create elb
+          Type: String
+          Default: true
+        EcsDesiredCount:
+          Description: Ecs desired count
+          Type: String
+          Default: ''
+        EcsSchedulingStrategy:
+          Description: The scheduling strategy to use for the service
+          Type: String
+          Default: REPLICA
+      EOL
+      YAML.load(yaml).deep_symbolize_keys
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/base.rb

@@ -0,0 +1,4 @@
+class Ufo::Cfn::Stack::Builder::Resources
+  class Base < Ufo::Cfn::Stack::Builder::Base
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/dns.rb

@@ -0,0 +1,47 @@
+class Ufo::Cfn::Stack::Builder::Resources
+  class Dns < Base
+    def build
+      return unless vars[:create_route53]
+
+      props = {
+        Name: dns_name, # {stack_name}.yourdomain. dont forget the trailing period
+        Comment: dns.comment,
+        Type: dns.type, # CNAME
+        TTL: dns.ttl, # 60 ttl has special casing
+        ResourceRecords: [{"Fn::GetAtt": "Elb.DNSName"}]
+      }
+      # HostedZoneName: yourdomain. # dont forget the trailing period
+      props[:HostedZoneName] = hosted_zone_name if hosted_zone_name
+      props[:HostedZoneId] = dns.hosted_zone_id if dns.hosted_zone_id
+
+      {
+        Type: "AWS::Route53::RecordSet",
+        Properties: props
+      }
+    end
+
+  private
+    def dns_name
+      return unless dns.domain || dns.name
+      name = dns.name # my.domain.com
+      name ||= "#{@stack_name}.#{dns.domain}" # demo-web-dev.domain.com
+      ensure_trailing_dot(name)
+    end
+
+    def hosted_zone_name
+      return if dns.hosted_zone_id # hosted_zone_id takes precedence over hosted_zone_name
+      return unless dns.domain || dns.host_zone_name
+      name = dns.hosted_zone_name
+      name ||= dns.domain
+      ensure_trailing_dot(name)
+    end
+
+    def ensure_trailing_dot(s)
+      s.ends_with?('.') ? s : "#{s}."
+    end
+
+    def dns
+      Ufo.config.dns
+    end
+  end
+end

data/lib/ufo/{stack/builder/resources/ecs.rb → cfn/stack/builder/resources/ecs_service.rb}

@@ -1,12 +1,12 @@
-class Ufo::Stack::Builder::Resources
-  class Ecs < Base
+class Ufo::Cfn::Stack::Builder::Resources
+  class EcsService < Base
     def build
       attrs = {
         Type: "AWS::ECS::Service",
         Properties: properties
       }
 
-      attrs[:DependsOn] = "Listener" if @create_elb
+      attrs[:DependsOn] = "Listener" if vars[:create_elb]
 
       attrs
     end
@@ -21,13 +21,14 @@ class Ufo::Stack::Builder::Resources
             {Ref: "EcsDesiredCount"}
           ]
         },
+        EnableExecuteCommand: Ufo.config.exec.enabled,
         LoadBalancers: {
           "Fn::If": [
             "CreateTargetGroupIsTrue",
             [
               {
-                ContainerName: @container[:name],
-                ContainerPort: @container[:port],
+                ContainerName: vars[:container][:name],
+                ContainerPort: vars[:container][:port],
                 TargetGroupArn: {Ref: "TargetGroup"}
               }
             ],
@@ -37,8 +38,8 @@ class Ufo::Stack::Builder::Resources
                 [],
                 [
                   {
-                    ContainerName: @container[:name],
-                    ContainerPort: @container[:port],
+                    ContainerName: vars[:container][:name],
+                    ContainerPort: vars[:container][:port],
                     TargetGroupArn: {Ref: "ElbTargetGroup"}
                   }
                 ]
@@ -49,9 +50,9 @@ class Ufo::Stack::Builder::Resources
         SchedulingStrategy: {Ref: "EcsSchedulingStrategy"}
       }
 
-      props[:TaskDefinition] = @rollback_definition_arn ? @rollback_definition_arn : {Ref: "TaskDefinition"}
+      props[:TaskDefinition] = vars[:rollback_task_definition] ? vars[:rollback_task_definition] : {Ref: "TaskDefinition"}
 
-      if @container[:network_mode].to_s == 'awsvpc'
+      if vars[:container][:network_mode].to_s == 'awsvpc'
         props[:NetworkConfiguration] = {
           AwsvpcConfiguration: {
             Subnets: {Ref: "EcsSubnets"},
@@ -59,7 +60,7 @@ class Ufo::Stack::Builder::Resources
           }
         }
 
-        if @container[:fargate]
+        if vars[:container][:fargate]
           props[:LaunchType] = "FARGATE"
           props[:NetworkConfiguration][:AwsvpcConfiguration][:AssignPublicIp] = "ENABLED" # Works with fargate but doesnt seem to work with non-fargate
         end

data/lib/ufo/cfn/stack/builder/resources/elb.rb

@@ -0,0 +1,35 @@
+class Ufo::Cfn::Stack::Builder::Resources
+  class Elb < Base
+    def build
+      {
+        Type: "AWS::ElasticLoadBalancingV2::LoadBalancer",
+        Condition: "CreateElbIsTrue",
+        Properties: properties,
+      }
+    end
+
+    def properties
+      props = {
+        Type: vars[:elb_type],
+        Tags: [
+          {Key: "Name", Value: @stack_name}
+        ],
+        Scheme: "internet-facing"
+      }
+
+      props[:SecurityGroups] = security_groups(:elb) if vars[:elb_type] == "application"
+      subnets(props)
+
+      props
+    end
+
+    def subnets(props)
+      mappings = Ufo.config.elb.subnet_mappings
+      if mappings && vars[:elb_type] == "network"
+        props[:SubnetMappings] = mappings
+      else
+        props[:Subnets] = {Ref: "ElbSubnets"}
+      end
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/iam_roles/base.rb

@@ -0,0 +1,32 @@
+module Ufo::Cfn::Stack::Builder::Resources::IamRoles
+  class Base < Ufo::Cfn::Stack::Builder::Base
+    def build
+      return unless self.class.build? # important because it runs DSL#evaluate
+      Ufo::IamRole::Builder.new(self.class.role_type).build
+    end
+
+    class << self
+      def role_type
+        self.name.to_s.split("::").last.underscore
+      end
+
+      def build?
+        path = lookup_path
+        return unless path.nil? || File.exist?(path)
+        Ufo::IamRole::DSL.new(path).evaluate # runs the role.rb and registers items
+        Ufo::IamRole::Builder.new(role_type).build?
+      end
+
+      def lookup_path
+        iam_roles = "#{Ufo.root}/.ufo/resources/iam_roles"
+        paths = ["#{Ufo.app}/#{role_type}", "#{role_type}"]
+        paths.map! do |path|
+          "#{iam_roles}/#{path}.rb"
+        end
+        paths.find do |path|
+          File.exist?(path)
+        end
+      end
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/iam_roles/execution_role.rb

@@ -0,0 +1,4 @@
+module Ufo::Cfn::Stack::Builder::Resources::IamRoles
+  class ExecutionRole < Base
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/iam_roles/task_role.rb

@@ -0,0 +1,4 @@
+module Ufo::Cfn::Stack::Builder::Resources::IamRoles
+  class TaskRole < Base
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/listener.rb

@@ -0,0 +1,65 @@
+class Ufo::Cfn::Stack::Builder::Resources
+  class Listener < Base
+    def build
+      {
+        Type: "AWS::ElasticLoadBalancingV2::Listener",
+        Condition: "CreateElbIsTrue",
+        Properties: properties,
+      }
+    end
+
+    def properties
+      {
+        DefaultActions: default_actions,
+        LoadBalancerArn: {Ref: "Elb"},
+        Port: port,
+        Protocol: protocol,
+      }
+    end
+
+    def protocol
+      vars[:default_listener_protocol]
+    end
+
+    def port
+      80
+    end
+
+    def default_actions
+      elb = Ufo.config.elb
+      default_actions = elb.default_actions # allow use to override for full control like redirection support
+      return default_actions if default_actions
+
+      redirect = elb.redirect
+      if redirect.enabled
+        [redirect_action(redirect)]
+      else
+        [default_action]
+      end
+    end
+
+    def redirect_action(redirect)
+      {
+        Type: "redirect",
+        RedirectConfig: {
+          Protocol: redirect.protocol,
+          StatusCode: "HTTP_#{redirect.code}", # HTTP_301 and HTTP_302 are valid
+          Port: redirect.port,
+        }
+      }
+    end
+
+    def default_action
+      {
+        Type: "forward",
+        TargetGroupArn: {
+          "Fn::If": [
+            "ElbTargetGroupIsBlank",
+            {Ref: "TargetGroup"},
+            {Ref: "ElbTargetGroup"}
+          ]
+        }
+      }
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/listener_ssl.rb

@@ -0,0 +1,44 @@
+class Ufo::Cfn::Stack::Builder::Resources
+  class ListenerSsl < Listener
+    def build
+      return unless vars[:create_listener_ssl]
+      super
+    end
+
+    def properties
+      props = super
+      props[:Certificates] = certificates
+      props
+    end
+
+    def protocol
+      vars[:default_listener_ssl_protocol]
+    end
+
+    def port
+      Ufo.config.elb.ssl.port
+    end
+
+    # Do not use redirect settings. Only use by normal http listener
+    def default_actions
+      [default_action]
+    end
+
+    # nil on purpose
+    def certificates
+      ssl = Ufo.config.elb.ssl
+      normalize(ssl.certificates)
+    end
+
+    def normalize(*certs)
+      certs = certs.flatten
+      certs.map do |cert|
+        if cert.is_a?(String)
+          {CertificateArn: cert}
+        else # Assume correct Hash structure
+          cert
+        end
+      end
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/scaling/base.rb

@@ -0,0 +1,5 @@
+module Ufo::Cfn::Stack::Builder::Resources::Scaling
+  class Base < Ufo::Cfn::Stack::Builder::Base
+    include Ufo::Concerns::Autoscaling
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/scaling/policy.rb

@@ -0,0 +1,27 @@
+module Ufo::Cfn::Stack::Builder::Resources::Scaling
+  class Policy < Base
+    def build
+      return unless autoscaling_enabled?
+
+      text =<<~EOL
+        Type: AWS::ApplicationAutoScaling::ScalingPolicy
+        Properties:
+          PolicyName: !Sub "${AWS::StackName}-auto-scaling-policy"
+          PolicyType: TargetTrackingScaling
+          ScalingTargetId: !Ref ScalingTarget
+          TargetTrackingScalingPolicyConfiguration:
+            PredefinedMetricSpecification:
+              PredefinedMetricType: #{autoscaling.predefined_metric_type}
+            TargetValue: #{autoscaling.target_value}
+      EOL
+
+      attrs = Ufo::Yaml.load(text).deep_symbolize_keys
+      props = attrs[:Properties]
+      conf = props[:TargetTrackingScalingPolicyConfiguration]
+      conf[:ScaleInCooldown] = autoscaling.scale_in_cooldown if autoscaling.scale_in_cooldown
+      conf[:ScaleOutCooldown] = autoscaling.scale_out_cooldown if autoscaling.scale_out_cooldown
+
+      attrs
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/scaling/role.rb

@@ -0,0 +1,33 @@
+module Ufo::Cfn::Stack::Builder::Resources::Scaling
+  class Role < Base
+    def build
+      return unless autoscaling_enabled?
+
+      text =<<~EOL
+        Type: AWS::IAM::Role
+        Properties:
+          AssumeRolePolicyDocument:
+            Statement:
+              - Effect: Allow
+                Principal:
+                  Service: [application-autoscaling.amazonaws.com]
+                Action: ["sts:AssumeRole"]
+          Policies:
+            - PolicyName: !Sub "${AWS::StackName}-auto-scaling-policy"
+              PolicyDocument:
+                Version: "2012-10-17"
+                Statement:
+                  - Effect: Allow
+                    Action:
+                      - ecs:DescribeServices
+                      - ecs:UpdateService
+                      - cloudwatch:PutMetricAlarm
+                      - cloudwatch:DescribeAlarms
+                      - cloudwatch:DeleteAlarms
+                    Resource:
+                      - "*"
+      EOL
+      Ufo::Yaml.load(text).deep_symbolize_keys
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/scaling/target.rb

@@ -0,0 +1,22 @@
+module Ufo::Cfn::Stack::Builder::Resources::Scaling
+  class Target < Base
+    def build
+      return unless autoscaling_enabled?
+
+      text =<<~EOL
+        Type: AWS::ApplicationAutoScaling::ScalableTarget
+        DependsOn: EcsService
+        Properties:
+          RoleARN: !GetAtt ScalingRole.Arn
+          ResourceId: !Join
+            - "/"
+            - [service, #{@cluster}, !GetAtt [EcsService, Name]]
+          ServiceNamespace: ecs
+          ScalableDimension: ecs:service:DesiredCount
+          MinCapacity: #{autoscaling.min_capacity}
+          MaxCapacity: #{autoscaling.max_capacity}
+      EOL
+      Ufo::Yaml.load(text).deep_symbolize_keys
+    end
+  end
+end

data/lib/ufo/cfn/stack/builder/resources/security_group/base.rb

@@ -0,0 +1,4 @@
+module Ufo::Cfn::Stack::Builder::Resources::SecurityGroup
+  class Base < Ufo::Cfn::Stack::Builder::Base
+  end
+end

data/lib/ufo/{stack → cfn/stack}/builder/resources/security_group/ecs.rb

@@ -1,4 +1,4 @@
-module Ufo::Stack::Builder::Resources::SecurityGroup
+module Ufo::Cfn::Stack::Builder::Resources::SecurityGroup
   class Ecs < Base
     def build
       return unless managed_security_groups?
@@ -28,11 +28,11 @@ module Ufo::Stack::Builder::Resources::SecurityGroup
         ]
       }
 
-      if @elb_type == "network"
+      if vars[:elb_type] == "network"
         props[:SecurityGroupIngress] = {
           IpProtocol: "tcp",
-          FromPort: @container[:port],
-          ToPort: @container[:port],
+          FromPort: vars[:container][:port],
+          ToPort: vars[:container][:port],
           CidrIp: "0.0.0.0/0",
           Description: "docker ephemeral port range for network elb",
         }

data/lib/ufo/{stack → cfn/stack}/builder/resources/security_group/ecs_rule.rb

@@ -1,8 +1,8 @@
-module Ufo::Stack::Builder::Resources::SecurityGroup
+module Ufo::Cfn::Stack::Builder::Resources::SecurityGroup
   class EcsRule < Base
     def build
       return unless managed_security_groups?
-      return unless @elb_type == "application"
+      return unless vars[:elb_type] == "application"
 
       {
         Type: "AWS::EC2::SecurityGroupIngress",

data/lib/ufo/{stack → cfn/stack}/builder/resources/security_group/elb.rb

@@ -1,8 +1,8 @@
-module Ufo::Stack::Builder::Resources::SecurityGroup
+module Ufo::Cfn::Stack::Builder::Resources::SecurityGroup
   class Elb < Base
     def build
       return unless managed_security_groups?
-      return unless @elb_type == "application"
+      return unless vars[:elb_type] == "application"
 
       {
         Type: "AWS::EC2::SecurityGroup",
@@ -12,8 +12,7 @@ module Ufo::Stack::Builder::Resources::SecurityGroup
     end
 
     def properties
-      port = cfn.dig(:Listener, :Port) || cfn.dig(:listener, :port) # backwards compatiblity
-
+      port = Ufo.config.elb.port # 80
       props = {
         GroupDescription: "Allow http to client host",
         VpcId: {Ref: "Vpc"},
@@ -41,8 +40,8 @@ module Ufo::Stack::Builder::Resources::SecurityGroup
         ]
       }
 
-      if @create_listener_ssl
-        ssl_port = cfn.dig(:ListenerSsl, :Port) || cfn.dig(:listener_ssl, :port) # backwards compatiblity
+      if vars[:create_listener_ssl]
+        ssl_port = Ufo.config.elb.ssl.port
         props[:SecurityGroupIngress] << {
           IpProtocol: "tcp",
           FromPort: ssl_port,