cumulus-aws 0.11.1

data/lib/elb/models/AccessLogConfig.rb

@@ -0,0 +1,82 @@
+require "elb/models/AccessLogDiff"
+
+module Cumulus
+  module ELB
+    # Public: An object representing configuration for a load balancer
+    class AccessLogConfig
+      attr_reader :enabled
+      attr_reader :s3_bucket
+      attr_reader :emit_interval
+      attr_reader :bucket_prefix
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the load balancer
+      def initialize(json = nil)
+        @enabled = !json.nil?
+        if !json.nil?
+          @s3_bucket = json["s3-bucket"]
+          @emit_interval = json["emit-interval"]
+          @bucket_prefix = json["bucket-prefix"]
+        end
+      end
+
+      def to_hash
+        if @enabled
+          {
+            "s3-bucket" => @s3_bucket,
+            "emit-interval" => @emit_interval,
+            "bucket-prefix" => @bucket_prefix,
+          }.reject { |k, v| v.nil? }
+        else
+          false
+        end
+      end
+
+      def to_aws
+        {
+          enabled: @enabled,
+          s3_bucket_name: @s3_bucket,
+          emit_interval: @emit_interval,
+          s3_bucket_prefix: @bucket_prefix,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def populate!(aws)
+        @enabled = aws.enabled
+        @s3_bucket = aws.s3_bucket_name
+        @emit_interval = aws.emit_interval
+        @bucket_prefix = aws.s3_bucket_prefix
+      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 HealthCheckDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @enabled != aws.enabled
+          diffs << AccessLogDiff.new(AccessLogChange::ENABLED, aws.enabled, @enabled)
+        end
+
+        if @s3_bucket != aws.s3_bucket_name
+          diffs << AccessLogDiff.new(AccessLogChange::BUCKET, aws.s3_bucket_name, @s3_bucket)
+        end
+
+        if @emit_interval != aws.emit_interval
+          diffs << AccessLogDiff.new(AccessLogChange::EMIT, aws.emit_interval, @emit_interval)
+        end
+
+        if @bucket_prefix != aws.s3_bucket_prefix
+          diffs << AccessLogDiff.new(AccessLogChange::PREFIX, aws.s3_bucket_prefix, @bucket_prefix)
+        end
+
+        diffs.flatten
+      end
+
+    end
+  end
+end

data/lib/elb/models/AccessLogDiff.rb

@@ -0,0 +1,47 @@
+require "common/models/Diff"
+require "util/Colors"
+
+module Cumulus
+  module ELB
+    # Public: The types of changes that can be made to an access log config
+    module AccessLogChange
+      include Common::DiffChange
+
+      ENABLED = Common::DiffChange.next_change_id
+      BUCKET = Common::DiffChange.next_change_id
+      EMIT = Common::DiffChange.next_change_id
+      PREFIX = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and
+    # an AWS Load Balancer Access Log.
+    class AccessLogDiff < Common::Diff
+      include AccessLogChange
+
+      def asset_type
+        "Access Log Config"
+      end
+
+      def change_string
+        case @type
+        when ENABLED
+          "enabled:"
+        when BUCKET
+          "S3 bucket:"
+        when EMIT
+          "emit interval:"
+        when PREFIX
+          "bucket prefix:"
+        end
+      end
+
+      def diff_string
+        [
+          change_string,
+          Colors.aws_changes("\tAWS - #{aws}"),
+          Colors.local_changes("\tLocal - #{local}"),
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/elb/models/HealthCheckConfig.rb

@@ -0,0 +1,91 @@
+require "elb/models/HealthCheckDiff"
+
+require "json"
+
+module Cumulus
+  module ELB
+    # Public: An object representing configuration for a load balancer
+    class HealthCheckConfig
+      attr_reader :target
+      attr_reader :interval
+      attr_reader :timeout
+      attr_reader :healthy
+      attr_reader :unhealthy
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the load balancer
+      def initialize(json = nil)
+        if !json.nil?
+          @target = json["target"]
+          @interval = json["interval"]
+          @timeout = json["timeout"]
+          @healthy = json["healthy"]
+          @unhealthy = json["unhealthy"]
+        end
+      end
+
+      def to_hash
+        {
+          "target" => @target,
+          "interval" => @interval,
+          "timeout" => @timeout,
+          "healthy" => @healthy,
+          "unhealthy" => @unhealthy,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def to_aws
+        {
+          target: @target,
+          interval: @interval,
+          timeout: @timeout,
+          healthy_threshold: @healthy,
+          unhealthy_threshold: @unhealthy,
+        }
+      end
+
+      def populate!(aws)
+        @target = aws.target
+        @interval = aws.interval
+        @timeout = aws.timeout
+        @healthy = aws.healthy_threshold
+        @unhealthy = aws.unhealthy_threshold
+      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 HealthCheckDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @target != aws.target
+          diffs << HealthCheckDiff.new(HealthCheckChange::TARGET, aws.target, @target)
+        end
+
+        if @interval != aws.interval
+          diffs << HealthCheckDiff.new(HealthCheckChange::INTERVAL, aws.interval, @interval)
+        end
+
+        if @timeout != aws.timeout
+          diffs << HealthCheckDiff.new(HealthCheckChange::TIMEOUT, aws.timeout, @timeout)
+        end
+
+        if @healthy != aws.healthy_threshold
+          diffs << HealthCheckDiff.new(HealthCheckChange::HEALTHY, aws.healthy_threshold, @healthy)
+        end
+
+        if @unhealthy != aws.unhealthy_threshold
+          diffs << HealthCheckDiff.new(HealthCheckChange::UNHEALTHY, aws.unhealthy_threshold, @unhealthy)
+        end
+
+        diffs
+      end
+
+
+    end
+  end
+end

data/lib/elb/models/HealthCheckDiff.rb

@@ -0,0 +1,50 @@
+require "common/models/Diff"
+require "util/Colors"
+
+module Cumulus
+  module ELB
+    # Public: The types of changes that can be made to an access log config
+    module HealthCheckChange
+      include Common::DiffChange
+
+      TARGET = Common::DiffChange.next_change_id
+      INTERVAL = Common::DiffChange.next_change_id
+      TIMEOUT = Common::DiffChange.next_change_id
+      HEALTHY = Common::DiffChange.next_change_id
+      UNHEALTHY = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and
+    # an AWS Load Balancer Health Check
+    class HealthCheckDiff < Common::Diff
+      include HealthCheckChange
+
+      def asset_type
+        "Health Check Config"
+      end
+
+      def change_string
+        case @type
+        when TARGET
+          "target:"
+        when INTERVAL
+          "interval:"
+        when TIMEOUT
+          "timeout:"
+        when HEALTHY
+          "healthy threshold:"
+        when UNHEALTHY
+          "unhealthy threshold:"
+        end
+      end
+
+      def diff_string
+        [
+          change_string,
+          Colors.aws_changes("\tAWS - #{aws}"),
+          Colors.local_changes("\tLocal - #{local}"),
+        ].join("\n")
+      end
+    end
+  end
+end

data/lib/elb/models/ListenerConfig.rb

@@ -0,0 +1,99 @@
+require "elb/models/ListenerDiff"
+
+require "json"
+
+module Cumulus
+  module ELB
+    # Public: An object representing configuration for a listener
+    class ListenerConfig
+      attr_reader :load_balancer_protocol
+      attr_reader :load_balancer_port
+      attr_reader :instance_protocol
+      attr_reader :instance_port
+      attr_reader :ssl_certificate_id
+      attr_reader :policies
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the listener
+      def initialize(json = nil)
+        if !json.nil?
+          @load_balancer_protocol = json["load-balancer-protocol"]
+          @load_balancer_port = json["load-balancer-port"]
+          @instance_protocol = json["instance-protocol"]
+          @instance_port = json["instance-port"]
+          @ssl_certificate_id = json["ssl-certificate-id"]
+          @policies = json["policies"] || []
+        end
+      end
+
+      def to_hash
+        {
+          "load-balancer-protocol" => @load_balancer_protocol,
+          "load-balancer-port" => @load_balancer_port,
+          "instance-protocol" => @instance_protocol,
+          "instance-port" => @instance_port,
+          "ssl-certificate-id" => @ssl_certificate_id,
+          "policies" => @policies,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def to_aws
+        {
+          protocol: @load_balancer_protocol,
+          load_balancer_port: @load_balancer_port,
+          instance_protocol: @instance_protocol,
+          instance_port: @instance_port,
+          ssl_certificate_id: @ssl_certificate_id,
+        }.reject { |k, v| v.nil? }
+      end
+
+      def populate!(aws)
+        @load_balancer_protocol = aws.listener.protocol
+        @load_balancer_port = aws.listener.load_balancer_port
+        @instance_protocol = aws.listener.instance_protocol
+        @instance_port = aws.listener.instance_port
+        @ssl_certificate_id = aws.listener.ssl_certificate_id
+        @policies = aws.policy_names
+      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 ListenerDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @load_balancer_protocol != aws.listener.protocol
+          diffs << ListenerDiff.new(ListenerChange::LB_PROTOCOL, aws.listener.protocol, @load_balancer_protocol)
+        end
+
+        if @load_balancer_port != aws.listener.load_balancer_port
+          diffs << ListenerDiff.new(ListenerChange::LB_PORT, aws.listener.load_balancer_port, @load_balancer_port)
+        end
+
+        if @instance_protocol != aws.listener.instance_protocol
+          diffs << ListenerDiff.new(ListenerChange::INST_PROTOCOL, aws.listener.instance_protocol, @instance_protocol)
+        end
+
+        if @instance_port != aws.listener.instance_port
+          diffs << ListenerDiff.new(ListenerChange::INST_PORT, aws.listener.instance_port, @instance_port)
+        end
+
+        if @ssl_certificate_id != aws.listener.ssl_certificate_id
+          diffs << ListenerDiff.new(ListenerChange::SSL, aws.listener.ssl_certificate_id, @ssl_certificate_id)
+        end
+
+        if @policies.sort != aws.policy_names.sort
+          diffs << ListenerDiff.policies(aws.policy_names, @policies)
+        end
+
+        diffs
+      end
+
+
+    end
+  end
+end

data/lib/elb/models/ListenerDiff.rb

@@ -0,0 +1,91 @@
+require "common/models/Diff"
+require "util/Colors"
+
+module Cumulus
+  module ELB
+    # Public: The types of changes that can be made to an access log config
+    module ListenerChange
+      include Common::DiffChange
+
+      LB_PROTOCOL = Common::DiffChange.next_change_id
+      LB_PORT = Common::DiffChange.next_change_id
+      INST_PROTOCOL = Common::DiffChange.next_change_id
+      INST_PORT = Common::DiffChange.next_change_id
+      SSL = Common::DiffChange.next_change_id
+      POLICIES = Common::DiffChange.next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and
+    # an AWS Load Balancer Listener
+    class ListenerDiff < Common::Diff
+      include ListenerChange
+
+      attr_accessor :policies
+
+      def asset_type
+        "Listener for port"
+      end
+
+      def aws_name
+        "#{aws.listener.load_balancer_port}"
+      end
+
+      def local_name
+        "#{local.load_balancer_port}"
+      end
+
+      def unmanaged_string
+        "will be deleted."
+      end
+
+      def self.policies(aws, local)
+        added = local - aws
+        removed = aws - local
+        diff = ListenerDiff.new(POLICIES, aws, local)
+        diff.policies = Common::ListChange.new(added, removed)
+        diff
+      end
+
+      def diff_string
+        case @type
+        when LB_PROTOCOL
+          [
+            "load balancer protocol:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when LB_PORT
+          [
+            "load balancer port:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when INST_PROTOCOL
+          [
+            "instance protocol:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when INST_PORT
+          [
+            "instance port:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when SSL
+          [
+            "ssl certificate id:",
+            Colors.aws_changes("\tAWS - #{aws}"),
+            Colors.local_changes("\tLocal - #{local}"),
+          ].join("\n")
+        when POLICIES
+          [
+            "policies:",
+            @policies.removed.map { |p| Colors.removed("\t#{p}") },
+            @policies.added.map { |p| Colors.added("\t#{p}") },
+          ].flatten.join("\n")
+        end
+      end
+    end
+  end
+end