record_store 0.3.0 → 1.0.0

data/lib/record_store/provider.rb

@@ -0,0 +1,102 @@
+module RecordStore
+  class Provider
+    def self.provider_for(zone_name)
+      dns = Resolv::DNS.new(nameserver: ['8.8.8.8', '8.8.4.4'])
+
+      begin
+        ns_server = dns.getresource(zone_name, Resolv::DNS::Resource::IN::SOA).mname.to_s
+      rescue Resolv::ResolvError => e
+        abort "Domain doesn't exist"
+      end
+
+      case ns_server
+      when /dnsimple\.com\z/
+        'DNSimple'
+      when /dynect\.net\z/
+        'DynECT'
+      else
+        nil
+      end
+    end
+
+    def self.record_types
+      Set.new([
+        'A',
+        'AAAA',
+        'CNAME',
+        'MX',
+        'NS',
+        'SPF',
+        'SRV',
+        'TXT',
+      ])
+    end
+
+    def initialize(zone:)
+      @zone_name = zone
+    end
+
+    def add(record)
+      raise NotImplementedError
+    end
+
+    def remove(record)
+      raise NotImplementedError
+    end
+
+    def update(id, record)
+      raise NotImplementedError
+    end
+
+    # Applies changeset to provider
+    def apply_changeset(changeset, stdout = $stdout)
+      begin
+        stdout.puts "Applying #{changeset.additions.size} additions, #{changeset.removals.size} removals, & #{changeset.updates.size} updates..."
+
+        changeset.changes.each do |change|
+          case change.type
+            when :removal;
+              stdout.puts "Removing #{change.record}..."
+              remove(change.record)
+            when :addition;
+              stdout.puts "Creating #{change.record}..."
+              add(change.record)
+            when :update;
+              stdout.puts "Updating record with ID #{change.id} to #{change.record}..."
+              update(change.id, change.record)
+            else
+              raise ArgumentError, "Unknown change type #{change.type.inspect}"
+          end
+        end
+
+        puts "\nPublished #{@zone_name} changes"
+      end
+    end
+
+    # returns an array of Record objects that match the records which exist in the provider
+    def retrieve_current_records(stdout = $stdout)
+      raise NotImplementedError
+    end
+
+    # Returns an array of the zones managed by provider as strings
+    def zones
+      raise NotImplementedError
+    end
+
+    def secrets
+      @secrets ||= if File.exists?(RecordStore.secrets_path)
+        JSON.parse(File.read(RecordStore.secrets_path))
+      else
+        raise "You don't have a secrets.json file set up!"
+      end
+    end
+
+    def thawable?
+      self.class.method_defined?(:thaw)
+    end
+
+    def freezable?
+      self.class.method_defined?(:freeze_zone)
+    end
+  end
+end

data/lib/record_store/provider/dnsimple.rb

@@ -0,0 +1,158 @@
+require 'fog/dnsimple'
+
+module RecordStore
+  class Provider::DNSimple < Provider
+    def self.record_types
+      super.add('ALIAS')
+    end
+
+    def add(record)
+      record_hash = api_hash(record)
+      res = session.create_record(
+        @zone_name,
+        record_hash.fetch(:name),
+        record.type,
+        record_hash.fetch(:content),
+        ttl: record_hash.fetch(:ttl),
+        priority: record_hash.fetch(:prio, nil)
+      )
+
+      if record.type == 'ALIAS'
+        txt_alias = retrieve_current_records.detect do |rr|
+          rr.type == 'TXT' && rr.fqdn == record.fqdn && rr.txtdata == "ALIAS for #{record.cname.gsub(/.\z/, '')}"
+        end
+        remove(txt_alias)
+      end
+
+      res
+    end
+
+    def remove(record)
+      session.delete_record(@zone_name, record.id)
+    end
+
+    def update(id, record)
+      record_hash = api_hash(record)
+      session.update_record(@zone_name, id, api_hash(record))
+    end
+
+    # returns an array of Record objects that match the records which exist in the provider
+    def retrieve_current_records(stdout = $stdout)
+      session.list_records(@zone_name).body.map do |record|
+        record_body = record.fetch('record')
+
+        begin
+          build_from_api(record_body)
+        rescue StandardError
+          stdout.puts "Cannot build record: #{record_body}"
+          raise
+        end
+      end.select(&:present?)
+    end
+
+    # Returns an array of the zones managed by provider as strings
+    def zones
+      session.zones.map(&:domain)
+    end
+
+    private
+
+    def discard_change_set
+      session.request(expects: 200, method: :delete, path: "ZoneChanges/#{@zone_name}")
+    end
+
+    def session
+      @dns ||= Fog::DNS.new(session_params)
+    end
+
+    def session_params
+      {
+        provider: 'DNSimple',
+        dnsimple_email: secrets.fetch('email'),
+        dnsimple_token: secrets.fetch('api_token'),
+      }
+    end
+
+    def secrets
+      super.fetch('dnsimple')
+    end
+
+    def build_from_api(api_record)
+      record_type = api_record.fetch('record_type')
+      record = {
+        record_id: api_record.fetch('id'),
+        ttl: api_record.fetch('ttl'),
+        fqdn: api_record.fetch('name').present? ? "#{api_record.fetch('name')}.#{@zone_name}" : @zone_name,
+      }
+
+      return if record_type == 'SOA'
+
+      case record_type
+      when 'A'
+        record.merge!(address: api_record.fetch('content'))
+      when 'AAAA'
+        record.merge!(address: api_record.fetch('content'))
+      when 'ALIAS'
+        record.merge!(cname: api_record.fetch('content'))
+      when 'CNAME'
+        record.merge!(cname: api_record.fetch('content'))
+      when 'MX'
+        record.merge!(preference: api_record.fetch('prio'), exchange: api_record.fetch('content'))
+      when 'NS'
+        record.merge!(nsdname: api_record.fetch('content'))
+      when 'SPF'
+        record.merge!(txtdata: api_record.fetch('content'))
+      when 'SRV'
+        weight, port, host = api_record.fetch('content').split(' ')
+
+        record.merge!(
+          priority: api_record.fetch('prio'),
+          weight: weight,
+          port: port,
+          target: Record.ensure_ends_with_dot(host),
+        )
+      when 'TXT'
+        record.merge!(txtdata: api_record.fetch('content'))
+      end
+
+      unless record.fetch(:fqdn).ends_with?('.')
+        record[:fqdn] += '.'
+      end
+
+      Record.const_get(record_type).new(record)
+    end
+
+    def api_hash(record)
+      record_hash = {
+        name: record.fqdn.gsub("#{Record.ensure_ends_with_dot(@zone_name)}", '').gsub(/.\z/, ''),
+        ttl: record.ttl,
+        type: record.type,
+      }
+
+      case record.type
+      when 'A'
+        record_hash[:content] = record.address
+      when 'AAAA'
+        record_hash[:content] = record.address
+      when 'ALIAS'
+        record_hash[:content] = record.cname.gsub(/.\z/, '')
+      when 'CNAME'
+        record_hash[:content] = record.cname.gsub(/.\z/, '')
+      when 'MX'
+        record_hash[:prio] = record.preference
+        record_hash[:content] = record.exchange.gsub(/.\z/, '')
+      when 'NS'
+        record_hash[:content] = record.nsdname.gsub(/.\z/, '')
+      when 'SPF'
+        record_hash[:content] = record.txtdata
+      when 'SRV'
+        record_hash[:content] = "#{record.weight} #{record.port} #{record.target.gsub(/.\z/, '')}"
+        record_hash[:prio] = record.priority
+      when 'TXT'
+        record_hash[:content] = record.txtdata
+      end
+
+      record_hash
+    end
+  end
+end

data/lib/record_store/provider/dynect.rb

@@ -0,0 +1,97 @@
+require 'fog/dynect'
+
+module RecordStore
+  class Provider::DynECT < Provider
+    def freeze_zone
+      session.put_zone(@zone_name, freeze: true)
+    end
+
+    def thaw
+      session.put_zone(@zone_name, thaw: true)
+    end
+
+    def add(record)
+      session.post_record(record.type, @zone_name, record.fqdn, record.rdata, ttl: record.ttl)
+    end
+
+    def remove(record)
+      session.delete_record(record.type, @zone_name, record.fqdn, record.id)
+    end
+
+    def update(id, record)
+      session.put_record(record.type, @zone_name, record.fqdn, record.rdata, ttl: record.ttl, record_id: id)
+    end
+
+    def publish
+      session.put_zone(@zone_name, publish: true)
+    end
+
+    # Applies changeset to provider
+    def apply_changeset(changeset, stdout = $stdout)
+      begin
+        thaw
+        super
+        publish
+      rescue StandardError
+        puts "An exception occurred while applying DNS changes, deleting changeset"
+        discard_change_set
+        raise
+      ensure
+        freeze_zone
+      end
+    end
+
+    # returns an array of Record objects that match the records which exist in the provider
+    def retrieve_current_records(stdout = $stdout)
+      session.get_all_records(@zone_name).body.fetch('data').flat_map do |type, records|
+        records.map do |record_body|
+          begin
+            build_from_api(record_body)
+          rescue StandardError => e
+            stdout.puts "Cannot build record: #{record_body}"
+          end
+        end
+      end.select(&:present?)
+    end
+
+    # Returns an array of the zones managed by provider as strings
+    def zones
+      session.zones.map(&:domain)
+    end
+
+    private
+
+    def discard_change_set
+      session.request(expects: 200, method: :delete, path: "ZoneChanges/#{@zone_name}")
+    end
+
+    def session
+      @dns ||= Fog::DNS.new(session_params)
+    end
+
+    def session_params
+      {
+        provider: 'Dynect',
+        dynect_customer: secrets.fetch('customer'),
+        dynect_username: secrets.fetch('username'),
+        dynect_password: secrets.fetch('password')
+      }
+    end
+
+    def secrets
+      super.fetch('dynect')
+    end
+
+    def build_from_api(api_record)
+      record = api_record.merge(api_record.fetch('rdata')).slice!('rdata').symbolize_keys
+
+      return if record.fetch(:record_type) == 'SOA'
+
+      unless record.fetch(:fqdn).ends_with?('.')
+        record[:fqdn] = "#{record.fetch(:fqdn)}."
+      end
+
+      Record.const_get(record.fetch(:record_type)).new(record)
+    end
+  end
+end

data/lib/record_store/record.rb

@@ -0,0 +1,70 @@
+module RecordStore
+  class Record
+    FQDN_REGEX  = /\A(\*\.)?([a-z0-9_]+(-[a-z0-9]+)*\._?)+[a-z]{2,}\.\Z/i
+    CNAME_REGEX =  /\A(\*\.)?([a-z0-9]+(-[a-z0-9]+)*\._?)+[a-z]{2,}\.\Z/i
+
+    include ActiveModel::Validations
+
+    attr_accessor :fqdn, :ttl, :id
+
+    validates :ttl, numericality: { only_integer: true, greater_than_or_equal_to: 0, less_than_or_equal_to: 2147483647 }
+    validates :fqdn, format: { with: Record::FQDN_REGEX }, length: { maximum: 254 }
+    validate :validate_label_length
+
+    def initialize(record)
+      @fqdn = Record.ensure_ends_with_dot(record.fetch(:fqdn))
+      @ttl  = record.fetch(:ttl)
+      @id   = record.fetch(:record_id, nil)
+    end
+
+    def self.build_from_yaml_definition(yaml_definition)
+      Record.const_get(yaml_definition.fetch(:type)).new(yaml_definition)
+    end
+
+    def log!(logger=STDOUT)
+      logger.puts to_s
+    end
+
+    def to_hash
+      {
+        type: type,
+        fqdn: fqdn,
+        ttl: ttl
+      }.merge(rdata)
+    end
+
+    def type
+      self.class.name.split('::').last
+    end
+
+    def ==(other)
+      other.class == self.class && other.to_hash == self.to_hash
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      to_hash.hash
+    end
+
+    def to_json
+      { ttl: ttl, rdata: rdata }
+    end
+
+    def key
+      "#{type},#{fqdn}"
+    end
+
+    protected
+
+    def validate_label_length
+      unless fqdn.split('.').all? { |label| label.length <= 63 }
+        errors.add(:fqdn, "A label should be at most 63 characters")
+      end
+    end
+
+    def self.ensure_ends_with_dot(fqdn)
+      fqdn.end_with?(".") ? fqdn : "#{fqdn}."
+    end
+  end
+end

data/lib/record_store/record/a.rb

@@ -0,0 +1,32 @@
+module RecordStore
+  class Record::A < Record
+    attr_accessor :address
+
+    validates_presence_of :address
+    validate :valid_address?
+
+    def initialize(record)
+      super
+      @address = record.fetch(:address)
+    end
+
+    def to_s
+      "[ARecord] #{fqdn} #{ttl} IN A #{address}"
+    end
+
+    def rdata
+      { address: address }
+    end
+
+    private
+
+    def valid_address?
+      begin
+        ip = IPAddr.new(address)
+        errors.add(:address, 'is not an IPv4 address') unless ip.ipv4?
+      rescue IPAddr::InvalidAddressError => e
+        errors.add(:address, 'is invalid')
+      end
+    end
+  end
+end