record_store 2.1.0 → 3.0.0

data/lib/record_store/provider/dnsimple.rb

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

data/lib/record_store/provider/dynect.rb

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

data/lib/record_store/record.rb

@@ -19,6 +19,7 @@ module RecordStore
 
     def self.build_from_yaml_definition(yaml_definition)
       record_type = yaml_definition.fetch(:type)
+
       # TODO: remove backward compatibility support for ALIAS records using cname attribute instead of alias
       #       REMOVE after merging https://github.com/Shopify/record-store/pull/781
       case record_type