cumulus-aws 0.11.1

data/lib/cloudfront/models/CacheBehaviorDiff.rb

@@ -0,0 +1,211 @@
+require "common/models/Diff"
+require "common/models/ListChange"
+require "util/Colors"
+
+module Cumulus
+  module CloudFront
+
+    # Public: The types of changes that can be made to cache behaviors
+    module CacheBehaviorChange
+      include Common::DiffChange
+
+      PATH = Common::DiffChange::next_change_id
+      TARGET = Common::DiffChange::next_change_id
+      QUERY = Common::DiffChange::next_change_id
+      COOKIES = Common::DiffChange::next_change_id
+      COOKIES_WHITELIST = Common::DiffChange::next_change_id
+      HEADERS = Common::DiffChange::next_change_id
+      SIGNERS = Common::DiffChange::next_change_id
+      VIEWER_PROTOCOL = Common::DiffChange::next_change_id
+      MINTTL = Common::DiffChange::next_change_id
+      MAXTTL = Common::DiffChange::next_change_id
+      DEFTTL = Common::DiffChange::next_change_id
+      STREAMING = Common::DiffChange::next_change_id
+      METHODS_ALLOWED = Common::DiffChange::next_change_id
+      METHODS_CACHED = Common::DiffChange::next_change_id
+      COMPRESS = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration of zones.
+    class CacheBehaviorDiff < Common::Diff
+      include CacheBehaviorChange
+
+      attr_accessor :cookies
+      attr_accessor :headers
+      attr_accessor :signers
+      attr_accessor :allowed_methods
+      attr_accessor :cached_methods
+
+      # Public: Static method that produces a diff representing changes in CacheBehavior cookies whitelist
+      #
+      # added_cookies   - the cookies that were added
+      # removed_cookies - the cookies that were removed
+      # local           - the local configuration for the zone
+      #
+      # Returns the diff
+      def self.cookies_whitelist(added_cookies, removed_cookies, local)
+        diff = CacheBehaviorDiff.new(COOKIES_WHITELIST, nil, local)
+        diff.cookies = Common::ListChange.new(added_cookies, removed_cookies)
+        diff
+      end
+
+      # Public: Static method that produces a diff representing changes in CacheBehavior headers
+      #
+      # added_headers   - the headers that were added
+      # removed_headers - the headers that were removed
+      # local           - the local configuration for the zone
+      #
+      # Returns the diff
+      def self.headers(added_headers, removed_headers, local)
+        diff = CacheBehaviorDiff.new(HEADERS, nil, local)
+        diff.headers = Common::ListChange.new(added_headers, removed_headers)
+        diff
+      end
+
+      # Public: Static method that produces a diff representing changes in CacheBehavior trusted signers
+      #
+      # added_signers   - the trusted signers that were added
+      # removed_signers - the trusted signers that were removed
+      # local           - the local configuration for the zone
+      #
+      # Returns the diff
+      def self.signers(added_signers, removed_signers, local)
+        diff = CacheBehaviorDiff.new(SIGNERS, nil, local)
+        diff.signers = Common::ListChange.new(added_signers, removed_signers)
+        diff
+      end
+
+      # Public: Static method that produces a diff representing changes in CacheBehavior allowed methods
+      #
+      # added_allowed_methods   - the allowed methods that were added
+      # removed_allowed_methods - the allowed methods that were removed
+      # local                   - the local configuration for the zone
+      #
+      # Returns the diff
+      def self.allowed_methods(added_allowed_methods, removed_allowed_methods, local)
+        diff = CacheBehaviorDiff.new(METHODS_ALLOWED, nil, local)
+        diff.allowed_methods = Common::ListChange.new(added_allowed_methods, removed_allowed_methods)
+        diff
+      end
+
+      # Public: Static method that produces a diff representing changes in CacheBehavior cached methods
+      #
+      # added_cached_methods   - the cached methods that were added
+      # removed_cached_methods - the cached methods that were removed
+      # local                   - the local configuration for the zone
+      #
+      # Returns the diff
+      def self.cached_methods(added_cached_methods, removed_cached_methods, local)
+        diff = CacheBehaviorDiff.new(METHODS_CACHED, nil, local)
+        diff.cached_methods = Common::ListChange.new(added_cached_methods, removed_cached_methods)
+        diff
+      end
+
+      def diff_string
+        case @type
+        when PATH
+          [
+            "path:",
+            Colors.aws_changes("\tAWS - #{@aws.path_pattern}"),
+            Colors.local_changes("\tLocal - #{@local.path_pattern}"),
+          ].join("\n")
+        when TARGET
+          [
+            "target origin id:",
+            Colors.aws_changes("\tAWS - #{@aws.target_origin_id}"),
+            Colors.local_changes("\tLocal - #{@local.target_origin_id}"),
+          ].join("\n")
+        when QUERY
+          [
+            "forward query strings:",
+            Colors.aws_changes("\tAWS - #{@aws.forwarded_values.query_string}"),
+            Colors.local_changes("\tLocal - #{@local.forward_query_strings}"),
+          ].join("\n")
+        when COOKIES
+          [
+            "forwarded cookies:",
+            Colors.aws_changes("\tAWS - #{@aws.forwarded_values.cookies.forward}"),
+            Colors.local_changes("\tLocal - #{@local.forwarded_cookies}"),
+          ].join("\n")
+        when COOKIES_WHITELIST
+          [
+            "whitelisted forwarded cookies:",
+            cookies.removed.map{ |removed| Colors.removed("\t#{removed}")},
+            cookies.added.map{ |added| Colors.added("\t#{added}")},
+          ].flatten.join("\n")
+        when HEADERS
+          [
+            "forwarded headers:",
+            headers.removed.map{ |removed| Colors.removed("\t#{removed}")},
+            headers.added.map{ |added| Colors.added("\t#{added}")},
+          ].flatten.join("\n")
+        when SIGNERS
+          [
+            "trusted signers:",
+            signers.removed.map{ |removed| Colors.removed("\t#{removed}")},
+            signers.added.map{ |added| Colors.added("\t#{added}")},
+          ].flatten.join("\n")
+        when VIEWER_PROTOCOL
+          [
+            "viewer protocol policy:",
+            Colors.aws_changes("\tAWS - #{@aws.viewer_protocol_policy}"),
+            Colors.local_changes("\tLocal - #{@local.viewer_protocol_policy}"),
+          ].join("\n")
+        when MINTTL
+          [
+            "min ttl:",
+            Colors.aws_changes("\tAWS - #{@aws.min_ttl}"),
+            Colors.local_changes("\tLocal - #{@local.min_ttl}"),
+          ].join("\n")
+        when MAXTTL
+          [
+            "max ttl:",
+            Colors.aws_changes("\tAWS - #{@aws.max_ttl}"),
+            Colors.local_changes("\tLocal - #{@local.max_ttl}"),
+          ].join("\n")
+        when DEFTTL
+          [
+            "default ttl:",
+            Colors.aws_changes("\tAWS - #{@aws.default_ttl}"),
+            Colors.local_changes("\tLocal - #{@local.default_ttl}"),
+          ].join("\n")
+        when STREAMING
+          [
+            "smooth streaming:",
+            Colors.aws_changes("\tAWS - #{@aws.smooth_streaming}"),
+            Colors.local_changes("\tLocal - #{@local.smooth_streaming}"),
+          ].join("\n")
+        when METHODS_ALLOWED
+          [
+            "allowed methods:",
+            allowed_methods.removed.map{ |removed| Colors.removed("\t#{removed}")},
+            allowed_methods.added.map{ |added| Colors.added("\t#{added}")},
+          ].flatten.join("\n")
+        when METHODS_CACHED
+          [
+            "cached methods:",
+            cached_methods.removed.map{ |removed| Colors.removed("\t#{removed}")},
+            cached_methods.added.map{ |added| Colors.added("\t#{added}")},
+          ].flatten.join("\n")
+        when COMPRESS
+          [
+            "compress:",
+            Colors.aws_changes("\tAWS - #{@aws.compress}"),
+            Colors.local_changes("\tLocal - #{@local.compress}"),
+          ].join("\n")
+        end
+      end
+
+      def asset_type
+        "Cache Behavior"
+      end
+
+      def aws_name
+        "#{@aws.target_origin_id}/#{@aws.path_pattern}"
+      end
+
+    end
+
+  end
+end

data/lib/cloudfront/models/CustomOriginConfig.rb

@@ -0,0 +1,51 @@
+require "cloudfront/models/CustomOriginDiff"
+
+module Cumulus
+  module CloudFront
+    CustomOriginConfig = Struct.new(:http_port, :https_port, :protocol_policy, :origin_ssl_protocols) do
+
+      def diff(aws)
+        diffs = []
+
+        aws_http_port = aws && aws.http_port
+        if self.http_port != aws_http_port
+          diffs << CustomOriginDiff.new(CustomOriginChange::HTTP, aws_http_port, self.http_port)
+        end
+
+        aws_https_port = aws && aws.https_port
+        if self.https_port != aws_https_port
+          diffs << CustomOriginDiff.new(CustomOriginChange::HTTPS, aws_https_port, self.https_port)
+        end
+
+        aws_protocol = aws && aws.origin_protocol_policy
+        if self.protocol_policy != aws_protocol
+          diffs << CustomOriginDiff.new(CustomOriginChange::POLICY, aws_protocol, self.protocol_policy)
+        end
+
+        if self.origin_ssl_protocols
+          ssl_protocol_diffs = self.origin_ssl_protocols.diff(aws.origin_ssl_protocols)
+        else
+          if aws.origin_ssl_protocols && aws.origin_protocol_policy != "http-only"
+            ssl_protocol_diffs = OriginSslProtocols.new([]).diff(aws.origin_ssl_protocols)
+          end
+        end
+        if ssl_protocol_diffs && ssl_protocol_diffs.length > 0
+          diffs << CustomOriginDiff.ssl_protocols(ssl_protocol_diffs, aws, self)
+        end
+
+        diffs
+      end
+
+      def to_local
+        {
+          "http-port" => self.http_port,
+          "https-port" => self.https_port,
+          "protocol-policy" => self.protocol_policy,
+          "origin-ssl-protocols" => if self.origin_ssl_protocols
+            self.origin_ssl_protocols.to_local
+          end
+        }.reject { |k, v| v.nil? }
+      end
+    end
+  end
+end

data/lib/cloudfront/models/CustomOriginDiff.rb

@@ -0,0 +1,74 @@
+require "common/models/Diff"
+require "util/Colors"
+
+module Cumulus
+  module CloudFront
+
+  	# Public: The types of changes that can be made to zones
+    module CustomOriginChange
+      include Common::DiffChange
+
+      HTTP = Common::DiffChange::next_change_id
+      HTTPS = Common::DiffChange::next_change_id
+      POLICY = Common::DiffChange::next_change_id
+      SSL_PROTOCOLS = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration of zones.
+    class CustomOriginDiff < Common::Diff
+      include CustomOriginChange
+
+      attr_accessor :ssl_protocol_changes
+
+      # Public: Static method that produces a diff representing changes in ssl protocols
+      #
+      # changes - the OriginSslProtocolsDiffs
+      # aws     - the aws configuration for the custom origin
+      # local   - the local configuration for the custom origin
+      #
+      # Returns the diff containing those changes
+      def self.ssl_protocols(changes, aws, local)
+        diff = CustomOriginDiff.new(SSL_PROTOCOLS, aws, local)
+        diff.ssl_protocol_changes = changes
+        diff
+      end
+
+      def diff_string
+        case @type
+        when HTTP
+          [
+            "http port:",
+            Colors.aws_changes("\tAWS - #{@aws}"),
+            Colors.local_changes("\tLocal - #{@local}"),
+          ].join("\n")
+        when HTTPS
+          [
+            "https port:",
+            Colors.aws_changes("\tAWS - #{@aws}"),
+            Colors.local_changes("\tLocal - #{@local}"),
+          ].join("\n")
+        when POLICY
+          [
+            "protocol policy:",
+            Colors.aws_changes("\tAWS - #{@aws}"),
+            Colors.local_changes("\tLocal - #{@local}"),
+          ].join("\n")
+        when SSL_PROTOCOLS
+          [
+            "origin ssl protocols:",
+            (@ssl_protocol_changes.flat_map do |c|
+              c.to_s.lines.map { |l| "\t#{l.chomp}" }
+            end).join("\n"),
+          ].join("\n")
+        end
+      end
+
+      def aws_name
+        @aws.id
+      end
+
+    end
+
+  end
+end

data/lib/cloudfront/models/DistributionConfig.rb

@@ -0,0 +1,183 @@
+require "conf/Configuration"
+require "cloudfront/models/DistributionDiff"
+require "cloudfront/models/OriginConfig"
+require "cloudfront/models/CacheBehaviorConfig"
+
+require "json"
+
+module Cumulus
+  module CloudFront
+    # Public: An object representing configuration for a distribution
+    class DistributionConfig
+      attr_accessor :id
+      attr_reader :name
+      attr_reader :aliases
+      attr_reader :origins
+      attr_reader :default_cache_behavior
+      attr_reader :cache_behaviors
+      attr_reader :comment
+      attr_reader :enabled
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the distribution
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+          @id = json["id"]
+          @aliases = json["aliases"] || []
+          @origins = json["origins"].map { |o| OriginConfig.new(o) }
+          @default_cache_behavior = CacheBehaviorConfig.new(json["default-cache-behavior"], true)
+          @cache_behaviors = (json["cache-behaviors"] || []).map { |cb| CacheBehaviorConfig.new(cb) }
+          @comment = json["comment"]
+          @enabled = json["enabled"]
+        end
+      end
+
+      def populate!(id, aws)
+        @id = id
+        @name = id
+        @aliases = aws.aliases.items
+        @origins = aws.origins.items.map do |origin|
+          config = OriginConfig.new()
+          config.populate!(origin)
+          config
+        end
+        @default_cache_behavior = CacheBehaviorConfig.new()
+        @default_cache_behavior.populate!(aws.default_cache_behavior, true)
+        @cache_behaviors = aws.cache_behaviors.items.map do |cache_behavior|
+          config = CacheBehaviorConfig.new()
+          config.populate!(cache_behavior)
+          config
+        end
+        @comment = aws.comment
+        @enabled = aws.enabled
+      end
+
+      # Public: Get the config as a prettified JSON string.
+      #
+      # Returns the JSON string
+      def pretty_json
+        JSON.pretty_generate({
+          "id" => @id,
+          "aliases" => @aliases,
+          "origins" => @origins.map(&:to_local),
+          "default-cache-behavior" => @default_cache_behavior.to_local,
+          "cache-behaviors" => @cache_behaviors.map(&:to_local),
+          "comment" => @comment,
+          "enabled" => @enabled,
+        })
+      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 DistributionDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        added_aliases = (@aliases - aws.aliases.items)
+        removed_aliases = aws.aliases.items - @aliases
+        if !added_aliases.empty? or !removed_aliases.empty?
+          diffs << DistributionDiff.aliases(added_aliases, removed_aliases, self)
+        end
+
+        origin_diffs = diff_origins(aws.origins.items)
+        if !origin_diffs.empty?
+          diffs << DistributionDiff.origins(origin_diffs, self)
+        end
+
+        default_cache_diffs = @default_cache_behavior.diff(aws.default_cache_behavior)
+        if !default_cache_diffs.empty?
+          diffs << DistributionDiff.default_cache(default_cache_diffs, self)
+        end
+
+        diffs << diff_caches(aws)
+
+        if @comment != aws.comment
+          diffs << DistributionDiff.new(DistributionChange::COMMENT, aws, self)
+        end
+
+        if @enabled != aws.enabled
+          diffs << DistributionDiff.new(DistributionChange::ENABLED, aws, self)
+        end
+
+        diffs.flatten
+      end
+
+      private
+
+      # Internal: Produce an array of differences between the local origins and the aws origins
+      #
+      # aws_origins - the AWS origins from a cloudfront config
+      #
+      # Returns an array of OriginDiffs that were found
+      def diff_origins(aws_origins)
+        diffs = []
+
+        # map the origins to their keys
+        aws = Hash[aws_origins.map { |o| [o.id, o] }]
+        local = Hash[@origins.map { |o| [o.id, o] }]
+
+        # find origins that are not configured locally
+        aws.each do |origin_id, origin|
+          if !local.include?(origin_id)
+            diffs << OriginDiff.unmanaged(origin)
+          end
+        end
+
+        local.each do |origin_id, origin|
+          if !aws.include?(origin_id)
+            diffs << OriginDiff.added(origin)
+          else
+            diffs << origin.diff(aws[origin_id])
+          end
+        end
+
+        diffs.flatten
+      end
+
+      # Internal: Produce an array of differences between local cache behaviors and aws cache behaviors
+      #
+      # aws - the AWS config
+      #
+      # Returns an array of CacheBehaviorDiff
+      def diff_caches(aws)
+        removed = []
+        added = []
+        changed = Hash.new
+
+        aws_cache_behaviors = if aws.cache_behaviors.nil? then [] else aws.cache_behaviors.items end
+
+        aws = Hash[aws_cache_behaviors.map { |c| ["#{c.target_origin_id}/#{c.path_pattern}", c]}]
+        local = Hash[@cache_behaviors.map { |c| ["#{c.target_origin_id}/#{c.path_pattern}", c]}]
+
+        # find cache behaviors that are not configured locally
+        aws.each do |cache_id, cache|
+          if !local.include?(cache_id)
+            removed << CacheBehaviorDiff.unmanaged(cache)
+          end
+        end
+
+        local.each do |cache_id, cache|
+          if !aws.include?(cache_id)
+            added << CacheBehaviorDiff.added(cache)
+          else
+            diffs = cache.diff(aws[cache_id])
+            changed[cache_id] = diffs if !diffs.empty?
+          end
+        end
+
+        if !removed.empty? or !added.empty? or !changed.empty?
+          DistributionDiff.caches(removed, added, changed, self)
+        else
+          []
+        end
+
+      end
+
+    end
+  end
+end