zonesync 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a674bd1519c4b8bd6a30814b43e70365191c18a59b24615e0ed93bbf8f79c286
-  data.tar.gz: c929821a57474a2d4be05f39f2e24e0cef38ab1484d5dbe6d8fbefba05ec60fc
+  metadata.gz: ed23482c3eeed63566e03e79231562447d9f63c09a2d382151d6cd3b123b3502
+  data.tar.gz: 45c154c9bd89d9f1ad97df54ec0c4d30ab49995716fbd3e519b4381f890c2259
 SHA512:
-  metadata.gz: e7678dc403b138a88de0d30a19a980c6c9d23ec3dcb6aa89157530cfc2e260b9e2dd610a1461b3d09174d3c70246c35d34d418a51802cc3c52cd651e5a42d1b2
-  data.tar.gz: 42bf9f0ba6346af233735e236e0cc39e69adc3caf9e41901f8aeddc6936cfdf602086b9a0b3b2999bc8852c493f72a453d66106c8543bc9c95b218caaae35a53
+  metadata.gz: 2870e1fd94f37248ddd609da2a90be47e9487f11e371043b48ed00465fbc727f69fd36614d83b8adf4ff7661bc90dfbbeb100c964c572a49b2ad97ab36b4ad97
+  data.tar.gz: 3dcde654cdbdcaa806734b41c99286ba4724b812c58a4b22af7232bde1e5410892edda80b4475918b512738750a44a709c87c0af4b3483d6a9cc669bc12158b5

data/Gemfile

@@ -4,3 +4,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem "debug"
+gem "activesupport"

data/lib/zonesync/cli.rb

@@ -1,22 +1,37 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "thor"
 
 module Zonesync
   class CLI < Thor
+    extend T::Sig
+
     default_command :sync
-    desc "sync", "syncs the contents of Zonefile to the DNS server configured in Rails.application.credentials.zonesync"
+    desc "sync --source=Zonefile --destination=zonesync", "syncs the contents of the Zonefile to the DNS server configured in Rails.application.credentials.zonesync"
+    option :source, default: "Zonefile", desc: "path to the zonefile"
+    option :destination, default: "zonesync", desc: "key to the DNS server configuration in Rails.application.credentials"
     method_option :dry_run, type: :boolean, default: false, aliases: :n, desc: "log operations to STDOUT but don't perform the sync"
+    method_option :force, type: :boolean, default: false, desc: "ignore checksum mismatches and force the sync"
+    sig { void }
     def sync
-      Zonesync.call dry_run: options[:dry_run]
+      kwargs = options.to_hash.transform_keys(&:to_sym)
+      Zonesync.call(**kwargs)
     rescue ConflictError, MissingManifestError, ChecksumMismatchError => e
       puts e.message
       exit 1
     end
 
-    desc "generate", "generates a Zonefile from the DNS server configured in Rails.application.credentials.zonesync"
+    desc "generate --source=zonesync --destination=Zonefile", "generates a Zonefile from the DNS server configured in Rails.application.credentials.zonesync"
+    option :source, default: "zonesync", desc: "key to the DNS server configuration in Rails.application.credentials"
+    option :destination, default: "Zonefile", desc: "path to the zonefile"
+    sig { void }
     def generate
-      Zonesync.generate
+      kwargs = options.to_hash.transform_keys(&:to_sym)
+      Zonesync.generate(**kwargs)
     end
 
+    sig { returns(TrueClass) }
     def self.exit_on_failure? = true
   end
 end

data/lib/zonesync/cloudflare.rb

@@ -1,83 +1,107 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "zonesync/record"
 require "zonesync/http"
 
 module Zonesync
   class Cloudflare < Provider
+    sig { returns(String) }
     def read
-      ([fake_soa] + all.keys.map do |hash|
-        Record.new(hash)
-      end).map(&:to_s).join("\n") + "\n"
+      records = [fake_soa] + all.keys
+      records.map(&:to_s).join("\n") + "\n"
     end
 
+    sig { params(record: Record).void }
     def remove record
-      id = all.fetch(record.to_h)
+      id = all.fetch(record)
       http.delete("/#{id}")
     end
 
+    sig { params(old_record: Record, new_record: Record).void }
     def change old_record, new_record
-      id = all.fetch(old_record.to_h)
-      http.patch("/#{id}", {
-        name: new_record[:name],
-        type: new_record[:type],
-        ttl: new_record[:ttl],
-        content: new_record[:rdata],
-        comment: new_record[:comment],
-      })
+      id = all.fetch(old_record)
+      http.patch("/#{id}", to_hash(new_record))
     end
 
+    sig { params(record: Record).void }
     def add record
-      http.post(nil, {
-        name: record[:name],
-        type: record[:type],
-        ttl: record[:ttl],
-        content: record[:rdata],
-        comment: record[:comment],
-      })
+      add_with_duplicate_handling(record) do
+        begin
+          http.post("", to_hash(record))
+        rescue RuntimeError => e
+          # Convert CloudFlare-specific duplicate error to standard exception
+          if e.message.include?('"code":81058') && e.message.include?("An identical record already exists")
+            raise DuplicateRecordError.new(record, "CloudFlare error 81058")
+          else
+            # Re-raise other errors
+            raise
+          end
+        end
+      end
     end
 
+    sig { returns(T::Hash[Record, String]) }
     def all
-      @all ||= begin
-        response = http.get(nil)
-        response["result"].reduce({}) do |map, attrs|
-          map.merge to_record(attrs) => attrs["id"]
-        end
+      response = http.get("")
+      response["result"].reduce({}) do |map, attrs|
+        map.merge to_record(attrs) => attrs["id"]
       end
     end
 
     private
 
+    sig { params(record: Record).returns(T::Hash[String, String]) }
+    def to_hash record
+      hash = record.to_h
+      content = hash.delete(:rdata)
+
+      if record.type == "MX"
+        # For MX records, split "priority hostname" into separate fields
+        priority, hostname = T.must(content).split(" ", 2)
+        hash[:priority] = priority.to_i
+        hash[:content] = hostname.sub(/\.$/, "") # remove trailing dot
+      else
+        hash[:content] = content
+      end
+
+      hash[:comment] = hash.delete(:comment) # maintain original order
+      hash
+    end
+
+    sig { params(attrs: T::Hash[String, String]).returns(Record) }
     def to_record attrs
       rdata = attrs["content"]
       if %w[CNAME MX].include?(attrs["type"])
-        rdata = normalize_trailing_period(rdata)
+        rdata = normalize_trailing_period(T.must(rdata))
       end
       if attrs["type"] == "MX"
         rdata = "#{attrs["priority"]} #{rdata}"
       end
       if %w[TXT SPF NAPTR].include?(attrs["type"])
-        rdata = normalize_quoting(rdata)
-      end
-      if attrs["type"] == "TXT"
-        rdata = normalize_quoting(rdata)
+        rdata = normalize_quoting(T.must(rdata))
       end
       Record.new(
-        name: normalize_trailing_period(attrs["name"]),
+        name: normalize_trailing_period(T.must(attrs["name"])),
         type: attrs["type"],
         ttl: attrs["ttl"].to_i,
         rdata:,
         comment: attrs["comment"],
-      ).to_h
+      )
     end
 
+    sig { params(value: String).returns(String) }
     def normalize_trailing_period value
       value =~ /\.$/ ? value : value + "."
     end
 
+    sig { params(value: String).returns(String) }
     def normalize_quoting value
-      value =~ /^".+"$/ ? value : %("#{value}") # handle quote wrapping
+      value = value =~ /^".+"$/ ? value : %("#{value}") # handle quote wrapping
       value.gsub('" "', "") # handle multiple txt record joining
     end
 
+    sig { returns(Zonesync::Record) }
     def fake_soa
       zone_name = http.get("/..")["result"]["name"]
       Record.new(
@@ -89,19 +113,20 @@ module Zonesync
       )
     end
 
+    sig { returns(HTTP) }
     def http
       return @http if @http
-      @http = HTTP.new("https://api.cloudflare.com/client/v4/zones/#{credentials[:zone_id]}/dns_records")
-      @http.before_request do |request|
+      @http = T.let(HTTP.new("https://api.cloudflare.com/client/v4/zones/#{config.fetch(:zone_id)}/dns_records"), T.nilable(Zonesync::HTTP))
+      T.must(@http).before_request do |request|
         request["Content-Type"] = "application/json"
-        if credentials[:token]
-          request["Authorization"] = "Bearer #{credentials[:token]}"
+        if config[:token]
+          request["Authorization"] = "Bearer #{config[:token]}"
         else
-          request["X-Auth-Email"] = credentials[:email]
-          request["X-Auth-Key"] = credentials[:key]
+          request["X-Auth-Email"] = config.fetch(:email)
+          request["X-Auth-Key"] = config.fetch(:key)
         end
       end
-      @http
+      T.must(@http)
     end
   end
 end

data/lib/zonesync/diff.rb

@@ -1,11 +1,20 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "diff/lcs"
 
 module Zonesync
-  class Diff < Struct.new(:from, :to)
+  Operation = T.type_alias { [Symbol, T::Array[Record]] }
+
+  Diff = Struct.new(:from, :to) do
+    extend T::Sig
+
+    sig { params(from: T::Array[Record], to: T::Array[Record]).returns(T.untyped) }
     def self.call(from:, to:)
       new(from, to).call
     end
 
+    sig { returns(T::Array[[Symbol, T::Array[Record]]]) }
     def call
       changes = ::Diff::LCS.sdiff(from, to)
       changes.map do |change|

data/lib/zonesync/errors.rb

@@ -1,10 +1,17 @@
+# typed: strict
+require "sorbet-runtime"
+
 module Zonesync
   class ConflictError < StandardError
+    extend T::Sig
+
+    sig { params(existing: T.nilable(Record), new: Record).void }
     def initialize existing, new
       @existing = existing
       @new = new
     end
 
+    sig { returns(String) }
     def message
       <<~MSG
         The following untracked DNS record already exists and would be overwritten.
@@ -15,10 +22,14 @@ module Zonesync
   end
 
   class MissingManifestError < StandardError
+    extend T::Sig
+
+    sig { params(manifest: Record).void }
     def initialize manifest
       @manifest = manifest
     end
 
+    sig { returns(String) }
     def message
       <<~MSG
         The zonesync_manifest TXT record is missing. If this is the very first sync, make sure the Zonefile matches what's on the DNS server exactly. Otherwise, someone else may have removed it.
@@ -28,11 +39,15 @@ module Zonesync
   end
 
   class ChecksumMismatchError < StandardError
+    extend T::Sig
+
+    sig { params(existing: T.nilable(Record), new: Record).void }
     def initialize existing, new
       @existing = existing
       @new = new
     end
 
+    sig { returns(String) }
     def message
       <<~MSG
         The zonesync_checksum TXT record does not match the current state of the DNS records. This probably means that someone else has changed them.
@@ -41,5 +56,25 @@ module Zonesync
       MSG
     end
   end
+
+  class DuplicateRecordError < StandardError
+    extend T::Sig
+
+    sig { params(record: Record, provider_message: T.nilable(String)).void }
+    def initialize record, provider_message = nil
+      @record = record
+      @provider_message = provider_message
+    end
+
+    sig { returns(String) }
+    def message
+      msg = "Record already exists: #{@record.name} #{@record.type}"
+      msg += " (#{@provider_message})" if @provider_message
+      msg
+    end
+
+    sig { returns(Record) }
+    attr_reader :record
+  end
 end
 

data/lib/zonesync/generate.rb

@@ -0,0 +1,14 @@
+# typed: strict
+require "sorbet-runtime"
+
+module Zonesync
+  Generate = Struct.new(:source, :destination) do
+    extend T::Sig
+
+    sig { void }
+    def call
+      destination.write(source.read)
+      nil
+    end
+  end
+end

data/lib/zonesync/http.rb

@@ -1,38 +1,51 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "net/http"
 require "json"
 
 module Zonesync
-  class HTTP < Struct.new(:base)
-    def initialize(...)
-      super 
-      @before_request = []
-      @after_response = []
+  HTTP = Struct.new(:base) do
+    extend T::Sig
+
+    sig { params(base: String).void }
+    def initialize(base)
+      super
+      @before_request = T.let([], T::Array[T.untyped])
+      @after_response = T.let([], T::Array[T.untyped])
     end
 
+    sig { params(path: String).returns(T.untyped) }
     def get path
       request("get", path)
     end
 
+    sig { params(path: String, body: T.untyped).returns(T.untyped) }
     def post path, body
       request("post", path, body)
     end
 
+    sig { params(path: String, body: T.untyped).returns(T.untyped) }
     def patch path, body
       request("patch", path, body)
     end
 
+    sig { params(path: String).returns(T.untyped) }
     def delete path
       request("delete", path)
     end
 
+    sig { params(block: T.proc.params(arg0: T.untyped, arg1: T.untyped, arg2: T.untyped).void).void }
     def before_request &block
       @before_request << block
     end
 
+    sig { params(block: T.proc.params(arg0: T.untyped).void).void }
     def after_response &block
       @after_response << block
     end
 
+    sig { params(method: String, path: String, body: T.untyped).returns(T.untyped) }
     def request method, path, body=nil
       uri = URI.parse("#{base}#{path}")
       request = Net::HTTP.const_get(method.to_s.capitalize).new(uri.path)
@@ -42,12 +55,15 @@ module Zonesync
       end
 
       response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-        body = JSON.dump(body) if request.fetch("Content-Type", "").include?("application/json")
-        http.request(request, body)
+        if request.fetch("Content-Type", "").include?("application/json")
+          http.request(request, JSON.dump(body))
+        else
+          http.request(request, body)
+        end
       end
 
       @after_response.each do |block|
-        call(response)
+        block.call(response)
       end
 
       raise response.body unless response.code =~ /^20.$/

data/lib/zonesync/logger.rb

@@ -1,24 +1,29 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "logger"
 require "fileutils"
 
-class Logger
-  def self.log method, args, dry_run: false
-    loggers = [::Logger.new(STDOUT)]
+module Zonesync
+  class Logger
+    extend T::Sig
 
-    if !dry_run
-      FileUtils.mkdir_p("log")
-      loggers << ::Logger.new("log/zonesync.log")
-    end
+    sig { params(method: Symbol, records: T::Array[Record], dry_run: T::Boolean).void }
+    def self.log method, records, dry_run: false
+      loggers = [::Logger.new(STDOUT)]
 
-    loggers.each do |logger|
-      operation = case args
-      when Array
-        (args.length == 2 ? "\n" : "") +
-          args.map { |r| r.to_h.values.join(" ") }.join("->\n")
-      else
-        args.to_h.values.join(" ")
+      if !dry_run
+        FileUtils.mkdir_p("log")
+        loggers << ::Logger.new("log/zonesync.log")
+      end
+
+      loggers.each do |logger|
+        operation =
+          (records.length == 2 ? "\n" : "") +
+          records.map { |r| r.to_h.values.join(" ") }.join("->\n")
+        logger.info "Zonesync: #{method.capitalize} #{operation}"
       end
-      logger.info "Zonesync: #{method.capitalize} #{operation}"
     end
   end
 end
+

data/lib/zonesync/manifest.rb

@@ -1,19 +1,26 @@
+# typed: strict
+require "sorbet-runtime"
+
 require "zonesync/record"
 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}",
@@ -24,10 +31,12 @@ module Zonesync
       )
     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 +49,7 @@ module Zonesync
       )
     end
 
+    sig { params(record: Zonesync::Record).returns(T::Boolean) }
     def diffable? record
       if existing?
         matches?(record)
@@ -48,9 +58,10 @@ module Zonesync
       end
     end
 
+    sig { params(record: Zonesync::Record).returns(T::Boolean) }
     def matches? record
       return false unless existing?
-      hash = existing
+      hash = T.must(existing)
         .rdata[1..-2] # remove quotes
         .split(";")
         .reduce({}) do |hash, pair|
@@ -62,6 +73,7 @@ module Zonesync
       shorthands.include?(shorthand_for(record))
     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 +85,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