record_store 0.3.0 → 1.0.0

data/lib/record_store/record/aaaa.rb

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

data/lib/record_store/record/alias.rb

@@ -0,0 +1,20 @@
+module RecordStore
+  class Record::ALIAS < Record
+    attr_accessor :cname
+
+    validates :cname, presence: true, format: { with: Record::CNAME_REGEX, message: 'is not a fully qualified domain name' }
+
+    def initialize(record)
+      super
+      @cname = Record.ensure_ends_with_dot(record.fetch(:cname))
+    end
+
+    def rdata
+      { cname: cname }
+    end
+
+    def to_s
+      "[ALIASRecord] #{fqdn} #{ttl} IN ALIAS #{cname}"
+    end
+  end
+end

data/lib/record_store/record/cname.rb

@@ -0,0 +1,20 @@
+module RecordStore
+  class Record::CNAME < Record
+    attr_accessor :cname
+
+    validates :cname, presence: true, format: { with: Record::CNAME_REGEX, message: 'is not a fully qualified domain name' }
+
+    def initialize(record)
+      super
+      @cname = Record.ensure_ends_with_dot(record.fetch(:cname))
+    end
+
+    def rdata
+      { cname: cname }
+    end
+
+    def to_s
+      "[CNAMERecord] #{fqdn} #{ttl} IN CNAME #{cname}"
+    end
+  end
+end

data/lib/record_store/record/mx.rb

@@ -0,0 +1,25 @@
+module RecordStore
+  class Record::MX < Record
+    attr_accessor :exchange, :preference
+
+    validates :preference, numericality: { only_integer: true, greater_than_or_equal_to: 0 }, presence: true
+    validates :exchange, presence: true, format: { with: Record::FQDN_REGEX, message: 'is not a fully qualified domain name' }
+
+    def initialize(record)
+      super
+      @exchange = Record.ensure_ends_with_dot(record.fetch(:exchange))
+      @preference = record.fetch(:preference)
+    end
+
+    def rdata
+      {
+        preference: preference,
+        exchange: exchange
+      }
+    end
+
+    def to_s
+      "[MXRecord] #{fqdn} #{ttl} IN MX #{preference} #{exchange}"
+    end
+  end
+end

data/lib/record_store/record/ns.rb

@@ -0,0 +1,20 @@
+module RecordStore
+  class Record::NS < Record
+    attr_accessor :nsdname
+
+    validates :nsdname, presence: true, format: { with: Record::FQDN_REGEX, message: 'is not a fully qualified domain name' }
+
+    def initialize(record)
+      super
+      @nsdname = Record.ensure_ends_with_dot(record.fetch(:nsdname))
+    end
+
+    def rdata
+      { nsdname: nsdname }
+    end
+
+    def to_s
+      "[NSRecord] #{fqdn} #{ttl} IN NS #{nsdname}"
+    end
+  end
+end

data/lib/record_store/record/spf.rb

@@ -0,0 +1,20 @@
+module RecordStore
+  class Record::SPF < Record
+    attr_accessor :txtdata
+
+    validates :txtdata, presence: true, length: { maximum: 255 }
+
+    def initialize(record)
+      super
+      @txtdata = record.fetch(:txtdata)
+    end
+
+    def to_s
+      "[SPFRecord] #{fqdn} #{ttl} IN SPF \"#{txtdata}\""
+    end
+
+    def rdata
+      { txtdata: txtdata }
+    end
+  end
+end

data/lib/record_store/record/srv.rb

@@ -0,0 +1,27 @@
+module RecordStore
+  class Record::SRV < Record
+    attr_accessor :priority, :port, :weight, :target
+
+    validates :priority, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :port, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :weight, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :target, presence: true, format: { with: Record::CNAME_REGEX, message: 'is not a fully qualified domain name' }
+
+    def initialize(record)
+      super
+      @priority = record.fetch(:priority)
+      @weight   = record.fetch(:weight)
+      @port     = record.fetch(:port)
+      @target   = record.fetch(:target)
+    end
+
+    def to_s
+      "[SRVRecord] #{fqdn} #{ttl} IN SRV #{priority} #{weight} #{port} #{target}"
+    end
+
+    def rdata
+      { priority: priority, port: port, weight: weight, target: target }
+    end
+
+  end
+end

data/lib/record_store/record/txt.rb

@@ -0,0 +1,29 @@
+module RecordStore
+  class Record::TXT < Record
+    attr_accessor :txtdata
+
+    validates :txtdata, presence: true, length: { maximum: 255 }
+    validate :escaped_semicolons
+
+    def initialize(record)
+      super
+      @txtdata = record.fetch(:txtdata)
+    end
+
+    def to_s
+      "[TXTRecord] #{fqdn} #{ttl} IN TXT \"#{txtdata}\""
+    end
+
+    def rdata
+      { txtdata: txtdata }
+    end
+
+    private
+
+    def escaped_semicolons
+      if txtdata =~ /([^\\]|\A);/
+        errors.add(:txtdata, 'has unescaped semicolons (See RFC 1035).')
+      end
+    end
+  end
+end

data/lib/record_store/version.rb

@@ -0,0 +1,3 @@
+module RecordStore
+  VERSION = '1.0.0'
+end

data/lib/record_store/zone.rb

@@ -0,0 +1,193 @@
+module RecordStore
+  class Zone
+    module YamlDefinitions
+      include Enumerable
+
+      def all
+        defined.values
+      end
+
+      def defined
+        @defined ||= yaml_files.inject({}) { |zones, file| zones.merge(load_yaml_file(file)) }
+      end
+
+      def [](name)
+        defined.fetch(name)
+      end
+
+      def each(&block)
+        defined.each(&block)
+      end
+
+      def find(name)
+        return unless File.exists?(zone_path = "#{RecordStore.zones_path}/#{name}.yml")
+        Zone.from_yaml_definition(*YAML.load_file(zone_path).first)
+      end
+
+      private
+
+      def load_yaml_file(filename)
+        result = {}
+        YAML.load_file(filename).each do |name, definition|
+          result[name] = Zone.from_yaml_definition(name, definition)
+        end
+        result
+      end
+
+      def yaml_files
+        Dir["#{RecordStore.zones_path}/*.yml"]
+      end
+    end
+
+    extend YamlDefinitions
+    include ActiveModel::Validations
+
+    attr_accessor :name
+    attr_reader :config
+    attr_writer :records
+
+    validates :name, presence: true, format: { with: Record::FQDN_REGEX, message: 'is not a fully qualified domain name' }
+    validate :validate_records
+    validate :validate_config
+    validate :validate_all_records_are_unique
+    validate :validate_a_records_for_same_fqdn
+    validate :validate_cname_records_for_same_fqdn
+    validate :validate_cname_records_dont_point_to_root
+    validate :validate_provider_can_handle_zone_records
+
+    def self.from_yaml_definition(name, definition)
+      new(name, definition.deep_symbolize_keys)
+    end
+
+    def self.download(name, provider_name)
+      dns = new(name, config: {provider: provider_name}).provider
+      current_records = dns.retrieve_current_records
+
+      File.write("#{RecordStore.zones_path}/#{name}.yml", {
+        name => {
+          config: {
+            provider: provider_name,
+            ignore_patterns: [{type: "NS", fqdn: "#{name}."}],
+          },
+          records: current_records.map(&:to_hash).sort_by! {|r| [r.fetch(:fqdn), r.fetch(:type), r[:nsdname] || r[:address]]}
+        }
+      }.deep_stringify_keys.to_yaml.gsub("---\n", ''))
+    end
+
+    def initialize(name, records: [], config: {})
+      @name            = Record.ensure_ends_with_dot(name)
+      @config          = RecordStore::Zone::Config.new(config)
+      @records         = build_records(records)
+    end
+
+    def changeset
+      current_records = Zone.filter_records(provider.retrieve_current_records, config.ignore_patterns)
+
+      Changeset.new(
+        current_records: current_records,
+        desired_records: records
+      )
+    end
+
+    def unchanged?
+      changeset.empty?
+    end
+
+    def records
+      @records_cache ||= Zone.filter_records(@records, config.ignore_patterns)
+    end
+
+    def config=(config)
+      @records_cache = nil
+      @config = config
+    end
+
+    def provider
+      Provider.const_get(config.provider).new(zone: name.gsub(/\.\z/, ''))
+    end
+
+    private
+
+    def build_records(records)
+      records.map { |record| Record.build_from_yaml_definition(record) }
+    end
+
+    def validate_records
+      records.each do |record|
+        unless record.fqdn.end_with?(name)
+          errors.add(:records, "record #{record} does not belong in zone #{name}")
+        end
+
+        unless record.valid?
+          errors.add(:records, "invalid record: #{record}")
+        end
+      end
+    end
+
+    def validate_config
+      unless config.valid?
+        errors.add(:config, "invalid config: #{config}")
+      end
+    end
+
+    def validate_all_records_are_unique
+      duplicates = records.select { |r| records.count(r) > 1 }
+      duplicates.uniq.each do |record|
+        errors.add(:records, "Duplicate record: #{record}")
+      end
+    end
+
+    def validate_a_records_for_same_fqdn
+      a_records = records.select { |record| record.is_a?(Record::A) }.group_by(&:fqdn)
+      a_records.each do |fqdn, records|
+        if records.map(&:ttl).uniq.size > 1
+          errors.add(:records, "All A records for #{fqdn} should have the same TTL")
+        end
+      end
+    end
+
+    def validate_cname_records_for_same_fqdn
+      cname_records = records.select { |record| record.is_a?(Record::CNAME) }
+      cname_records.each do |cname_record|
+        records.each do |record|
+          if record.fqdn == cname_record.fqdn && record != cname_record
+            case record.type
+              when 'SIG', 'NXT', 'KEY'
+                # this is fine
+              when 'CNAME'
+                errors.add(:records, "Multiple CNAME records are defined for #{record.fqdn}: #{record}")
+              else
+                errors.add(:records, "A CNAME record is defined for #{cname_record.fqdn}, so this record is not allowed: #{record}")
+            end
+          end
+        end
+      end
+    end
+
+    def validate_cname_records_dont_point_to_root
+      cname_record = records.detect { |record| record.is_a?(Record::CNAME) && record.fqdn == @name }
+
+      unless cname_record.nil?
+        errors.add(:records, "A CNAME record cannot be defined on the root of the zone: #{cname_record}")
+      end
+    end
+
+    def self.filter_records(current_records, ignore_patterns)
+      ignore_patterns.inject(current_records) do |remaining_records, pattern|
+        remaining_records.reject do |record|
+          pattern.all? { |(key, value)| record.respond_to?(key) && value === record.send(key) }
+        end
+      end
+    end
+
+    def validate_provider_can_handle_zone_records
+      record_types = records.map(&:type).to_set
+      return unless config.valid?
+      provider_supported_record_types = Provider.const_get(config.provider).record_types
+
+      (record_types - provider_supported_record_types).each do |record_type|
+        errors.add(:records, "#{record_type} is a not a supported record type in #{config.provider}")
+      end
+    end
+  end
+end

data/lib/record_store/zone/config.rb

@@ -0,0 +1,24 @@
+module RecordStore
+  class Zone
+    class Config
+      include ActiveModel::Validations
+
+      attr_reader :ignore_patterns, :provider
+
+      validate :validate_zone_config
+
+      def initialize(ignore_patterns: [], provider: nil)
+        @ignore_patterns = ignore_patterns
+        @provider = provider
+      end
+
+      private
+
+      def validate_zone_config
+        unless Provider.constants.include?(provider.to_s.to_sym)
+          errors.add(:provider, 'provider specified does not exist')
+        end
+      end
+    end
+  end
+end

data/record_store.gemspec

@@ -1,20 +1,36 @@
-# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'record_store/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "record_store"
-  spec.version       = "0.3.0"
-  spec.authors       = ["Paul Barry"]
-  spec.email         = ["mail@paulbarry.com"]
+  spec.name        = 'record_store'
+  spec.version     = RecordStore::VERSION
+  spec.authors     = ['Willem van Bergen', 'Emil Stolarsky']
+  spec.email       = ['willem@railsdoctors.com', 'emil@shopify.com']
 
-  spec.summary       = %q{Easily store records in your database with Sequel}
-  spec.homepage      = "http://github.com/pjb3/record_store"
-  spec.license       = "MIT"
+  spec.summary     = 'Manage DNS using git'
+  spec.description = "Manage DNS through a git-based workflow. If you're looking for the original 'record_store', that has been renamed to 'sequel_record_store'."
+  spec.homepage    = 'https://github.com/Shopify/record_store'
+  spec.license     = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|DESIGN)}) }
+  spec.executables = ['record-store']
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.9"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.required_ruby_version = '>= 2.0'
+
+  spec.add_runtime_dependency 'thor'
+  spec.add_runtime_dependency 'activesupport', '~> 4.2'
+  spec.add_runtime_dependency 'activemodel', '~> 4.2'
+  spec.add_runtime_dependency 'fog'
+  spec.add_runtime_dependency 'fog-json'
+  spec.add_runtime_dependency 'fog-xml'
+  spec.add_runtime_dependency 'fog-dynect'
+  spec.add_runtime_dependency 'ejson'
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'pry'
 end