dyndnsd 2.0.0.rc2 → 2.3.0

data/lib/dyndnsd/database.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require 'forwardable'
 
@@ -7,19 +8,22 @@ module Dyndnsd
 
     def_delegators :@db, :[], :[]=, :each, :has_key?
 
+    # @param db_file [String]
     def initialize(db_file)
       @db_file = db_file
     end
 
+    # @return [void]
     def load
       if File.file?(@db_file)
-        @db = JSON.parse(File.open(@db_file, 'r', &:read))
+        @db = JSON.parse(File.read(@db_file, mode: 'r'))
       else
         @db = {}
       end
       @db_hash = @db.hash
     end
 
+    # @return [void]
     def save
       Helper.span('database_save') do |_span|
         File.open(@db_file, 'w') { |f| JSON.dump(@db, f) }
@@ -27,6 +31,7 @@ module Dyndnsd
       end
     end
 
+    # @return [Boolean]
     def changed?
       @db_hash != @db.hash
     end

data/lib/dyndnsd/generator/bind.rb

@@ -1,15 +1,20 @@
+# frozen_string_literal: true
 
 module Dyndnsd
   module Generator
     class Bind
-      def initialize(domain, config)
+      # @param domain [String]
+      # @param updater_params [Hash{String => Object}]
+      def initialize(domain, updater_params)
         @domain = domain
-        @ttl = config['ttl']
-        @dns = config['dns']
-        @email_addr = config['email_addr']
-        @additional_zone_content = config['additional_zone_content']
+        @ttl = updater_params['ttl']
+        @dns = updater_params['dns']
+        @email_addr = updater_params['email_addr']
+        @additional_zone_content = updater_params['additional_zone_content']
       end
 
+      # @param db [Dyndnsd::Database]
+      # @return [String]
       def generate(db)
         out = []
         out << "$TTL #{@ttl}"

data/lib/dyndnsd/helper.rb

@@ -1,8 +1,12 @@
+# frozen_string_literal: true
 
 require 'ipaddr'
 
 module Dyndnsd
   class Helper
+    # @param hostname [String]
+    # @param domain [String]
+    # @return [Boolean]
     def self.fqdn_valid?(hostname, domain)
       return false if hostname.length < domain.length + 2
       return false if !hostname.end_with?(domain)
@@ -11,6 +15,8 @@ module Dyndnsd
       true
     end
 
+    # @param ip [String]
+    # @return [Boolean]
     def self.ip_valid?(ip)
       IPAddr.new(ip)
       true
@@ -18,23 +24,45 @@ module Dyndnsd
       false
     end
 
+    # @param username [String]
+    # @param password [String]
+    # @param users [Hash]
+    # @return [Boolean]
     def self.user_allowed?(username, password, users)
       (users.key? username) && (users[username]['password'] == password)
     end
 
+    # @param hostname [String]
+    # @param myips [Array]
+    # @param hosts [Hash]
+    # @return [Boolean]
     def self.changed?(hostname, myips, hosts)
       # myips order is always deterministic
       ((!hosts.include? hostname) || (hosts[hostname] != myips)) && !myips.empty?
     end
 
+    # @param operation [String]
+    # @param block [Proc]
+    # @return [void]
     def self.span(operation, &block)
-      span = OpenTracing.start_span(operation)
+      scope = OpenTracing.start_active_span(operation)
+      span = scope.span
       span.set_tag('component', 'dyndnsd')
       span.set_tag('span.kind', 'server')
       begin
         block.call(span)
+      rescue StandardError => e
+        span.set_tag('error', true)
+        span.log_kv(
+          event: 'error',
+          'error.kind': e.class.to_s,
+          'error.object': e,
+          message: e.message,
+          stack: e.backtrace&.join("\n") || ''
+        )
+        raise
       ensure
-        span.finish
+        scope.close
       end
     end
   end

data/lib/dyndnsd/responder/dyndns_style.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
 
 module Dyndnsd
   module Responder
     class DynDNSStyle
+      # @param app [#call]
       def initialize(app)
         @app = app
       end
 
+      # @param env [Hash{String => String}]
+      # @return [Array{Integer,Hash{String => String},Array{String}}]
       def call(env)
         @app.call(env).tap do |status_code, headers, body|
           if headers.key?('X-DynDNS-Response')
@@ -18,6 +22,10 @@ module Dyndnsd
 
       private
 
+      # @param status_code [Integer]
+      # @param headers [Hash{String => String}]
+      # @param body [Array{String}]
+      # @return [Array{Integer,Hash{String => String},Array{String}}]
       def decorate_dyndnsd_response(status_code, headers, body)
         if status_code == 200
           [200, {'Content-Type' => 'text/plain'}, [get_success_body(body[0], body[1])]]
@@ -26,6 +34,10 @@ module Dyndnsd
         end
       end
 
+      # @param status_code [Integer]
+      # @param headers [Hash{String => String}]
+      # @param _body [Array{String}]
+      # @return [Array{Integer,Hash{String => String},Array{String}}]
       def decorate_other_response(status_code, headers, _body)
         if status_code == 400
           [status_code, headers, ['Bad Request']]
@@ -34,10 +46,14 @@ module Dyndnsd
         end
       end
 
+      # @param changes [Array{Symbol}]
+      # @param myips [Array{String}]
+      # @return [String]
       def get_success_body(changes, myips)
         changes.map { |change| "#{change} #{myips.join(' ')}" }.join("\n")
       end
 
+      # @return [Hash{String => Object}]
       def error_response_map
         {
           # general http errors

data/lib/dyndnsd/responder/rest_style.rb

@@ -1,11 +1,15 @@
+# frozen_string_literal: true
 
 module Dyndnsd
   module Responder
     class RestStyle
+      # @param app [#call]
       def initialize(app)
         @app = app
       end
 
+      # @param env [Hash{String => String}]
+      # @return [Array{Integer,Hash{String => String},Array{String}}]
       def call(env)
         @app.call(env).tap do |status_code, headers, body|
           if headers.key?('X-DynDNS-Response')
@@ -18,6 +22,10 @@ module Dyndnsd
 
       private
 
+      # @param status_code [Integer]
+      # @param headers [Hash{String => String}]
+      # @param body [Array{String}]
+      # @return [Array{Integer,Hash{String => String},Array{String}}]
       def decorate_dyndnsd_response(status_code, headers, body)
         if status_code == 200
           [200, {'Content-Type' => 'text/plain'}, [get_success_body(body[0], body[1])]]
@@ -26,6 +34,10 @@ module Dyndnsd
         end
       end
 
+      # @param status_code [Integer]
+      # @param headers [Hash{String => String}]
+      # @param _body [Array{String}]
+      # @return [Array{Integer,Hash{String => String},Array{String}}]
       def decorate_other_response(status_code, headers, _body)
         if status_code == 400
           [status_code, headers, ['Bad Request']]
@@ -34,10 +46,14 @@ module Dyndnsd
         end
       end
 
+      # @param changes [Array{Symbol}]
+      # @param myips [Array{String}]
+      # @return [String]
       def get_success_body(changes, myips)
         changes.map { |change| change == :good ? "Changed to #{myips.join(' ')}" : "No change needed for #{myips.join(' ')}" }.join("\n")
       end
 
+      # @return [Hash{String => Object}]
       def error_response_map
         {
           # general http errors

data/lib/dyndnsd/textfile_reporter.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 # Adapted from https://github.com/eric/metriks-graphite/blob/master/lib/metriks/reporter/graphite.rb
 
@@ -5,8 +6,11 @@ require 'metriks'
 
 module Dyndnsd
   class TextfileReporter
+    # @return [String]
     attr_reader :file
 
+    # @param file [String]
+    # @param options [Hash{Symbol => Object}]
     def initialize(file, options = {})
       @file = file
 
@@ -17,6 +21,7 @@ module Dyndnsd
       @on_error  = options[:on_error] || proc { |ex| }
     end
 
+    # @return [void]
     def start
       @thread ||= Thread.new do
         loop do
@@ -33,16 +38,19 @@ module Dyndnsd
       end
     end
 
+    # @return [void]
     def stop
       @thread&.kill
       @thread = nil
     end
 
+    # @return [void]
     def restart
       stop
       start
     end
 
+    # @return [void]
     def write
       File.open(@file, 'w') do |f|
         @registry.each do |name, metric|
@@ -85,6 +93,12 @@ module Dyndnsd
       end
     end
 
+    # @param file [String]
+    # @param base_name [String]
+    # @param metric [Object]
+    # @param keys [Array{Symbol}]
+    # @param snapshot_keys [Array{Symbol}]
+    # @return [void]
     def write_metric(file, base_name, metric, keys, snapshot_keys = [])
       time = Time.now.to_i
 

data/lib/dyndnsd/updater/command_with_bind_zone.rb

@@ -1,26 +1,34 @@
+# frozen_string_literal: true
 
 module Dyndnsd
   module Updater
     class CommandWithBindZone
-      def initialize(domain, config)
-        @zone_file = config['zone_file']
-        @command = config['command']
-        @generator = Generator::Bind.new(domain, config)
+      # @param domain [String]
+      # @param updater_params [Hash{String => Object}]
+      def initialize(domain, updater_params)
+        @zone_file = updater_params['zone_file']
+        @command = updater_params['command']
+        @generator = Generator::Bind.new(domain, updater_params)
       end
 
-      def update(zone)
+      # @param db [Dyndnsd::Database]
+      # @return [void]
+      def update(db)
+        # do not regenerate zone file (assumed to be persistent) if DB did not change
+        return if !db.changed?
+
         Helper.span('updater_update') do |span|
-          span.set_tag('dyndnsd.updater.name', self.class.name.split('::').last)
+          span.set_tag('dyndnsd.updater.name', self.class.name&.split('::')&.last || 'None')
 
           # write zone file in bind syntax
-          File.open(@zone_file, 'w') { |f| f.write(@generator.generate(zone)) }
+          File.open(@zone_file, 'w') { |f| f.write(@generator.generate(db)) }
           # call user-defined command
           pid = fork do
             exec @command
           end
 
           # detach so children don't become zombies
-          Process.detach(pid)
+          Process.detach(pid) if pid
         end
       end
     end

data/lib/dyndnsd/updater/zone_transfer_server.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'resolv'
+require 'securerandom'
+
+require 'async/dns'
+
+module Dyndnsd
+  module Updater
+    class ZoneTransferServer
+      DEFAULT_SERVER_LISTENS = ['0.0.0.0@53'].freeze
+
+      # @param domain [String]
+      # @param updater_params [Hash{String => Object}]
+      def initialize(domain, updater_params)
+        @domain = domain
+
+        @server_listens = self.class.parse_endpoints(updater_params['server_listens'] || DEFAULT_SERVER_LISTENS)
+        @notify_targets = (updater_params['send_notifies'] || []).map { |e| self.class.parse_endpoints([e]) }
+
+        @zone_rr_ttl = updater_params['zone_ttl']
+        @zone_nameservers = updater_params['zone_nameservers'].map { |n| Resolv::DNS::Name.create(n) }
+        @zone_email_address = Resolv::DNS::Name.create(updater_params['zone_email_address'])
+        @zone_additional_ips = updater_params['zone_additional_ips'] || []
+
+        @server = ZoneTransferServerHelper.new(@server_listens, @domain)
+
+        # run Async::DNS server in background thread
+        Thread.new do
+          @server.run
+        end
+      end
+
+      # @param db [Dyndnsd::Database]
+      # @return [void]
+      def update(db)
+        Helper.span('updater_update') do |span|
+          span.set_tag('dyndnsd.updater.name', self.class.name&.split('::')&.last || 'None')
+
+          soa_rr = Resolv::DNS::Resource::IN::SOA.new(
+            @zone_nameservers[0], @zone_email_address,
+            db['serial'],
+            10_800,  # 3h
+            300,     # 5m
+            604_800, # 1w
+            3_600    # 1h
+          )
+
+          default_options = {ttl: @zone_rr_ttl}
+
+          # array containing all resource records for an AXFR request in the right order
+          rrs = []
+          # AXFR responses need to start with zone's SOA RR
+          rrs << [soa_rr, default_options]
+
+          # return RRs for all of the zone's nameservers
+          @zone_nameservers.each do |ns|
+            rrs << [Resolv::DNS::Resource::IN::NS.new(ns), default_options]
+          end
+
+          # return A/AAAA RRs for all additional IPv4s/IPv6s for the domain itself
+          @zone_additional_ips.each do |ip|
+            rrs << [create_addr_rr_for_ip(ip), default_options]
+          end
+
+          # return A/AAAA RRs for the dyndns hostnames
+          db['hosts'].each do |hostname, ips|
+            ips.each do |ip|
+              rrs << [create_addr_rr_for_ip(ip), default_options.merge({name: hostname})]
+            end
+          end
+
+          # AXFR responses need to end with zone's SOA RR again
+          rrs << [soa_rr, default_options]
+
+          # point Async::DNS server thread's variable to this new RR array
+          @server.axfr_rrs = rrs
+
+          # only send DNS NOTIFY if there really was a change
+          if db.changed?
+            send_dns_notify
+          end
+        end
+      end
+
+      # converts into suitable parameter form for Async::DNS::Resolver or Async::DNS::Server
+      #
+      # @param endpoint_list [Array{String}]
+      # @return [Array{Array{Object}}]
+      def self.parse_endpoints(endpoint_list)
+        endpoint_list.map { |addr_string| addr_string.split('@') }
+                     .map { |addr_parts| [addr_parts[0], addr_parts[1].to_i || 53] }
+                     .map { |addr| [:tcp, :udp].map { |type| [type] + addr } }
+                     .flatten(1)
+      end
+
+      private
+
+      # creates correct Resolv::DNS::Resource object for IP address type
+      #
+      # @param ip_string [String]
+      # @return [Resolv::DNS::Resource::IN::A,Resolv::DNS::Resource::IN::AAAA]
+      def create_addr_rr_for_ip(ip_string)
+        ip = IPAddr.new(ip_string).native
+
+        if ip.ipv6?
+          Resolv::DNS::Resource::IN::AAAA.new(ip.to_s)
+        else
+          Resolv::DNS::Resource::IN::A.new(ip.to_s)
+        end
+      end
+
+      # https://tools.ietf.org/html/rfc1996
+      #
+      # @return [void]
+      def send_dns_notify
+        Async::Reactor.run do
+          @notify_targets.each do |notify_target|
+            target = Async::DNS::Resolver.new(notify_target)
+
+            # assemble DNS NOTIFY message
+            request = Resolv::DNS::Message.new(SecureRandom.random_number(2**16))
+            request.opcode = Resolv::DNS::OpCode::Notify
+            request.add_question("#{@domain}.", Resolv::DNS::Resource::IN::SOA)
+
+            _response = target.dispatch_request(request)
+          end
+        end
+      end
+    end
+
+    class ZoneTransferServerHelper < Async::DNS::Server
+      attr_accessor :axfr_rrs
+
+      def initialize(endpoints, domain)
+        super(endpoints, logger: Dyndnsd.logger)
+        @domain = domain
+      end
+
+      # @param name [String]
+      # @param resource_class [Resolv::DNS::Resource]
+      # @param transaction [Async::DNS::Transaction]
+      # @return [void]
+      def process(name, resource_class, transaction)
+        if name != @domain || resource_class != Resolv::DNS::Resource::Generic::Type252_Class1
+          transaction.fail!(:NXDomain)
+          return
+        end
+
+        # https://tools.ietf.org/html/rfc5936
+        transaction.append_question!
+        @axfr_rrs.each do |rr|
+          transaction.add([rr[0]], rr[1])
+        end
+      end
+    end
+  end
+end