cumulus-aws 0.11.1

data/lib/cloudfront/models/DistributionDiff.rb

@@ -0,0 +1,131 @@
+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 zones
+    module DistributionChange
+      include Common::DiffChange
+
+      ALIASES = Common::DiffChange::next_change_id
+      ORIGINS = Common::DiffChange::next_change_id
+      CACHE_DEFAULT = Common::DiffChange::next_change_id
+      CACHES = Common::DiffChange::next_change_id
+      COMMENT = Common::DiffChange::next_change_id
+      ENABLED = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration of zones.
+    class DistributionDiff < Common::Diff
+      include DistributionChange
+
+      attr_accessor :changed_origins
+      attr_accessor :added_aliases
+      attr_accessor :removed_aliases
+      attr_accessor :default_cache
+      attr_accessor :cache
+
+      # Public: Static method that produces a diff representing changes in origins
+      #
+      # changes - the OriginDiffs
+      # local   - the local configuration for the distribution
+      #
+      # Returns the diff
+      def self.origins(changes, local)
+        diff = DistributionDiff.new(ORIGINS, nil, local)
+        diff.changed_origins = changes
+        diff
+      end
+
+      def self.aliases(added, removed, local)
+        diff = DistributionDiff.new(ALIASES, nil, local)
+        diff.added_aliases = added
+        diff.removed_aliases = removed
+        diff
+      end
+
+      def self.default_cache(diffs, local)
+        diff = DistributionDiff.new(CACHE_DEFAULT, nil, local)
+        diff.default_cache = diffs
+        diff
+      end
+
+      def self.caches(removed, added, diffs, local)
+        diff = DistributionDiff.new(CACHES, nil, local)
+        diff.cache = Common::ListChange.new(removed, added, diffs)
+        diff
+      end
+
+      def diff_string
+        case @type
+        when ALIASES
+          [
+            "aliases:",
+            @removed_aliases.map { |removed| Colors.removed("\t#{removed}") },
+            @added_aliases.map { |added| Colors.added("\t#{added}") },
+          ].flatten.join("\n")
+        when ORIGINS
+          [
+            "origins:",
+            @changed_origins.map do |o|
+              if o.type == ADD or o.type == UNMANAGED
+                o.to_s.lines.map { |l| "\t#{l}".chomp("\n")}
+              else
+                [
+                  "\t#{o.local_name}",
+                  o.to_s.lines.map { |l| "\t\t#{l}".chomp("\n")}
+                ].join("\n")
+              end
+            end
+          ].flatten.join("\n")
+        when CACHE_DEFAULT
+          [
+            "default cache behavior:",
+            (@default_cache.map do |c|
+              c.to_s.lines.map { |l| "\t#{l}".chomp("\n")}
+            end).join("\n"),
+          ].join("\n")
+        when CACHES
+          [
+            "cache behaviors:",
+            @cache.removed.map { |removed| Colors.removed("\t#{removed}") },
+            @cache.added.map { |added| Colors.added("\t#{added}") },
+            @cache.modified.map do |cache_name, cdiffs|
+              [
+                "\t#{cache_name}",
+                cdiffs.map do |cdiff|
+                  cdiff.to_s.lines.map { |l| "\t\t#{l.chomp}"}
+                end
+              ]
+            end
+          ].flatten.join("\n")
+        when COMMENT
+          [
+            "comment:",
+            Colors.aws_changes("\tAWS - #{@aws.comment}"),
+            Colors.local_changes("\tLocal - #{@local.comment}"),
+          ].join("\n")
+        when ENABLED
+          [
+            "enabled:",
+            Colors.aws_changes("\tAWS - #{@aws.enabled}"),
+            Colors.local_changes("\tLocal - #{@local.enabled}"),
+          ].join("\n")
+        end
+      end
+
+      def asset_type
+        "Cloudfront Distribution"
+      end
+
+      def aws_name
+        @aws.id
+      end
+
+    end
+
+  end
+end

data/lib/cloudfront/models/InvalidationConfig.rb

@@ -0,0 +1,37 @@
+require "json"
+
+module Cumulus
+  module CloudFront
+    # Public: An object representing configuration for a CloudFront invalidation
+    class InvalidationConfig
+      attr_reader :distribution_id
+      attr_reader :paths
+      attr_reader :name
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the invalidation
+      def initialize(name, json = nil)
+        if json
+          @name = name
+
+          begin
+            @distribution_id = json.fetch("distribution-id")
+          rescue KeyError
+            puts "Must supply 'distribution-id' in invalidation config"
+            exit
+          end
+
+          begin
+            @paths = json.fetch("paths")
+          rescue KeyError
+            puts "Must supply 'paths' in invalidation config"
+            exit
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/cloudfront/models/OriginConfig.rb

@@ -0,0 +1,144 @@
+require "conf/Configuration"
+require "cloudfront/models/CustomOriginConfig"
+require "cloudfront/models/OriginDiff"
+require "cloudfront/models/OriginSslProtocols"
+
+require "json"
+
+module Cumulus
+  module CloudFront
+    # Public: An object representing configuration for a origin
+    class OriginConfig
+      attr_reader :name
+      attr_reader :id
+      attr_reader :domain_name
+      attr_reader :origin_path
+      attr_reader :s3_access_origin_identity
+      attr_reader :custom_origin_config
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the origin
+      def initialize(json = nil)
+        if !json.nil?
+          @id = json["id"]
+          @domain_name = json["domain-name"]
+          @origin_path = json["origin-path"]
+          @s3_access_origin_identity = json["s3-origin-access-identity"]
+          @custom_origin_config = if json["custom-origin-config"].nil?
+            nil
+          else
+            CustomOriginConfig.new(
+              json["custom-origin-config"]["http-port"],
+              json["custom-origin-config"]["https-port"],
+              json["custom-origin-config"]["protocol-policy"],
+              json["custom-origin-config"]["origin-ssl-protocols"] && OriginSslProtocols.new(
+                json["custom-origin-config"]["origin-ssl-protocols"]
+              )
+            )
+          end
+          @name = @id
+        end
+      end
+
+      def populate!(aws)
+        @id = aws.id
+        @domain_name = aws.domain_name
+        @origin_path = aws.origin_path
+        @s3_access_origin_identity = if aws.s3_origin_config then aws.s3_origin_config.origin_access_identity end
+        @custom_origin_config = if aws.custom_origin_config
+          CustomOriginConfig.new(
+            aws.custom_origin_config.http_port,
+            aws.custom_origin_config.https_port,
+            aws.custom_origin_config.origin_protocol_policy,
+            aws.custom_origin_config.origin_ssl_protocols && OriginSslProtocols.new(
+              aws.custom_origin_config.origin_ssl_protocols.items
+            )
+          )
+        end
+        @name = @id
+      end
+
+      # Public: Get the config as a hash
+      #
+      # Returns the hash
+      def to_local
+        {
+          "id" => @id,
+          "domain-name" => @domain_name,
+          "origin-path" => @origin_path,
+          "s3-origin-access-identity" => @s3_access_origin_identity,
+          "custom-origin-config" => if @custom_origin_config.nil? then nil else @custom_origin_config.to_local end
+        }.reject { |k, v| v.nil? }
+      end
+
+      def to_aws
+        {
+          id: @id,
+          domain_name: @domain_name,
+          origin_path: @origin_path,
+          s3_origin_config: if @s3_access_origin_identity.nil? then nil else
+            {
+              origin_access_identity: @s3_access_origin_identity
+            }
+          end,
+          custom_origin_config: if @custom_origin_config.nil? then nil else
+            {
+              http_port: @custom_origin_config.http_port,
+              https_port: @custom_origin_config.https_port,
+              origin_protocol_policy: @custom_origin_config.protocol_policy,
+              origin_ssl_protocols: if @custom_origin_config.origin_ssl_protocols
+                {
+                  quantity: @custom_origin_config.origin_ssl_protocols.quantity,
+                  items: @custom_origin_config.origin_ssl_protocols.items,
+                }
+              end
+            }
+          end
+        }
+      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 OriginDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @domain_name != aws.domain_name
+          diffs << OriginDiff.new(OriginChange::DOMAIN, aws, self)
+        end
+
+        if @origin_path != aws.origin_path
+          diffs << OriginDiff.new(OriginChange::PATH, aws, self)
+        end
+
+        # If s3 origin is defined here but not aws
+        if !aws.s3_origin_config.nil?
+          if @s3_access_origin_identity != aws.s3_origin_config.origin_access_identity
+            diffs << OriginDiff.new(OriginChange::S3, aws, self)
+          end
+        else
+          if !@s3_access_origin_identity.nil?
+            diffs << OriginDiff.new(OriginChange::S3, aws, self)
+          end
+        end
+
+        if @custom_origin_config.nil?
+          if !aws.custom_origin_config.nil?
+            custom_diffs = CustomOriginConfig.new(nil, nil, nil).diff(aws.custom_origin_config)
+            diffs << OriginDiff.custom(custom_diffs, aws, self) if !custom_diffs.empty?
+          end
+        else
+          custom_diffs = @custom_origin_config.diff(aws.custom_origin_config)
+          diffs << OriginDiff.custom(custom_diffs, aws, self) if !custom_diffs.empty?
+        end
+
+        diffs.flatten
+      end
+
+    end
+  end
+end

data/lib/cloudfront/models/OriginDiff.rb

@@ -0,0 +1,86 @@
+require "common/models/Diff"
+require "util/Colors"
+
+module Cumulus
+  module CloudFront
+
+  	# Public: The types of changes that can be made to zones
+    module OriginChange
+      include Common::DiffChange
+
+      DOMAIN = Common::DiffChange::next_change_id
+      PATH = Common::DiffChange::next_change_id
+      S3 = Common::DiffChange::next_change_id
+      CUSTOM = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration of zones.
+    class OriginDiff < Common::Diff
+      include OriginChange
+
+      attr_accessor :custom_changes
+
+      # Public: Static method that produces a diff representing changes in custom origin
+      #
+      # changed_origins - the CustomOriginDiffs
+      # local           - the local configuration for the zone
+      #
+      # Returns the diff
+      def self.custom(changes, aws, local)
+        diff = OriginDiff.new(CUSTOM, aws, local)
+        diff.custom_changes = changes
+        diff
+      end
+
+      def diff_string
+        case @type
+        when DOMAIN
+          [
+            "domain:",
+            Colors.aws_changes("\tAWS - #{@aws.domain_name}"),
+            Colors.local_changes("\tLocal - #{@local.domain_name}"),
+          ].join("\n")
+        when PATH
+          [
+            "path:",
+            Colors.aws_changes("\tAWS - #{@aws.origin_path}"),
+            Colors.local_changes("\tLocal - #{@local.origin_path}"),
+          ].join("\n")
+        when S3
+          aws_value = (@aws.s3_origin_config.origin_access_identity rescue nil)
+          [
+            "s3 origin access identity:",
+            Colors.aws_changes("\tAWS - #{aws_value}"),
+            Colors.local_changes("\tLocal - #{@local.s3_access_origin_identity}"),
+          ].join("\n")
+        when CUSTOM
+          [
+            "custom origin config:",
+            (@custom_changes.flat_map do |c|
+              c.to_s.lines.map { |l| "\t#{l.chomp}"}
+            end).join("\n"),
+          ].join("\n")
+        end
+      end
+
+      def asset_type
+        if (!@local.nil? and @local.s3_access_origin_identity.nil?) or (!@aws.nil? and @aws.s3_origin_config.nil?)
+          "Custom Origin"
+        else
+          "S3 Origin"
+        end
+      end
+
+      def local_name
+        @local.id
+      end
+
+      def aws_name
+        @aws.id
+      end
+
+    end
+
+  end
+end

data/lib/cloudfront/models/OriginSslProtocols.rb

@@ -0,0 +1,28 @@
+require "cloudfront/models/OriginSslProtocolsDiff"
+
+module Cumulus
+  module CloudFront
+    OriginSslProtocols = Struct.new(:items) do
+      def quantity
+        items && items.length || 0
+      end
+
+      def diff(aws)
+        diffs = []
+
+        aws_items = aws && aws.items || []
+        added_items = self.items - aws_items
+        removed_items = aws_items - self.items
+        if !added_items.empty? || !removed_items.empty?
+          diffs << OriginSslProtocolsDiff.items(added_items, removed_items, self)
+        end
+
+        diffs
+      end
+
+      def to_local
+        self.items
+      end
+    end
+  end
+end

data/lib/cloudfront/models/OriginSslProtocolsDiff.rb

@@ -0,0 +1,39 @@
+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 origin ssl protocols
+    module OriginSslProtocolsChange
+      include Common::DiffChange
+
+      ITEMS = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration of origin ssl protocols
+    class OriginSslProtocolsDiff < Common::Diff
+      include OriginSslProtocolsChange
+
+      attr_accessor :items
+
+      def self.items(added, removed, local)
+        diff = OriginSslProtocolsDiff.new(ITEMS, nil, local)
+        diff.items = Common::ListChange.new(added, removed)
+        diff
+      end
+
+      def diff_string
+        case @type
+        when ITEMS
+          [
+            "items:",
+            @items.removed.map { |removed| Colors.removed("\t#{removed}") },
+            @items.added.map { |added| Colors.added("\t#{added}") },
+          ].flatten.join("\n")
+        end
+      end
+    end
+  end
+end