zonesync 0.9.0 → 0.10.0

data/lib/zonesync/route53.rb

@@ -1,34 +1,57 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "zonesync/record"
 require "zonesync/http"
 require "rexml/document"
 
 module Zonesync
   class Route53 < Provider
+    sig { returns(String) }
     def read
-      doc = REXML::Document.new(http.get(nil))
-      records = doc.elements.collect("*/ResourceRecordSets/ResourceRecordSet") do |record_set|
-        to_records(record_set)
-      end.flatten.sort
-      records.map(&:to_s).join("\n") + "\n"
+      @read = T.let(@read, T.nilable(String))
+      @read ||= begin
+        doc = REXML::Document.new(http.get(""))
+        records = doc.elements.collect("*/ResourceRecordSets/ResourceRecordSet") do |record_set|
+          to_records(record_set)
+        end.flatten.sort
+        records.map(&:to_s).join("\n") + "\n"
+      end
     end
 
+    sig { params(record: Record).void }
     def remove(record)
       change_record("DELETE", record)
     end
 
+    sig { params(old_record: Record, new_record: Record).void }
     def change(old_record, new_record)
       remove(old_record)
       add(new_record)
     end
 
+    sig { params(record: Record).void }
     def add(record)
-      change_record("CREATE", record)
+      add_with_duplicate_handling(record) do
+        begin
+          change_record("CREATE", record)
+        rescue RuntimeError => e
+          # Convert Route53-specific duplicate error to standard exception
+          if e.message.include?("RRSet already exists")
+            raise DuplicateRecordError.new(record, "Route53 duplicate record error")
+          else
+            # Re-raise other errors
+            raise
+          end
+        end
+      end
     end
 
     private
 
+    sig { params(action: String, record: Record).void }
     def change_record(action, record)
-      http.post(nil, <<~XML)
+      http.post("", <<~XML)
         <?xml version="1.0" encoding="UTF-8"?>
         <ChangeResourceRecordSetsRequest xmlns="https://route53.amazonaws.com/doc/2013-04-01/">
           <ChangeBatch>
@@ -36,12 +59,12 @@ module Zonesync
               <Change>
                 <Action>#{action}</Action>
                 <ResourceRecordSet>
-                  <Name>#{record[:name]}</Name>
-                  <Type>#{record[:type]}</Type>
-                  <TTL>#{record[:ttl]}</TTL>
+                  <Name>#{record.name}</Name>
+                  <Type>#{record.type}</Type>
+                  <TTL>#{record.ttl}</TTL>
                   <ResourceRecords>
                     <ResourceRecord>
-                      <Value>#{record[:rdata]}</Value>
+                      <Value>#{record.rdata}</Value>
                     </ResourceRecord>
                   </ResourceRecords>
                 </ResourceRecordSet>
@@ -52,50 +75,47 @@ module Zonesync
       XML
     end
 
+    sig { params(el: REXML::Element).returns(T::Array[Record]) }
     def to_records(el)
       el.elements.collect("ResourceRecords/ResourceRecord") do |rr|
         name = normalize_trailing_period(get_value(el, "Name"))
         type = get_value(el, "Type")
+        ttl = get_value(el, "TTL")
         rdata = get_value(rr, "Value")
 
         record = Record.new(
           name:,
           type:,
-          ttl: get_value(el, "TTL"),
+          ttl:,
           rdata:,
           comment: nil, # Route 53 does not have a direct comment field
         )
       end
     end
 
+    sig { params(el: REXML::Element, field: String).returns(String) }
     def get_value el, field
       el.elements[field].text.gsub(/\\(\d{3})/) { $1.to_i(8).chr } # unescape octal
     end
 
-    def from_record(record)
-      {
-        Name: normalize_trailing_period(record[:name]),
-        Type: record[:type],
-        TTL: record[:ttl],
-        ResourceRecords: record[:rdata].split(",").map { |value| { Value: value } }
-      }
-    end
-
+    sig { params(value: String).returns(String) }
     def normalize_trailing_period(value)
       value =~ /\.$/ ? value : value + "."
     end
 
+    sig { returns(HTTP) }
     def http
       return @http if @http
-      @http = HTTP.new("https://route53.amazonaws.com/2013-04-01/hostedzone/#{credentials.fetch(:hosted_zone_id)}/rrset")
-      @http.before_request do |request, uri, body|
+      @http = T.let(HTTP.new("https://route53.amazonaws.com/2013-04-01/hostedzone/#{config.fetch(:hosted_zone_id)}/rrset"), T.nilable(Zonesync::HTTP))
+      T.must(@http).before_request do |request, uri, body|
         request["Content-Type"] = "application/xml"
         request["X-Amz-Date"] = Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
         request["Authorization"] = sign_request(request.method, uri, body)
       end
-      @http
+      T.must(@http)
     end
 
+    sig { params(method: String, uri: URI::HTTPS, body: T.nilable(String)).returns(String) }
     def sign_request(method, uri, body)
       service = "route53"
       date = Time.now.utc.strftime("%Y%m%d")
@@ -115,7 +135,7 @@ module Zonesync
       ].join("\n")
 
       algorithm = "AWS4-HMAC-SHA256"
-      credential_scope = "#{date}/#{credentials.fetch(:aws_region)}/#{service}/aws4_request"
+      credential_scope = "#{date}/#{config.fetch(:aws_region)}/#{service}/aws4_request"
       string_to_sign = [
         algorithm,
         amz_date,
@@ -123,12 +143,13 @@ module Zonesync
         OpenSSL::Digest::SHA256.hexdigest(canonical_request)
       ].join("\n")
 
-      signing_key = get_signature_key(credentials.fetch(:aws_secret_access_key), date, credentials.fetch(:aws_region), service)
+      signing_key = get_signature_key(config.fetch(:aws_secret_access_key), date, config.fetch(:aws_region), service)
       signature = OpenSSL::HMAC.hexdigest("SHA256", signing_key, string_to_sign)
 
-      "#{algorithm} Credential=#{credentials.fetch(:aws_access_key_id)}/#{credential_scope}, SignedHeaders=#{signed_headers}, Signature=#{signature}"
+      "#{algorithm} Credential=#{config.fetch(:aws_access_key_id)}/#{credential_scope}, SignedHeaders=#{signed_headers}, Signature=#{signature}"
     end
 
+    sig { params(key: String, date_stamp: String, region_name: String, service_name: String).returns(String) }
     def get_signature_key(key, date_stamp, region_name, service_name)
       k_date = OpenSSL::HMAC.digest("SHA256", "AWS4" + key, date_stamp)
       k_region = OpenSSL::HMAC.digest("SHA256", k_date, region_name)

data/lib/zonesync/sync.rb

@@ -0,0 +1,40 @@
+# typed: strict
+require "sorbet-runtime"
+
+require "zonesync/logger"
+
+module Zonesync
+  Sync = Struct.new(:source, :destination) do
+    extend T::Sig
+
+    sig { params(dry_run: T::Boolean, force: T::Boolean).void }
+    def call dry_run: false, force: false
+      operations = destination.diff!(source, force: force)
+
+      smanifest = source.manifest.generate
+      dmanifest = destination.manifest.existing
+      if smanifest != dmanifest
+        if dmanifest
+          operations << [:change, [dmanifest, smanifest]]
+        else
+          operations << [:add, [smanifest]]
+        end
+      end
+
+      schecksum = source.manifest.generate_checksum
+      dchecksum = destination.manifest.existing_checksum
+      if schecksum != dchecksum
+        if dchecksum
+          operations << [:change, [dchecksum, schecksum]]
+        else
+          operations << [:add, [schecksum]]
+        end
+      end
+
+      operations.each do |method, records|
+        Logger.log(method, records, dry_run: dry_run)
+        destination.send(method, *records) unless dry_run
+      end
+    end
+  end
+end

data/lib/zonesync/validator.rb

@@ -1,28 +1,40 @@
+# typed: strict
+require "sorbet-runtime"
+
 module Zonesync
-  class Validator < Struct.new(:operations, :destination)
-    def self.call(...)
-      new(...).call
+  Validator = Struct.new(:operations, :destination) do
+    extend T::Sig
+
+    sig { params(operations: T::Array[Operation], destination: Provider, force: T::Boolean).void }
+    def self.call(operations, destination, force: false)
+      new(operations, destination).call(force: force)
     end
 
-    def call
+    sig { params(force: T::Boolean).void }
+    def call(force: false)
       if operations.any? && !manifest.existing?
         raise MissingManifestError.new(manifest.generate)
       end
-      if manifest.existing_checksum && manifest.existing_checksum != manifest.generate_checksum
+      if !force && manifest.existing_checksum && manifest.existing_checksum != manifest.generate_checksum
         raise ChecksumMismatchError.new(manifest.existing_checksum, manifest.generate_checksum)
       end
       operations.each do |method, args|
-        send(method, *args)
+        if method == :add
+          validate_addition args.first
+        end
       end
+      nil
     end
 
     private
 
+    sig { returns(Manifest) }
     def manifest
       destination.manifest
     end
 
-    def add record
+    sig { params(record: Record).void }
+    def validate_addition record
       return if manifest.matches?(record)
       shorthand = manifest.shorthand_for(record, with_type: true)
       conflicting_record = destination.records.find do |r|
@@ -32,14 +44,6 @@ module Zonesync
       return if conflicting_record == record
       raise Zonesync::ConflictError.new(conflicting_record, record)
     end
-
-    def change *records
-      # FIXME? is it possible to break something with a tracked changed record
-    end
-
-    def remove record
-      # FIXME? is it possible to break something with a tracked removed record
-    end
   end
 end
 

data/lib/zonesync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zonesync
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/zonesync/zonefile.rb

@@ -1,323 +1,34 @@
-require "treetop"
-Treetop.load File.join(__dir__, "zonefile")
+# typed: strict
+require "sorbet-runtime"
 
-module Zonesync
-  module Zonefile
-    class << self
-      def parse(zone_string)
-        parser = ZonefileParser.new
-        result = parser.parse(zone_string)
-        return result if result
-        puts zone_string
-        raise ParsingError, parser.failure_reason
-      end
-
-      def load(zone_string)
-        parsed = parse(zone_string)
-        Zone.new(parsed.entries,
-          origin: parsed.variables["ORIGIN"],
-        )
-      end
-    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
-      # assign, with handling for global TTL
-      def self.writer_for_ttl(*attribs)
-        attribs.each do |attrib|
-          define_method "#{attrib}=" do |val|
-            instance_variable_set("@#{attrib}", val || @vars["ttl"])
-          end
-        end
-      end
-
-      attr_reader :ttl
-      attr_writer :klass
-      writer_for_ttl :ttl
-
-      def klass
-        @klass = nil if @klass == ""
-        @klass ||= "IN"
-      end
-
-      attr_accessor :comment
-
-      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
-    end
-
-    class A < Record
-      attr_accessor :host, :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
-    end
-
-    class AAAA < A
-    end
-
-    class CAA < Record
-      attr_accessor :host, :flags, :tag, :value
+require "zonesync/parser"
 
-      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 :host, :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 alias host
-    end
-
-    class MX < Record
-      attr_accessor :host, :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
-
-      alias exchange domainname
-      alias exchanger domainname
-    end
-
-    class NAPTR < Record
-      attr_accessor :host, :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
-    end
-
-    class NS < Record
-      attr_accessor :host, :domainname
+module Zonesync
+  class Zonefile
+    extend T::Sig
 
-      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
+    sig { params(zone_string: String).returns(Zonefile) }
+    def self.load(zone_string)
+      if zone_string !~ /\sSOA\s/ # insert dummy SOA to trick parser if needed
+        zone_string.sub!(/\n([^$])/, "\n@ 1 SOA example.com example.com ( 2000010101 1 1 1 1 )\n\\1")
       end
-
-      alias nameserver domainname
-    end
-
-    class PTR < Record
-      attr_accessor :host, :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
+      zone = Parser.parse(zone_string)
+      records = zone.records.map do |dns_zonefile_record|
+        Zonesync::Record.from_dns_zonefile_record(dns_zonefile_record)
       end
-
-      alias target domainname
+      new(records, origin: zone.origin)
     end
 
-    class SRV < Record
-      attr_accessor :host, :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
+    sig { params(records: T::Array[Zonesync::Record], origin: String).void }
+    def initialize records, origin:
+      @records = records
+      @origin = origin
     end
 
-    class SSHFP < Record
-      attr_accessor :host, :alg, :fptype, :fp
+    sig { returns(T::Array[Zonesync::Record]) }
+    attr_reader :records
 
-      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 :host, :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
-    end
-
-    class SPF < TXT
-    end
+    sig { returns(String) }
+    attr_reader :origin
   end
 end