dnsync 1.0.0

data/lib/dnsync/dnsimple.rb

@@ -0,0 +1,65 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'active_support/core_ext/object/blank'
+
+require 'dnsync/zone'
+
+module Dnsync
+  class Dnsimple
+    attr_reader :domain
+
+    def initialize(email, token, domain)
+      unless email.present?
+        raise ArgumentError, "email must be specified"
+      end
+
+      unless token.present?
+        raise ArgumentError, "token must be specified"
+      end
+
+      unless domain.present?
+        raise ArgumentError, "domain must be specified"
+      end
+
+      @email  = email
+      @token  = token
+      @domain = domain
+    end
+
+    def connection
+      @connection ||= Faraday.new('https://api.dnsimple.com/v1/') do |conn|
+        conn.request :url_encoded # form-encode POST params
+
+        # conn.response :logger
+        conn.response :raise_error
+        conn.response :json, :content_type => /\bjson$/
+
+        conn.adapter Faraday.default_adapter
+
+        conn.headers['X-DNSimple-Token'] = "#{@email}:#{@token}"
+
+        conn.options.timeout      = 5
+        conn.options.open_timeout = 5
+      end
+    end
+
+    def zone
+      records_by_record = connection.get("domains/#{@domain}/records").body.group_by do |dnsimple_record|
+        [ dnsimple_record['record']['name'], dnsimple_record['record']['record_type'] ]
+      end
+
+      records = records_by_record.map do |(name, record_type), records|
+        fqdn = name.present? ? "#{name}.#{@domain}" : @domain
+        ttl = records.first['record']['ttl']
+
+        answers = records.map do |record|
+          Answer.new(record['record']['content'], record['record']['prio'])
+        end
+
+        Record.new(fqdn, record_type, ttl, answers)
+      end
+
+      Zone.new(@domain, records)
+    end
+  end
+end

data/lib/dnsync/http_status.rb

@@ -0,0 +1,56 @@
+require 'webrick'
+
+module Dnsync
+  class HttpStatus
+    def initialize(port, updater)
+      @port    = port
+      @updater = updater
+    end
+
+    def start
+      return if @server || @thread
+
+      logger = WEBrick::Log.new
+      logger.level = WEBrick::Log::WARN
+
+      @server = WEBrick::HTTPServer.new(:Port => @port,
+        :Logger => logger, :AccessLog => [])
+      @server.mount_proc("/status", &method(:handler))
+
+      @thread = Thread.new do
+        Thread.current.abort_on_exception = true
+        @server.start
+      end
+
+      self
+    end
+
+    def stop
+      if @server
+        @server.stop
+      end
+
+      self
+    end
+
+    def join
+      if @thread
+        @thread.join
+      end
+
+      self
+    end
+
+    def handler(request, response)
+      health_problems = @updater.health_problems
+
+      if health_problems.blank?
+        response.status = 200
+        response.body   = "OK\n"
+      else
+        response.status = 500
+        response.body = health_problems + "\n"
+      end
+    end
+  end
+end

data/lib/dnsync/nsone.rb

@@ -0,0 +1,106 @@
+module Dnsync
+  class Nsone
+    def initialize(api_key, domain)
+      unless api_key.present?
+        raise ArgumentError, "api_key must be specified"
+      end
+
+      unless domain.present?
+        raise ArgumentError, "domain must be specified"
+      end
+      
+      @api_key = api_key
+      @domain  = domain
+    end
+    
+    def connection
+      @connection ||= Faraday.new('https://api.nsone.net/v1/') do |conn|
+        conn.request :json
+
+        # conn.response :logger
+        conn.response :raise_error
+        conn.response :json, :content_type => /\bjson$/
+
+        conn.adapter Faraday.default_adapter
+
+        conn.headers['X-NSONE-Key'] = @api_key
+
+        conn.options.timeout      = 5
+        conn.options.open_timeout = 5
+      end
+    end
+
+    def zone
+      zone = connection.get("zones/#{@domain}").body
+      
+      records = zone['records'].map do |record|
+        record_for(record['domain'], record['type'])
+      end
+      
+      Zone.new(@domain, records)
+    end
+    
+    def record_for(fqdn, record_type)
+      record = connection.get("zones/#{@domain}/#{fqdn}/#{record_type}").body
+      
+      answers = record['answers'].map do |answer_record|
+        case answer_record['answer'].length
+        when 2
+          priority, content = *answer_record['answer']
+        when 1
+          content = answer_record['answer'].first
+        else
+          raise "Unknown answer format: #{answer_record.inspect}"
+        end
+        
+        Answer.new(content, priority)
+      end
+      
+      Record.new(record['domain'], record['type'], record['ttl'], answers)
+    end
+
+    def create_record(record)
+      answers = record.answers.map do |answer|
+        if answer.priority
+          { :answer => [ answer.priority, answer.content ] }
+        else
+          { :answer => [ answer.content ] }
+        end
+      end
+
+      connection.put("zones/#{@domain}/#{record.name}/#{record.type}") do |req|
+        req.body = {
+          :type    => record.type,
+          :zone    => @domain,
+          :domain  => record.name,
+          :ttl     => record.ttl,
+          :answers => answers
+        }
+      end
+    end
+
+    def update_record(record)
+      answers = record.answers.map do |answer|
+        if answer.priority
+          { :answer => [ answer.priority, answer.content ] }
+        else
+          { :answer => [ answer.content ] }
+        end
+      end
+
+      connection.post("zones/#{@domain}/#{record.name}/#{record.type}") do |req|
+        req.body = {
+          :type    => record.type,
+          :zone    => @domain,
+          :domain  => record.name,
+          :ttl     => record.ttl,
+          :answers => answers
+        }
+      end
+    end
+
+    def remove_record(record)
+      connection.delete("zones/#{@domain}/#{record.name}/#{record.type}")
+    end
+  end
+end

data/lib/dnsync/record.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/object/blank'
+
+require 'dnsync/answer'
+require 'dnsync/record_identifier'
+
+module Dnsync
+  class Record
+    include Comparable
+
+    attr_reader :identifier, :ttl, :answers
+
+    def initialize(name, type, ttl, answers)
+      unless ttl.present?
+        raise ArgumentError, 'ttl must be provided'
+      end
+
+      unless answers.present?
+        raise ArgumentError, 'at least one answer must be provided'
+      end
+      
+      @identifier = RecordIdentifier.new(name, type)
+      @ttl        = ttl
+      @answers    = answers.sort
+
+      freeze
+    end
+    
+    def name
+      @identifier.name
+    end
+    
+    def type
+      @identifier.type
+    end
+    
+    def <=>(other)
+      [ identifier, ttl, answers ] <=> [ other.identifier, other.ttl, other.answers ]
+    end
+    
+    def hash
+      [ identifier, ttl, answers ].hash
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/dnsync/record_identifier.rb

@@ -0,0 +1,34 @@
+require 'active_support/core_ext/object/blank'
+
+module Dnsync
+  class RecordIdentifier
+    include Comparable
+
+    attr_reader :name, :type
+
+    def initialize(name, type)
+      unless name.present?
+        raise ArgumentError, 'name must be provided'
+      end
+
+      unless type.present?
+        raise ArgumentError, 'type must be provided'
+      end
+
+      @name = name
+      @type = type
+
+      freeze
+    end
+
+    def <=>(other)
+      [ name, type ] <=> [ other.name, other.type ]
+    end
+
+    def hash
+      [ name, type ].hash
+    end
+
+    alias_method :eql?, :==
+  end
+end

data/lib/dnsync/recurring_zone_updater.rb

@@ -0,0 +1,152 @@
+require 'dnsync/zone_updater'
+require 'atomic'
+
+module Dnsync
+  class RecurringZoneUpdater
+    def initialize(source, destination, frequency)
+      @source      = source
+      @destination = destination
+      @frequency   = frequency
+
+      @thread          = Atomic.new(nil)
+      @running         = Atomic.new(false)
+      @last_updated_at = Atomic.new(nil)
+      @last_exception  = Atomic.new(nil)
+    end
+
+    def start
+      if (thread = @thread.value) && thread.alive?
+        return self
+      end
+
+      @running.value = true
+
+      @thread.value = Thread.new do
+        Thread.current.abort_on_exception = true
+        run
+      end
+    end
+
+    def stop
+      @running.value = false
+      self
+    end
+
+    def join
+      if thread = @thread.value
+        thread.join
+      end
+
+      self
+    end
+
+    def healthy?
+      health_problems.blank?
+    end
+
+    def health_problems
+      thread    = @thread.value
+      running   = @running.value
+      updated   = last_updated
+      exception = @last_exception.value
+
+      problems = []
+
+      unless running
+        problems << "Component not running"
+      end
+
+      unless thread && thread.alive?
+        problems << "Thread not alive"
+      end
+
+      unless recently_updated?(updated)
+        if updated
+          time_description = "in %0.2f seconds (should have been %d seconds)" % [ updated.to_f, @frequency ]
+        else
+          time_description = "ever"
+        end
+
+        problems << "Successful update hasn't occured #{time_description}"
+      end
+
+      if exception
+        problems << "Last update failed with #{exception.class}: #{exception.message}"
+      end
+
+      unless problems.empty?
+        problems.join('; ')
+      end
+    end
+
+    def recently_updated?(updated = nil)
+      updated ||= last_updated
+      updated && updated < (@frequency * 2)
+    end
+
+    def last_updated
+      if at = @last_updated_at.value
+        Time.now.to_f - at.to_f
+      end
+    end
+
+    protected
+    def run
+      active_zone = nil
+
+      while @running.value
+        begin
+          source_zone = nil
+
+          Scrolls.log(:from => :recurring_zone_updater, :zone => @source.domain, :for => :source) do
+            source_zone = @source.zone
+          end
+
+          if !active_zone
+            Scrolls.log(:from => :recurring_zone_updater, :zone => @source.domain, :for => :destination) do
+              active_zone = @destination.zone
+            end
+          end
+
+          diff = ZoneDifference.new(active_zone, source_zone, %w(NS SOA))
+
+          Scrolls.log(:from => :recurring_zone_updater, :zone => @source.domain,
+            :action => :updating, :adding => diff.added.length,
+            :updating => diff.changed.length, :removing => diff.removed.length) do
+
+              updater = ZoneUpdater.new(diff, @destination)
+              updater.call
+          end
+
+          active_zone            = source_zone
+          @last_updated_at.value = Time.now
+          @last_exception.value  = nil
+        rescue => e
+          Scrolls.log_exception({ :from => :recurring_zone_updater, :zone => @source.domain }, e)
+          @last_exception.value = e
+        end
+
+        if @running.value
+          sleep_until_next_deadline
+        end
+      end
+    end
+
+    def sleep_until_next_deadline
+      if !@deadline
+        @deadline = Time.now.to_f
+      end
+
+      @deadline = @deadline + @frequency
+
+      sleep_duration = @deadline - Time.now.to_f
+
+      if sleep_duration <= 0
+        Scrolls.log(:from => :recurring_zone_updater, :for => :missed_deadline, :by => sleep_duration)
+        @deadline = Time.now.to_f
+      else
+        sleep sleep_duration
+      end
+    end
+  end
+end

data/lib/dnsync/zone.rb

@@ -0,0 +1,36 @@
+require 'set'
+require 'dnsync/record'
+
+
+module Dnsync
+  class Zone
+    attr_reader :name
+
+    def initialize(name, records)
+      @name = name
+
+      @records_by_identifier = {}
+      records.each do |record|
+        @records_by_identifier[record.identifier] = record
+      end
+
+      freeze
+    end
+    
+    def [](identifier)
+      @records_by_identifier[identifier]
+    end
+    
+    def records_at(*identifiers)
+      @records_by_identifier.values_at(*identifiers.flatten)
+    end
+    
+    def records
+      @records_by_identifier.values
+    end
+    
+    def record_identifiers
+      @records_by_identifier.keys
+    end
+  end
+end

data/lib/dnsync/zone_difference.rb

@@ -0,0 +1,52 @@
+module Dnsync
+  class ZoneDifference
+    def initialize(original, updated, ignored_types = nil)
+      @original      = original
+      @updated       = updated
+      @ignored_types = ignored_types || []
+    end
+    
+    def added
+      @added ||= begin
+        added_identifiers = @updated.record_identifiers - @original.record_identifiers
+        added_identifiers = filter_types(added_identifiers)
+        @updated.records_at(added_identifiers)
+      end
+    end
+    
+    def changed
+      @changed ||= begin
+        overlapping_identifiers = @updated.record_identifiers & @original.record_identifiers
+        overlapping_identifiers = filter_types(overlapping_identifiers)
+      
+        overlapping_identifiers.map do |identifier|
+          original_record = @original[identifier]
+          updated_record  = @updated[identifier]
+        
+          if original_record != updated_record
+            updated_record
+          else
+            nil
+          end
+        end.compact
+      end
+    end
+    
+    def removed
+      @removed ||= begin
+        removed_identifiers = @original.record_identifiers - @updated.record_identifiers
+        removed_identifiers = filter_types(removed_identifiers)
+
+        @original.records_at(removed_identifiers)
+      end
+    end
+
+    def filter_types(identifiers)
+      if @ignored_types.blank?
+        return identifiers
+      end
+
+      identifiers.reject { |identifier| @ignored_types.include?(identifier.type) }
+    end
+  end
+end

data/lib/dnsync/zone_updater.rb

@@ -0,0 +1,22 @@
+module Dnsync
+  class ZoneUpdater
+    def initialize(difference, target)
+      @difference = difference
+      @target     = target
+    end
+
+    def call
+      @difference.added.each do |record|
+        @target.create_record(record)
+      end
+
+      @difference.changed.each do |record|
+        @target.update_record(record)
+      end
+
+      @difference.removed.each do |record|
+        @target.remove_record(record)
+      end
+    end
+  end
+end

data/lib/dnsync.rb

@@ -0,0 +1,4 @@
+
+module Dnsync
+  VERSION = '1.0.0'
+end

data/test/record_identifier_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+require 'set'
+
+require 'dnsync/record_identifier'
+
+class RecordIdentifierTest < Minitest::Test
+  def test_equality
+    a1 = Dnsync::RecordIdentifier.new("record1", "A")
+    a2 = Dnsync::RecordIdentifier.new("record1", "A")
+
+    assert a1 == a2
+  end
+
+  def test_eql
+    a1 = Dnsync::RecordIdentifier.new("record1", "A")
+    a2 = Dnsync::RecordIdentifier.new("record1", "A")
+
+    assert a1.eql?(a2)
+  end
+
+  def test_spaceship
+    a1 = Dnsync::RecordIdentifier.new("record1", "A")
+    a2 = Dnsync::RecordIdentifier.new("record1", "A")
+
+    assert (a1 <=> a2) == 0
+  end
+
+  def test_array_subtract
+    a1 = Dnsync::RecordIdentifier.new("record1", "A")
+    a2 = Dnsync::RecordIdentifier.new("record1", "A")
+
+    assert [a1] - [a2] == []
+  end
+end

data/test/record_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+require 'set'
+
+require 'dnsync/record'
+
+class RecordTest < Minitest::Test
+  def test_equality
+    a1 = Dnsync::Record.new("record1", "a", 300, [ Dnsync::Answer.new("127.0.0.1", nil) ])
+    a2 = Dnsync::Record.new("record1", "a", 300, [ Dnsync::Answer.new("127.0.0.1", nil) ])
+
+    assert a1 == a2
+  end
+
+  def test_inequality
+    a1 = Dnsync::Record.new("record1", "a", 300, [ Dnsync::Answer.new("127.0.0.1", nil) ])
+    a2 = Dnsync::Record.new("record1", "a", 300, [ Dnsync::Answer.new("127.0.0.1", nil) ])
+
+    assert !(a1 != a2)
+  end
+
+  def test_spaceship
+    a1 = Dnsync::Record.new("record1", "a", 300, [ Dnsync::Answer.new("127.0.0.1", nil) ])
+    a2 = Dnsync::Record.new("record1", "a", 300, [ Dnsync::Answer.new("127.0.0.1", nil) ])
+
+    assert (a1 <=> a2) == 0
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/autorun'
+
+Thread.abort_on_exception = true
+
+require 'dnsync'