kelbim 0.0.1

data/lib/kelbim/dsl/ec2.rb

@@ -0,0 +1,37 @@
+require 'ostruct'
+require 'set'
+require 'kelbim/dsl/load-balancer'
+
+module Kelbim
+  class DSL
+    class EC2
+      attr_reader :result
+
+      def initialize(vpc, &block)
+        @names = []
+        @error_identifier = "EC2 `#{vpc || :classic}`"
+
+        @result = OpenStruct.new({
+          :vpc            => vpc,
+          :load_balancers => [],
+        })
+
+        instance_eval(&block)
+      end
+
+      private
+      def load_balancer(name, opts = {}, &block)
+        if @names.include?(name)
+          raise "#{@error_identifier}: `#{name}` is already defined"
+        end
+
+        unless (invalid_keys = (opts.keys - [:internal])).empty?
+          raise "LoadBalancer `#{name}`: Invalid option keys: #{invalid_keys}"
+        end
+
+        @result.load_balancers << LoadBalancer.new(name, @result.vpc, opts[:internal], &block).result
+        @names << name
+      end
+    end # EC2
+  end # DSL
+end # Kelbim

data/lib/kelbim/dsl/health-check.rb

@@ -0,0 +1,57 @@
+require 'ostruct'
+require 'kelbim/dsl/checker'
+
+module Kelbim
+  class DSL
+    class EC2
+      class LoadBalancer
+        class HealthCheck
+          include Checker
+
+          def initialize(load_balancer, &block)
+            @error_identifier = "LoadBalancer `#{load_balancer}`"
+            @result = {}
+            instance_eval(&block)
+          end
+
+          def result
+            [:target, :timeout, :interval, :healthy_threshold, :unhealthy_threshold].each do |name|
+              required(name, @result[name])
+            end
+
+            @result
+          end
+
+          def target(value)
+            call_once(:target)
+            @result[:target] = value
+          end
+
+          def timeout(value)
+            call_once(:timeout)
+            expected_type(value, Integer)
+            @result[:timeout] = value
+          end
+
+          def interval(value)
+            call_once(:interval)
+            expected_type(value, Integer)
+            @result[:interval] = value
+          end
+
+          def healthy_threshold(value)
+            call_once(:healthy_threshold)
+            expected_type(value, Integer)
+            @result[:healthy_threshold] = value
+          end
+
+          def unhealthy_threshold(value)
+            call_once(:unhealthy_threshold)
+            expected_type(value, Integer)
+            @result[:unhealthy_threshold] = value
+          end
+        end # HealthCheck
+      end # LoadBalancer
+    end # EC2
+  end # DSL
+end # Kelbim

data/lib/kelbim/dsl/listener.rb

@@ -0,0 +1,61 @@
+require 'ostruct'
+require 'kelbim/dsl/checker'
+require 'kelbim/policy-types'
+
+module Kelbim
+  class DSL
+    class EC2
+      class LoadBalancer
+        class Listeners
+          class Listener
+            include Checker
+
+            def initialize(load_balancer, protocol_prots, &block)
+              @error_identifier = "LoadBalancer `#{load_balancer}`: #{protocol_prots}"
+
+              @result = OpenStruct.new({
+                :policies => []
+              })
+
+              instance_eval(&block)
+            end
+
+            attr_reader :result
+
+            def server_certificate(value)
+              call_once(:server_certificate)
+              @result.server_certificate = value
+            end
+
+            def policies(value)
+              call_once(:policies)
+              expected_type(value, Hash)
+
+              unless value.kind_of?(Hash)
+                raise "LoadBalancer `#{@load_balancer}`: #{@protocol_prots}: Invalid policies: #{value}"
+              end
+
+              value = value.map do |policy, name_or_attrs|
+                expected_type(name_or_attrs, String, Hash)
+                policy = PolicyTypes.symbol_to_string(policy)
+                [policy, name_or_attrs]
+              end
+
+              @result.policies = value
+            end
+
+            PolicyTypes::POLICIES.keys.each do |attr_name|
+              class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+                def #{attr_name}(name_or_attrs)
+                  call_once(#{attr_name.inspect})
+                  expected_type(name_or_attrs, String, Hash, Array)
+                  @result.policies << [#{attr_name.inspect}, name_or_attrs]
+                end
+              EOS
+            end
+          end # Listener
+        end # Listeners
+      end # LoadBalancer
+    end # EC2
+  end # DSL
+end # Kelbim

data/lib/kelbim/dsl/listeners.rb

@@ -0,0 +1,56 @@
+require 'ostruct'
+require 'kelbim/dsl/checker'
+require 'kelbim/dsl/listener'
+
+module Kelbim
+  class DSL
+    class EC2
+      class LoadBalancer
+        class Listeners
+          include Checker
+
+          def initialize(load_balancer, &block)
+            @error_identifier = "LoadBalancer `#{load_balancer}`"
+            @result = {}
+            instance_eval(&block)
+          end
+
+          def result
+            required(:listener, @result)
+
+            @result.map do |protocol_ports, listener|
+              protocol, port, instance_protocol, instance_port = protocol_ports.first.flatten
+
+              OpenStruct.new({
+                :protocol           => protocol,
+                :port               => port,
+                :instance_protocol  => instance_protocol,
+                :instance_port      => instance_port,
+                :server_certificate => listener.server_certificate,
+                :policies           => listener.policies,
+              })
+            end
+          end
+
+          private
+          def listener(protocol_ports, &block)
+            expected_type(protocol_ports, Hash)
+            expected_length(protocol_ports, 1)
+
+            block = proc {} unless block
+
+            protocol_ports.first.each do |protocol_port|
+              protocol, port = protocol_port
+              expected_type(protocol_port, Array)
+              expected_length(protocol_port, 2)
+              expected_value(protocol, :http, :https, :tcp, :ssl)
+              expected_type(port, Integer)
+            end
+
+            @result[protocol_ports] = Listener.new(@load_balancer, protocol_ports, &block).result
+          end
+        end # Listeners
+      end # LoadBalancer
+    end # EC2
+  end # DSL
+end # Kelbim

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

@@ -0,0 +1,85 @@
+require 'ostruct'
+require 'kelbim/dsl/checker'
+require 'kelbim/dsl/health-check'
+require 'kelbim/dsl/listeners'
+
+module Kelbim
+  class DSL
+    class EC2
+      class LoadBalancer
+        include Checker
+
+        def initialize(name, vpc, internal, &block)
+          @name = name
+          @vpc = vpc
+          @error_identifier = "LoadBalancer `#{name}`"
+
+          @result = OpenStruct.new({
+            :name      => name,
+            :instances => [],
+            :internal  => internal,
+          })
+
+          instance_eval(&block)
+        end
+
+        def result
+          required(:listeners, @result.listeners)
+          required(:health_check, @result.health_check)
+
+          if @vpc
+            required(:subnets, @result.subnets)
+            required(:security_groups, @result.security_groups)
+          else
+            required(:availability_zones, @result.availability_zones)
+          end
+
+          @result
+        end
+
+        def test(&block)
+          call_once(:instances)
+          @result.test = block
+        end
+
+        def instances(*values)
+          call_once(:instances)
+
+          values.each do |instance_id_or_name|
+            instance_id = instance_id_or_name
+            not_include(instance_id_or_name, @result.instances)
+            @result.instances << instance_id
+          end
+        end
+
+        def listeners(&block)
+          call_once(:listeners)
+          @result.listeners = Listeners.new(@name, &block).result
+        end
+
+        def health_check(&block)
+          call_once(:health_check)
+          @result.health_check = HealthCheck.new(@name, &block).result
+        end
+
+        def subnets(*values)
+          call_once(:subnets)
+          raise "#{@error_identifier}: Subnet cannot be specified in EC2-Classic" unless @vpc
+          @result.subnets = values
+        end
+
+        def security_groups(*values)
+          call_once(:security_groups)
+          raise "#{@error_identifier}: SecurityGroup cannot be specified in EC2-Classic" unless @vpc
+          @result.security_groups = values
+        end
+
+        def availability_zones(*values)
+          call_once(:availability_zone)
+          raise "#{@error_identifier}: SecurityGroup cannot be specified in EC2-VPC" if @vpc
+          @result.availability_zones = values
+        end
+      end # LoadBalancer
+    end # EC2
+  end # DSL
+end # Kelbim

data/lib/kelbim/dsl.rb

@@ -0,0 +1,44 @@
+require 'ostruct'
+require 'kelbim/dsl/converter'
+require 'kelbim/dsl/ec2'
+
+module Kelbim
+  class DSL
+    class << self
+      def define(source, path)
+        self.new(path) do
+          eval(source, binding)
+        end
+      end
+
+      def convert(exported, instance_names)
+        Converter.convert(exported, instance_names)
+      end
+    end # of class methods
+
+    attr_reader :result
+
+    def initialize(path, &block)
+      @path = path
+      @result = OpenStruct.new(:ec2s => {})
+      instance_eval(&block)
+    end
+
+    private
+    def require(file)
+      balancerfile = File.expand_path(File.join(File.dirname(@path), file))
+
+      if File.exist?(balancerfile)
+        instance_eval(File.read(balancerfile))
+      elsif File.exist?(balancerfile + '.rb')
+        instance_eval(File.read(balancerfile + '.rb'))
+      else
+        Kernel.require(file)
+      end
+    end
+
+    def ec2(vpc = nil, &block)
+      @result.ec2s[vpc] = EC2.new(vpc, &block).result
+    end
+  end # DSL
+end # Kelbim

data/lib/kelbim/exporter.rb

@@ -0,0 +1,66 @@
+require 'kelbim/ext/elb-load-balancer-ext'
+require 'kelbim/ext/elb-listener-ext'
+
+module Kelbim
+  class Exporter
+    class << self
+      def export(elb)
+        self.new(elb).export
+      end
+    end # of class methods
+
+    def initialize(elb)
+      @elb = elb
+    end
+
+    def export
+      result = {}
+
+      @elb.load_balancers.each do |lb|
+        result[lb.vpc_id] ||= {}
+        result[lb.vpc_id][lb.name] = export_load_balancer(lb)
+      end
+
+      return result
+    end
+
+    private
+    def export_load_balancer(load_balancer)
+      attrs = {
+        :instances    => load_balancer.instances.map {|i| i.id },
+        :listeners    => load_balancer.listeners.map {|i| export_listener(i) },
+        :health_check => load_balancer.health_check,
+        :scheme       => load_balancer.scheme,
+        :dns_name     => load_balancer.dns_name,
+      }
+
+      if load_balancer.vpc_id
+        attrs[:subnets] = load_balancer.subnets.map {|i| i.id }
+        attrs[:security_groups] = load_balancer.security_groups.map {|i| i.name }
+      else
+        attrs[:availability_zones] = load_balancer.availability_zones.map {|i| i.name }
+      end
+
+      return attrs
+    end
+
+    def export_listener(listener)
+      {
+        :protocol           => listener.protocol,
+        :port               => listener.port,
+        :instance_protocol  => listener.instance_protocol,
+        :instance_port      => listener.instance_port,
+        :server_certificate => listener.server_certificate,
+        :policies           => listener.policies.map {|i| export_policy(i) },
+      }
+    end
+
+    def export_policy(policy)
+      {
+        :name       => policy.name,
+        :type       => policy.type,
+        :attributes => policy.attributes
+      }
+    end
+  end # Exporter
+end # Kelbim

data/lib/kelbim/ext/ec2-ext.rb

@@ -0,0 +1,27 @@
+require 'aws-sdk'
+
+module AWS
+  class EC2
+    def instance_names
+      vpc_instance_id_names = {}
+
+      self.instances.each do |i|
+        vpc_instance_id_names[i.vpc_id] ||= {}
+        vpc_instance_id_names[i.vpc_id][i.id] = i.tags['Name']
+      end
+
+      return vpc_instance_id_names
+    end
+
+    def security_group_names
+      vpc_sg_id_names = {}
+
+      self.security_groups.each do |i|
+        vpc_sg_id_names[i.vpc_id] ||= {}
+        vpc_sg_id_names[i.vpc_id][i.id] = i.name
+      end
+
+      return vpc_sg_id_names
+    end
+  end # EC2
+end # AWS

data/lib/kelbim/ext/elb-listener-ext.rb

@@ -0,0 +1,21 @@
+require 'aws-sdk'
+
+module AWS
+  class ELB
+    class Listener
+      def policy_names
+        _description[:policy_names]
+      end
+
+      def policies
+        if AWS.memoizing? and @policy_list
+          return @policy_list
+        end
+
+        @policy_list = policy_names.map do |name|
+          load_balancer.policies.find {|i| i.name == name }
+        end
+      end
+    end # Listener
+  end # ELB
+end # AWS

data/lib/kelbim/ext/elb-load-balancer-ext.rb

@@ -0,0 +1,15 @@
+require 'aws-sdk'
+
+module AWS
+  class ELB
+    class LoadBalancer
+      attribute :vpc_id, :static => true
+
+      populates_from(:describe_load_balancers) do |resp|
+        resp.data[:load_balancer_descriptions].find do |lb|
+          lb[:load_balancer_name] == name
+        end
+      end
+    end # LoadBalancer
+  end # ELB
+end # AWS

data/lib/kelbim/ext/string-ext.rb

@@ -0,0 +1,27 @@
+require 'term/ansicolor'
+
+class String
+  @@colorize = false
+
+  class << self
+    def colorize=(value)
+      @@colorize = value
+    end
+
+    def colorize
+      @@colorize
+    end
+  end # of class methods
+
+  Term::ANSIColor::Attribute.named_attributes.map do |attr|
+    class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+      def #{attr.name}
+        if @@colorize
+          Term::ANSIColor.send(#{attr.name.inspect}, self)
+        else
+          self
+        end
+      end
+    EOS
+  end
+end # String

data/lib/kelbim/logger.rb

@@ -0,0 +1,33 @@
+require 'logger'
+require 'singleton'
+require 'kelbim/ext/string-ext'
+
+module Kelbim
+  class Logger < ::Logger
+    include Singleton
+
+    def initialize
+      super($stdout)
+
+      self.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+
+      self.level = Logger::INFO
+    end
+
+    def set_debug(value)
+      self.level = value ? Logger::DEBUG : Logger::INFO
+    end
+
+    module ClientHelper
+      def log(level, message, color, log_id = nil)
+        message = "[#{level.to_s.upcase}] #{message}" unless level == :info
+        message << ": #{log_id}" if log_id
+        message << ' (dry-run)' if @options && @options.dry_run
+        logger = (@options && @options.logger) || Kelbim::Logger.instance
+        logger.send(level, message.send(color))
+      end
+    end # ClientHelper
+  end # Logger
+end # Kelbim

data/lib/kelbim/policy-types.rb

@@ -0,0 +1,100 @@
+module Kelbim
+  module PolicyTypes
+    POLICIES = {
+      :ssl_negotiation               => 'SSLNegotiationPolicyType',
+      :app_cookie_stickiness         => 'AppCookieStickinessPolicyType',
+      :lb_cookie_stickiness          => 'LBCookieStickinessPolicyType',
+      #:proxy_protocol                => 'ProxyProtocolPolicyType',
+      #:backend_server_authentication => 'BackendServerAuthenticationPolicyType',
+      #:public_key                    => 'PublicKeyPolicyType',
+    }
+
+    EXPANDERS = {
+      :ssl_negotiation => proc {|attrs|
+        attrs.select {|name, value|
+          value[0] =~ /\Atrue\Z/i
+        }.map {|n, v| n }
+      },
+      :app_cookie_stickiness => proc {|attrs| h = {}; attrs.map {|k, v| h[k] = [v].flatten[0] }; h },
+      :lb_cookie_stickiness => proc {|attrs| h = {}; attrs.map {|k, v| h[k] = [v].flatten[0] }; h },
+    }
+
+    UNEXPANDERS = {
+      :ssl_negotiation => proc {|attrs|
+        unexpanded = {}
+
+        attrs.each do |name|
+          unexpanded[name] = ['true']
+        end
+
+        unexpanded
+      },
+      :app_cookie_stickiness => proc {|attrs| h = {}; attrs.map {|k, v| h[k] = [v].flatten }; h },
+      :lb_cookie_stickiness => proc {|attrs| h = {}; attrs.map {|k, v| h[k] = [v].flatten }; h },
+    }
+
+    class << self
+      def symbol_to_string(sym)
+        str = POLICIES[sym]
+        raise "PolicyTypes `#{sym}` is not supported" unless str
+        return str
+      end
+
+      def string_to_symbol(str)
+        sym = POLICIES.key(str)
+        raise "PolicyTypes `#{str}` is not supported" unless sym
+        return sym
+      end
+
+      def convert_to_dsl(policy)
+        policy_name = policy[:name]
+        policy_type = policy[:type]
+        policy_attrs = policy[:attributes]
+        sym = string_to_symbol(policy_type)
+
+        if (expander = EXPANDERS[sym])
+          policy_attrs = expander.call(policy_attrs)
+
+          if policy_attrs.kind_of?(Hash)
+            new_policy_attrs = {}
+
+            policy_attrs.each do |name, value|
+              value = value[0] if value.length < 2
+              new_policy_attrs[name] = value
+            end
+
+            args = new_policy_attrs.inspect.gsub(/\A\s*\{/, '').gsub(/\}\s*\Z/, '')
+          else
+            args = policy_attrs.inspect
+          end
+        else
+          args = policy_name.inspect
+        end
+
+        "#{sym} #{args}"
+      end
+
+      def name?(name_or_attrs)
+        name_or_attrs.kind_of?(String)
+      end
+
+      def expand(sym_or_str, policy_attrs)
+        if sym_or_str.kind_of?(String)
+          sym_or_str = string_to_symbol(sym_or_str)
+        end
+
+        expander = EXPANDERS[sym_or_str]
+        expander ? expander.call(policy_attrs) : policy_attrs
+      end
+
+      def unexpand(sym_or_str, expanded_attrs)
+        if sym_or_str.kind_of?(String)
+          sym_or_str = string_to_symbol(sym_or_str)
+        end
+
+        unexpander = UNEXPANDERS[sym_or_str]
+        unexpander ? unexpander.call(expanded_attrs) : expanded_attrs
+      end
+    end # of class methods
+  end # PolicyTypes
+end # Kelbim

data/lib/kelbim/version.rb

@@ -0,0 +1,3 @@
+module Kelbim
+  VERSION = "0.0.1"
+end

data/lib/kelbim/wrapper/elb-wrapper.rb

@@ -0,0 +1,21 @@
+require 'kelbim/wrapper/load-balancer-collection'
+require 'kelbim/ext/ec2-ext'
+
+module Kelbim
+  class ELBWrapper
+    def initialize(elb, options)
+      @elb = elb
+      @options = options.dup
+      @options.instance_names = @options.ec2.instance_names
+      @options.security_group_names = @options.ec2.security_group_names
+    end
+
+    def load_balancers
+      LoadBalancerCollection.new(@elb.load_balancers, @options)
+    end
+
+    def updated?
+      !!@options.updated
+    end
+  end # EC2Wrapper
+end # Kelbim