cumulus-aws 0.11.1

data/lib/elb/models/LoadBalancerConfig.rb

@@ -0,0 +1,239 @@
+require "conf/Configuration"
+require "elb/models/LoadBalancerDiff"
+require "elb/models/ListenerConfig"
+require "elb/models/HealthCheckConfig"
+require "elb/models/AccessLogConfig"
+require "elb/loader/Loader"
+require "elb/ELB"
+require "ec2/EC2"
+require "security/SecurityGroups"
+
+require "json"
+
+module Cumulus
+  module ELB
+
+    # Public: An object representing configuration for a load balancer
+    class LoadBalancerConfig
+      attr_reader :name
+      attr_reader :listeners
+      attr_reader :availability_zones
+      attr_reader :subnets
+      attr_reader :security_groups
+      attr_reader :internal
+      attr_reader :tags
+      attr_reader :manage_instances
+      attr_reader :health_check
+      attr_reader :cross_zone
+      attr_reader :access_log
+      attr_reader :connection_draining
+      attr_reader :idle_timeout
+      attr_reader :backend_policies
+
+      require "aws_extensions/elb/BackendServerDescription"
+      Aws::ElasticLoadBalancing::Types::BackendServerDescription.send(:include, AwsExtensions::ELB::BackendServerDescription)
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the load balancer
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+
+          # load the included listeners and templates
+          @listeners = []
+          if json["listeners"]
+            if json["listeners"]["includes"]
+              json["listeners"]["includes"].each do |template_json|
+                @listeners << Loader.listener(template_json["template"], template_json["vars"])
+              end
+            end
+            if json["listeners"]["inlines"]
+              json["listeners"]["inlines"].each do |inline|
+                @listeners << ListenerConfig.new(inline)
+              end
+            end
+          end
+
+          # Map subnets to their actual subnet description from aws
+          @subnets = (json["subnets"] || []).map do |subnet|
+            full_subnet = EC2::named_subnets[subnet]
+
+            if full_subnet.nil?
+              raise "#{subnet} is not a valid subnet name or id"
+            else
+              full_subnet
+            end
+          end
+
+          # Map backend policies to the Aws::ElasticLoadBalancing::Types::BackendServerDescription
+          # reject any local polices with empty policies array which means it should be deleted from aws
+          @backend_policies = (json["backend-policies"] || []).map do |backend|
+            Aws::ElasticLoadBalancing::Types::BackendServerDescription.new({
+              instance_port: backend["port"],
+              policy_names: backend["policies"]
+            })
+          end.reject { |backend| backend.policy_names.empty? }
+
+          @security_groups = json["security-groups"] || []
+          @internal = json["internal"] || false
+          @tags = json["tags"] || {}
+          @manage_instances = json["manage-instances"] || false
+          @health_check = if json["health-check"] then HealthCheckConfig.new(json["health-check"]) end
+          @cross_zone = json["cross-zone"] || false
+          @access_log = if json["access-log"] then AccessLogConfig.new(json["access-log"]) else false end
+          @connection_draining = json["connection-draining"] || false
+          @idle_timeout = json["idle-timeout"]
+        end
+      end
+
+      # Public: Returns the vpc id for the load balancer config using the first subnet
+      def vpc_id
+        first_subnet = @subnets.first
+        first_subnet.vpc_id if first_subnet
+      end
+
+      # Public: Get the config as a prettified JSON string.
+      #
+      # Returns the JSON string
+      def pretty_json
+        JSON.pretty_generate({
+          "listeners" => {
+            "includes" => [],
+            "inlines" => @listeners.map(&:to_hash)
+          },
+          "subnets" => @subnets.map { |s| s.name || s.subnet_id },
+          "security-groups" => @security_groups,
+          "internal" => @internal,
+          "tags" => @tags,
+          "manage-instances" => @manage_instances,
+          "health-check" => @health_check.to_hash,
+          "backend-policies" => @backend_policies.map do |backend_policy|
+            {
+              "port" => backend_policy.instance_port,
+              "policies" => backend_policy.policy_names
+            }
+          end,
+          "cross-zone" => @cross_zone,
+          "access-log" => if @access_log then @access_log.to_hash else @access_log end,
+          "connection-draining" => @connection_draining,
+          "idle-timeout" => @idle_timeout,
+        })
+      end
+
+      # Public: populates the fields of a LoadBalancerConfig from AWS config
+      #
+      # aws_elb - the elb
+      def populate!(aws_elb, aws_tags, aws_attributes)
+        @listeners = aws_elb.listener_descriptions.map do |l|
+          config = ListenerConfig.new
+          config.populate!(l)
+          config
+        end
+        @subnets = aws_elb.subnets.map { |subnet_id| EC2::id_subnets[subnet_id] }
+        @security_groups = aws_elb.security_groups.map do |sg_id|
+            SecurityGroups::id_security_groups[sg_id].group_name
+        end
+        @internal = aws_elb.scheme == "internal"
+        @tags = Hash[aws_tags.map do |tag|
+          [tag.key, tag.value]
+        end]
+        @manage_instances = aws_elb.instances.map { |i| i.instance_id }
+        @health_check = HealthCheckConfig.new
+        @health_check.populate!(aws_elb.health_check)
+        @backend_policies = aws_elb.backend_server_descriptions
+        @cross_zone = aws_attributes.cross_zone_load_balancing.enabled
+        @access_log = AccessLogConfig.new
+        @access_log.populate!(aws_attributes.access_log)
+        @connection_draining = aws_attributes.connection_draining.enabled && aws_attributes.connection_draining.timeout
+        @idle_timeout = aws_attributes.connection_settings.idle_timeout
+      end
+
+      # Public: Produce an array of differences between this local configuration and the
+      # configuration in AWS
+      #
+      # aws - the AWS resource
+      #
+      # Returns an array of the LoadBalancerDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        listener_diff = LoadBalancerDiff.listeners(aws.listener_descriptions, @listeners)
+        if listener_diff
+          diffs << listener_diff
+        end
+
+        aws_subnets = aws.subnets.map { |subnet_id| EC2::id_subnets[subnet_id] }
+        if @subnets.sort != aws_subnets.sort
+          diffs << LoadBalancerDiff.subnets(aws_subnets, @subnets)
+        end
+
+        named_aws_security_groups = aws.security_groups.map do |sg_id|
+          SecurityGroups::id_security_groups[sg_id].group_name
+        end
+        if @security_groups.sort != named_aws_security_groups.sort
+          diffs << LoadBalancerDiff.security_groups(named_aws_security_groups, @security_groups)
+        end
+
+        aws_internal = (aws.scheme == "internal")
+        if @internal != aws_internal
+          diffs << LoadBalancerDiff.internal(aws_internal, @internal)
+        end
+
+        aws_tags = Hash[ELB::elb_tags(@name).map { |tag| [tag.key, tag.value] }]
+        if @tags != aws_tags
+          diffs << LoadBalancerDiff.tags(aws_tags, @tags)
+        end
+
+        aws_instances = (aws.instances || []).map { |i| i.instance_id }
+        if (@manage_instances != false) && @manage_instances.sort != aws_instances.sort
+          diffs << LoadBalancerDiff.instances(aws_instances, @manage_instances)
+        end
+
+        aws_health_check = aws.health_check
+        health_diffs = @health_check.diff(aws_health_check)
+        if !health_diffs.empty?
+          diffs << LoadBalancerDiff.health_check(health_diffs)
+        end
+
+        aws_backend_policies = aws.backend_server_descriptions
+        if @backend_policies.sort != aws_backend_policies.sort
+          diffs << LoadBalancerDiff.backend_policies(aws_backend_policies, @backend_policies)
+        end
+
+        aws_attributes = ELB::elb_attributes(@name)
+
+        aws_cross_zone = (aws_attributes.cross_zone_load_balancing.enabled) rescue false
+        if @cross_zone != aws_cross_zone
+          diffs << LoadBalancerDiff.new(LoadBalancerChange::CROSS, aws_cross_zone, @cross_zone)
+        end
+
+        aws_access_log = aws_attributes.access_log
+        if @access_log == false
+          if aws_access_log.enabled == true
+            log_diffs = (AccessLogConfig.new).diff(aws_access_log)
+            diffs << LoadBalancerDiff.access_log(log_diffs)
+          end
+        else
+          log_diffs = @access_log.diff(aws_access_log)
+          if !log_diffs.empty?
+            diffs << LoadBalancerDiff.access_log(log_diffs)
+          end
+        end
+
+        aws_connection_draining = if aws_attributes.connection_draining.enabled then aws_attributes.connection_draining.timeout else false end
+        if @connection_draining != aws_connection_draining
+          diffs << LoadBalancerDiff.new(LoadBalancerChange::DRAINING, aws_connection_draining, @connection_draining)
+        end
+
+        aws_idle_timeout = aws_attributes.connection_settings.idle_timeout
+        if @idle_timeout != aws_idle_timeout
+          diffs << LoadBalancerDiff.new(LoadBalancerChange::IDLE, aws_idle_timeout, @idle_timeout)
+        end
+
+        diffs.flatten
+      end
+
+    end
+  end
+end

data/lib/elb/models/LoadBalancerDiff.rb

@@ -0,0 +1,265 @@
+require "common/models/Diff"
+require "common/models/ListChange"
+require "elb/models/ListenerDiff"
+require "util/Colors"
+
+module Cumulus
+  module ELB
+    # Public: The types of changes that can be made to a load balancer
+    module LoadBalancerChange
+      include Common::DiffChange
+
+      LISTENERS = Common::DiffChange.next_change_id
+      SUBNETS = Common::DiffChange.next_change_id
+      SECURITY = Common::DiffChange.next_change_id
+      INTERNAL = Common::DiffChange.next_change_id
+      TAGS = Common::DiffChange.next_change_id
+      INSTANCES = Common::DiffChange.next_change_id
+      HEALTH = Common::DiffChange.next_change_id
+      BACKEND = Common::DiffChange.next_change_id
+      CROSS = Common::DiffChange.next_change_id
+      LOG = Common::DiffChange.next_change_id
+      DRAINING = Common::DiffChange.next_change_id
+      IDLE = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and
+    # an AWS Load Balancer.
+    class LoadBalancerDiff < Common::Diff
+      include LoadBalancerChange
+
+      attr_accessor :listeners
+      attr_accessor :subnets
+      attr_accessor :security_groups
+      attr_accessor :tags
+      attr_accessor :instances
+      attr_accessor :health_diffs
+      attr_accessor :backend_policies
+      attr_accessor :log_diffs
+
+      def self.listeners(aws, local)
+        # map listeners to load balancer port
+        aws_listeners = Hash[aws.map { |l| [l.listener.load_balancer_port, l] }]
+        local_listeners = Hash[local.map { |l| [l.load_balancer_port, l] }]
+
+        added_listeners = local_listeners.reject { |k, v| aws_listeners.has_key? k }
+        removed_listeners = aws_listeners.reject { |k, v| local_listeners.has_key? k }
+        modified_listeners = local_listeners.select { |k, v| aws_listeners.has_key? k }
+
+        added_diffs = Hash[added_listeners.map { |port, added| [port, ListenerDiff.added(added)] }]
+        removed_diffs = Hash[removed_listeners.map { |port, removed| [port, ListenerDiff.unmanaged(removed)] }]
+        modified_diffs = Hash[modified_listeners.map do |port, modified|
+          [port, modified.diff(aws_listeners[port])]
+        end].reject { |k, v| v.empty? }
+
+        if !added_diffs.empty? or !removed_diffs.empty? or !modified_diffs.empty?
+          diff = LoadBalancerDiff.new(LISTENERS, aws, local)
+          diff.listeners = Common::ListChange.new(added_diffs, removed_diffs, modified_diffs)
+          diff
+        end
+      end
+
+      def self.subnets(aws, local)
+        local_ids = local.map { |s| s.subnet_id }
+        aws_ids = aws.map { |s| s.subnet_id }
+
+        added = local.reject { |s| aws_ids.include? s.subnet_id }
+        removed = aws.reject { |s| local_ids.include? s.subnet_id }
+        diff = LoadBalancerDiff.new(SUBNETS, aws, local)
+        diff.subnets = Common::ListChange.new(added, removed)
+        diff
+      end
+
+      def self.security_groups(aws, local)
+        added = local - aws
+        removed = aws - local
+        diff = LoadBalancerDiff.new(SECURITY, aws, local)
+        diff.security_groups = Common::ListChange.new(added, removed)
+        diff
+      end
+
+      def self.internal(aws, local)
+        LoadBalancerDiff.new(INTERNAL, aws, local)
+      end
+
+      TagChange = Struct.new(:key, :aws, :local)
+      def self.tags(aws, local)
+        added = []
+        removed = []
+        modified = []
+
+        aws.each_pair do |key, val|
+          if local.has_key?(key)
+            if local[key] != val
+              modified << TagChange.new(key, val, local[key])
+            end
+          else
+            removed << TagChange.new(key, val, nil)
+          end
+        end
+
+        local.each_pair do |key, val|
+          if !aws.has_key?(key)
+            added << TagChange.new(key, nil, val)
+          end
+        end
+
+        diff = LoadBalancerDiff.new(TAGS, aws, local)
+        diff.tags = Common::ListChange.new(added, removed, modified)
+        diff
+      end
+
+      def self.instances(aws, local)
+        added = local - aws
+        removed = aws - local
+        diff = LoadBalancerDiff.new(INSTANCES, aws, local)
+        diff.instances = Common::ListChange.new(added, removed)
+        diff
+      end
+
+      def self.health_check(health_diffs)
+        diff = LoadBalancerDiff.new(HEALTH, nil, nil)
+        diff.health_diffs = health_diffs
+        diff
+      end
+
+      BackendChange = Struct.new(:port, :aws_policies, :local_policies)
+      def self.backend_policies(aws, local)
+        # map the aws and local policies to their ports
+        aws_backends = Hash[aws.map { |b| [b.instance_port, b.policy_names] }]
+        local_backends = Hash[local.map { |b| [b.instance_port, b.policy_names] }]
+
+        added = local_backends.reject { |port, _| aws_backends.has_key? port }.map do |port, policies|
+          BackendChange.new(port, nil, policies)
+        end
+        removed = aws_backends.reject { |port, _| local_backends.has_key? port }.map do |port, policies|
+          BackendChange.new(port, policies, nil)
+        end
+        modified = local_backends.reject { |port, _| !aws_backends.has_key? port }.map do |port, policies|
+          if aws_backends[port].sort != policies.sort
+            BackendChange.new(port, aws_backends[port], policies)
+          end
+        end.reject(&:nil?)
+
+        diff = LoadBalancerDiff.new(BACKEND, aws, local)
+        diff.backend_policies = Common::ListChange.new(added, removed, modified)
+        diff
+      end
+
+      def self.access_log(log_diffs)
+        diff = LoadBalancerDiff.new(LOG, nil, nil)
+        diff.log_diffs = log_diffs
+        diff
+      end
+
+      def asset_type
+        "Load Balancer"
+      end
+
+      def aws_name
+        @aws.load_balancer_name
+      end
+
+      def diff_string
+        case @type
+        when LISTENERS
+          [
+            "listeners:",
+            @listeners.removed.map { |_, diff| "\t#{diff}" },
+            @listeners.added.map { |_, diff| "\t#{diff}" },
+            @listeners.modified.map do |port, diffs|
+              [
+                "\tListener for port #{port}:",
+                diffs.map do |diff|
+                  diff.to_s.lines.map { |l| "\t\t#{l}".chomp("\n") }
+                end
+              ].join("\n")
+            end
+          ].flatten.join("\n")
+        when SUBNETS
+          [
+            "subnets:",
+            @subnets.removed.map { |s| Colors.removed("\t#{s.subnet_id} (#{s.name})") },
+            @subnets.added.map { |s| Colors.added("\t#{s.subnet_id} (#{s.name})") },
+          ].flatten.join("\n")
+        when SECURITY
+          [
+            "security groups:",
+            @security_groups.removed.map { |s| Colors.removed("\t#{s}") },
+            @security_groups.added.map { |s| Colors.added("\t#{s}") },
+          ].flatten.join("\n")
+        when INTERNAL
+          [
+            "internal:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when TAGS
+          [
+            "tags:",
+            @tags.removed.map { |t| Colors.removed("\t#{t.key}: #{t.aws}") },
+            @tags.added.map { |t| Colors.added("\t#{t.key}: #{t.local}") },
+            @tags.modified.map do |t|
+              [
+                "\t#{t.key}:",
+                Colors.aws_changes("(AWS) #{t.aws}"),
+                Colors.local_changes("(Local) #{t.local}")
+              ].join(" ")
+            end
+          ].flatten.join("\n")
+        when INSTANCES
+          [
+            "managed instances:",
+            @instances.removed.map { |i| Colors.removed("\t#{i}") },
+            @instances.added.map { |i| Colors.added("\t#{i}") },
+          ].flatten.join("\n")
+        when HEALTH
+          [
+            "health check:",
+            @health_diffs.map do |d|
+              d.to_s.lines.map { |l| "\t#{l}".chomp("\n") }
+            end
+          ].join("\n")
+        when BACKEND
+          [
+            "backend policies:",
+            @backend_policies.removed.map { |bc| Colors.removed("\tinstance port #{bc.port}: #{bc.aws_policies.join(" ")}") },
+            @backend_policies.added.map { |bc| Colors.added("\tinstance port #{bc.port}: #{bc.local_policies.join(" ")}") },
+            @backend_policies.modified.map do |bc|
+              [
+                "\tinstance port #{bc.port}:",
+                (bc.aws_policies - bc.local_policies).map { |p| Colors.removed("#{p}") },
+                (bc.local_policies - bc.aws_policies).map { |p| Colors.added("#{p}") },
+              ].flatten.join(" ")
+            end
+          ].flatten.join("\n")
+        when CROSS
+          [
+            "cross zone load balancing:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].flatten.join("\n")
+        when LOG
+          [
+            "access log:",
+            @log_diffs.map do |d|
+              d.to_s.lines.map { |l| "\t#{l}".chomp("\n") }
+            end
+          ].join("\n")
+        when DRAINING
+          [
+            "connection draining:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when IDLE
+          [
+            "idle timeout:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        end
+      end
+    end
+  end
+end