record_store 2.1.0 → 3.0.0

data/lib/record_store/version.rb

@@ -1,3 +1,3 @@
 module RecordStore
-  VERSION = '2.1.0'
+  VERSION = '3.0.0'
 end

data/lib/record_store/zone.rb

@@ -1,108 +1,10 @@
 module RecordStore
   class Zone
-    module YamlDefinitions
-      include Enumerable
-
-      def all
-        defined.values
-      end
-
-      def defined
-        @defined ||= yaml_files.inject({}) { |zones, file| zones.merge(load_yml_zone_definition(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")
-        load_yml_zone_definition(zone_path).first.last
-      end
-
-      def write(name, config:, records:, format: :file)
-        raise ArgumentError, "format must be :directory or :file" unless %i(file directory).include?(format)
-        name = name.chomp('.')
-        zone_file = "#{RecordStore.zones_path}/#{name}.yml"
-        zone = { name => { config: config.to_hash } }
-        records = records.map(&:to_hash).sort_by! {|r| [r.fetch(:fqdn), r.fetch(:type), r[:nsdname] || r[:address]]}
-
-        if format == :file
-          zone[name][:records] = records
-          write_yml_file(zone_file, zone.deep_stringify_keys)
-          remove_record_files(name)
-        else
-          write_yml_file(zone_file, zone.deep_stringify_keys)
-          remove_record_files(name)
-          write_record_files(name, records)
-        end
-      end
-
-      private
-
-      def write_yml_file(filename, data)
-        lines = data.to_yaml.lines
-        lines.shift if lines.first == "---\n"
-        File.write(filename, lines.join)
-      end
-
-      def load_yml_zone_definition(filename)
-        result = {}
-        dir = File.dirname(filename)
-        YAML.load_file(filename).each do |name, definition|
-          definition['records'] ||= []
-          Dir["#{dir}/#{name}/*__*.yml"].each do |record_file|
-            definition['records'] += load_yml_record_definitions(name, record_file)
-          end
-          result[name] = Zone.from_yaml_definition(name, definition)
-        end
-        result
-      end
-
-      def load_yml_record_definitions(name, record_file)
-        type, domain = File.basename(record_file, '.yml').split('__')
-        Array.wrap(YAML.load_file(record_file)).map do |record_definition|
-          record_definition.merge(fqdn: "#{domain}.#{name}", type: type)
-        end
-      end
-
-      def remove_record_files(name)
-        dir = "#{RecordStore.zones_path}/#{name}"
-        File.unlink(*Dir["#{dir}/*"])
-        Dir.unlink(dir)
-      rescue Errno::ENOENT
-      end
-
-      def write_record_files(name, records)
-        dir = "#{RecordStore.zones_path}/#{name}"
-        Dir.mkdir(dir)
-        records.group_by { |record| [record.fetch(:fqdn), record.fetch(:type)] }.each do |(fqdn, type), grouped_records|
-          grouped_records.each do |record|
-            record.delete(:fqdn)
-            record.delete(:type)
-            record.deep_stringify_keys!
-          end
-          grouped_records = grouped_records.first if grouped_records.size == 1
-          domain = fqdn.chomp('.').chomp(name).chomp('.')
-          write_yml_file("#{dir}/#{type}__#{domain}.yml", grouped_records)
-        end
-      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
@@ -115,50 +17,80 @@ module RecordStore
     validate :validate_can_handle_alias_records
     validate :validate_alias_points_to_root
 
-    def self.from_yaml_definition(name, definition)
-      new(name, definition.deep_symbolize_keys)
-    end
+    class << self
+      def download(name, provider_name, **write_options)
+        zone = Zone.new(name: name, config: {providers: [provider_name]})
+        raise ArgumentError, zone.errors.full_messages.join("\n") unless zone.valid?
 
-    def self.download(name, provider_name, **write_options)
-      dns = new(name, config: {provider: provider_name}).provider
-      current_records = dns.retrieve_current_records
-      write(name, records: current_records, config: {
-        provider: provider_name,
-        ignore_patterns: [{type: "NS", fqdn: "#{name}."}],
-        supports_alias: current_records.map(&:type).include?('ALIAS') || nil
-      }, **write_options)
-    end
+        zone.records = zone.providers.first.retrieve_current_records(zone: name)
+
+        zone.config = Zone::Config.new(
+          providers: [provider_name],
+          ignore_patterns: [{type: "NS", fqdn: "#{name}."}],
+          supports_alias: (zone.records.map(&:type).include?('ALIAS') || nil)
+        )
+
+        zone.write(**write_options)
+      end
 
-    def initialize(name, records: [], config: {})
-      @name            = Record.ensure_ends_with_dot(name)
-      @config          = RecordStore::Zone::Config.new(config)
-      @records         = build_records(records)
+      def 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 modified
+        modified_zones, mutex = [], Mutex.new
+        self.all.map do |zone|
+          thread = Thread.new do
+            mutex.synchronize {modified_zones << zone} unless zone.unchanged?
+          end
+        end.each(&:join)
+
+        modified_zones
+      end
     end
 
-    def changeset
-      current_records = Zone.filter_records(provider.retrieve_current_records, config.ignore_patterns)
+    def initialize(name:, records: [], config: {})
+      @name = Record.ensure_ends_with_dot(name)
+      @config = RecordStore::Zone::Config.new(config.deep_symbolize_keys)
+      @records = build_records(records)
+    end
 
-      Changeset.new(
-        current_records: current_records,
-        desired_records: records
-      )
+    def build_changesets
+      @changesets ||= begin
+        providers.map do |provider|
+          Changeset.build_from(provider: provider, zone: self)
+        end
+      end
     end
 
     def unchanged?
-      changeset.empty?
+      build_changesets.all?(&:empty?)
+    end
+
+    def unrooted_name
+      @name.chomp('.')
     end
 
     def records
       @records_cache ||= Zone.filter_records(@records, config.ignore_patterns)
     end
 
+    def records=(records)
+      @records_cache = nil
+      @records = records
+    end
+
     def config=(config)
       @records_cache = nil
       @config = config
     end
 
-    def provider
-      Provider.const_get(config.provider).new(zone: name.chomp('.'))
+    def providers
+      @providers ||= config.providers.map { |provider| Provider.const_get(provider) }
     end
 
     def write(**write_options)
@@ -232,28 +164,23 @@ module RecordStore
       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}")
+      providers.each do |provider|
+        (record_types - provider.record_types).each do |record_type|
+          errors.add(:records, "#{record_type} is a not a supported record type in #{provider.to_s}")
+        end
       end
     end
 
     def validate_can_handle_alias_records
       return unless records.any? { |record| record.is_a?(Record::ALIAS) }
       return if config.supports_alias?
-      errors.add(:records, "#{config.provider} does not support ALIAS records for #{name.chomp('.')} zone")
+
+      # TODO(es): refactor to specify which provider
+      errors.add(:records, "one of the providers for #{unrooted_name} does not support ALIAS records")
     end
 
     def validate_alias_points_to_root

data/lib/record_store/zone/config.rb

@@ -3,35 +3,42 @@ module RecordStore
     class Config
       include ActiveModel::Validations
 
-      attr_reader :ignore_patterns, :provider, :supports_alias
+      attr_reader :ignore_patterns, :providers, :supports_alias
 
       validate :validate_zone_config
 
-      def initialize(ignore_patterns: [], provider: nil, supports_alias: nil)
+      def initialize(ignore_patterns: [], providers: nil, supports_alias: nil)
         @ignore_patterns = ignore_patterns
-        @provider = provider
+        @providers = providers
         @supports_alias = supports_alias
       end
 
       def supports_alias?
-        @supports_alias.nil? && valid_provider? ? Provider.const_get(provider).supports_alias? : @supports_alias
+        if @supports_alias.nil?
+          valid_providers? && providers.all? { |provider| Provider.const_get(provider).supports_alias? }
+        else
+          @supports_alias
+        end
       end
 
       def to_hash
-        {
-          provider: provider,
+        config_hash = {
+          providers: providers,
           ignore_patterns: ignore_patterns,
         }
+        config_hash.merge!(supports_alias: supports_alias) if supports_alias
+
+        config_hash
       end
 
       private
 
       def validate_zone_config
-        errors.add(:provider, 'provider specified does not exist') unless valid_provider?
+        errors.add(:providers, 'provider specified does not exist') unless valid_providers?
       end
 
-      def valid_provider?
-        Provider.constants.include?(provider.to_s.to_sym)
+      def valid_providers?
+        providers.present? && providers.all? { |provider| Provider.constants.include?(provider.to_s.to_sym) }
       end
     end
   end

data/lib/record_store/zone/yaml_definitions.rb

@@ -0,0 +1,105 @@
+module RecordStore
+  class Zone
+    module YamlDefinitions
+      include Enumerable
+
+      def all
+        defined.values
+      end
+
+      def defined
+        @defined ||= yaml_files
+          .map { |file| load_yml_zone_definition(file) }
+          .index_by { |zone| zone.unrooted_name }
+      end
+
+      def [](name)
+        defined.fetch(name)
+      end
+
+      def each(&block)
+        defined.each(&block)
+      end
+
+      def find(name)
+        defined[name]
+      end
+
+      def reset
+        @defined = nil
+      end
+
+      def write(name, config:, records:, format: :file)
+        raise ArgumentError, "format must be :directory or :file" unless %i(file directory).include?(format)
+        name = name.chomp('.')
+        zone_file = "#{RecordStore.zones_path}/#{name}.yml"
+        zone = { name => { config: config.to_hash } }
+        records = records.map(&:to_hash).sort_by! {|r| [r.fetch(:fqdn), r.fetch(:type), r[:nsdname] || r[:address]]}
+
+        if format == :file
+          zone[name][:records] = records
+          write_yml_file(zone_file, zone.deep_stringify_keys)
+          remove_record_files(name)
+        else
+          write_yml_file(zone_file, zone.deep_stringify_keys)
+          remove_record_files(name)
+          write_record_files(name, records)
+        end
+      end
+
+      private
+
+      def write_yml_file(filename, data)
+        lines = data.to_yaml.lines
+        lines.shift if lines.first == "---\n"
+        File.write(filename, lines.join)
+      end
+
+      def load_yml_zone_definition(filename)
+        dir = File.dirname(filename)
+        data = YAML.load_file(filename)
+        raise 'more than one zone in file' if data.size > 1
+        name, definition = data.first
+        definition['records'] ||= []
+        definition['records'] = definition['records'].map(&:deep_symbolize_keys)
+        Dir["#{dir}/#{name}/*__*.yml"].each do |record_file|
+          definition['records'] += load_yml_record_definitions(name, record_file)
+        end
+        Zone.new(name: name, records: definition['records'], config: definition['config'])
+      end
+
+      def load_yml_record_definitions(name, record_file)
+        type, domain = File.basename(record_file, '.yml').split('__')
+        Array.wrap(YAML.load_file(record_file)).map do |record_definition|
+          record_definition.merge('fqdn' => "#{domain}.#{name}", 'type' => type)
+        end.map(&:deep_symbolize_keys)
+      end
+
+      def remove_record_files(name)
+        dir = "#{RecordStore.zones_path}/#{name}"
+        File.unlink(*Dir["#{dir}/*"])
+        Dir.unlink(dir)
+      rescue Errno::ENOENT
+      end
+
+      def write_record_files(name, records)
+        dir = "#{RecordStore.zones_path}/#{name}"
+        Dir.mkdir(dir)
+        records.group_by { |record| [record.fetch(:fqdn), record.fetch(:type)] }.each do |(fqdn, type), grouped_records|
+          grouped_records.each do |record|
+            record.delete(:fqdn)
+            record.delete(:type)
+            record.deep_stringify_keys!
+          end
+          grouped_records = grouped_records.first if grouped_records.size == 1
+          domain = fqdn.chomp('.').chomp(name).chomp('.')
+          write_yml_file("#{dir}/#{type}__#{domain}.yml", grouped_records)
+        end
+      end
+
+      def yaml_files
+        Dir["#{RecordStore.zones_path}/*.yml"]
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: record_store
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Willem van Bergen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-22 00:00:00.000000000 Z
+date: 2016-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -234,6 +234,7 @@ files:
 - lib/record_store/version.rb
 - lib/record_store/zone.rb
 - lib/record_store/zone/config.rb
+- lib/record_store/zone/yaml_definitions.rb
 - record_store.gemspec
 - template/Gemfile
 - template/bin/record-store