record_store 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b939adb80cff762bc3463596e80a684a8a4accc6
-  data.tar.gz: a97fdd41e9ef24859af390d2004ff3468911b637
+  metadata.gz: 6533d74657e0ba545a411f88adeab33272cb728b
+  data.tar.gz: 79cdc4fd12512478cad79039f0c69eb38b7cd504
 SHA512:
-  metadata.gz: 187c99f674558e6032f722d9bc352acca2385380c981dacae81d1ae1e24b7f4893d6bc4e61e91d1eb1e4ffe028d42fe128c4ec8b7cd15cd2f9c56160085c6c02
-  data.tar.gz: 33e19e66a3d68da1f1af1eb0147dca02e430e769bee89617f199c3684509a2137f9eca5ff52fbf20e007a27c2399524e92ec9b3abf70af3ac05df22998afb34c
+  metadata.gz: 14019ec878ecc6593d7034c17c0cbd83eefeefc9b52b30ec8bb03c3178861ccd1c89c53c294654defec078bef29a3ca1eedd0ea72c838f0bd83cc25c70f9a7e2
+  data.tar.gz: 418e35bc70829c278102d6f4442ef4c0a93612055ccf48eed85812b7bda57eac81475f1d1df643349d15ea4ed5342a5c93e9f2edd504083285c7d81409707850

data/bin/console

@@ -5,6 +5,7 @@ require 'bundler/setup'
 require 'record_store'
 
 RecordStore.zones_path = File.expand_path('../../dev/zones', __FILE__)
+RecordStore.config_path = File.expand_path('../../dev/config.yml', __FILE__)
 
-require 'irb'
-IRB.start
+require 'pry'
+binding.pry(RecordStore)

data/lib/record_store.rb

@@ -2,6 +2,7 @@ require 'json'
 require 'yaml'
 require 'active_support'
 require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/string'
 require 'active_model'
@@ -20,6 +21,7 @@ require 'record_store/record/ns'
 require 'record_store/record/txt'
 require 'record_store/record/spf'
 require 'record_store/record/srv'
+require 'record_store/zone/yaml_definitions'
 require 'record_store/zone'
 require 'record_store/zone/config'
 require 'record_store/changeset'

data/lib/record_store/changeset.rb

@@ -33,15 +33,34 @@ module RecordStore
       end
     end
 
-    attr_reader :current_records, :desired_records, :removals, :additions, :updates
+    attr_reader :current_records, :desired_records, :removals, :additions, :updates, :provider, :zone
+
+    def self.build_from(provider:, zone:)
+      current_zone = provider.build_zone(zone_name: zone.unrooted_name, config: zone.config)
+
+      self.new(
+        current_records: current_zone.records,
+        desired_records: zone.records,
+        provider: provider,
+        zone: zone.unrooted_name
+      )
+    end
+
+    def initialize(current_records: [], desired_records: [], provider:, zone:)
+      @current_records = Set.new(current_records)
+      @desired_records = Set.new(desired_records)
+      @provider = provider
+      @zone = zone
 
-    def initialize(current_records: [], desired_records: [])
-      @current_records, @desired_records = Set.new(current_records), Set.new(desired_records)
       @additions, @removals, @updates = [], [], []
 
       build_changeset
     end
 
+    def apply
+      provider.apply_changeset(self)
+    end
+
     def unchanged
       current_records & desired_records
     end

data/lib/record_store/cli.rb

@@ -11,14 +11,18 @@ module RecordStore
     desc 'thaw', 'Thaws all zones under management to allow manual edits'
     def thaw
       Zone.each do |_, zone|
-        zone.provider.thaw if zone.provider.thawable?
+        zone.providers.each do |provider|
+          provider.thaw_zone(zone.unrooted_name) if provider.thawable?
+        end
       end
     end
 
     desc 'freeze', 'Freezes all zones under management to prevent manual edits'
     def freeze
       Zone.each do |_, zone|
-        zone.provider.freeze_zone if zone.provider.freezable?
+        zone.providers.each do |provider|
+          provider.freeze_zone(zone.unrooted_name) if provider.freezable?
+        end
       end
     end
 
@@ -35,47 +39,55 @@ module RecordStore
     option :verbose, desc: 'Print records that haven\'t diverged', aliases: '-v', type: :boolean, default: false
     desc 'diff', 'Displays the DNS differences between the zone files in this repo and production'
     def diff
+      puts "Diffing #{Zone.defined.count} zones"
+
       Zone.each do |name, zone|
+        changesets = zone.build_changesets
+
+        next if !options.fetch('verbose') && changesets.empty?
         puts "Zone: #{name}"
 
-        diff = zone.changeset
+        changesets.each do |changeset|
+          next if !options.fetch('verbose') && changeset.changes.empty?
 
-        if !diff.additions.empty? || options.fetch('verbose')
-          puts "Add:"
-          diff.additions.map(&:record).each do |record|
-            puts " - #{record.to_s}"
+          puts '-' * 20
+          puts "Provider: #{changeset.provider.to_s}"
+
+          if !changeset.additions.empty? || options.fetch('verbose')
+            puts "Add:"
+            changeset.additions.map(&:record).each do |record|
+              puts " - #{record.to_s}"
+            end
           end
-        end
 
-        if !diff.removals.empty? || options.fetch('verbose')
-          puts "Remove:"
-          diff.removals.map(&:record).each do |record|
-            puts " - #{record.to_s}"
+          if !changeset.removals.empty? || options.fetch('verbose')
+            puts "Remove:"
+            changeset.removals.map(&:record).each do |record|
+              puts " - #{record.to_s}"
+            end
           end
-        end
 
-        if !diff.updates.empty? || options.fetch('verbose')
-          puts "Update:"
-          diff.updates.map(&:record).each do |record|
-            puts " - #{record.to_s}"
+          if !changeset.updates.empty? || options.fetch('verbose')
+            puts "Update:"
+            changeset.updates.map(&:record).each do |record|
+              puts " - #{record.to_s}"
+            end
           end
-        end
 
-        if options.fetch('verbose')
-          puts "Unchanged:"
-          diff.unchanged.each do |record|
-            puts " - #{record.to_s}"
+          if options.fetch('verbose')
+            puts "Unchanged:"
+            changeset.unchanged.each do |record|
+              puts " - #{record.to_s}"
+            end
           end
         end
-
-        puts "Empty diff" if diff.changes.empty?
         puts '=' * 20
       end
     end
 
     desc 'apply', 'Applies the DNS changes'
     def apply
-      zones = zones_modified
+      zones = Zone.modified
 
       if zones.empty?
         puts "No changes to sync"
@@ -84,8 +96,9 @@ module RecordStore
 
       zones.each do |zone|
         abort "Attempted to apply invalid zone: #{zone.name}" unless zone.valid?
-        provider = zone.provider
-        provider.apply_changeset(zone.changeset)
+
+        changesets = zone.build_changesets
+        changesets.each(&:apply)
       end
 
       puts "All zone changes deployed"
@@ -93,7 +106,6 @@ module RecordStore
 
     option :name, desc: 'Zone to download', aliases: '-n', type: :string, required: true
     option :provider, desc: 'Provider in which this zone exists', aliases: '-p', type: :string
-    option :format, desc: 'Format', aliases: '-f', type: :string, default: 'file', enum: FORMATS
     desc 'download', 'Downloads all records from zone and creates YAML zone definition in zones/ e.g. record-store download --name=shopify.io'
     def download
       name = options.fetch('name')
@@ -109,23 +121,19 @@ module RecordStore
       end
 
       puts "Downloading records for #{name}"
-      Zone.download(name, provider, format: options.fetch('format').to_sym)
+      Zone.download(name, provider)
       puts "Records have been downloaded & can be found in zones/#{name}.yml"
     end
 
     option :name, desc: 'Zone to reformat', aliases: '-n', type: :string, required: false
-    option :format, desc: 'Format', aliases: '-f', type: :string, default: 'file', enum: FORMATS
     desc 'reformat', 'Sorts and re-outputs the zone (or all zones) as specified format (file)'
     def reformat
       name = options['name']
-      zones = if name
-        [Zone.find(name)]
-      else
-        Zone.all
-      end
+      zones = name ? [Zone.find(name)] : Zone.all
+
       zones.each do |zone|
         puts "Writing #{zone.name}"
-        zone.write(format: options.fetch('format').to_sym)
+        zone.write
       end
     end
 
@@ -163,7 +171,7 @@ module RecordStore
 
     desc 'assert_empty_diff', 'Asserts there is no divergence between DynECT & the zone files'
     def assert_empty_diff
-      zones = zones_modified.map(&:name)
+      zones = Zone.modified.map(&:name)
 
       unless zones.empty?
         abort "The following zones have diverged: #{zones.join(', ')}"
@@ -173,23 +181,21 @@ module RecordStore
     desc 'validate_records', 'Validates that all DNS records have valid definitions'
     def validate_records
       invalid_zones = []
-      Zone.each do |name, zone|
-        if !zone.valid?
-          invalid_zones << name
+      Zone.all.reject(&:valid?).each do |zone|
+        invalid_zones << zone.unrooted_name
 
-          puts "#{name} definition is not valid:"
-          zone.errors.each do |field, msg|
-            puts " - #{field}: #{msg}"
-          end
+        puts "#{zone.unrooted_name} definition is not valid:"
+        zone.errors.each do |field, msg|
+          puts " - #{field}: #{msg}"
+        end
 
-          invalid_records = zone.records.reject(&:valid?)
-          puts '  Invalid records' if invalid_records.size > 0
+        invalid_records = zone.records.reject(&:valid?)
+        puts '  Invalid records' if invalid_records.size > 0
 
-          invalid_records.each do |record|
-            puts "    #{record.to_s}"
-            record.errors.each do |field, msg|
-              puts "      - #{field}: #{msg}"
-            end
+        invalid_records.each do |record|
+          puts "    #{record.to_s}"
+          record.errors.each do |field, msg|
+            puts "      - #{field}: #{msg}"
           end
         end
       end
@@ -197,13 +203,13 @@ module RecordStore
       if invalid_zones.size > 0
         abort "The following zones were invalid: #{invalid_zones.join(', ')}"
       else
-        puts "All records have valid definitions."
+        puts "All zones have valid definitions."
       end
     end
 
     desc 'validate_change_size', "Validates no more then particular limit of DNS records are removed per zone at a time"
     def validate_change_size
-      zones = zones_modified
+      zones = Zone.modified
 
       unless zones.empty?
         removals = zones.select do |zone|
@@ -256,18 +262,5 @@ module RecordStore
         end
       end
     end
-
-    private
-
-    def zones_modified
-      modified_zones, mutex = [], Mutex.new
-      Zone.all.map do |zone|
-        thread = Thread.new do
-          mutex.synchronize {modified_zones << zone} unless zone.unchanged?
-        end
-      end.each(&:join)
-
-      modified_zones
-    end
   end
 end

data/lib/record_store/provider.rb

@@ -1,107 +1,117 @@
 module RecordStore
   class Provider
-    def self.provider_for(zone_name)
-      dns = Resolv::DNS.new(nameserver: ['8.8.8.8', '8.8.4.4'])
+    class << self
+      def 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
 
-      begin
-        ns_server = dns.getresource(zone_name, Resolv::DNS::Resource::IN::SOA).mname.to_s
-      rescue Resolv::ResolvError => e
-        abort "Domain doesn't exist"
+        case ns_server
+        when /dnsimple\.com\z/
+          'DNSimple'
+        when /dynect\.net\z/
+          'DynECT'
+        else
+          nil
+        end
       end
 
-      case ns_server
-      when /dnsimple\.com\z/
-        'DNSimple'
-      when /dynect\.net\z/
-        'DynECT'
-      else
-        nil
+      def record_types
+        Set.new([
+          'A',
+          'AAAA',
+          'ALIAS',
+          'CNAME',
+          'MX',
+          'NS',
+          'SPF',
+          'SRV',
+          'TXT',
+        ])
       end
-    end
 
-    def self.record_types
-      Set.new([
-        'A',
-        'AAAA',
-        'ALIAS',
-        'CNAME',
-        'MX',
-        'NS',
-        'SPF',
-        'SRV',
-        'TXT',
-      ])
-    end
+      def supports_alias?
+        false
+      end
 
-    def self.supports_alias?
-      false
-    end
+      def build_zone(zone_name:, config:)
+        zone = Zone.new(name: zone_name)
+        zone.records = retrieve_current_records(zone: zone_name)
+        zone.config = config
 
-    def initialize(zone:)
-      @zone_name = zone
-    end
+        zone
+      end
 
-    def add(record)
-      raise NotImplementedError
-    end
+      # returns an array of Record objects that match the records which exist in the provider
+      def retrieve_current_records(zone:, stdout: $stdout)
+        raise NotImplementedError
+      end
 
-    def remove(record)
-      raise NotImplementedError
-    end
+      def add(record)
+        raise NotImplementedError
+      end
 
-    def update(id, record)
-      raise NotImplementedError
-    end
+      def remove(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}"
+      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, changeset.zone)
+              when :addition;
+                stdout.puts "Creating #{change.record}..."
+                add(change.record, changeset.zone)
+              when :update;
+                stdout.puts "Updating record with ID #{change.id} to #{change.record}..."
+                update(change.id, change.record, changeset.zone)
+              else
+                raise ArgumentError, "Unknown change type #{change.type.inspect}"
+            end
           end
-        end
 
-        puts "\nPublished #{@zone_name} changes"
+          puts "\nPublished #{changeset.zone} changes to #{changeset.provider.to_s}\n"
+        end
       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
 
-    # 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 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!"
+      def thawable?
+        self.respond_to?(:thaw_zone)
       end
-    end
 
-    def thawable?
-      self.class.method_defined?(:thaw)
-    end
+      def freezable?
+        self.respond_to?(:freeze_zone)
+      end
 
-    def freezable?
-      self.class.method_defined?(:freeze_zone)
+      def to_s
+        self.name.demodulize
+      end
     end
   end
 end