applb 0.1.0

data/lib/applb/dsl/rule.rb

@@ -0,0 +1,157 @@
+module Applb
+  class DSL
+    class EC2
+      class LoadBalancer
+        class Listeners
+          class Listener
+            class Rules
+              class Rule
+                include Applb::DSL::Checker
+
+                class Result
+                  ATTRIBUTES = %i/priority actions conditions listener_arn rule_arn/
+                  attr_accessor *ATTRIBUTES
+
+                  def initialize(context, listener)
+                    @context = context
+                    @options = context.options
+                    @listener = listener
+                  end
+
+                  def aws(aws_rule)
+                    @aws_rule = aws_rule
+                    self
+                  end
+
+                  def to_h
+                    Hash[ATTRIBUTES.sort.map { |name| [name, public_send(name)] }]
+                  end
+
+                  def create
+                    Applb.logger.info("Create rule #{conditions.first[:values].first}")
+                    return if @options[:dry_run]
+
+                    Applb.logger.debug("create rule with option blow.")
+                    Applb.logger.debug(create_option.pretty_inspect)
+                    rule = client.create_rule(create_option).rules.first
+                    rule_arn = rule.rule_arn
+                    rule
+                  end
+
+                  def modify
+                    dsl_hash = to_diff_h
+                    aws_hash = to_diff_h_aws
+                    result = nil
+
+                    # modify rule
+                    if dsl_hash != aws_hash
+                      Applb.logger.info("Modify rule #{@aws_rule.rule_arn}")
+                      Applb.logger.info("<diff>\n#{Applb::Utils.diff(aws_hash, dsl_hash, color: @options[:color])}")
+
+                      unless @options[:dry_run]
+                        result = client.modify_rule(modify_option).rules.first
+                      end
+                    end
+
+                    # modify rule priority
+                    if priority.to_s != @aws_rule.priority
+                      Applb.logger.info("Modify priority #{@aws_rule.priority} to #{priority}")
+                      Applb.logger.info("<diff>\n#{Applb::Utils.diff(@aws_rule.priority, priority, color: @options[:color])}")
+
+                      unless @options[:dry_run]
+                        rule_priority_option = {
+                          rule_priorities: [{ rule_arn: @aws_rule.rule_arn, priority: priority}]
+                        }
+                        result = client.set_rule_priorities(rule_priority_option).rules.first
+                      end
+                    end
+                    result
+                  end
+
+                  private
+
+                  def create_option
+                    options = to_h.reject { |k, v| k == :rule_arn }
+                    options[:actions].first.delete(:target_group_name)
+                    options
+                  end
+
+                  def modify_option
+                    options = to_h.reject { |k, v| k == :priority }
+                    options[:rule_arn] = @aws_rule.rule_arn
+                    options[:actions].first.delete(:target_group_name)
+                    options.delete(:listener_arn)
+                    options
+                  end
+
+                  def to_diff_h
+                    Applb::Utils.normalize_hash(to_h).reject do |k, v|
+                      %i/:priority listener_arn rule_arn priority/.include?(k)
+                    end.tap { |h| h[:actions].first.delete(:target_group_name) }
+                  end
+
+                  def to_diff_h_aws
+                    Applb::Utils.normalize_hash(@aws_rule.to_h).reject do |k, v|
+                      %i/priority is_default rule_arn/.include?(k)
+                    end
+                  end
+
+                  def needs_modify?
+                    to_diff_h != to_diff_h_aws
+                  end
+
+                  def client
+                    @client ||= Applb::ClientWrapper.new(@options)
+                  end
+                end
+
+                def initialize(context, listener, &block)
+                  @context = context.dup
+                  @listener = listener
+
+                  @result = Result.new(context, listener)
+                  @result.actions = []
+                  @result.conditions =  []
+
+                  instance_eval(&block)
+                end
+
+                def result
+                  required(:conditions, @result.conditions)
+                  required(:priority, @result.priority)
+                  required(:actions, @result.actions)
+                  @result
+                end
+                
+                private
+
+                def rule_arn(rule_arn)
+                  @result.rule_arn = rule_arn
+                end
+
+                def priority(priority)
+                  @result.priority = priority
+                end
+
+                def actions(target_group_name: nil, target_group_arn: nil, type:)
+                  @result.actions << {
+                    target_group_arn: target_group_arn,
+                    target_group_name: target_group_name,
+                    type: type,
+                  }
+                end
+
+                def conditions(field: , values:)
+                  @result.conditions << {
+                    field: field,
+                    values: values,
+                  }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applb/dsl/rules.rb

@@ -0,0 +1,32 @@
+require 'applb/dsl/rule'
+
+module Applb
+  class DSL
+    class EC2
+      class LoadBalancer
+        class Listeners
+          class Listener
+            class Rules
+              def initialize(context, listener, &block)
+                @context = context.dup
+                @listener = listener
+
+                @result = []
+
+                instance_eval(&block)
+              end
+
+              attr_reader :result
+              
+              private
+
+              def rule(&block)
+                @result << Rule.new(@context, @listener, &block).result
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applb/dsl/target_group.rb

@@ -0,0 +1,156 @@
+module Applb
+  class DSL
+    class EC2
+      class LoadBalancer
+        class TargetGroups
+          class TargetGroup
+            include Checker
+            include Applb::TemplateHelper
+
+            class Result
+              ATTRIBUTES = %i/
+                name protocol port vpc_id health_check_protocol health_check_port health_check_path
+                health_check_interval_seconds health_check_timeout_seconds healthy_threshold_count
+                unhealthy_threshold_count matcher
+              /
+
+              attr_accessor *ATTRIBUTES
+
+              def initialize(context)
+                @context = context
+                @options = context.options
+              end
+
+              def to_h
+                Hash[ATTRIBUTES.sort.map { |name| [name, public_send(name)] }]
+              end
+
+              def aws(aws_tg)
+                @aws_tg = aws_tg
+                self
+              end
+
+              def create
+                Applb.logger.info("Create target group #{name}")
+                return if @options[:dry_run]
+                client.create_target_group(create_option).target_groups.first
+              end
+
+              def modify
+                dsl_hash = to_diff_h
+                aws_hash = to_diff_h_aws
+                return if dsl_hash == aws_hash
+
+                Applb.logger.info("Modify target group #{name}")
+                Applb.logger.info("<diff>\n#{Applb::Utils.diff(aws_hash, dsl_hash, color: @options[:color])}")
+                return if @options[:dry_run]
+
+                puts modify_option
+                client.modify_target_group(modify_option).target_groups.first
+              end
+
+              private
+
+              def create_option
+                to_h
+              end
+
+              UNMODIFIABLE_ATTRIBUTES = %i/name port protocol vpc_id/
+              def modify_option
+                options = to_h.
+                  merge(target_group_arn: @aws_tg.target_group_arn).
+                  reject! { |k, v| UNMODIFIABLE_ATTRIBUTES.include?(k) }
+              end
+
+              def to_diff_h
+                hash = to_h
+                hash.delete(:target_group_arn)
+                Hash[hash.sort]
+              end
+
+              def to_diff_h_aws
+                hash = @aws_tg.to_h
+                hash[:name] = hash.delete(:target_group_name)
+                hash.delete(:target_group_arn)
+                hash.delete(:load_balancer_arns)
+                Hash[hash.sort]
+              end
+
+              def client
+                @client ||= Applb::ClientWrapper.new(@options)
+              end
+            end
+
+            def initialize(context, name, lb_name, &block)
+              @context = context.dup
+              @lb_name = lb_name
+              @result = Result.new(@context)
+              @result.name = name
+
+              instance_eval(&block)
+            end
+
+            def result
+              required(:name, @result.name)
+              required(:protocol, @result.protocol)
+              required(:port, @result.port)
+              required(:vpc_id, @result.vpc_id)
+
+              @result
+            end
+
+            private
+
+            def name(name)
+              @result.name = name
+            end
+
+            def protocol(protocol)
+              @result.protocol = protocol
+            end
+
+            def port(port)
+              @result.port = port
+            end
+
+            def vpc_id(vpc_id)
+              @result.vpc_id = vpc_id
+            end
+
+            def health_check_protocol(health_check_protocol)
+              @result.health_check_protocol = health_check_protocol
+            end
+
+            def health_check_port(health_check_port)
+              @result.health_check_port = health_check_port
+            end
+
+            def health_check_path(health_check_path)
+              @result.health_check_path = health_check_path
+            end
+
+            def health_check_interval_seconds(health_check_interval_seconds)
+              @result.health_check_interval_seconds = health_check_interval_seconds
+            end
+
+            def health_check_timeout_seconds(health_check_timeout_seconds)
+              @result.health_check_timeout_seconds = health_check_timeout_seconds
+            end
+
+            def healthy_threshold_count(healthy_threshold_count)
+              @result.healthy_threshold_count = healthy_threshold_count
+            end
+
+            def unhealthy_threshold_count(unhealthy_threshold_count)
+              @result.unhealthy_threshold_count = unhealthy_threshold_count
+            end
+
+            def matcher(http_code:)
+              @result.matcher = { http_code: http_code }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applb/dsl/target_groups.rb

@@ -0,0 +1,28 @@
+require 'applb/dsl/target_group'
+
+module Applb
+  class DSL
+    class EC2
+      class LoadBalancer
+        class TargetGroups
+          include Applb::TemplateHelper
+
+          attr_reader :result
+
+          def initialize(context, lb, &block)
+            @context = context.dup
+            @lb = lb
+            @result = []
+            instance_eval(&block)
+          end
+
+          private
+
+          def target_group(name, &block)
+            @result << TargetGroup.new(@context, name, @lb, &block).result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applb/error.rb

@@ -0,0 +1,4 @@
+module Applb
+  class Error < StandardError
+  end
+end

data/lib/applb/exporter.rb

@@ -0,0 +1,7 @@
+module Applb
+  class Exporter
+    def initialize(lbs)
+      
+    end
+  end
+end

data/lib/applb/filterable.rb

@@ -0,0 +1,13 @@
+module Applb
+  module Filterable
+    def target?(lb_name)
+      unless @options[:includes].empty?
+        return @options[:includes].include?(lb_name)
+      end
+      unless @options[:excludes].empty?
+        return !@options[:excludes].any? { |regex| lb_name =~ regex }
+      end
+      true
+    end
+  end
+end

data/lib/applb/output_alb.erb

@@ -0,0 +1,122 @@
+ec2 <%= vpc_id.inspect %> do
+  <%- lbs_by_name.each do |name, attr| -%>
+  elb_v2 <%= name.inspect %> do
+    subnets(
+    <%- attr[:availability_zones].each do |az| -%>
+      <%= az[:subnet_id].inspect %>, # <%= az[:zone_name] %>
+    <%- end -%>
+    )
+
+    security_groups(
+    <%- attr[:security_groups].each do |sg| -%>
+      <%= sg.inspect %>,
+    <%- end -%>
+    )
+
+    scheme(<%= attr[:scheme].inspect %>)
+
+    <%- unless tags_by_arn[attr[:load_balancer_arn]].empty? -%>
+    tags(
+    <%- tags_by_arn[attr[:load_balancer_arn]].each do |key, value| -%>
+      <%= key.inspect %> => <%= value.inspect %>,
+    <%- end -%>
+    )
+
+    <%- end -%>
+    ip_address_type(<%= attr[:ip_address_type].inspect %>)
+
+    attributes do
+      <%- attr[:attributes].each do |key, value|
+        case key
+        when "access_logs" then -%>
+      access_logs({
+        s3_enabled: <%= value[:s3][:enabled] %>,
+        s3_bucket: <%=  value[:s3][:bucket].inspect %>,
+        s3_prefix: <%=  value[:s3][:prefix].inspect %>,
+      })
+      <%- else -%>
+      <%= key.gsub('.', ' ') %>: <%= value %>
+      <%- end
+      end
+      -%>
+    end
+
+    target_groups do
+      <%- attr[:target_groups].each do |target_group| -%>
+      target_group <%= target_group.target_group_name.inspect %> do
+        protocol <%= target_group.protocol.inspect %>
+        port <%= target_group.port %>
+        vpc_id <%= vpc_id.inspect %>
+        health_check_interval_seconds <%= target_group.health_check_interval_seconds %>
+        health_check_path <%= target_group.health_check_path.inspect %>
+        health_check_port <%= target_group.health_check_port.inspect %>
+        health_check_protocol <%= target_group.health_check_protocol.inspect %>
+        health_check_timeout_seconds <%= target_group.health_check_timeout_seconds %>
+        healthy_threshold_count <%= target_group.healthy_threshold_count %>
+        unhealthy_threshold_count <%= target_group.unhealthy_threshold_count %>
+        matcher http_code: <%= target_group.matcher.http_code.inspect %>
+      end
+      <%- end -%>
+    end
+
+    listeners do
+      <%- attr[:listeners].each do |listener| -%>
+      listener do
+        <%- listener.certificates.each do |certificate| -%>
+        certificates certificate_arn: <%= certificate.certificate_arn.inspect %>
+        <%- end -%>
+        <%- if listener.ssl_policy -%>
+        ssl_policy <%= listener.ssl_policy.inspect %>
+        <%- end -%>
+        port <%= listener.port %>
+        protocol <%= listener.protocol.inspect %>
+        <%- listener.default_actions.each do |action| -%>
+
+        default_actions(
+          target_group_name: <%= attr[:target_groups].find { |target_group| target_group.target_group_arn == action.target_group_arn }.target_group_name.inspect %>,
+          target_group_arn: <%= action.target_group_arn.inspect %>,
+          type: <%= action.type.inspect %>,
+        )
+        <%- end -%>
+
+        rules do
+          <%- if attr[:rules_by_listener_arn][listener.listener_arn].reject(&:is_default).empty? -%>
+          # no rules
+          <%- end -%>
+          <%- attr[:rules_by_listener_arn][listener.listener_arn].reject(&:is_default).each do |rule| -%>
+          rule do
+            rule_arn <%= rule.rule_arn.inspect %>
+            priority <%= rule.priority.inspect %>
+
+            <%- rule.actions.each do |action| -%>
+            actions(
+              target_group_name: <%= attr[:target_groups].find { |target_group| target_group.target_group_arn == action.target_group_arn }.target_group_name.inspect %>,
+              target_group_arn: <%= action.target_group_arn.inspect %>,
+              type: <%= action.type.inspect %>,
+            )
+
+            <%- end -%>
+            conditions(
+              <%- rule.conditions.each do |condition| -%>
+              field: <%= condition.field.inspect %>,
+              values: <%= condition.values.inspect %>,
+              <%- end -%>
+            )
+          end
+            <%- if attr[:rules_by_listener_arn][listener.listener_arn].reject(&:is_default).last != rule -%>
+
+            <%- end -%>
+          <%- end -%>
+        end
+      end
+        <%- if attr[:listeners].last != listener -%>
+
+        <%- end -%>
+      <%- end -%>
+    end
+  end
+    <%- if lbs_by_name.keys.last != name -%>
+
+    <%- end -%>
+  <%- end -%>
+end