zonesync 0.9.0 → 0.11.0

data/lib/zonesync/manifest.rb

@@ -1,33 +1,37 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "zonesync/record"
+require "zonesync/record_hash"
 require "digest"
 
 module Zonesync
-  class Manifest < Struct.new(:records, :zone)
+  Manifest = Struct.new(:records, :zone) do
+    extend T::Sig
     DIFFABLE_RECORD_TYPES =
-      %w[A AAAA CNAME MX TXT SPF NAPTR PTR].sort
+      T.let(%w[A AAAA CNAME MX TXT SPF NAPTR PTR].sort, T::Array[String])
 
+    sig { returns(T.nilable(Zonesync::Record)) }
     def existing
       records.find(&:manifest?)
     end
 
+    sig { returns(T::Boolean) }
     def existing?
       !!existing
     end
 
+    sig { returns(Zonesync::Record) }
     def generate
-      Record.new(
-        name: "zonesync_manifest.#{zone.origin}",
-        type: "TXT",
-        ttl: 3600,
-        rdata: generate_rdata,
-        comment: nil,
-      )
+      generate_v2
     end
 
+    sig { returns(T.nilable(Zonesync::Record)) }
     def existing_checksum
       records.find(&:checksum?)
     end
 
+    sig { returns(Zonesync::Record) }
     def generate_checksum
       input_string = diffable_records.map(&:to_s).join
       sha256 = Digest::SHA256.hexdigest(input_string)
@@ -40,6 +44,19 @@ module Zonesync
       )
     end
 
+    sig { returns(Zonesync::Record) }
+    def generate_v2
+      hashes = diffable_records.map { |record| RecordHash.generate(record) }
+      Record.new(
+        name: "zonesync_manifest.#{zone.origin}",
+        type: "TXT",
+        ttl: 3600,
+        rdata: hashes.join(',').inspect,
+        comment: nil,
+      )
+    end
+
+    sig { params(record: Zonesync::Record).returns(T::Boolean) }
     def diffable? record
       if existing?
         matches?(record)
@@ -48,20 +65,46 @@ module Zonesync
       end
     end
 
+    sig { returns(T::Boolean) }
+    def v1_format?
+      return false unless existing?
+      manifest_data = T.must(existing).rdata[1..-2]
+      # V1 format uses "TYPE:" syntax, v2 uses comma-separated hashes
+      manifest_data.include?(":") || manifest_data.include?(";")
+    end
+
+    sig { returns(T::Boolean) }
+    def v2_format?
+      return false unless existing?
+      !v1_format?
+    end
+
+    sig { params(record: Zonesync::Record).returns(T::Boolean) }
     def matches? record
       return false unless existing?
-      hash = existing
-        .rdata[1..-2] # remove quotes
-        .split(";")
-        .reduce({}) do |hash, pair|
-          type, short_names = pair.split(":")
-          hash[type] = short_names.split(",")
-          hash
-        end
-      shorthands = hash.fetch(record.type, [])
-      shorthands.include?(shorthand_for(record))
+      manifest_data = T.must(existing).rdata[1..-2] # remove quotes
+
+      # Check if this is v2 format (comma-separated hashes) or v1 format (type:names)
+      if manifest_data.include?(";")
+        # V1 format: "A:@,mail;CNAME:www;MX:@ 10,@ 20"
+        hash = manifest_data
+          .split(";")
+          .reduce({}) do |hash, pair|
+            type, short_names = pair.split(":")
+            hash[type] = short_names.split(",")
+            hash
+          end
+        shorthands = hash.fetch(record.type, [])
+        shorthands.include?(shorthand_for(record))
+      else
+        # V2 format: "1r81el0,60oib3,ky0g92,9pp0kg"
+        expected_hashes = manifest_data.split(",")
+        record_hash = RecordHash.generate(record)
+        expected_hashes.include?(record_hash)
+      end
     end
 
+    sig { params(record: Zonesync::Record, with_type: T::Boolean).returns(String) }
     def shorthand_for record, with_type: false
       shorthand = record.short_name(zone.origin)
       shorthand = "#{record.type}:#{shorthand}" if with_type
@@ -73,25 +116,29 @@ module Zonesync
 
     private
 
+    sig { returns(String) }
     def generate_rdata
       generate_manifest.map do |type, short_names|
         "#{type}:#{short_names.join(",")}"
       end.join(";").inspect
     end
 
+    sig { returns(T::Array[Zonesync::Record]) }
     def diffable_records
       records.select do |record|
         diffable?(record)
       end.sort
     end
 
+    sig { returns(T::Hash[String, T::Array[String]]) }
     def generate_manifest
-      diffable_records.reduce({}) do |hash, record|
+      hash = diffable_records.reduce({}) do |hash, record|
         hash[record.type] ||= []
         hash[record.type] << shorthand_for(record)
         hash[record.type].sort!
         hash
-      end.sort_by(&:first)
+      end
+      Hash[hash.sort_by(&:first)]
     end
   end
 end

data/lib/zonesync/parser.rb

@@ -0,0 +1,337 @@
+# typed: true
+require "sorbet-runtime"
+
+require "treetop"
+Treetop.load File.join(__dir__, "zonefile")
+
+module Zonesync
+  class Parser
+    def self.parse(zone_string)
+      parser = T.unsafe(ZonefileParser).new
+      result = parser.parse(zone_string)
+      if !result
+        puts zone_string
+        raise ParsingError, parser.failure_reason
+      end
+      origin = result.variables["ORIGIN"]
+      Zone.new(result.entries, origin: origin)
+    end
+
+    class ParsingError < RuntimeError; end
+    class UnknownRecordType < RuntimeError; end
+
+    class Zone
+      attr_reader :origin
+
+      attr_reader :records
+
+      def initialize(entries, origin: nil, alternate_origin: ".")
+        @origin = origin
+        @records = []
+        @vars = {"origin" => alternate_origin, :last_host => "."}
+        entries.each do |e|
+          case e.parse_type
+          when :variable
+            key = e.name.text_value.downcase
+            @vars[key] = case key
+            when "ttl"
+              e.value.text_value.to_i
+            else
+              e.value.text_value
+            end
+          when :soa
+            @records << SOA.new(@vars, e)
+          when :record
+            case e.record_type
+            when "A" then @records << A.new(@vars, e)
+            when "AAAA" then @records << AAAA.new(@vars, e)
+            when "CAA" then @records << CAA.new(@vars, e)
+            when "CNAME" then @records << CNAME.new(@vars, e)
+            when "MX" then @records << MX.new(@vars, e)
+            when "NAPTR" then @records << NAPTR.new(@vars, e)
+            when "NS" then @records << NS.new(@vars, e)
+            when "PTR" then @records << PTR.new(@vars, e)
+            when "SRV" then @records << SRV.new(@vars, e)
+            when "SPF" then @records << SPF.new(@vars, e)
+            when "SSHFP" then @records << SSHFP.new(@vars, e)
+            when "TXT" then @records << TXT.new(@vars, e)
+            when "SOA" then
+              # No-op
+            else
+              raise UnknownRecordType, "Unknown record type: #{e.record_type}"
+            end
+          end
+        end
+        @origin ||= soa.origin
+      end
+
+      def soa
+        records_of(SOA).first
+      end
+
+      def records_of(kl)
+        @records.select { |r| r.instance_of? kl }
+      end
+    end
+
+    class Record
+      attr_reader :ttl
+      def ttl= val
+        # handling for global TTL
+        @ttl = val || @vars["ttl"]
+      end
+
+      def klass
+        @klass = nil if @klass == ""
+        @klass ||= "IN"
+      end
+      attr_writer :klass
+
+      attr_accessor :comment, :host
+
+      def type
+        T.must(self.class.name).split("::").last
+      end
+
+      attr_reader :rdata
+
+      private
+
+      def qualify_host(host)
+        origin = vars["origin"]
+        host = vars[:last_host] if /^\s*$/.match?(host)
+        host = host.gsub(/@/, origin)
+        if /\.$/.match?(host)
+          host
+        elsif /^\./.match?(origin)
+          host + origin
+        else
+          host + "." + origin
+        end
+      end
+      attr_accessor :vars
+    end
+
+    class SOA < Record
+      attr_accessor :origin, :nameserver, :responsible_party, :serial, :refresh_time, :retry_time, :expiry_time, :nxttl
+
+      def initialize(vars, zonefile_soa = nil)
+        @vars = vars
+        if zonefile_soa
+          self.origin = qualify_host(zonefile_soa.origin.to_s)
+          @vars[:last_host] = origin
+          self.ttl = zonefile_soa.ttl.to_i
+          self.klass = zonefile_soa.klass.to_s
+          self.nameserver = qualify_host(zonefile_soa.ns.to_s)
+          self.responsible_party = qualify_host(zonefile_soa.rp.to_s)
+          self.serial = zonefile_soa.serial.to_i
+          self.refresh_time = zonefile_soa.refresh.to_i
+          self.retry_time = zonefile_soa.reretry.to_i
+          self.expiry_time = zonefile_soa.expiry.to_i
+          self.nxttl = zonefile_soa.nxttl.to_i
+        end
+      end
+
+      alias host origin
+    end
+
+    class A < Record
+      attr_accessor :address
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.address = zonefile_record.ip_address.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias rdata address
+    end
+
+    class AAAA < A
+    end
+
+    class CAA < Record
+      attr_accessor :flags, :tag, :value
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.flags = zonefile_record.flags.to_i
+          self.tag = zonefile_record.tag.to_s
+          self.value = zonefile_record.value.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+    end
+
+    class CNAME < Record
+      attr_accessor :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.domainname = qualify_host(zonefile_record.target.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias target domainname
+      alias rdata domainname
+      alias alias domainname
+    end
+
+    class MX < Record
+      attr_accessor :priority, :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.priority = zonefile_record.priority.to_i
+          self.domainname = qualify_host(zonefile_record.exchanger.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      def rdata
+        "#{priority} #{domainname}"
+      end
+
+      alias exchange domainname
+      alias exchanger domainname
+    end
+
+    class NAPTR < Record
+      attr_accessor :data
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.data = zonefile_record.data.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias rdata data
+    end
+
+    class NS < Record
+      attr_accessor :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.domainname = qualify_host(zonefile_record.nameserver.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias nameserver domainname
+      alias rdata domainname
+    end
+
+    class PTR < Record
+      attr_accessor :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.domainname = qualify_host(zonefile_record.target.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias target domainname
+      alias rdata domainname
+    end
+
+    class SRV < Record
+      attr_accessor :priority, :weight, :port, :domainname
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.priority = zonefile_record.priority.to_i
+          self.weight = zonefile_record.weight.to_i
+          self.port = zonefile_record.port.to_i
+          self.domainname = qualify_host(zonefile_record.target.to_s)
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+
+      alias target domainname
+    end
+
+    class SSHFP < Record
+      attr_accessor :alg, :fptype, :fp
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.alg = zonefile_record.alg.to_i
+          self.fptype = zonefile_record.fptype.to_i
+          self.fp = zonefile_record.fp.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+    end
+
+    class TXT < Record
+      attr_accessor :data
+
+      def initialize(vars, zonefile_record)
+        @vars = vars
+        if zonefile_record
+          self.host = qualify_host(zonefile_record.host.to_s)
+          @vars[:last_host] = host
+          self.ttl = zonefile_record.ttl.to_i
+          self.klass = zonefile_record.klass.to_s
+          self.data = zonefile_record.data.to_s
+          self.comment = zonefile_record.comment&.to_s
+        end
+      end
+      alias rdata data
+    end
+
+    class SPF < TXT
+    end
+  end
+end
+

data/lib/zonesync/provider.rb

@@ -1,58 +1,127 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "zonesync/record"
 require "zonesync/zonefile"
 require "zonesync/manifest"
+require "zonesync/diff"
+require "zonesync/validator"
 
 module Zonesync
-  class Provider < Struct.new(:credentials)
-    def self.from credentials
-      return credentials if credentials.is_a?(Provider)
-      Zonesync.const_get(credentials[:provider]).new(credentials)
+  class Provider
+    extend T::Sig
+
+    sig { params(config: T::Hash[Symbol, String]).void }
+    def initialize config
+      @config = T.let(config, T::Hash[Symbol, String])
+    end
+    sig { returns(T::Hash[Symbol, String]) }
+    attr_reader :config
+
+    sig { params(config: T::Hash[Symbol, String]).returns(Provider) }
+    def self.from config
+      Zonesync.const_get(config.fetch(:provider)).new(config)
+    end
+
+    sig { params(other: Provider, force: T::Boolean).returns(T::Array[Operation]) }
+    def diff! other, force: false
+      operations = diff(other).call
+      Validator.call(operations, self, force: force)
+      operations
+    end
+
+    sig { params(other: Provider).returns(Diff) }
+    def diff other
+      Diff.new(
+        from: diffable_records,
+        to: other.diffable_records,
+      )
     end
 
+    sig { returns(T::Array[Record]) }
     def records
-      zonefile.records.map do |record|
-        Record.from_dns_zonefile_record(record)
-      end
+      zonefile.records
     end
 
+    sig { returns(T::Array[Record]) }
     def diffable_records
       records.select do |record|
         manifest.diffable?(record)
       end.sort
     end
 
+    sig { returns(Manifest) }
     def manifest
-      @manifest ||= Manifest.new(records, zonefile)
+      Manifest.new(records, zonefile)
     end
 
+    sig { returns(Zonefile) }
     private def zonefile
-      @zonefile ||= begin
-        body = read
-        if body !~ /\sSOA\s/ # insert dummy SOA to trick parser if needed
-          body.sub!(/\n([^$])/, "\n@ 1 SOA example.com example.com ( 2000010101 1 1 1 1 )\n\\1")
-        end
-        Zonefile.load(body)
-      end
+      @zonefile ||= T.let(Zonefile.load(read), T.nilable(Zonefile))
     end
 
-    def read record
-      raise NotImplementedError
+    sig { returns(String) }
+    def read
+      Kernel.raise NotImplementedError
     end
 
-    def write text
-      raise NotImplementedError
+    sig { params(string: String).void }
+    def write string
+      Kernel.raise NotImplementedError
     end
 
+    sig { params(record: Record).void }
     def remove record
-      raise NotImplementedError
+      Kernel.raise NotImplementedError
     end
 
+    sig { params(old_record: Record, new_record: Record).void }
     def change old_record, new_record
-      raise NotImplementedError
+      Kernel.raise NotImplementedError
     end
 
+    sig { params(record: Record).void }
     def add record
-      raise NotImplementedError
+      Kernel.raise NotImplementedError
+    end
+
+    # Helper method for graceful duplicate record handling
+    # Child classes can use this in their add method implementations
+    sig { params(record: Record, block: T.proc.void).void }
+    def add_with_duplicate_handling record, &block
+      begin
+        block.call
+      rescue DuplicateRecordError => e
+        # Gracefully handle duplicate records - this means the record
+        # already exists and we just want to start tracking it
+        puts "Record already exists in #{self.class.name}: #{e.record.name} #{e.record.type} - will start tracking it"
+        return
+      end
+    end
+
+    private
+
+    sig { params(remote_records: T::Array[Record], expected_hashes: T::Array[String]).returns(T::Array[Record]) }
+    def hash_based_diffable_records(remote_records, expected_hashes)
+      require 'set'
+      expected_set = Set.new(expected_hashes)
+      found_set = Set.new
+      diffable = []
+
+      remote_records.each do |record|
+        hash = RecordHash.generate(record)
+        if expected_set.include?(hash)
+          found_set.add(hash)
+          diffable << record
+        end
+      end
+
+      missing = expected_set - found_set
+      if missing.any?
+        raise ConflictError.new(nil, diffable.first || remote_records.first)
+      end
+
+      diffable.sort
     end
   end
 
@@ -60,22 +129,32 @@ module Zonesync
   require "zonesync/route53"
 
   class Memory < Provider
+    extend T::Sig
+
+    sig { returns(String) }
     def read
-      credentials[:string]
+      config.fetch(:string)
     end
 
+    sig { params(string: String).void }
     def write string
-      credentials[:string] = string
+      config[:string] = string
+      nil
     end
   end
 
   class Filesystem < Provider
+    extend T::Sig
+
+    sig { returns(String) }
     def read
-      File.read(credentials[:path])
+      File.read(config.fetch(:path))
     end
 
+    sig { params(string: String).void }
     def write string
-      File.write(credentials[:path], string)
+      File.write(config.fetch(:path), string)
+      nil
     end
   end
 end