kelbim 0.0.1

data/lib/kelbim/wrapper/listener-collection.rb

@@ -0,0 +1,88 @@
+require 'ostruct'
+require 'kelbim/wrapper/listener'
+require 'kelbim/logger'
+
+module Kelbim
+  class ELBWrapper
+    class LoadBalancerCollection
+      class LoadBalancer
+        class ListenerCollection
+          include Logger::ClientHelper
+
+          def initialize(listeners, load_balancer, options)
+            @listeners = listeners
+            @load_balancer = load_balancer
+            @options = options
+          end
+
+          def each
+            @listeners.each do |lstnr|
+              yield(Listener.new(lstnr, @options))
+            end
+          end
+
+          def create(dsl)
+            log_id = [[dsl.protocol, dsl.port], [dsl.instance_protocol, dsl.instance_port]].map {|i| i.inspect }.join(' => ')
+            log_id = "#{@load_balancer.vpc_id || :classic} > #{@load_balancer.name} > #{log_id}"
+            log(:info, 'Create Listener', :cyan, log_id)
+
+            if @options.dry_run
+              lstnr = OpenStruct.new({
+                :protocol          => dsl.protocol,
+                :port              => dsl.port,
+                :instance_protocol => dsl.instance_protocol,
+                :instance_port     => dsl.instance_port,
+                :policies          => dsl.policies.map {|i| PolicyCollection.create_mock_policy(i) },
+              })
+
+              if dsl.server_certificate
+                lstnr.server_certificate = OpenStruct.new(:name => dsl.server_certificate)
+              end
+            else
+              lstnr_opts = {
+                :protocol          => dsl.protocol,
+                :port              => dsl.port,
+                :instance_protocol => dsl.instance_protocol,
+                :instance_port     => dsl.instance_port,
+              }
+
+              if (ss_name = dsl.server_certificate)
+                ss = @options.iam.server_certificates[ss_name]
+
+                unless ss
+                  raise "Can't find ServerCertificate: #{ss_name} in #{load_balancer.vpc_id || :classic} > #{@load_balancer.name}"
+                end
+
+                lstnr_opts[:server_certificate] = ss.arn
+              end
+
+              # lstnr_optsは破壊的に更新される
+              lstnr = @listeners.create(lstnr_opts.dup)
+              @options.updated = true
+
+              # XXX: 新規作成後、_descriptionはセットされない
+              fix_new_listener(lstnr, lstnr_opts)
+            end
+
+            Listener.new(lstnr, @options)
+          end
+
+          private
+          def fix_new_listener(lstnr, lstnr_opts)
+            lstnr.instance_variable_set(:@__server_certificate__, lstnr_opts[:server_certificate])
+
+            def lstnr.server_certificate
+              if @__server_certificate__
+                OpenStruct.new(:name => @__server_certificate__)
+              else
+                nil
+              end
+            end
+
+            def lstnr.policy_names; []; end
+          end
+        end # ListenerCollection
+      end # LoadBalancer
+    end # LoadBalancerCollection
+  end # ELBWrapper
+end # Kelbim

data/lib/kelbim/wrapper/listener.rb

@@ -0,0 +1,110 @@
+require 'forwardable'
+require 'kelbim/ext/elb-listener-ext'
+require 'kelbim/wrapper/policy-collection'
+require 'kelbim/logger'
+
+module Kelbim
+  class ELBWrapper
+    class LoadBalancerCollection
+      class LoadBalancer
+        class ListenerCollection
+          class Listener
+            extend Forwardable
+            include Logger::ClientHelper
+
+            def_delegators(
+              :@listener,
+              :protocol, :port, :instance_protocol, :instance_port, :load_balancer)
+
+            def initialize(listener, options)
+              @listener = listener
+              @options = options
+            end
+
+            def policies
+              PolicyCollection.new(@listener.policies, self, @options)
+            end
+
+            def eql?(dsl)
+              not has_difference_protocol_port?(dsl) and compare_server_certificate(dsl)
+            end
+
+            def update(dsl)
+              log(:info, 'Update Listener', :green, log_id)
+
+              compare_server_certificate(dsl) do
+                log(:info, "  set server_certificate=#{dsl.server_certificate}", :green)
+
+                unless @options.dry_run
+                  ss = @options.iam.server_certificates[dsl.server_certificate]
+
+                  unless ss
+                    raise "Can't find ServerCertificate: #{ss_name} in #{log_id}"
+                  end
+
+                  @listener.server_certificate = ss
+                  @options.updated = true
+                end
+              end
+            end
+
+            def policies=(policy_list)
+              log(:info, 'Update Listener Policies', :green, log_id)
+              log(:info, '  set policies=' + policy_list.map {|i| i.name }.join(', '), :green)
+
+              unless @options.dry_run
+                @options.elb.client.set_load_balancer_policies_of_listener({
+                  :load_balancer_name => @listener.load_balancer.name,
+                  :load_balancer_port => @listener.port,
+                  :policy_names       => policy_list.map {|i| i.name },
+                })
+
+                @options.updated = true
+              end
+            end
+
+            def delete
+              log(:info, 'Delete Listener', :red, log_id)
+
+              related_policies = self.policies
+
+              unless @options.dry_run
+                @listener.delete
+                @options.updated = true
+              end
+
+              unless @options.without_deleting_policy
+                related_policies.each do |plcy|
+                  plcy.delete
+                end
+              end
+            end
+
+            def has_difference_protocol_port?(dsl)
+              not (
+                @listener.protocol          == dsl.protocol          &&
+                @listener.port              == dsl.port              &&
+                @listener.instance_protocol == dsl.instance_protocol &&
+                @listener.instance_port     == dsl.instance_port
+              )
+            end
+
+            def log_id
+              log_id = [[@listener.protocol, @listener.port], [@listener.instance_protocol, @listener.instance_port]].map {|i| i.inspect }.join(' => ')
+              "#{@listener.load_balancer.vpc_id || :classic} > #{@listener.load_balancer.name} > #{log_id}"
+            end
+
+            private
+            def compare_server_certificate(dsl)
+              aws_server_certificate = @listener.server_certificate
+              aws_server_certificate = aws_server_certificate.name if aws_server_certificate
+              same = (aws_server_certificate == dsl.server_certificate)
+              yield if !same && block_given?
+              return same
+            end
+          end # Listener
+        end # ListenerCollection
+      end # LoadBalancer
+    end # LoadBalancerCollection
+  end # ELBWrapper
+end # Kelbim

data/lib/kelbim/wrapper/load-balancer-collection.rb

@@ -0,0 +1,101 @@
+require 'ostruct'
+require 'kelbim/wrapper/load-balancer'
+require 'kelbim/logger'
+
+module Kelbim
+  class ELBWrapper
+    class LoadBalancerCollection
+      include Logger::ClientHelper
+
+      def initialize(load_balancers, options)
+        @load_balancers = load_balancers
+        @options = options
+      end
+
+      def each
+        @load_balancers.each do |lb|
+          yield(LoadBalancer.new(lb, @options))
+        end
+      end
+
+      def create(dsl, vpc)
+        log(:info, 'Create LoadBalancer', :cyan, "#{vpc || :classic} > #{dsl.name}")
+
+        if @options.dry_run
+          listeners = dsl.listeners
+
+          lb = OpenStruct.new({
+            :id           => "<new load balancer name=#{dsl.name}>",
+            :name         => dsl.name,
+            :vpc_id       => vpc,
+            :instances    => dsl.instances,
+            :scheme       => (dsl.internal ? 'internal' : 'internet-facing'),
+            :listeners    => listeners,
+            :health_check => {}, # health_checkはLoadBalancerの処理で更新
+          })
+
+          listeners.each do |lstnr|
+            lstnr.load_balancer = lb
+
+            if lstnr.server_certificate
+              lstnr.server_certificate = OpenStruct.new(:name => lstnr.server_certificate)
+            end
+          end
+
+          if vpc
+            lb.subnets = dsl.subnets.map {|i| OpenStruct.new(:id => i) }
+            sg_names = @options.security_group_names[vpc] || {}
+            lb.security_group_ids = dsl.security_groups {|i| sg_names.key(i) || i }
+          else
+            lb.availability_zones = dsl.availability_zones.map {|i| OpenStruct.new(:name => i) }
+          end
+        else
+          opts = {
+            :scheme       => (dsl.internal ? 'internal' : 'internet-facing'),
+            :listeners    => [],
+          }
+
+          opts[:instances] = dsl.instances unless dsl.instances.empty?
+
+          dsl.listeners.each do |lstnr|
+            lstnr_opts = {
+              :port              => lstnr.port,
+              :protocol          => lstnr.protocol,
+              :instance_protocol => lstnr.instance_protocol,
+              :instance_port     => lstnr.instance_port,
+            }
+
+            if (ss_name = lstnr.server_certificate)
+              ss = @options.iam.server_certificates[ss_name]
+
+              unless ss
+                raise "Can't find ServerCertificate: #{ss_name} in #{vpc || :classic} > #{dsl.name}"
+              end
+
+              lstnr_opts[:server_certificate] = ss.arn
+            end
+
+            opts[:listeners] << lstnr_opts
+          end
+
+          if vpc
+            opts[:subnets] = dsl.subnets.map {|i| AWS::EC2::Subnet.new(i) }
+            sg_names = @options.security_group_names[vpc] || {}
+
+            opts[:security_groups] = dsl.security_groups.map do |i|
+              AWS::EC2::SecurityGroup.new(sg_names.key(i) || i)
+            end
+          else
+            opts[:availability_zones] = dsl.availability_zones.map {|i|  AWS::EC2::AvailabilityZone.new(i) }
+          end
+
+          # health_checkはLoadBalancerの処理で更新
+          lb = @load_balancers.create(dsl.name, opts)
+          @options.updated = true
+        end
+
+        LoadBalancer.new(lb, @options)
+      end
+    end # LoadBalancerCollection
+  end # ELBWrapper
+end # Kelbim

data/lib/kelbim/wrapper/load-balancer.rb

@@ -0,0 +1,217 @@
+require 'forwardable'
+require 'kelbim/wrapper/listener-collection'
+require 'kelbim/logger'
+
+module Kelbim
+  class ELBWrapper
+    class LoadBalancerCollection
+      class LoadBalancer
+        extend Forwardable
+        include Logger::ClientHelper
+
+        def_delegators(
+          :@load_balancer,
+          :vpc_id, :name)
+
+        def initialize(load_balancer, options)
+          @load_balancer = load_balancer
+          @options = options
+        end
+
+        def listeners
+          ListenerCollection.new(@load_balancer.listeners, self, @options)
+        end
+
+        def eql?(dsl)
+          compare_health_check(dsl) or return false
+
+          if self.vpc_id
+            compare_subnet_ids(dsl) or return false
+            compare_security_groups(dsl) or return false
+          else
+            compare_availability_zones(dsl) or return false
+          end
+
+          compare_instances(dsl)
+        end
+
+        def update(dsl)
+          log(:info, 'Update LoadBalancer', :green, log_id)
+
+          compare_instances(dsl) do |aws_instance_ids, dsl_instance_ids|
+            instance_names = @options.instance_names[self.vpc_id] || {}
+
+            add_ids = (dsl_instance_ids - aws_instance_ids)
+
+            unless add_ids.empty?
+              log(:info, '  register instances=' + add_ids.map {|i| instance_names.fetch(i, i) }.join(', '), :green)
+
+              unless @options.dry_run
+                @load_balancer.instances.register(*add_ids)
+                @options.updated = true
+              end
+            end
+
+            del_ids = (aws_instance_ids - dsl_instance_ids)
+
+            unless del_ids.empty?
+              log(:info, '  deregister instances=' + del_ids.map {|i| instance_names.fetch(i, i) }.join(', '), :green)
+
+              unless @options.dry_run
+                @load_balancer.instances.deregister(*del_ids)
+                @options.updated = true
+              end
+            end
+          end
+
+          compare_health_check(dsl) do
+              log(:info, '  set health_check=' + dsl.health_check.inspect, :green)
+
+            unless @options.dry_run
+              @load_balancer.configure_health_check(dsl.health_check)
+              @options.updated = true
+            end
+          end
+
+          if self.vpc_id
+            compare_subnet_ids(dsl) do |aws_subnet_ids, dsl_subnet_ids|
+              add_ids = (dsl_subnet_ids - aws_subnet_ids)
+
+              unless add_ids.empty?
+                log(:info, '  attach subnets=' + add_ids.join(', '), :green)
+
+                unless @options.dry_run
+                  @options.elb.client.attach_load_balancer_to_subnets(
+                    :load_balancer_name => @load_balancer.name,
+                    :subnets => add_ids,
+                  )
+
+                  @options.updated = true
+                end
+              end
+
+              del_ids = (aws_subnet_ids - dsl_subnet_ids)
+
+              unless del_ids.empty?
+                log(:info, '  detach subnets=' + del_ids.join(', '), :green)
+
+                unless @options.dry_run
+                  @options.elb.client.detach_load_balancer_from_subnets(
+                    :load_balancer_name => @load_balancer.name,
+                    :subnets => del_ids,
+                  )
+
+                  @options.updated = true
+                end
+              end
+            end
+
+            compare_security_groups(dsl) do |dsl_sg_ids|
+              sg_names = @options.security_group_names[self.vpc_id] || {}
+              log(:info, '  apply security groups=' + dsl_sg_ids.map {|i| sg_names.fetch(i, i) }.join(', '), :green)
+
+              unless @options.dry_run
+                @options.elb.client.apply_security_groups_to_load_balancer(
+                  :load_balancer_name => @load_balancer.name,
+                  :security_groups => dsl_sg_ids,
+                )
+
+                @options.updated = true
+              end
+            end
+          else
+            compare_availability_zones(dsl) do |aws_az_names, dsl_az_names|
+              add_names = (dsl_az_names - aws_az_names)
+
+              unless add_names.empty?
+                log(:info, '  enable availability zones=' + add_names.join(', '), :green)
+
+                unless @options.dry_run
+                  add_names.each do |az_name|
+                    @load_balancer.availability_zones.enable(az_name)
+                  end
+
+                  @options.updated = true
+                end
+              end
+
+              del_names = (aws_az_names - dsl_az_names)
+
+              unless del_names.empty?
+                log(:info, '  disable availability zones=' + del_names.join(', '), :green)
+
+                unless @options.dry_run
+                  del_names.each do |az_name|
+                    @load_balancer.availability_zones.disable(az_name)
+                  end
+
+                  @options.updated = true
+                end
+              end
+            end
+          end
+        end
+
+        def delete
+          log(:info, 'Delete LoadBalancer', :red, log_id)
+
+          unless @options.dry_run
+            @load_balancer.delete
+            @options.updated = true
+          end
+        end
+
+        private
+        def compare_health_check(dsl)
+          same = (@load_balancer.health_check.sort == dsl.health_check.sort)
+          yield if !same && block_given?
+          return same
+        end
+
+        def compare_subnet_ids(dsl)
+          subnet_ids = @load_balancer.subnets.map {|i| i.id }
+          same = (subnet_ids.sort == dsl.subnets.sort )
+          yield(subnet_ids, dsl.subnets) if !same && block_given?
+          return same
+        end
+
+        def compare_security_groups(dsl)
+          aws_sg_ids = @load_balancer.security_group_ids.sort
+          sg_names = @options.security_group_names[self.vpc_id] || {}
+
+          dsl_sg_ids = dsl.security_groups.map {|i|
+            sg_names.key(i) || i
+          }.sort
+
+          same = (aws_sg_ids == dsl_sg_ids)
+          yield(dsl_sg_ids) if !same && block_given?
+          return same
+        end
+
+        def compare_availability_zones(dsl)
+          az_names = @load_balancer.availability_zones.map {|i| i.name }
+          same = (az_names.sort == dsl.availability_zones.sort)
+          yield(az_names, dsl.availability_zones) if !same && block_given?
+          return same
+        end
+
+        def compare_instances(dsl)
+          aws_instance_ids = @load_balancer.instances.map {|i| i.id }.sort
+
+          dsl_instance_ids = dsl.instances.map {|i|
+            instance_names = @options.instance_names[self.vpc_id] || {}
+            instance_names.key(i) || i
+          }.sort
+
+          same = (aws_instance_ids == dsl_instance_ids)
+          yield(aws_instance_ids, dsl_instance_ids) if !same && block_given?
+          return same
+        end
+
+        def log_id
+          "#{self.vpc_id || :classic} > #{self.name}"
+        end
+      end # LoadBalancer
+    end # LoadBalancerCollection
+  end # ELBWrapper
+end # Kelbim

data/lib/kelbim/wrapper/policy-collection.rb

@@ -0,0 +1,96 @@
+require 'ostruct'
+require 'kelbim/wrapper/policy'
+require 'kelbim/policy-types'
+require 'kelbim/logger'
+require 'uuid'
+
+module Kelbim
+  class ELBWrapper
+    class LoadBalancerCollection
+      class LoadBalancer
+        class ListenerCollection
+          class Listener
+            class PolicyCollection
+              include Logger::ClientHelper
+
+              class << self
+                def create_mock_policy(dsl)
+                  dsl_type, dsl_name_or_attrs = dsl
+                  policy_type = PolicyTypes.symbol_to_string(dsl_type)
+                  plcy = OpenStruct.new(:type => policy_type)
+
+                  if PolicyTypes.name?(dsl_name_or_attrs)
+                    plcy.name = dsl_name_or_attrs
+                    plcy.type = {'<new policy attribute name>' => ['<new policy attribute value>']}
+                  else
+                    plcy.name = '<new policy name>'
+                    plcy.attributes = PolicyTypes.unexpand(dsl_type, dsl_name_or_attrs)
+                  end
+
+                  return plcy
+                end
+              end # of class methods
+
+              def initialize(policies, listener, options)
+                @policies = policies
+                @listener = listener
+                @options = options
+              end
+
+              def each
+                @policies.each do |plcy|
+                  yield(Policy.new(plcy, @listener, @options))
+                end
+              end
+
+              def create(dsl)
+                dsl_type, dsl_name_or_attrs = dsl
+                log_id = "#{@listener.load_balancer.vpc_id || :classic} > #{@listener.load_balancer.name} > #{PolicyTypes.symbol_to_string(dsl_type)}: "
+                log_id += PolicyTypes.name?(dsl_name_or_attrs) ? dsl_name_or_attrs : dsl_name_or_attrs.inspect
+                log(:info, 'Create Policy', :cyan, log_id)
+
+                plcy = @options.dry_run ? self.class.create_mock_policy(dsl) : create_policy(dsl)
+                Policy.new(plcy, @listener, @options)
+              end
+
+              private
+              def create_policy(dsl)
+                dsl_type, dsl_name_or_attrs = dsl
+                policy_type = PolicyTypes.symbol_to_string(dsl_type)
+
+                if PolicyTypes.name?(dsl_name_or_attrs)
+                  plcy = @listener.load_balancer.policies[dsl_name_or_attrs]
+
+                  unless plcy
+                    raise "Can't find Policy: #{dsl_name_or_attrs} in #{@listener.load_balancer.vpc_id || :classic} > #{@listener.load_balancer.name}"
+                  end
+                else
+                  policy_name = [
+                    @listener.load_balancer.vpc_id || :classic,
+                    @listener.load_balancer.name,
+                    @listener.protocol,
+                    @listener.port,
+                    @listener.instance_protocol,
+                    @listener.instance_port,
+                    policy_type,
+                    UUID.new.generate,
+                  ].join('-').gsub(/\s/, '_')
+
+                  plcy = @listener.load_balancer.policies.create(
+                    policy_name,
+                    policy_type,
+                    PolicyTypes.unexpand(dsl_type, dsl_name_or_attrs)
+                  )
+                end
+
+                @options.updated = true
+
+                return plcy
+              end
+            end # PolicyCollection
+          end # Listener
+        end # ListenerCollection
+      end # LoadBalancer
+    end # LoadBalancerCollection
+  end # ELBWrapper
+end # Kelbim

data/lib/kelbim/wrapper/policy.rb

@@ -0,0 +1,52 @@
+require 'forwardable'
+require 'kelbim/policy-types'
+require 'kelbim/logger'
+
+module Kelbim
+  class ELBWrapper
+    class LoadBalancerCollection
+      class LoadBalancer
+        class ListenerCollection
+          class Listener
+            class PolicyCollection
+              class Policy
+                extend Forwardable
+                include Logger::ClientHelper
+
+                def_delegators(
+                  :@policy,
+                  :name, :type)
+
+                def initialize(policy, listener, options)
+                  @policy = policy
+                  @listener = listener
+                  @options = options
+                end
+
+                def eql?(dsl)
+                  dsl_type, dsl_name_or_attrs = dsl
+
+                  if PolicyTypes.name?(dsl_name_or_attrs)
+                    @policy.name == dsl_name_or_attrs
+                  else
+                    aws_attrs = PolicyTypes.expand(@policy.type, @policy.attributes)
+                    aws_attrs.sort == dsl_name_or_attrs.sort
+                  end
+                end
+
+                def delete
+                  log(:info, 'Delete Policy', :red, "#{@listener.log_id} > #{self.name}")
+
+                  unless @options.dry_run
+                    @policy.delete
+                    @options.updated = true
+                  end
+                end
+              end # Policy
+            end # PolicyCollection
+          end # Listener
+        end # ListenerCollection
+      end # LoadBalancer
+    end # LoadBalancerCollection
+  end # ELBWrapper
+end # Kelbim

data/lib/kelbim.rb

@@ -0,0 +1,2 @@
+require 'kelbim/version'
+require 'kelbim/client'