sprinkle_dns 1.0.0

data/lib/sprinkle_dns/cli/interactive_change_request_printer.rb

@@ -0,0 +1,32 @@
+module SprinkleDNS::CLI
+  class InteractiveChangeRequestPrinter
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @redraws = 0
+    end
+
+    def draw(change_requests, sync_word = "SYNCING", synced_word = "SYNCED")
+      lines = []
+
+      change_requests.each do |change_request|
+        dots   = '.' * change_request.tries
+        sync   = change_request.in_sync ? '✔' : '✘'
+        status = change_request.in_sync ? synced_word : sync_word
+        lines << "#{sync} #{status} #{change_request.hosted_zone.name}#{dots}"
+      end
+
+      if @redraws > 0
+        clear = "\r" + ("\e[A\e[K") * lines.size
+        puts clear + lines.join("\n")
+      else
+        puts lines.join("\n")
+      end
+
+      @redraws += 1
+      sleep(2)
+    end
+  end
+end

data/lib/sprinkle_dns/cli/propagated_change_request_printer.rb

@@ -0,0 +1,33 @@
+module SprinkleDNS::CLI
+  class PropagatedChangeRequestPrinter
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @completed = []
+      @printed = []
+    end
+
+    def draw(change_requests, sync_word: "SYNCING", synced_word: "SYNCED")
+      change_requests.each do |change_request|
+        if change_request.in_sync
+          hosted_zone_name = change_request.hosted_zone.name
+
+          unless @completed.include?(hosted_zone_name)
+            @completed << hosted_zone_name + '.' * change_request.tries
+          end
+        end
+      end
+
+      @completed.each do |complete|
+        unless @printed.include?(complete)
+          puts "#{complete}.. #{synced_word}!"
+          @printed << complete
+        end
+      end
+
+      sleep(2)
+    end
+  end
+end

data/lib/sprinkle_dns/client.rb

@@ -0,0 +1,169 @@
+require 'sprinkle_dns/exceptions'
+require 'sprinkle_dns/config'
+require 'sprinkle_dns/hosted_zone'
+require 'sprinkle_dns/hosted_zone_domain'
+require 'sprinkle_dns/hosted_zone_entry'
+require 'sprinkle_dns/hosted_zone_alias'
+require 'sprinkle_dns/entry_policy_service'
+
+require 'sprinkle_dns/cli/hosted_zone_diff'
+require 'sprinkle_dns/cli/interactive_change_request_printer'
+require 'sprinkle_dns/cli/propagated_change_request_printer'
+
+require 'sprinkle_dns/core_ext/array_wrap'
+require 'sprinkle_dns/core_ext/zonify'
+
+module SprinkleDNS
+  class Client
+    attr_reader :wanted_hosted_zones, :config
+
+    def initialize(dns_provider, dry_run: false, diff: true, force: true, delete: false, interactive_progress: true, create_hosted_zones: false)
+      @config = SprinkleDNS::Config.new(
+        dry_run: dry_run,
+        diff: diff,
+        force: force,
+        delete: delete,
+        interactive_progress: interactive_progress,
+        create_hosted_zones: create_hosted_zones,
+      )
+      @dns_provider = dns_provider
+      @wanted_hosted_zones = []
+
+      @progress_printer = if @config.interactive_progress?
+        SprinkleDNS::CLI::InteractiveChangeRequestPrinter.new
+      else
+        SprinkleDNS::CLI::PropagatedChangeRequestPrinter.new
+      end
+    end
+
+    def entry(type, name, value, ttl = 3600, hosted_zone = nil)
+      hosted_zone = find_or_init_hosted_zone(name, hosted_zone)
+      name        = zonify!(name)
+
+      if ['CNAME', 'MX'].include?(type)
+        value = Array.wrap(value)
+        value.map!{|v| zonify!(v)}
+      end
+      hosted_zone.add_or_update_hosted_zone_entry(HostedZoneEntry.new(type, name, Array.wrap(value), ttl, hosted_zone.name))
+    end
+
+    def alias(type, name, hosted_zone_id, dns_name, hosted_zone = nil)
+      hosted_zone = find_or_init_hosted_zone(name, hosted_zone)
+      name        = zonify!(name)
+      dns_name    = zonify!(dns_name)
+
+      hosted_zone.add_or_update_hosted_zone_entry(HostedZoneAlias.new(type, name, hosted_zone_id, dns_name, hosted_zone.name))
+    end
+
+    def compare
+      existing_hosted_zones = @dns_provider.fetch_hosted_zones(filter: @wanted_hosted_zones.map(&:name))
+
+      # Tell our existing hosted zones about our wanted changes
+      existing_hosted_zones.each do |existing_hosted_zone|
+        wanted_hosted_zone = @wanted_hosted_zones.find{|whz| whz.name == existing_hosted_zone.name}
+
+        wanted_hosted_zone.resource_record_sets.each do |entry|
+          existing_hosted_zone.add_or_update_hosted_zone_entry(entry)
+        end
+      end
+
+      [@wanted_hosted_zones, existing_hosted_zones]
+    end
+
+    def sprinkle!
+      wanted_hosted_zones, existing_hosted_zones = compare
+
+      missing_hosted_zone_names = wanted_hosted_zones.map(&:name) - existing_hosted_zones.map(&:name)
+      missing_hosted_zones = wanted_hosted_zones.select{|whz| missing_hosted_zone_names.include?(whz.name)}
+
+      if missing_hosted_zones.any? && !@config.create_hosted_zones?
+        missing_hosted_zones_error(missing_hosted_zones)
+      end
+
+      if @config.diff?
+        SprinkleDNS::CLI::HostedZoneDiff.new.diff(existing_hosted_zones, missing_hosted_zones, @config).each do |line|
+          puts line.join(' ')
+        end
+      end
+
+      if @config.dry_run?
+        return [existing_hosted_zones, nil]
+      end
+
+      hosted_zones = (existing_hosted_zones + missing_hosted_zones)
+
+      unless @config.force?
+        changes = hosted_zones.map{|h| SprinkleDNS::EntryPolicyService.new(h, @config)}.collect{|eps| eps.entries_to_change}.sum
+
+        messages = []
+
+        messages << "#{missing_hosted_zones.size} hosted-zone(s) to create" if missing_hosted_zones.any?
+        messages << "#{changes} change(s) to make" if changes > 0
+        print messages.join(' and ').concat(". Continue? (y/N)")
+
+        case gets.strip
+        when 'y', 'Y'
+          # continue
+        else
+          puts ".. exiting!"
+          return [hosted_zones, nil]
+        end
+      end
+
+      # Create missing hosted zones
+      change_requests_hosted_zones = @dns_provider.create_hosted_zones(missing_hosted_zones)
+      if change_requests_hosted_zones.any?
+        puts
+        puts "Creating hosted zones:"
+        @progress_printer.reset!
+        begin
+          @dns_provider.check_change_requests(change_requests_hosted_zones)
+          @progress_printer.draw(change_requests_hosted_zones, 'CREATING', 'CREATED')
+        end until change_requests_hosted_zones.all?{|cr| cr.in_sync}
+      end
+
+      # Update hosted zones
+      change_requests_entries = @dns_provider.change_hosted_zones(hosted_zones, @config)
+      if change_requests_entries.any?
+        puts
+        puts "Updating hosted zones:"
+        @progress_printer.reset!
+        begin
+          @dns_provider.check_change_requests(change_requests_entries)
+          @progress_printer.draw(change_requests_entries, 'UPDATING', 'UPDATED')
+        end until change_requests_entries.all?{|cr| cr.in_sync}
+      end
+
+      change_requests = change_requests_hosted_zones + change_requests_entries
+
+      [hosted_zones, change_requests]
+    end
+
+    private
+
+    def find_or_init_hosted_zone(record_name, hosted_zone_name)
+      hosted_zone_name ||= HostedZoneDomain::parse(record_name)
+      hosted_zone_name   = zonify!(hosted_zone_name)
+
+      wanted_hosted_zone = @wanted_hosted_zones.find{|zone| zone.name == hosted_zone_name}
+      if wanted_hosted_zone.nil?
+        wanted_hosted_zone = HostedZone.new(hosted_zone_name)
+        @wanted_hosted_zones << wanted_hosted_zone
+      end
+
+      wanted_hosted_zone
+    end
+
+    def missing_hosted_zones_error(missing_hosted_zones)
+      error_message = []
+      error_message << "There are #{missing_hosted_zones.size} missing hosted zones:"
+
+      missing_hosted_zones.map(&:name).sort.each do |whz|
+        error_message << "- #{whz}"
+      end
+
+      raise error_message.join("\n")
+    end
+  end
+
+end

data/lib/sprinkle_dns/config.rb

@@ -0,0 +1,43 @@
+module SprinkleDNS
+  class Config
+    def initialize(dry_run: true, diff: true, force: false, delete: false, interactive_progress: true, create_hosted_zones: false)
+      @dry_run = dry_run
+      @diff = diff
+      @force = force
+      @delete = delete
+      @interactive_progress = interactive_progress
+      @create_hosted_zones = create_hosted_zones
+
+      raise SettingNotBoolean.new('dry_run is not a boolean') unless [true, false].include?(dry_run)
+      raise SettingNotBoolean.new('diff is not a boolean') unless [true, false].include?(diff)
+      raise SettingNotBoolean.new('force is not a boolean') unless [true, false].include?(force)
+      raise SettingNotBoolean.new('delete is not a boolean') unless [true, false].include?(delete)
+      raise SettingNotBoolean.new('interactive_progress is not a boolean') unless [true, false].include?(interactive_progress)
+      raise SettingNotBoolean.new('create_hosted_zones is not a boolean') unless [true, false].include?(create_hosted_zones)
+    end
+
+    def dry_run?
+      @dry_run
+    end
+
+    def diff?
+      @diff
+    end
+
+    def force?
+      @force
+    end
+
+    def delete?
+      @delete
+    end
+
+    def interactive_progress?
+      @interactive_progress
+    end
+
+    def create_hosted_zones?
+      @create_hosted_zones
+    end
+  end
+end

data/lib/sprinkle_dns/core_ext/array_wrap.rb

@@ -0,0 +1,11 @@
+class Array
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/lib/sprinkle_dns/core_ext/zonify.rb

@@ -0,0 +1,4 @@
+def zonify!(domain)
+  domain = "#{domain}." unless domain.end_with?('.')
+  domain
+end

data/lib/sprinkle_dns/entry_policy_service.rb

@@ -0,0 +1,100 @@
+module SprinkleDNS
+  class EntryPolicyService
+    def initialize(hosted_zone, configuration)
+      @hosted_zone = hosted_zone
+      @configuration = configuration
+    end
+
+    def entries_to_create
+      @hosted_zone.entries.select{|hze| hze.referenced? && hze.new?}
+    end
+
+    def entries_to_update
+      @hosted_zone.entries.select{|hze| hze.referenced? && hze.changed? && !hze.new?}
+    end
+
+    def entries_not_touched
+      not_touched = @hosted_zone.entries.select{|hze| hze.referenced? && !hze.changed? && !hze.new?}
+
+      if @configuration.delete?
+        not_touched
+      else
+        (not_touched + @hosted_zone.entries.select{|hze| !hze.referenced?}).flatten
+      end
+    end
+
+    def entries_to_delete
+      if @configuration.delete?
+        @hosted_zone.entries.select{|hze| !hze.referenced?}
+      else
+        []
+      end
+    end
+
+    def entries_to_change
+      [entries_to_create, entries_to_update, entries_to_delete].sum(&:size)
+    end
+
+    def entries_to_change?
+      entries_to_change > 0
+    end
+
+    def compile
+      generate_change_batch
+    end
+
+    private
+
+    def generate_change_batch
+      change_batch_options = []
+
+      entries_to_delete.each do |entry|
+        change_batch_options << {
+          action: 'DELETE',
+          resource_record_set: entry_to_rrs(entry),
+        }
+      end
+
+      entries_to_update.each do |entry|
+        change_batch_options << {
+          action: 'UPSERT',
+          resource_record_set: entry_to_rrs(entry.new_entry),
+        }
+      end
+
+      entries_to_create.each do |entry|
+        change_batch_options << {
+          action: 'CREATE',
+          resource_record_set: entry_to_rrs(entry)
+        }
+      end
+
+      change_batch_options
+    end
+
+    private
+
+    def entry_to_rrs(entry)
+      case entry
+      when HostedZoneEntry
+        {
+          name: entry.name,
+          type: entry.type,
+          ttl: entry.ttl,
+          resource_records: entry.value.map{|a| {value: a}},
+        }
+      when HostedZoneAlias
+        {
+          name: entry.name,
+          type: entry.type,
+          alias_target: {
+            hosted_zone_id: entry.target_hosted_zone_id,
+            dns_name: entry.target_dns_name,
+            evaluate_target_health: false,
+          },
+        }
+      else raise "Unknown entry"
+      end
+    end
+  end
+end

data/lib/sprinkle_dns/exceptions.rb

@@ -0,0 +1,9 @@
+module SprinkleDNS
+  class RecordNotAString < StandardError; end
+  class RecordNotValid   < StandardError; end
+  class TtlNotInteger    < StandardError; end
+  class SettingNotBoolean < StandardError; end
+
+  class MissingHostedZones < StandardError; end
+  class DuplicatedHostedZones < StandardError; end
+end

data/lib/sprinkle_dns/hosted_zone.rb

@@ -0,0 +1,36 @@
+module SprinkleDNS
+  class HostedZone
+    attr_reader :name
+    attr_accessor :resource_record_sets
+
+    def initialize(name)
+      @name                 = name
+      @resource_record_sets = []
+    end
+
+    def add_or_update_hosted_zone_entry(wanted_entry)
+      raise if wanted_entry.hosted_zone != self.name
+
+      existing_entry = @resource_record_sets.find{|hze| hze.type == wanted_entry.type && hze.name == wanted_entry.name}
+
+      if existing_entry
+        if existing_entry.persisted?
+          existing_entry.mark_referenced!
+          existing_entry.new_value(wanted_entry)
+        else
+          wanted_entry.mark_referenced!
+          @resource_record_sets[@resource_record_sets.index(existing_entry)] = wanted_entry
+        end
+      else
+        wanted_entry.mark_new!
+        wanted_entry.mark_referenced!
+        @resource_record_sets << wanted_entry
+      end
+    end
+
+    def entries
+      @resource_record_sets
+    end
+
+  end
+end

data/lib/sprinkle_dns/hosted_zone_alias.rb

@@ -0,0 +1,91 @@
+module SprinkleDNS
+  class HostedZoneAlias
+    attr_accessor :type, :name, :hosted_zone, :target_hosted_zone_id, :target_dns_name
+    attr_accessor :changed_type, :changed_name, :changed_target_hosted_zone_id, :changed_target_dns_name
+    attr_accessor :referenced, :persisted
+    attr_accessor :new_entry
+
+    def initialize(type, name, target_hosted_zone_id, target_dns_name, hosted_zone)
+      @type                  = type
+      @name                  = zonify!(name)
+      @target_hosted_zone_id = target_hosted_zone_id
+      @target_dns_name       = target_dns_name
+      @hosted_zone           = hosted_zone
+
+      @new_entry = nil
+
+      raise if [@type, @name, @target_hosted_zone_id, @target_dns_name, @hosted_zone].any?(&:nil?)
+
+      @changed_type = false
+      @changed_name = false
+      @changed_target_hosted_zone_id = false
+      @changed_target_dns_name = false
+      @referenced = false
+      @persisted = false
+    end
+
+    def mark_new!
+      @changed_type, @changed_name, @changed_target_hosted_zone_id, @changed_target_dns_name = [true, true, true, true]
+    end
+
+    def new?
+      [@changed_type, @changed_name, @changed_target_hosted_zone_id, @changed_target_dns_name].all?
+    end
+
+    def persisted!
+      @persisted = true
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def changed?
+      [@changed_type, @changed_name, @changed_target_hosted_zone_id, @changed_target_dns_name].any?
+    end
+
+    def mark_referenced!
+      @referenced = true
+    end
+
+    def referenced?
+      @referenced
+    end
+
+    def new_value(new_entry)
+      if new_entry.class == SprinkleDNS::HostedZoneAlias
+        @changed_target_hosted_zone_id = true if @target_hosted_zone_id != new_entry.target_hosted_zone_id
+        @changed_target_dns_name       = true if @target_dns_name       != new_entry.target_dns_name
+      else
+        @changed_target_hosted_zone_id = true
+        @changed_target_dns_name       = true
+      end
+
+      # TODO test this
+      if @changed_target_hosted_zone_id || @changed_target_dns_name
+        @new_entry = new_entry
+      end
+
+      self.changed?
+    end
+
+    def to_s
+      [
+        "Alias",
+        sprintf("%4s", type),
+        sprintf("%30s", name),
+        sprintf("%10s", target_hosted_zone_id),
+        sprintf("%30s", target_dns_name),
+        sprintf("%6s", hosted_zone),
+      ].join(" ")
+    end
+
+    private
+
+    def valid_record_types
+      ['SOA','A','TXT','NS','CNAME','MX','NAPTR','PTR','SRV','SPF','AAAA']
+    end
+
+  end
+end
+

data/lib/sprinkle_dns/hosted_zone_domain.rb

@@ -0,0 +1,18 @@
+module SprinkleDNS
+  class HostedZoneDomain
+    def self.parse(domain)
+      splitted = domain.split('.')
+
+      if two_dotted_domain?(domain)
+        [ splitted[-3], splitted[-2], splitted[-1] ].join('.') + '.'
+      else
+        [ splitted[-2], splitted[-1] ].join('.') + '.'
+      end
+    end
+
+   private
+    def self.two_dotted_domain?(domain)
+      true if domain.include?('.co.uk')
+    end
+  end
+end

data/lib/sprinkle_dns/hosted_zone_entry.rb

@@ -0,0 +1,97 @@
+module SprinkleDNS
+  class HostedZoneEntry
+    attr_accessor :type, :name, :value, :ttl, :hosted_zone
+    attr_accessor :changed_type, :changed_name, :changed_value, :changed_ttl
+    attr_accessor :referenced, :persisted
+    attr_accessor :new_entry
+
+    def initialize(type, name, value, ttl, hosted_zone)
+      @type           = type
+      @name           = zonify!(name)
+      @value          = Array.wrap(value)
+      @ttl            = ttl
+      @hosted_zone    = hosted_zone
+
+      @new_entry      = nil
+
+      raise if [@type, @name, @value, @ttl, @hosted_zone].any?(&:nil?)
+      raise SprinkleDNS::RecordNotAString.new('Record-type should be a string') unless @type.is_a?(String)
+      raise SprinkleDNS::RecordNotValid.new("Record #{@type} is not supported") if !valid_record_types.include?(@type)
+      raise SprinkleDNS::TtlNotInteger.new('TTL should be an integer') unless @ttl.is_a?(Integer)
+
+      @changed_type  = false
+      @changed_name  = false
+      @changed_value = false
+      @changed_ttl   = false
+      @referenced    = false
+      @persisted     = false
+
+      if ['CNAME', 'MX'].include?(type)
+        @value = @value.map!{|v| zonify!(v)}
+      end
+    end
+
+    def mark_new!
+      @changed_type, @changed_name, @changed_value, @changed_ttl = [true, true, true, true]
+    end
+
+    def new?
+      [@changed_type, @changed_name, @changed_value, @changed_ttl].all?
+    end
+
+    def persisted!
+      @persisted = true
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def changed?
+      [@changed_type, @changed_name, @changed_value, @changed_ttl].any?
+    end
+
+    def mark_referenced!
+      @referenced = true
+    end
+
+    def referenced?
+      @referenced
+    end
+
+    def new_value(new_entry)
+      if new_entry.class == SprinkleDNS::HostedZoneEntry
+        @changed_value = true if @value != new_entry.value
+        @changed_ttl   = true if @ttl   != new_entry.ttl
+      else
+        @changed_value = true
+        @changed_ttl   = true
+      end
+
+      # TODO test this
+      if @changed_value || @changed_ttl
+        @new_entry = new_entry
+      end
+
+      self.changed?
+    end
+
+    def to_s
+      [
+        "Entry",
+        sprintf("%4s", type),
+        sprintf("%30s", name),
+        sprintf("%50s", value.join(", ")),
+        sprintf("%6s", ttl),
+        sprintf("%6s", hosted_zone),
+      ].join(" ")
+    end
+
+    private
+
+    def valid_record_types
+      ['SOA','A','TXT','NS','CNAME','MX','NAPTR','PTR','SRV','SPF','AAAA']
+    end
+
+  end
+end