matchd 0.1.0

data/lib/matchd/helpers.rb

@@ -0,0 +1,14 @@
+module Matchd
+  module Helpers
+    module_function
+
+    # Creates a new Hash with the key-value pairs of options for the keys given
+    # and only if options has that keys.
+    # Also, new keys will get symbolized.
+    def extract_options(keys, options)
+      keys.each_with_object({}) do |key, o|
+        o[key.to_sym] = options[key] if options.key?(key)
+      end
+    end
+  end
+end

data/lib/matchd/registry.rb

@@ -0,0 +1,66 @@
+require "yaml"
+
+module Matchd
+  # Tthe dns pattern registry
+  # It basically delegates everything to a YAML::Store but handles the conversion
+  # of Regexp dns-patterns into YAML string keys and reverse.
+  class Registry
+    include Enumerable
+
+    LoadError = Class.new(RuntimeError)
+
+    class ParseError < RuntimeError
+      def initialize(registry_file = nil)
+        @registry_file = registry_file
+      end
+
+      def message
+        msg = "Missing 'rules' key"
+        msg += " in registry file '#{@registry_file}'" if @registry_file
+        msg
+      end
+    end
+
+    def initialize(rules)
+      raise ArgumentError unless rules.is_a?(Enumerable)
+      @rules = rules
+    end
+
+    attr_reader :rules
+
+    # Loads a registry YAML file
+    def self.load_file(registry_file)
+      unless File.file?(registry_file)
+        raise LoadError, "Registry file '#{registry_file}' does not exist"
+      end
+
+      load(YAML.load_file(registry_file), registry_file)
+    end
+
+    def self.load(data, registry_file = nil)
+      raise ParseError, registry_file unless data.is_a?(Hash) && data.key?("rules")
+
+      rules = data["rules"]
+
+      new(rules ? parse(rules) : [])
+    end
+
+    # Parses raw rule hash definitions (like those read from a YAML config) into
+    # `Matchd::Rule`s
+    #
+    # @param rules [Array<Hash>] the raw rule definitions
+    # @return [Array<Matchd::Rule>]
+    def self.parse(rules)
+      rules = rules.is_a?(Array) ? rules : [rules]
+      rules.map { |r| Matchd.Rule(r) }
+    end
+
+    def each(&block)
+      rules.each(&block) if rules
+    end
+
+    def valid?
+      none? { |r| r.is_a?(Matchd::Rule::Invalid) }
+    end
+  end
+end

data/lib/matchd/response.rb

@@ -0,0 +1,72 @@
+module Matchd
+  class Response
+    autoload :A,     "matchd/response/a"
+    autoload :AAAA,  "matchd/response/aaaa"
+    autoload :CNAME, "matchd/response/cname"
+    autoload :MX,    "matchd/response/mx"
+    autoload :NS,    "matchd/response/ns"
+    autoload :PTR,   "matchd/response/ptr"
+    autoload :SOA,   "matchd/response/soa"
+    autoload :SRV,   "matchd/response/srv"
+    autoload :TXT,   "matchd/response/txt"
+
+    NotImplementedError = Class.new(RuntimeError)
+
+    # @param [Hash] options (Mind the string keys!)
+    # @option options [Numeric] "ttl" The Time-To-Live of the record (default: `Async::DNS::Transaction::DEFAULT_TTL` = 86400sec = 24h)
+    # @option options [String] "name" The absolute DNS name. Default is the question name.
+    # @option options [String] "section" The answer section. One of "answer", "additional", "authority" (default: "answer")
+    def initialize(options)
+      @resource_options = {}
+
+      return unless options.is_a?(Hash)
+
+      @resource_options[:ttl]     = options["ttl"] if options.key?("ttl")
+      @resource_options[:name]    = options["name"] if options.key?("name")
+      @resource_options[:section] = options["section"] if options.key?("section")
+    end
+
+    attr_reader :resource_options
+
+    def resource
+      raise NotImplementedError
+    end
+
+    def call(transaction)
+      transaction.add([resource], resource_options)
+    end
+
+    def valid?
+      # TODO: this needs to be more suffisticated
+      resource && true
+    rescue ArgumentError
+      false
+    end
+
+    module Factory
+      # Creates new instances of a {Matchd::Response} subclass. Which class is being used
+      # is defines via the {respond} or {fallback_resource_class} parameters.
+      #
+      # @param respond [Array<Hash>|Hash] One or multiple response configurations (See subclasses)
+      # @param fallback_resource_class [Array[String]|String] One or multiple ressource class names (like `"A"`, `"AAAA"`, `"MX"` etc)
+      #   defining which Resource subclass is being used if the {respond} doesn't include a `"resource_class"` configuration
+      #
+      # @return [Array<Matchd::Response>] Instances of {Matchd::Response} subclasses.
+      def Response(respond, fallback_resource_class) # rubocop:disable Naming/MethodName
+        respond = [respond] unless respond.is_a?(Array) # don't convert Hash to Array
+        respond.flat_map do |r|
+          resource_class =
+            if r.is_a?(Hash)
+              r.fetch("resource_class", fallback_resource_class)
+            else
+              fallback_resource_class
+            end
+
+          raise ArgumentError, "Missing resource_class for Response" unless resource_class
+
+          Array(resource_class).map { |klass| Matchd::Response.const_get(klass.upcase).new(r) }
+        end
+      end
+    end
+  end
+end

data/lib/matchd/response/a.rb

@@ -0,0 +1,12 @@
+class Matchd::Response::A < Matchd::Response
+  def initialize(opts)
+    super
+    @ip = opts.is_a?(Hash) ? opts.fetch("ip") : opts
+  end
+
+  attr_reader :ip
+
+  def resource
+    Resolv::DNS::Resource::IN::A.new(ip)
+  end
+end

data/lib/matchd/response/aaaa.rb

@@ -0,0 +1,5 @@
+class Matchd::Response::AAAA < Matchd::Response::A
+  def resource
+    Resolv::DNS::Resource::IN::AAAA.new(ip)
+  end
+end

data/lib/matchd/response/cname.rb

@@ -0,0 +1,12 @@
+class Matchd::Response::CNAME < Matchd::Response
+  def initialize(opts)
+    super
+    @alias_name = opts.is_a?(Hash) ? opts.fetch("alias") : opts
+  end
+
+  attr_reader :alias_name
+
+  def resource
+    Resolv::DNS::Resource::IN::CNAME.new(Resolv::DNS::Name.create(alias_name))
+  end
+end

data/lib/matchd/response/mx.rb

@@ -0,0 +1,16 @@
+class Matchd::Response::MX < Matchd::Response
+  def initialize(opts)
+    super
+    @preference = opts.fetch("preference")
+    @host = opts.fetch("host")
+  end
+
+  attr_reader :preference, :host
+
+  def resource
+    Resolv::DNS::Resource::IN::MX.new(
+      preference,
+      Resolv::DNS::Name.create(host),
+    )
+  end
+end

data/lib/matchd/response/ns.rb

@@ -0,0 +1,12 @@
+class Matchd::Response::NS < Matchd::Response
+  def initialize(opts)
+    super
+    @host = opts.is_a?(Hash) ? opts.fetch("host") : opts
+  end
+
+  attr_reader :host
+
+  def resource
+    Resolv::DNS::Resource::IN::NS.new(Resolv::DNS::Name.create(host))
+  end
+end

data/lib/matchd/response/ptr.rb

@@ -0,0 +1,12 @@
+class Matchd::Response::PTR < Matchd::Response
+  def initialize(opts)
+    super
+    @host = opts.is_a?(Hash) ? opts.fetch("host") : opts
+  end
+
+  attr_reader :host
+
+  def resource
+    Resolv::DNS::Resource::IN::PTR.new(Resolv::DNS::Name.create(host))
+  end
+end

data/lib/matchd/response/soa.rb

@@ -0,0 +1,28 @@
+require "time"
+
+class Matchd::Response::SOA < Matchd::Response
+  def initialize(opts)
+    super
+    @mname = opts.fetch("mname")
+    @rname = opts.fetch("rname")
+    @serial = opts.fetch("serial")
+    @refresh_time = opts.fetch("refresh")
+    @retry_time = opts.fetch("retry")
+    @expire_time = opts.fetch("expire")
+    @minimum_ttl = opts.fetch("minimum_ttl")
+  end
+
+  attr_reader :mname, :rname, :serial, :refresh_time, :retry_time, :expire_time, :minimum_ttl
+
+  def resource
+    Resolv::DNS::Resource::IN::SOA.new(
+      Resolv::DNS::Name.create(mname),
+      Resolv::DNS::Name.create(rname),
+      serial,
+      refresh_time,
+      retry_time,
+      expire_time,
+      minimum_ttl
+    )
+  end
+end

data/lib/matchd/response/srv.rb

@@ -0,0 +1,20 @@
+class Matchd::Response::SRV < Matchd::Response
+  def initialize(opts)
+    super
+    @target = opts.fetch("target")
+    @priority = opts.fetch("priority")
+    @weight = opts.fetch("weight")
+    @port = opts.fetch("port")
+  end
+
+  attr_reader :target, :priority, :weight, :port
+
+  def resource
+    Resolv::DNS::Resource::IN::SRV.new(
+      priority,
+      weight,
+      port,
+      target
+    )
+  end
+end

data/lib/matchd/response/txt.rb

@@ -0,0 +1,12 @@
+class Matchd::Response::TXT < Matchd::Response
+  def initialize(opts)
+    super
+    @txt = opts.is_a?(Hash) ? opts.fetch("txt") : opts
+  end
+
+  attr_reader :txt
+
+  def resource
+    Resolv::DNS::Resource::IN::TXT.new(txt)
+  end
+end

data/lib/matchd/rule.rb

@@ -0,0 +1,116 @@
+require "resolv"
+
+module Matchd
+  class Rule
+    autoload :Append,      "matchd/rule/append"
+    autoload :Fail,        "matchd/rule/fail"
+    autoload :Invalid,     "matchd/rule/invalid"
+    autoload :Passthrough, "matchd/rule/passthrough"
+    autoload :Respond,     "matchd/rule/respond"
+
+    REGEXP_MATCHER = %r{\A/(.*)/([mix]*)\Z}m
+
+    REGEXP_OPTIONS = {
+      "m" => Regexp::MULTILINE,
+      "i" => Regexp::IGNORECASE,
+      "x" => Regexp::EXTENDED
+    }.freeze
+
+    # parses a Regexp lookalike String into Regexp or returns the String
+    def self.parse_match(name)
+      if name.is_a?(Regexp)
+        name
+      elsif (r = name.match(REGEXP_MATCHER))
+        regexp_opts = r[2].each_char.reduce(0) { |o, c| o |= REGEXP_OPTIONS[c] } # rubocop:disable Lint/UselessAssignment # No, it's not!
+        Regexp.new(r[1], regexp_opts)
+      else
+        name
+      end
+    end
+
+    def self.parse_resource_class(resource_class)
+      resource_class.map do |klass|
+        case klass
+        when ::Resolv::DNS::Resource then klass
+        when String, Symbol then ::Resolv::DNS::Resource::IN.const_get(klass.upcase)
+        end
+      end
+    end
+
+    NotImplementedError = Class.new(RuntimeError)
+
+    def initialize(options)
+      @raw = options
+      @name = options.fetch("match")
+      @resource_classes = Array(options.fetch("resource_class"))
+    end
+    attr_reader :raw
+
+    # Implements the rule logic formulating the DNS response to a query.
+    # It's return value signals whether this rule was a successful match (in the
+    # sense of the rule) and evaluating later rules shall be stopped.
+    #
+    # @note You should not need to call this method directly, use {#call} instead .
+    #
+    # @abstract This method needs to be implemented by subclasses.
+    #
+    # @param server [Matchd::Server]
+    # @param name [String] The query name
+    # @param resource_class [Resolv::DNS::Resource] The query IN ressource
+    # @param transaction [Async::DNS::Transaction]
+    # @return [TrueClass|FalseClass] Whether further processing shall stop
+    def visit!(_server, _name, _resource_class, _transaction)
+      raise NotImplementedError
+    end
+
+    # Checks if this rule matches a DNS query (name and ressource class).
+    # @return [TrueClass|FalseClass]
+    def matches?(query_name, query_resource_class)
+      name_for_match === query_name && # rubocop:disable Style/CaseEquality #  This does string equality and Regexp matching at the same time
+        resource_classes_for_match.include?(query_resource_class)
+    end
+
+    # This is the main interface for executing rules.
+    # It tests if this rule matches by calling {#matches?} and runs it by
+    # calling {#visit!}
+    #
+    # @param server [Matchd::Server]
+    # @param name [String] The query name
+    # @param resource_class [Resolv::DNS::Resource] The query IN ressource
+    # @param transaction [Async::DNS::Transaction]
+    # @return [TrueClass|FalseClass] Whether further processing shall stop
+    def call(server, name, resource_class, transaction)
+      return false unless matches?(name, resource_class)
+
+      visit!(server, name, resource_class, transaction)
+    end
+
+    # @private
+    def match_name
+      @match_name ||= self.class.parse_match(@name)
+    end
+
+    # @private
+    def match_resource_classes
+      @match_resource_classes ||= self.class.parse_resource_class(@resource_classes)
+    end
+
+    module Factory
+      def Rule(data) # rubocop:disable Naming/MethodName
+        return Rule::Invalid.new(data) unless data.is_a?(Hash)
+
+        if data["respond"]
+          Rule::Respond.new(data)
+        elsif data["append_question"]
+          Rule::Append.new(data)
+        elsif data["passthrough"]
+          Rule::Passthrough.new(data)
+        elsif data["fail"]
+          Rule::Fail.new(data)
+        else
+          Rule::Invalid.new(data)
+        end
+      end
+    end
+  end
+end

data/lib/matchd/rule/append.rb

@@ -0,0 +1,23 @@
+class Matchd::Rule::Append < Matchd::Rule
+  def initialize(options)
+    super
+    opts = options.fetch("append_question")
+
+    if opts.is_a?(Hash)
+      @append_questions = Array(opts.fetch("resource_class"))
+      @transaction_options = Matchd::Helpers.extract_options(%w(ttl name section), opts)
+    else
+      @append_questions = Array(opts)
+      @transaction_options = {}
+    end
+  end
+
+  attr_reader :append_questions, :transaction_options
+
+  def visit!(_server, _name, _resource_class, transaction)
+    transaction.append_question!
+    Matchd::Rule.parse_resource_class(append_questions).each do |append_resource_class|
+      transaction.append!(transaction.name, append_resource_class, transaction_options)
+    end
+  end
+end

data/lib/matchd/rule/fail.rb

@@ -0,0 +1,18 @@
+class Matchd::Rule::Fail < Matchd::Rule
+  def initialize(options)
+    super
+    @fail = options.fetch("fail")
+  end
+
+  def visit!(_server, _name, _resource_class, transaction)
+    transaction.fail!(rcode)
+  end
+
+  def rcode
+    @rcode ||=
+      case @fail
+      when Symbol, String then Resolv::DNS::RCode.const_get(@fail)
+      else @fail
+      end
+  end
+end