applb 0.1.0

data/lib/applb/converter.rb

@@ -0,0 +1,22 @@
+require 'erb'
+
+module Applb
+  class Converter
+    def initialize(lbs_by_vpc_id, tags_by_arn)
+      @lbs_by_vpc_id = lbs_by_vpc_id
+      @tags_by_arn = tags_by_arn
+    end
+
+    def convert
+      @lbs_by_vpc_id.each do |vpc_id, lbs_by_name|
+        yield vpc_id, output_alb(vpc_id, @tags_by_arn, lbs_by_name)
+      end
+    end
+
+    private
+
+    def output_alb(vpc_id, tags_by_arn, lbs_by_name)
+      ERB.new(File.read('lib/applb/output_alb.erb'), nil, '-').result(binding)
+    end
+  end
+end

data/lib/applb/dsl.rb

@@ -0,0 +1,56 @@
+require 'hashie'
+require 'applb/template_helper'
+require 'applb/dsl/ec2'
+
+module Applb
+  class DSL
+    include Applb::TemplateHelper
+
+    class << self
+      def define(source, filepath, options)
+        self.new(filepath, options) do
+          eval(source, binding, filepath)
+        end
+      end
+    end
+
+    attr_reader :result
+    
+    def initialize(filepath, options,&block)
+      @filepath = filepath
+      @result = OpenStruct.new(ec2s: {})
+
+      @context = Hashie::Mash.new(
+        filepath: filepath,
+        templates: {},
+        options: options,
+      )
+
+      instance_eval(&block)
+    end
+
+    def require(file)
+      albfile = (file =~ %r|\A/|) ? file : File.expand_path(File.join(File.dirname(@path), file))
+
+      if File.exist?(albfile)
+        instance_eval(File.read(albfile), albfile)
+      elsif File.exist?("#{albfile}.rb")
+        instance_eval(File.read("#{albfile}.rb"), "#{albfile}.rb")
+      else
+        Kernel.require(file)
+      end
+    end
+
+    def template(name, &block)
+      @context.templates[name.to_s] = block
+    end
+
+    def ec2(vpc_id, &block)
+      if ec2_result = @result.ec2s[vpc_id]
+        @result.ec2s[vpc_id] = EC2.new(@context, vpc_id, ec2_result.load_balancers, &block).result
+      else
+        @result.ec2s[vpc_id] = EC2.new(@context, vpc_id, [], &block).result
+      end
+    end
+  end
+end

data/lib/applb/dsl/attributes.rb

@@ -0,0 +1,49 @@
+module Applb
+  class DSL
+    class EC2
+      class LoadBalancer
+        class Attributes
+          include Applb::DSL::Checker
+          include Applb::TemplateHelper
+
+          attr_reader :result
+          
+          def initialize(context, lb_name, &block)
+            @context = context.dup
+            @lb_name = lb_name
+
+            @result = {
+              'access_logs.s3.enabled' => false,
+              'access_logs.s3.bucket' => '',
+              'access_logs.s3.prefix' => '',
+              'idle_timeout.timeout_seconds' => 60,
+              'deletion_protection.enabled' => false,
+            }
+            
+            instance_eval(&block)
+          end
+
+          def result
+            @result.map { |k, v| {key: k, value: v} }
+          end
+
+          private
+
+          def access_logs(args)
+            @result['access_logs.s3.enabled'] = args[:s3_enabled] if args[:s3_enabled]
+            @result['access_logs.s3.bucket'] = args[:s3_bucket] if args[:s3_bucket]
+            @result['access_logs.s3.prefix'] = args[:s3_prefix] if args[:s3_prefix]
+          end
+
+          def idle_timeout(timeout_seconds:)
+            @result['idle_timeout.timeout_seconds'] = timeout_seconds if timeout_seconds
+          end
+
+          def deletion_protection(enabled:)
+            @result['deletion_protection.enabled'] = enabled if enabled
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applb/dsl/checker.rb

@@ -0,0 +1,27 @@
+require 'applb/error'
+
+module Applb
+  class DSL
+    module Checker
+      private
+
+      class ValidationError < Error
+      end
+
+      def required(name, value)
+        if value
+          case value
+          when String
+            invalid = value.strip.empty?
+          when Array, Hash
+            invalid = value.empty?
+          end
+        else
+          invalid = true
+        end
+
+        raise ValidationError.new("`#{name}' is required") if invalid
+      end
+    end
+  end
+end

data/lib/applb/dsl/ec2.rb

@@ -0,0 +1,35 @@
+require 'ostruct'
+require 'applb/dsl/load_balancer'
+
+module Applb
+  class DSL
+    class EC2
+      include Applb::TemplateHelper
+
+      attr_reader :result
+
+      def initialize(context, vpc_id, lbs, &block)
+        @context = context.merge(vpc_id: vpc_id)
+
+        @result = OpenStruct.new({
+          vpc_id: vpc_id,
+          load_balancers: lbs,
+        })
+
+        @names = lbs.map(&:name)
+        instance_eval(&block)
+      end
+
+      private
+
+      def elb_v2(name, &block)
+        if @names.include?(name)
+          raise "#{@result.vpc_id}: #{name} is already defined"
+        end
+
+        @result.load_balancers << LoadBalancer.new(@context, name, @result.vpc_id, &block).result
+        @names << name
+      end
+    end
+  end
+end

data/lib/applb/dsl/listener.rb

@@ -0,0 +1,140 @@
+require 'applb/dsl/rules'
+require 'applb/utils'
+require 'applb/client_wrapper'
+
+module Applb
+  class DSL
+    class EC2
+      class LoadBalancer
+        class Listeners
+          class Listener
+            include Checker
+            include Applb::TemplateHelper
+
+            class Result
+              ATTRIBUTES = %i/certificates ssl_policy port protocol default_actions rules load_balancer_arn/
+              attr_accessor *ATTRIBUTES
+
+              def initialize(context, lb_name)
+                @context = context
+                @options = context.options
+                @lb_name = lb_name
+              end
+
+              def to_h
+                Hash[ATTRIBUTES.sort.map { |name| [name, public_send(name)] }]
+              end
+
+              def aws(aws_listener)
+                @aws_listener = aws_listener
+                self
+              end
+
+              def create
+                Applb.logger.info("#{@lb_name} Create listener for port #{port}")
+                return if @options[:dry_run]
+                client.create_listener(create_option).listeners.first
+              end
+
+              def modify
+                dsl_hash = to_diff_h
+                aws_hash = to_diff_h_aws
+                return if dsl_hash == aws_hash
+
+                Applb.logger.info("#{@lb_name} Modify listener for port #{port}")
+                Applb.logger.info("<diff>\n#{Applb::Utils.diff(aws_hash, dsl_hash, color: @options[:color])}")
+                return if @options[:dry_run]
+
+                client.modify_listener(modify_option).listeners.first
+              end
+
+              private
+
+              def to_diff_h
+                options = Applb::Utils.normalize_hash(to_h)
+                target_group_name = options[:default_actions].first.delete(:target_group_name)
+                if options[:ssl_policy] && options[:ssl_policy].empty?
+                  options.delete(:certificates)
+                  options.delete(:ssl_policy)
+                end
+                options.reject! { |k, v| %i/listener_arn load_balancer_arn rules/.include?(k) }
+              end
+
+              def to_diff_h_aws
+                options = Applb::Utils.normalize_hash(@aws_listener.to_h)
+                if options[:ssl_policy] && options[:ssl_policy].empty?
+                  options.delete(:certificates)
+                  options.delete(:ssl_policy)
+                end
+                options.reject! { |k, v| %i/listener_arn load_balancer_arn rules/.include?(k) }
+              end
+
+              def create_option
+                options = to_h.reject { |k, _| %i/policy_name rules/.include?(k) }
+                options[:default_actions].first.delete(:target_group_name)
+                options
+              end
+
+              def modify_option
+                to_diff_h.merge(listener_arn: @aws_listener.listener_arn)
+              end
+
+              def client
+                @client ||= Applb::ClientWrapper.new(@options)
+              end
+            end
+
+            attr_reader :result
+            
+            def initialize(context, lb_name, &block)
+              @context = context.dup
+              @lb_name = lb_name
+
+              @result = Result.new(@context, @lb_name)
+
+              instance_eval(&block)
+            end
+
+            private
+
+            def certificates(certificate_arn:)
+              @result.certificates ||= []
+              @result.certificates << {certificate_arn: certificate_arn}
+            end
+
+            def ssl_policy(ssl_policy)
+              @result.ssl_policy = ssl_policy if ssl_policy
+            end
+
+            def port(port)
+              @result.port = port
+            end
+
+            def protocol(protocol)
+              @result.protocol = protocol
+            end
+
+            def default_actions(target_group_name: nil, target_group_arn: nil, type:)
+              unless target_group_name || target_group_arn
+                raise "target_group_name or target_group_arn is required"
+              end
+              @result.default_actions ||= []
+              @result.default_actions << {
+                target_group_arn: target_group_arn,
+                target_group_name: target_group_name,
+                type: type,
+              }
+            end
+
+            def rules(&block)
+              rules = Rules.new(@context, self, &block).result
+              unless rules.empty?
+                @result.rules = rules
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applb/dsl/listeners.rb

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

data/lib/applb/dsl/load_balancer.rb

@@ -0,0 +1,209 @@
+require 'applb/dsl/checker'
+require 'applb/dsl/attributes'
+require 'applb/dsl/listeners'
+require 'applb/dsl/target_groups'
+
+module Applb
+  class DSL
+    class EC2
+      class LoadBalancer
+        include Applb::DSL::Checker
+        include Applb::TemplateHelper
+
+        class Result
+          ATTRIBUTES = %i/name instances scheme subnets security_groups tags ip_address_type attributes target_groups listeners load_balancer_arn/
+          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
+
+          CREATE_KEYS = %i/name subnets security_groups scheme tags ip_address_type/
+          def create_option
+            to_h.select { |k, _| CREATE_KEYS.include?(k) }
+          end
+
+          def create
+            Applb.logger.info "Create ELB v2 #{name}"
+            return if @options[:dry_run]
+
+            client.create_load_balancer(create_option).load_balancers.first
+          end
+
+          def aws(aws_lb)
+            @aws_lb = aws_lb
+            self
+          end
+
+          def subnets_updated?
+            subnets.sort != @aws_lb.availability_zones.map(&:subnet_id).sort
+          end
+
+          def security_groups_updated?
+            security_groups.sort != @aws_lb.security_groups.sort
+          end
+
+          def ip_address_type_updated?
+            ip_address_type != @aws_lb.ip_address_type
+          end
+
+          def modify_subnets
+            return unless subnets_updated?
+
+            Applb.logger.info("Modify #{name} subnets")
+            diff = Applb::Utils.diff(
+              @aws_lb.availability_zones.map(&:subnet_id).sort,
+              subnets.sort,
+              color: @options[:color],
+            )
+            Applb.logger.info("<diff>\n#{diff}")
+            return if @options[:dry_run]
+
+            client.set_subnets(
+              load_balancer_arn: @aws_lb.load_balancer_arn,
+              subnets: subnets,
+            ).availability_zones
+          end
+
+          def modify_security_groups
+            return unless security_groups_updated?
+
+            Applb.logger.info "Modify #{name} security_groups"
+            diff = Applb::Utils.diff(
+              @aws_lb.security_groups.sort,
+              security_groups.sort,
+              color: @options[:color],
+            )
+            Applb.logger.info("<diff>\n#{diff}")
+            return if @options[:dry_run]
+
+            client.set_security_groups(
+              load_balancer_arn: @aws_lb.load_balancer_arn,
+              security_groups: security_groups,
+            ).security_group_ids
+          end
+
+          def modify_ip_address_type
+            return unless ip_address_type_updated?
+
+            Applb.logger.info "Modify #{name} ip_address_type"
+            diff = Applb::Utils.diff(
+              @aws_lb.ip_address_type,
+              ip_address_type,
+              color: @options[:color],
+            )
+            Applb.logger.info("<diff>\n#{diff}")
+
+            return if @options[:dry_run]
+            client.set_ip_address_type(
+              load_balancer_arn: @aws_lb.load_balancer_arn,
+              ip_address_type: ip_address_type,
+            ).ip_address_type
+          end
+
+          def modify_load_balancer_attributes
+            attrs = attributes.map do |attr|
+              {key: attr[:key], value: attr[:value].to_s}
+            end
+            log_enabled = attrs.find { |attr| attr[:key] == 'access_logs.s3.enabled' }[:value]
+            if log_enabled.to_s == 'false'
+              attrs.reject! do |attr|
+                %w/access_logs.s3.bucket access_logs.s3.prefix/.include?(attr[:key])
+              end
+            end
+            dsl_hash = attrs.map { |a| a.to_h }.sort { |a, b| a[:key] <=> b[:key] }
+
+            aws_attributes = client.describe_load_balancer_attributes(
+              load_balancer_arn: @aws_lb.load_balancer_arn,
+            ).attributes
+            aws_hash = aws_attributes.map { |a| a.to_h }.sort { |a, b| a[:key] <=> b[:key] }
+            aws_log_enabled = aws_attributes.find { |attr| attr[:key] == 'access_logs.s3.enabled' }[:value]
+            if aws_log_enabled == 'false'
+              aws_hash.reject! do |attr|
+                %w/access_logs.s3.bucket access_logs.s3.prefix/.include?(attr[:key])
+              end
+            end
+
+            return if dsl_hash == aws_hash
+
+            Applb.logger.info "Modify #{name} load_balancer_attributes"
+            Applb.logger.info("<diff>\n#{Applb::Utils.diff(aws_hash, dsl_hash, color: @options[:color])}")
+            return if @options[:dry_run]
+
+            client.modify_load_balancer_attributes(
+              load_balancer_arn: @aws_lb.load_balancer_arn,
+              attributes: attrs,
+            ).attributes
+          end
+
+          private
+
+          def client
+            @client ||= Applb::ClientWrapper.new(@options)
+          end
+        end
+
+        def initialize(context, name, vpc_id, &block)
+          @name = name
+          @vpc_id = vpc_id
+          @context = context.merge(name: name)
+
+          @result = Result.new(@context)
+          @result.name = name
+          @result.attributes = Attributes.new(@context, @name) {}.result
+          @result.instances = []
+          @result.target_groups = []
+          @result.listeners = []
+
+          instance_eval(&block)
+        end
+
+        def result
+          required(:subnets, @result.subnets)
+          required(:security_groups, @result.security_groups)
+          
+          @result
+        end
+
+        private
+        
+        def subnets(*subnets)
+          @result.subnets = subnets
+        end
+
+        def security_groups(*security_groups)
+          @result.security_groups = security_groups
+        end
+
+        def scheme(scheme)
+          @result.scheme = scheme
+        end
+
+        def tags(tags)
+          @result.tags = tags.map { |k, v| { key: k, value: v } }
+        end
+
+        def ip_address_type(ip_address_type)
+          @result.ip_address_type = ip_address_type
+        end
+
+        def attributes(&block)
+          @result.attributes = Attributes.new(@context, @name, &block).result
+        end
+
+        def target_groups(&block)
+          @result.target_groups = TargetGroups.new(@context, @name, &block).result
+        end
+      
+        def listeners(&block)
+          @result.listeners = Listeners.new(@context, @name, &block).result
+        end
+      end
+    end
+  end
+end