class Kelbim::Client

Public Class Methods

new(options = {}) click to toggle source
# File lib/kelbim/client.rb, line 6
def initialize(options = {})
  @options = OpenStruct.new(options)
  @options.elb = AWS::ELB.new
  @options.ec2 = AWS::EC2.new
  @options.iam = AWS::IAM.new
end

Public Instance Methods

apply(file) click to toggle source
# File lib/kelbim/client.rb, line 13
def apply(file)
  AWS.memoize { walk(file) }
end
export(opts = {}) { |exported, converter| ... } click to toggle source
# File lib/kelbim/client.rb, line 68
def export(opts = {})
  exported = nil
  instance_names = nil

  AWS.memoize do
    exported = Exporter.export(@options.elb, opts)
    instance_names = @options.ec2.instance_names
  end

  if block_given?
    converter = proc do |src|
      DSL.convert(src, instance_names)
    end

    yield(exported, converter)
  else
    DSL.convert(exported, instance_names)
  end
end
load_balancers() click to toggle source
# File lib/kelbim/client.rb, line 24
def load_balancers
  exported = nil

  AWS.memoize do
    exported = Exporter.export(@options.elb)
  end

  retval = {}

  exported.map do |vpc, lbs|
    vpc = vpc || 'classic'
    retval[vpc] = {}

    lbs.map do |name, attrs|
      retval[vpc][name] = attrs[:dns_name]
    end
  end

  return retval
end
policies() click to toggle source
# File lib/kelbim/client.rb, line 45
def policies
  exported = nil

  AWS.memoize do
    exported = Exporter.export(@options.elb, :fetch_policies => true)
  end

  retval = {}

  exported.map do |vpc, lbs|
    vpc = vpc || 'classic'

    lbs.map do |name, attrs|
      if attrs[:policies]
        retval[vpc] ||= {}
        retval[vpc][name] = attrs[:policies]
      end
    end
  end

  return retval
end
test(file) click to toggle source
# File lib/kelbim/client.rb, line 17
def test(file)
  AWS.memoize do
    dsl = load_file(file)
    Tester.test(dsl)
  end
end

Private Instance Methods

collect_to_hash(collection, *key_attrs) { |item| ... } click to toggle source
# File lib/kelbim/client.rb, line 256
def collect_to_hash(collection, *key_attrs)
  options = key_attrs.last.kind_of?(Hash) ? key_attrs.pop : {}
  hash = {}

  collection.each do |item|
    key = block_given? ? yield(item) : key_attrs.map {|k| item.send(k) }

    if options[:has_many]
      hash[key] ||= []
      hash[key] << item
    else
      hash[key] = item
    end
  end

  return hash
end
load_file(file) click to toggle source
# File lib/kelbim/client.rb, line 89
def load_file(file)
  if file.kind_of?(String)
    open(file) do |f|
      DSL.define(f.read, file).result
    end
  elsif file.respond_to?(:read)
    DSL.define(file.read, file.path).result
  else
    raise TypeError, "can't convert #{file} into File"
  end
end
walk(file) click to toggle source
# File lib/kelbim/client.rb, line 101
def walk(file)
  dsl = load_file(file)

  dsl_ec2s = dsl.ec2s
  elb = ELBWrapper.new(@options.elb, @options)

  aws_ec2s = collect_to_hash(elb.load_balancers, :has_many => true) do |item|
    item.vpc_id
  end

  vpc_ids = @options.ec2.vpcs.map {|i| i.id }

  dsl_ec2s.each do |vpc, ec2_dsl|
    if @options.ec2s
      next unless @options.ec2s.include?(vpc || 'classic')
    end

    if vpc and not vpc_ids.include?(vpc)
      log(:warn, "EC2 `#{vpc}` is not found", :yellow)
      next
    end

    ec2_aws = aws_ec2s[vpc]

    if ec2_aws
      walk_ec2(vpc, ec2_dsl, ec2_aws, elb.load_balancers)
    else
      walk_ec2(vpc, ec2_dsl, [], elb.load_balancers)
    end
  end

  elb.updated?
end
walk_ec2(vpc, ec2_dsl, ec2_aws, collection_api) click to toggle source
# File lib/kelbim/client.rb, line 135
def walk_ec2(vpc, ec2_dsl, ec2_aws, collection_api)
  lb_list_dsl = collect_to_hash(ec2_dsl.load_balancers, :name)
  lb_list_aws = collect_to_hash(ec2_aws, :name)

  lb_list_dsl.each do |key, lb_dsl|
    name = key[0]
    next unless matched_elb?(name)
    lb_aws = lb_list_aws[key]

    unless lb_aws
      lb_aws = collection_api.create(lb_dsl, vpc)
      lb_list_aws[key] = lb_aws
    end
  end

  lb_list_dsl.each do |key, lb_dsl|
    name = key[0]
    next unless matched_elb?(name)
    log(:info, "Comparing #{vpc || :classic} > #{name}", :intense_black)

    lb_aws = lb_list_aws.delete(key)
    walk_load_balancer(lb_dsl, lb_aws)
  end

  lb_list_aws.each do |key, lb_aws|
    name = key[0]
    next unless matched_elb?(name)
    lb_aws.delete
  end
end
walk_listener(listener_dsl, listener_aws, collection_api) click to toggle source
# File lib/kelbim/client.rb, line 198
def walk_listener(listener_dsl, listener_aws, collection_api)
  unless listener_aws.eql?(listener_dsl)
    if listener_aws.has_difference_protocol_port?(listener_dsl)
      listener_aws.delete
      listener_aws = collection_api.create(listener_dsl)
    else
      listener_aws.update(listener_dsl)
    end
  end

  plcy_list_dsl = collect_to_hash(listener_dsl.policies) do |policy_type, name_or_attrs|
    [PolicyTypes.symbol_to_string(policy_type)]
  end

  policies = listener_aws.policies
  plcy_list_aws = collect_to_hash(policies, :type)

  walk_policies(listener_aws, plcy_list_dsl, plcy_list_aws, policies)
end
walk_listeners(listeners_dsl, listeners_aws, collection_api) click to toggle source
# File lib/kelbim/client.rb, line 178
def walk_listeners(listeners_dsl, listeners_aws, collection_api)
  listeners_dsl.each do |key, lstnr_dsl|
    lstnr_aws = listeners_aws[key]

    unless lstnr_aws
      lstnr_aws = collection_api.create(lstnr_dsl)
      listeners_aws[key] = lstnr_aws
    end
  end

  listeners_dsl.each do |key, lstnr_dsl|
    lstnr_aws = listeners_aws.delete(key)
    walk_listener(lstnr_dsl, lstnr_aws, collection_api)
  end

  listeners_aws.each do |key, lstnr_aws|
    lstnr_aws.delete
  end
end
walk_load_balancer(load_balancer_dsl, load_balancer_aws) click to toggle source
# File lib/kelbim/client.rb, line 166
def walk_load_balancer(load_balancer_dsl, load_balancer_aws)
  unless load_balancer_aws.eql?(load_balancer_dsl)
    load_balancer_aws.update(load_balancer_dsl)
  end

  lstnr_list_dsl = collect_to_hash(load_balancer_dsl.listeners, :port)
  listeners = load_balancer_aws.listeners
  lstnr_list_aws = collect_to_hash(listeners, :port)

  walk_listeners(lstnr_list_dsl, lstnr_list_aws, listeners)
end
walk_policies(listener, policies_dsl, policies_aws, collection_api) click to toggle source
# File lib/kelbim/client.rb, line 218
def walk_policies(listener, policies_dsl, policies_aws, collection_api)
  orig_policy_names = policies_aws.map {|k, v| v.name }
  new_policies = []
  old_policies = []

  policies_dsl.each do |key, plcy_dsl|
    unless policies_aws[key]
      new_policies << collection_api.create(plcy_dsl)
    end
  end

  policies_dsl.each do |key, plcy_dsl|
    plcy_aws = policies_aws.delete(key)
    next unless plcy_aws

    if plcy_aws.eql?(plcy_dsl)
      new_policies << plcy_aws
    else
      new_policies << collection_api.create(plcy_dsl)
      old_policies << plcy_aws
    end
  end

  policies_aws.each do |key, plcy_aws|
    old_policies << plcy_aws
  end

  if orig_policy_names.sort != new_policies.map {|i| i.name }.sort
    listener.update_policies(new_policies, old_policies)
  end

  if not old_policies.empty? and not @options.without_deleting_policy
    old_policies.each do |plcy_aws|
      plcy_aws.delete
    end
  end
end