ufo 5.0.7 → 6.0.0

data/lib/ufo/setting.rb

@@ -1,75 +0,0 @@
-require 'yaml'
-
-module Ufo
-  class Setting
-    extend Memoist
-    def initialize(check_ufo_project=true)
-      @check_ufo_project = check_ufo_project
-    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
-      if @check_ufo_project && !File.exist?(project_settings_path)
-        Ufo.check_ufo_project!
-      end
-
-      # project based settings files
-      project = load_file(project_settings_path)
-
-      user_file = "#{ENV['HOME']}/.ufo/settings.yml"
-      user = File.exist?(user_file) ? YAML.load_file(user_file) : {}
-
-      default_file = File.expand_path("../default/settings.yml", __FILE__)
-      default = load_file(default_file)
-
-      all_envs = default.deep_merge(user.deep_merge(project))
-      all_envs = merge_base(all_envs)
-      data = all_envs[ufo_env] || all_envs["base"] || {}
-      data.deep_symbolize_keys
-    end
-    memoize :data
-
-    # Resovles infinite problem since Ufo.env can be determined from UFO_ENV or settings.yml files.
-    # When ufo is determined from settings it should not called Ufo.env since that in turn calls
-    # Settings.new.data which can then cause an infinite loop.
-    def ufo_env
-      settings = YAML.load_file("#{Ufo.root}/.ufo/settings.yml")
-      env = settings.find do |_env, section|
-        section ||= {}
-        ENV['AWS_PROFILE'] && ENV['AWS_PROFILE'] == section['aws_profile']
-      end
-
-      ufo_env = env.first if env
-      ufo_env = ENV['UFO_ENV'] if ENV['UFO_ENV'] # highest precedence
-      ufo_env || 'development'
-    end
-
-  private
-    def load_file(path)
-      return Hash.new({}) unless File.exist?(path)
-
-      content = RenderMePretty.result(path)
-      data = YAML.load(content)
-      # If key is is accidentally set to nil it screws up the merge_base later.
-      # So ensure that all keys with nil value are set to {}
-      data.each do |env, _setting|
-        data[env] ||= {}
-      end
-      data
-    end
-
-    # automatically add base settings to the rest of the environments
-    def merge_base(all_envs)
-      base = all_envs["base"] || {}
-      all_envs.each do |env, settings|
-        all_envs[env] = base.merge(settings) unless env == "base"
-      end
-      all_envs
-    end
-
-    def project_settings_path
-      "#{Ufo.root}/.ufo/settings.yml"
-    end
-  end
-end

data/lib/ufo/settings.rb

@@ -1,20 +0,0 @@
-module Ufo
-  module Settings
-    extend Memoist
-
-    def network
-      Ufo::Setting::Profile.new(:network, settings[:network_profile]).data
-    end
-    memoize :network
-
-    def cfn
-      Ufo::Setting::Profile.new(:cfn, settings[:cfn_profile]).data
-    end
-    memoize :cfn
-
-    def settings
-      Setting.new.data
-    end
-    memoize :settings
-  end
-end

data/lib/ufo/ship.rb

@@ -1,103 +0,0 @@
-module Ufo
-  class UfoError < RuntimeError; end
-  class ShipmentOverridden < UfoError; end
-
-  class Ship < Base
-    def initialize(service, options={})
-      super
-      @task_definition = options[:task_definition]
-    end
-
-    def deploy
-      message = "Deploying service #{@service.color(:green)} to cluster #{@cluster.color(:green)}..."
-      unless @options[:mute]
-        if @options[:noop]
-          puts "NOOP: #{message}"
-          return
-        else
-          puts message
-        end
-      end
-
-      ensure_log_group_exist
-      ensure_cluster_exist
-      stop_old_tasks if @options[:stop_old_tasks]
-      success = deploy_stack
-
-      return if @options[:mute] || !@options[:wait]
-      if success
-        puts "Software shipped!"
-      else
-        puts "Software fail to ship."
-        exit 1
-      end
-    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]
-
-      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
-      end
-    end
-
-    def ensure_log_group_exist
-      LogGroup.new(@task_definition, @options).create
-    end
-
-    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)
-      puts "Equivalent aws cli command:"
-      # Use .ufo/data instead of .ufo/output because output files all get looped
-      # through as part of `ufo tasks register`
-      rel_path = ".ufo/data/#{action}-params.json"
-      output_path = "#{Ufo.root}/#{rel_path}"
-      FileUtils.rm_f(output_path)
-
-      # Thanks: https://www.mnishiguchi.com/2017/11/29/rails-hash-camelize-and-underscore-keys/
-      params = params.deep_transform_keys { |key| key.to_s.camelize(:lower) }
-      json = JSON.pretty_generate(params)
-      IO.write(output_path, json)
-
-      file_path = "file://#{rel_path}"
-      puts "  aws ecs #{action}-service --cli-input-json #{file_path}".color(:green)
-    end
-
-    def ensure_cluster_exist
-      cluster = ecs_clusters.first
-      unless cluster && cluster.status == "ACTIVE"
-        message = "#{@cluster} cluster created."
-        if @options[:noop]
-          message = "NOOP #{message}"
-        else
-          ecs.create_cluster(cluster_name: @cluster)
-          # TODO: Add Waiter logic, sometimes the cluster does not exist by the time
-          # we create the service
-        end
-
-        puts message unless @options[:mute]
-      end
-    end
-
-    def ecs_clusters
-      ecs.describe_clusters(clusters: [@cluster]).clusters
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-class Ufo::Stack::Builder
-  class Conditions < Base
-    def build
-      {
-        CreateElbIsTrue: {
-          "Fn::Equals": [{Ref: "CreateElb"}, true]
-        },
-        ElbTargetGroupIsBlank: {
-          "Fn::Equals": [{Ref: "ElbTargetGroup"}, ""]
-        },
-        CreateTargetGroupIsTrue: {
-          "Fn::And": [
-            {Condition: "CreateElbIsTrue"},
-            {Condition: "ElbTargetGroupIsBlank"},
-          ]
-        },
-        EcsDesiredCountIsBlank: {
-          "Fn::Equals": [{Ref: "EcsDesiredCount"}, ""]
-        }
-      }
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-class Ufo::Stack::Builder
-  class Parameters < Base
-    def build
-      {
-        "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": 1
-        },
-        "ElbEipIds": {
-          "Description": "ELB EIP Allocation ids to use for network load balancer",
-          "Type": "String",
-          "Default": ""
-        },
-        "EcsSchedulingStrategy": {
-          "Description": "The scheduling strategy to use for the service",
-          "Type": "String",
-          "Default": "REPLICA"
-        }
-      }
-    end
-  end
-end

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

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

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

@@ -1,17 +0,0 @@
-class Ufo::Stack::Builder::Resources
-  class Dns < Base
-    def build
-      return unless @create_route53
-
-      {
-        Type: "AWS::Route53::RecordSet",
-        Properties: {
-          Comment: "cname to load balancer",
-          Type: "CNAME",
-          TTL: 60, # ttl has special casing
-          ResourceRecords: [{"Fn::GetAtt": "Elb.DNSName"}]
-        }
-      }
-    end
-  end
-end

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

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

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

@@ -1,42 +0,0 @@
-class Ufo::Stack::Builder::Resources
-  class Listener < Base
-    def build
-      {
-        Type: "AWS::ElasticLoadBalancingV2::Listener",
-        Condition: "CreateElbIsTrue",
-        Properties: properties,
-      }
-    end
-
-    def properties
-      props = {
-        DefaultActions: [
-          {
-            Type: "forward",
-            TargetGroupArn: {
-              "Fn::If": [
-                "ElbTargetGroupIsBlank",
-                {Ref: "TargetGroup"},
-                {Ref: "ElbTargetGroup"}
-              ]
-            }
-          }
-        ],
-        LoadBalancerArn: {Ref: "Elb"},
-        Protocol: protocol,
-      }
-
-      props[:Port] = port if port
-
-      props
-    end
-
-    def protocol
-      @default_listener_protocol
-    end
-
-    def port
-      80
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-class Ufo::Stack::Builder::Resources
-  class ListenerSsl < Listener
-    def build
-      return unless @create_listener_ssl
-      super
-    end
-
-    def protocol
-      @default_listener_ssl_protocol
-    end
-
-    # nil on purpose
-    def port
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-module Ufo::Stack::Builder::Resources::Roles
-  class Base < Ufo::Stack::Builder::Base
-    def build
-      return unless self.class.build? # important because it runs DSL#evaluate
-      Ufo::Role::Builder.new(self.class.role_type).build
-    end
-
-
-    class << self
-      def role_type
-        self.name.to_s.split("::").last.underscore
-      end
-
-      def build?
-        path = "#{Ufo.root}/.ufo/iam_roles/#{role_type}.rb"
-        return unless File.exist?(path)
-        Ufo::Role::DSL.new(path).evaluate # runs the role.rb and registers items
-        Ufo::Role::Builder.new(role_type).build?
-      end
-    end
-  end
-end

data/lib/ufo/stack/builder/resources/roles/execution_role.rb

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

data/lib/ufo/stack/builder/resources/roles/task_role.rb

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

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

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

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

@@ -1,20 +0,0 @@
-class Ufo::Stack::Builder
-  class Resources < Base
-    def build
-      {
-        Dns: Dns.build,
-        Ecs: Ecs.build,
-        EcsSecurityGroup: SecurityGroup::Ecs.build,
-        EcsSecurityGroupRule: SecurityGroup::EcsRule.build,
-        Elb: Elb.build,
-        ElbSecurityGroup: SecurityGroup::Elb.build,
-        ExecutionRole: Roles::ExecutionRole.build,
-        Listener: Listener.build,
-        ListenerSsl: ListenerSsl.build,
-        TargetGroup: TargetGroup.build,
-        TaskDefinition: TaskDefinition.build,
-        TaskRole: Roles::TaskRole.build,
-      }
-    end
-  end
-end

data/lib/ufo/stack/builder.rb

@@ -1,26 +0,0 @@
-class Ufo::Stack
-  class Builder
-    class_attribute :context
-
-    def initialize(context)
-      @context = context
-      # This builder class is really used as a singleton.
-      # To avoid having to pass context to all the builder classes.
-      self.class.context = @context
-      @template = {
-        Description: "Ufo ECS stack #{context.stack_name}",
-      }
-    end
-
-    def build
-      @template[:Parameters] = Parameters.new.build
-      @template[:Conditions] = Conditions.new.build
-      @template[:Resources] = Resources.new.build
-      @template[:Outputs] = Outputs.new.build
-      @template.deep_stringify_keys!
-      @template = Ufo::Utils::Squeezer.new(@template).squeeze
-      @template = CustomProperties.new(@template, @context.stack_name).apply
-      YAML.dump(@template)
-    end
-  end
-end