cumulus-aws 0.11.1

data/lib/route53/models/AliasTarget.rb

@@ -0,0 +1,86 @@
+require "cloudfront/CloudFront"
+require "elb/ELB"
+require "s3/S3"
+
+module Cumulus
+  module Route53
+    # Public: A struct that matches the structure of the AWS alias target struct
+    AliasTarget = Struct.new(:name, :type, :local_zone_id) do
+      # Public: Produce the dns_name for this alias
+      #
+      # Returns the dns_name
+      def dns_name
+        if is_elb?
+          "dualstack.#{ELB::get_aws(name).dns_name}"
+        elsif is_s3?
+          "s3-website-#{S3::get_aws(name).location}.amazonaws.com"
+        elsif is_cloudfront?
+          CloudFront::get_aws(name).domain_name
+        else
+          name
+        end
+      end
+
+      # Public: Produce a hash representing this alias target
+      #
+      # Returns the hash
+      def to_hash
+        {
+          "name" => name,
+          "type" => type
+        }.reject { |k, v| v.nil? }
+      end
+
+      # Public: Produce the hosted_zone_id for this alias
+      #
+      # Returns the hosted_zone_id
+      def hosted_zone_id
+        if is_elb?
+          ELB::get_aws(name).canonical_hosted_zone_name_id
+        elsif is_record_set?
+          local_zone_id
+        elsif is_s3?
+          S3::zone_ids[S3::get_aws(name).location]
+        elsif is_cloudfront?
+          "Z2FDTNDATAQYW2" # AWS hard codes this
+        end
+      end
+
+      # Public: Determine whether to evaluate the health check on the target. Always
+      # false.
+      #
+      # Returns false
+      def evaluate_target_health
+        false
+      end
+
+      # Public: Determine if this alias is for an ELB
+      #
+      # Returns true if the alias is an ELB
+      def is_elb?
+        type.downcase == "elb"
+      end
+
+      # Public: Determine if this alias is for a record set
+      #
+      # Returns true if the alias is for a record set
+      def is_record_set?
+        type.downcase == "record"
+      end
+
+      # Public: Determine if this alias is for an s3 website
+      #
+      # Returns true if the alias is for an s3 website
+      def is_s3?
+        type.downcase == "s3"
+      end
+
+      # Public: Determine if this alias is for a Cloudfront distribution
+      #
+      # Returns true if the alias is for a Cloudfront distribution
+      def is_cloudfront?
+        type.downcase == "cloudfront"
+      end
+    end
+  end
+end

data/lib/route53/models/RecordConfig.rb

@@ -0,0 +1,178 @@
+require "aws_extensions/route53/AliasTarget"
+require "aws_extensions/s3/Bucket"
+require "cloudfront/CloudFront"
+require "elb/ELB"
+require "route53/models/AliasTarget"
+require "route53/models/RecordDiff"
+require "s3/S3"
+
+require "aws-sdk"
+
+module Cumulus
+  module Route53
+    # Monkey patch AliasTarget so we can call a method that will compare ELB DNS names correctly
+    Aws::Route53::Types::AliasTarget.send(:include, AwsExtensions::Route53::AliasTarget)
+    # Monkey patch Bucket so we can get the location of the bucket
+    Aws::S3::Types::Bucket.send(:include, AwsExtensions::S3::Types::Bucket)
+
+    # Public: An object representing configurationf for a single record in a zone
+    class RecordConfig
+
+      attr_reader :alias_target
+      attr_reader :name
+      attr_reader :ttl
+      attr_reader :type
+      attr_reader :value
+
+      # Public: Constructor.
+      #
+      # json    - a hash containing the JSON configuration for the record
+      # domain  - the domain of the zone this record belongs to
+      # zone_id - the id of the zone this record belongs to
+      def initialize(json = nil, domain = nil, zone_id = nil)
+        if !json.nil?
+          @name = if json["name"] == "" then domain else "#{json["name"].chomp(".")}.#{domain}".chomp(".") end
+          @ttl = json["ttl"]
+          @type = json["type"]
+
+          if !json["value"].nil?
+            @value = json["value"]
+
+            # TXT and SPF records have each value wrapped in quotes
+            if @type == "TXT" or @type == "SPF"
+              @value = @value.map { |v| "\"#{v}\"" }
+            end
+          else
+            alias_name = if json["alias"]["name"].nil?
+              if json["alias"]["type"] == "s3" then @name else domain end
+            else
+              json["alias"]["name"].chomp(".")
+            end
+            @alias_target = AliasTarget.new(
+              alias_name,
+              json["alias"]["type"],
+              zone_id
+            )
+          end
+        end
+      end
+
+      # Public: Populate this RecordConfig from an AWS resource.
+      #
+      # aws     - the aws resource
+      # domain  - the domain of the parent hosted zone
+      def populate(aws, domain)
+        @name = aws.name.chomp(domain).chomp(".")
+        @ttl = aws.ttl
+        @type = aws.type
+        if !aws.resource_records.nil?
+          if @type == "TXT" or @type == "SPF"
+            @value = aws.resource_records.map { |r| r.value[1..-2] }
+          else
+            @value = aws.resource_records.map(&:value)
+          end
+        end
+
+        if !aws.alias_target.nil?
+          if aws.alias_target.dns_name.include? "elb"
+            @alias_target = AliasTarget.new(
+              Cumulus::ELB::get_aws_by_dns_name(aws.alias_target.elb_dns_name).load_balancer_name,
+              "elb",
+              nil
+            )
+          elsif aws.alias_target.dns_name.include? "s3"
+            @alias_target = AliasTarget.new(nil, "s3", nil)
+          elsif aws.alias_target.dns_name.include? "cloudfront"
+            @alias_target = AliasTarget.new(nil, "cloudfront", nil)
+          else
+            @alias_target = AliasTarget.new(aws.alias_target.dns_name.chomp("."), "record", nil)
+          end
+        end
+      end
+
+      # Public: Get the config as a hash
+      #
+      # Returns the hash
+      def to_hash
+        {
+          "name" => @name,
+          "type" => @type,
+          "ttl" => @ttl,
+          "value" => @value,
+          "alias" => if @alias_target.nil? then nil else @alias_target.to_hash end,
+        }.reject { |k, v| v.nil? }
+      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 RecordDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @ttl != aws.ttl
+          diffs << SingleRecordDiff.new(RecordChange::TTL, aws, self)
+        end
+        if !@value.nil? and @value.sort != aws.resource_records.map(&:value).sort
+          diffs << SingleRecordDiff.new(RecordChange::VALUE, aws, self)
+        end
+        if !@alias_target.nil?
+          if aws.alias_target.nil? or
+            (is_elb_alias? and aws.alias_target.elb_dns_name != ELB::get_aws(@alias_target.name).dns_name) or
+            (aws.alias_target.chomped_dns != @alias_target.dns_name)
+            diffs << SingleRecordDiff.new(RecordChange::ALIAS, aws, self)
+          end
+        end
+
+        diffs
+      end
+
+      # Public: Determine if the record is an alias for an ELB
+      #
+      # Returns whether this record is an alias for an ELB
+      def is_elb_alias?
+        !@alias_target.nil? and @alias_target.is_elb?
+      end
+
+      # Public: Determine if the recourd is an alias for another record
+      #
+      # Returns whether this record is an alias for another record
+      def is_record_set_alias?
+        !@alias_target.nil? and @alias_target.is_record_set?
+      end
+
+      # Public: Determine if the record is an alias for an S3 website
+      #
+      # Returns whether this record is an alias for an S3 website
+      def is_s3_alias?
+        !@alias_target.nil? and @alias_target.is_s3?
+      end
+
+      # Public: Determine if the record is an alias for a Cloudfront distribution
+      #
+      # Returns whether this record is an alias for a Cloudfront distribution
+      def is_cloudfront_alias?
+        !@alias_target.nil? and @alias_target.is_cloudfront?
+      end
+
+      # Public: Produce a `resource_records` array that is analogous to the one used in AWS from
+      # the values array used by Cumulus
+      #
+      # Returns the `resource_records`
+      def resource_records
+        if !@value.nil?
+          @value.map { |v| { value: v } }
+        end
+      end
+
+      # Public: Produce a useful human readable version of the name of this RecordConfig
+      #
+      # Returns the string name
+      def readable_name
+        "(#{@type}) #{@name}"
+      end
+    end
+  end
+end

data/lib/route53/models/RecordDiff.rb

@@ -0,0 +1,140 @@
+require "common/models/Diff"
+require "elb/ELB"
+require "util/Colors"
+
+module Cumulus
+  module Route53
+    # Public: The types of changes that can be made to records
+    module RecordChange
+      include Common::DiffChange
+
+      ALIAS = Common::DiffChange::next_change_id
+      CHANGED = Common::DiffChange::next_change_id
+      DEFAULT = Common::DiffChange::next_change_id
+      IGNORED = Common::DiffChange::next_change_id
+      TTL = Common::DiffChange::next_change_id
+      VALUE = Common::DiffChange::next_change_id
+    end
+
+    # Public: Represents differences between local configuration and AWS
+    # configuration for records.
+    class RecordDiff < Common::Diff
+      include RecordChange
+
+      attr_accessor :message
+      attr_accessor :changes
+
+      # Public: Static method that will create a diff that contains a message but is
+      # ignored when syncing because it is a default record.
+      #
+      # message - the message to display
+      # aws     - the aws configuration for the record
+      #
+      # Returns the diff
+      def self.default(message, aws)
+        diff = RecordDiff.new(DEFAULT, aws)
+        diff.message = message
+        diff
+      end
+
+      # Public: Static method that will create a diff that contains a message but is
+      # ignored when syncing.
+      #
+      # message - the message to display
+      # aws     - the aws configuration for the record
+      #
+      # Returns the diff
+      def self.ignored(message, aws)
+        diff = RecordDiff.new(IGNORED, aws)
+        diff.message = message
+        diff.info_only = true
+        diff
+      end
+
+      # Public: Static method that will create a diff that contains a bunch of
+      # singular changes.
+      #
+      # changes - the changes for the record
+      # local   - the local configuration for the record
+      #
+      # Returns the diff
+      def self.changed(changes, local)
+        diff = RecordDiff.new(CHANGED, nil, local)
+        diff.changes = changes
+        diff
+      end
+
+      def asset_type
+        "Record"
+      end
+
+      def aws_name
+        "(#{@aws.type}) #{@aws.name}"
+      end
+
+      def local_name
+        @local.readable_name
+      end
+
+      def diff_string
+        case @type
+        when IGNORED
+          message
+        when DEFAULT
+          message
+        when CHANGED
+          [
+            "Record #{local_name}:",
+            changes.map { |c| "\t\t#{c}" }
+          ].flatten.join("\n")
+        end
+      end
+
+    end
+
+    # Public: Represents a single difference between local configuration and AWS
+    # configuration for a single record. This class allows all the changes for a
+    # record to be grouped together when printed.
+    class SingleRecordDiff < Common::Diff
+      include RecordChange
+
+      def diff_string
+        case @type
+        when ALIAS
+          if @local.is_elb_alias?
+            aws_name = ELB::get_aws_by_dns_name(@aws.alias_target.elb_dns_name).load_balancer_name
+            "Alias: AWS - #{Colors.aws_changes(aws_name)}, Local - #{Colors.local_changes(@local.alias_target.name)}"
+          else
+            "Alias: AWS - #{Colors.aws_changes(@aws.alias_target.chomped_dns)}, Local - #{Colors.local_changes(@local.alias_target.dns_name)}"
+          end
+        when TTL
+          "TTL: AWS - #{Colors.aws_changes(@aws.ttl)}, Local - #{Colors.local_changes(@local.ttl)}"
+        when VALUE
+          [
+            "Value:",
+            values_to_add.map { |v| Colors.added("\t\t\t#{v}") },
+            values_to_remove.map { |v| Colors.removed("\t\t\t#{v}") }
+          ].flatten.join("\n")
+        end
+      end
+
+      private
+
+      # Internal: Get the value parts that are in local configuration but not in AWS
+      #
+      # Returns the local value parts
+      def values_to_add
+        aws_value = @aws.resource_records.map(&:value)
+        @local.value.reject { |v| aws_value.include?(v) }
+      end
+
+      # Internal: Get the value parts that are in AWS but not local configuration
+      #
+      # Returns the AWS value parts
+      def values_to_remove
+        aws_value = @aws.resource_records.map(&:value)
+        aws_value.reject { |v| @local.value.include?(v) }
+      end
+    end
+  end
+end

data/lib/route53/models/Vpc.rb

@@ -0,0 +1,24 @@
+module Cumulus
+  module Route53
+    Vpc = Struct.new(:id, :region) do
+      # Public: Implement <=> to allow sorting. Sorts by id and then region
+      def <=>(other)
+        if self.id == other.id
+          self.region <=> other.region
+        else
+          self.id <=> self.id
+        end
+      end
+
+      # Public: Produce a hash representing the VPC
+      #
+      # Returns the hash
+      def to_hash
+        {
+          "id" => id,
+          "region" => region
+        }
+      end
+    end
+  end
+end

data/lib/route53/models/ZoneConfig.rb

@@ -0,0 +1,156 @@
+require "conf/Configuration"
+require "route53/loader/Loader"
+require "route53/models/RecordConfig"
+require "route53/models/RecordDiff"
+require "route53/models/Vpc"
+require "route53/models/ZoneDiff"
+
+require "json"
+
+module Cumulus
+  module Route53
+    # Public: An object representing configuration for a zone
+    class ZoneConfig
+      attr_reader :comment
+      attr_reader :domain
+      attr_reader :id
+      attr_reader :name
+      attr_reader :private
+      attr_reader :records
+      attr_reader :vpc
+
+      # Public: Constructor
+      #
+      # json - a hash containing the JSON configuration for the zone
+      def initialize(name, json = nil)
+        @name = name
+        if !json.nil?
+          @id = "/hostedzone/#{json["zone-id"]}"
+          @domain = json["domain"].chomp(".")
+          @private = json["private"]
+          @vpc = if @private then json["vpc"].map { |v| Vpc.new(v["id"], v["region"]) } else [] end
+          @comment = json["comment"]
+
+          includes = if json["records"]["includes"].nil? then [] else json["records"]["includes"] end
+          includes = includes.flat_map(&Loader.method(:includes_file))
+          @records = (json["records"]["inlines"] + includes).map do |j|
+            RecordConfig.new(j, @domain, json["zone-id"])
+          end
+          @ignored = if json["records"]["ignored"].nil? then [] else json["records"]["ignored"] end
+        end
+      end
+
+      # Public: Populate this ZoneConfig from an AWS resource
+      #
+      # aws - the aws resource
+      def populate(aws)
+        @id = aws.id.sub(/\/hostedzone\//, '')
+        @domain = aws.name
+        @private = aws.config.private_zone
+        @vpc = if @private then aws.vpc else nil end
+        @comment = aws.config.comment
+        @records = aws.records.map do |record|
+          r = RecordConfig.new()
+          r.populate(record, @domain)
+          r
+        end
+      end
+
+      # Public: Get the config as a prettified JSON string.
+      #
+      # Returns the JSON string
+      def pretty_json
+        JSON.pretty_generate({
+          "zone-id" => @id,
+          "domain" => @domain,
+          "private" => @private,
+          "vpc" => if @vpc.nil? then nil else @vpc.map(&:to_hash) end,
+          "comment" => @comment,
+          "records" => {
+            "ignored" => if @ignored.nil? then [] else @ignored end,
+            "includes" => [],
+            "inlines" => @records.map(&:to_hash),
+          },
+        }.reject { |k, v| v.nil? })
+      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 ZoneDiffs that were found
+      def diff(aws)
+        diffs = []
+
+        if @comment != aws.config.comment
+          diffs << ZoneDiff.new(ZoneChange::COMMENT, aws, self)
+        end
+        if @domain != aws.name
+          diffs << ZoneDiff.new(ZoneChange::DOMAIN, aws, self)
+        end
+        if @private != aws.config.private_zone
+          diffs << ZoneDiff.new(ZoneChange::PRIVATE, aws, self)
+        end
+        if @private and @vpc.sort != aws.vpc.sort
+          diffs << ZoneDiff.new(ZoneChange::VPC, aws, self)
+        end
+
+        record_diffs = diff_records(aws.records)
+        if !record_diffs.empty?
+          diffs << ZoneDiff.records(record_diffs, self)
+        end
+
+        diffs
+      end
+
+      private
+
+      # The unique key on a record is a combination of name and type
+      RecordKey = Struct.new(:name, :type)
+
+      # Internal: Produce an array of differences between local record configuration and the
+      # configuration in AWS.
+      #
+      # aws - an array of records in aws
+      #
+      # Returns an array of the RecordDiffs that were found
+      def diff_records(aws)
+        diffs = []
+
+        # map the records to their keys
+        aws = Hash[aws.map { |r| [RecordKey.new(r.name.gsub(/\\100/, "@"), r.type), r] }]
+        local = Hash[@records.map { |r| [RecordKey.new(r.name, r.type), r] }]
+
+        # find records in aws that are not configured locally, ignoring the NS and SOA
+        # record for the domain
+        aws.each do |key, record|
+          if !local.include?(key)
+            if @domain == record.name and record.type == "NS"
+              diffs << RecordDiff.default("Default NS record is supplied in AWS, but not locally. It will be ignored when syncing.", record)
+            elsif @domain == record.name and record.type == "SOA"
+              diffs << RecordDiff.default("Default SOA record is supplied in AWS, but not locally. It will be ignored when syncing.", record)
+            elsif !@ignored.find_index { |i| !record.name.match(i).nil? }.nil?
+              diffs << RecordDiff.ignored("Record (#{record.type}) #{record.name} is ignored by your blacklist", record)
+            else
+              diffs << RecordDiff.unmanaged(record)
+            end
+          end
+        end
+
+        local.each do |key, record|
+          if !aws.include?(key)
+            diffs << RecordDiff.added(record)
+          else
+            d = record.diff(aws[key])
+            if !d.empty?
+              diffs << RecordDiff.changed(d, record)
+            end
+          end
+        end
+
+        diffs.flatten
+      end
+    end
+  end
+end