mock_dns_server 0.3.0

data/lib/mock_dns_server/conditional_actions.rb

@@ -0,0 +1,73 @@
+require 'forwardable'
+require 'thread_safe'
+
+module MockDnsServer
+
+  class ConditionalActions
+
+    attr_reader :context
+
+    extend Forwardable
+
+    def_delegators :@context, :port, :history, :verbose
+
+    def initialize(context)
+      @context = context
+      @records = ThreadSafe::Array.new
+    end
+
+
+    def find_conditional_action(request, protocol)
+      @records.detect { |cond_action| cond_action.condition.call(request, protocol) }
+    end
+
+
+    def respond_to(request, sender, protocol)
+      conditional_action = find_conditional_action(request, protocol)
+
+      if conditional_action
+        puts 'Found action' if verbose
+        history.add_incoming(request, sender, protocol, conditional_action.description)
+        conditional_action.run(request, sender, context, protocol)
+        puts 'Completed action' if verbose
+        conditional_action.increment_use_count
+        handle_use_count(conditional_action)
+      else
+        puts 'Action not found' if verbose
+        history.add_action_not_found(request)
+      end
+    end
+
+
+    def handle_use_count(conditional_action)
+      max_uses = conditional_action.max_uses
+      we_care = max_uses && max_uses > 0
+      if we_care && conditional_action.use_count >= max_uses
+        history.add_conditional_action_removal(conditional_action.description)
+        @records.delete(conditional_action)
+      end
+
+    end
+
+    def add(conditional_action)
+      # Place new record at beginning of array, so that the most recently
+      # added records are found first.
+      @records.unshift(conditional_action)
+    end
+
+
+    def remove(conditional_action)
+      @records.delete(conditional_action)
+    end
+
+
+    def size
+      @records.size
+    end
+
+
+    def empty?
+      size == 0
+    end
+  end
+end

data/lib/mock_dns_server/dnsruby_monkey_patch.rb

@@ -0,0 +1,19 @@
+require 'dnsruby'
+
+# When adding an RR to a Dnsruby::Message, add_answer checks to see if it already occurs,
+# and, if so, does not add it again. We need to disable this behavior so that we can
+# add a SOA record twice for an AXFR response.  So we implement add_answer!,
+# similar to add_answer except that it does not do the inclusion check.
+
+module Dnsruby
+  class Message
+
+    def add_answer!(rr) #:nodoc: all
+      #if (!@answer.include?rr)
+        @answer << rr
+        update_counts
+      #end
+    end
+  end
+end
+

data/lib/mock_dns_server/history.rb

@@ -0,0 +1,84 @@
+module MockDnsServer
+
+# Handles the history of events for this server.
+class History
+
+  def initialize(context)
+    @context = context
+    @records = ThreadSafe::Array.new
+  end
+
+
+  def size
+    @records.size
+  end
+
+
+  def add(entry_hash)
+    entry_hash[:time] ||= Time.now
+    @records << entry_hash
+    entry_hash
+  end
+
+
+  def add_incoming(message, sender, protocol, description = nil)
+    add( {
+      type: :incoming,
+      message: message,
+      sender: sender,
+      protocol: protocol,
+      description: description
+    })
+  end
+
+
+  def add_action_not_found(message)
+    add( {
+      type: :action_not_found,
+      message: message
+    })
+  end
+
+
+  def add_conditional_action_removal(conditional_action)
+    add( {
+      type: :conditional_action_removal,
+      conditional_action: conditional_action
+    })
+  end
+
+
+  def add_notify_response(response, zts_host, zts_port, protocol)
+    add( {
+        type: :notify_response,
+        message: response,
+        host: zts_host,
+        port: zts_port,
+        protocol: protocol,
+        description: "notify response from #{zts_host}:#{zts_port}"
+    })
+  end
+
+
+  def occurred?(inspection)
+    HistoryInspections.new.apply(@records, inspection).size > 0
+  end
+
+
+  # @return a clone of the array
+  def to_a
+    @records.clone
+  end
+
+
+  def copy
+    @records.map { |record| record.clone }
+  end
+
+
+  def to_s
+    "#{super}: #{@records}"
+  end
+
+end
+end

data/lib/mock_dns_server/history_inspections.rb

@@ -0,0 +1,58 @@
+require 'mock_dns_server/message_transformer'
+
+module MockDnsServer
+
+class HistoryInspections
+
+  MT = MessageTransformer
+
+  def type(type)
+    ->(record) { record[:type] == type }
+  end
+
+  def qtype(qtype)
+    ->(record) do
+      qtype_in_message = MT.new(record[:message]).qtype.to_s
+      qtype_in_message == qtype
+    end
+  end
+
+  def qname(qname)
+    ->(record) do
+      qname_in_message = MT.new(record[:message]).qname.to_s
+      qname_in_message == qname
+    end
+  end
+
+  def soa
+    qtype('SOA')
+  end
+
+  def protocol(protocol)
+    ->(record) { record[:protocol] == protocol }
+  end
+
+  def all(*inspections)
+    ->(record) do
+      inspections.all? { |inspection| inspection.(record) }
+    end
+  end
+
+  def any(*inspections)
+    ->(record) do
+      inspections.any? { |inspection| inspection.(record) }
+    end
+  end
+
+  def none(*inspections)
+    ->(record) do
+      inspections.none? { |inspection| inspection.(record) }
+    end
+  end
+
+  def apply(records, inspection)
+    records.select { |record| inspection.(record) }
+  end
+end
+
+end

data/lib/mock_dns_server/ip_address_dispenser.rb

@@ -0,0 +1,34 @@
+require 'ipaddr'
+require 'dnsruby'
+
+module MockDnsServer
+
+# Wraps Ruby's IPAddr class and yields successive IP addresses.
+# Instantiate it with a starting address (IPV4 or IPV6), and when
+# you call .next, it will provide addresses that increment by 1
+# or optional step parameter, starting with your initial address.
+#
+# We'll probably want to instruct it to be more intelligent, e.g. skip .0 and .255.
+class IpAddressDispenser
+
+  # @param initial_address first address dispensed, and basis for subsequent 'next' calls
+  def initialize(initial_address = '192.168.1.1')
+    @initial_address = initial_address
+  end
+
+
+  # @param step number of addresses to step in each next call, defaults to 1
+  def next(step = 1)
+    step.times do
+      if @address.nil?
+        @address = IPAddr.new(@initial_address)
+      elsif @address.to_s == '255.255.255.255'
+        @address = IPAddr.new('1.1.1.1')
+      else
+        @address = @address.succ
+      end
+    end
+    @address.to_s
+  end
+end
+end

data/lib/mock_dns_server/message_builder.rb

@@ -0,0 +1,199 @@
+require 'ipaddr'
+
+require 'dnsruby'
+require 'mock_dns_server/dnsruby_monkey_patch'
+require 'mock_dns_server/ip_address_dispenser'
+require 'mock_dns_server/serial_number'
+
+module MockDnsServer
+
+module MessageBuilder
+
+  module_function
+
+  #def soa_response(zone, serial, expire = nil, refresh = nil)
+  #
+  #  options = {
+  #      type: 'SOA', klass: 'IN', name: zone, ttl: 3600, serial: serial
+  #  }
+  #  options[:refresh] = refresh if refresh
+  #  options[:expire]  = expire  if expire
+  #
+  #
+  #  response = Dnsruby::Message.new
+  #
+  #  answer = Dnsruby::RR.new_from_hash(options)
+  #  response.add_answer(answer)
+  #
+  #  response
+  #
+  #  Additional options:
+  #  @mname = Name.create(hash[:mname])
+  #  @rname = Name.create(hash[:rname])
+  #  @serial = hash[:serial].to_i
+  #  @refresh = hash[:refresh].to_i
+  #  @retry = hash[:retry].to_i
+  #  @expire = hash[:expire].to_i
+  #  @minimum = hash[:minimum].to_i
+  #end
+
+
+  # Builds a response to an 'A' request from the encoded string passed.
+  # @param answer_string string in any format supported by Dnsruby::RR.create
+  # (see resource.rb, e.g. https://github.com/vertis/dnsruby/blob/master/lib/Dnsruby/resource/resource.rb,
+  # line 643 ff at the time of this writing):
+  #
+  #   a     = Dnsruby::RR.create("foo.example.com. 86400 A 10.1.2.3")
+  def specified_a_response(answer_string)
+    message = Dnsruby::Message.new
+    message.header.qr = true
+    answer = Dnsruby::RR.create(answer_string)
+    message.add_answer(answer)
+    message
+  end
+
+
+  def dummy_a_response(record_count, domain, ttl = 86400)
+    ip_dispenser = IpAddressDispenser.new
+    message = Dnsruby::Message.new
+    message.header.qr = true
+
+    record_count.times do
+      answer = Dnsruby::RR.new_from_hash(
+          name: domain, ttl: ttl, type: 'A', address: ip_dispenser.next, klass: 'IN')
+      message.add_answer(answer)
+    end
+    message
+  end
+
+
+  # Gets the serial value from the passed object; if it's a SerialNumber,
+  # calls its value method; if not, we assume it's a number and it's returned unchanged.
+  def serial_value(serial)
+    serial.is_a?(SerialNumber) ? serial.value : serial
+  end
+
+
+  def soa_request(name)
+    Dnsruby::Message.new(name, 'SOA', 'IN')
+  end
+
+
+  def soa_answer(options)
+    mname = options[:mname] || 'default.com'
+
+    Dnsruby::RR.create( {
+      name:    options[:name],
+      ttl:     options[:ttl] || 3600,
+      type:    'SOA',
+      serial:  serial_value(options[:serial]),
+      mname:   mname,
+      rname:   'admin.' + mname,
+      refresh: options[:refresh] || 3600,
+      retry:   options[:retry]   || 3600,
+      expire:  options[:expire]  || 3600,
+      minimum: options[:minimum] || 3600
+    } )
+  end
+
+
+  # Builds a Dnsruby::RR instance with the specified type, name, and rdata,
+  # with a hard coded TTL and class 'IN'.
+  def rr(type, name, rdata)
+    ttl = 3600
+    klass = 'IN'
+    string = [name, ttl, klass, type, rdata].join(' ')
+    Dnsruby::RR.new_from_string(string)
+  end
+
+
+  # Creates an NS RR record.
+  def ns(owner, address)
+    rr('NS', owner, address)
+  end
+
+
+  # Creates a Dnsruby::Update object from a hash,
+  # as it would be generated from a Cucumber table
+  # with the following headings:
+  # | Action | Type | Domain      | RDATA  |
+  def dns_update(zone, records)
+    update = Dnsruby::Update.new(zone)
+    records.each do |r|
+      if r.type.upcase == 'ADD'
+        s = "#{Domain} 3600 #{Type}  #{RDATA}"
+        rr = Dnsruby::RR.create(s)
+        update.add(rr)
+      else
+        update.delete(r['Domain'], r['Type'], r['RDATA'])
+      end
+    end
+    update
+  end
+
+
+  # @param options a hash containing values for keys [:name, :serial, :mname]
+  # TODO: Eliminate duplication of soa_response and notify_message
+  def soa_response(options)
+    raise "Must provide zone name as options[:name]." if options[:name].nil?
+    message = Dnsruby::Message.new(options[:name], 'SOA', 'IN')
+    message.header.qr = true
+    message.add_answer(soa_answer(options))
+    message
+  end
+
+
+  # Builds a SOA RR suitable for inclusion in the authority section of an IXFR query.
+  def ixfr_request_soa_rr(zone, serial)
+    options = {
+        name: zone,
+        type: 'SOA',
+        ttl: 3600,
+        klass: 'IN',
+        mname: '.',
+        rname: '.',
+        serial: serial_value(serial),
+        refresh: 0,
+        retry: 0,
+        expire: 0,
+        minimum: 0
+    }
+
+    Dnsruby::RR.new_from_hash(options)
+  end
+
+
+  def ixfr_request(zone, serial)
+    query = Dnsruby::Message.new(zone, 'IXFR')
+    query.add_authority(ixfr_request_soa_rr(zone, serial_value(serial)))
+    query
+  end
+
+
+  def axfr_request(zone)
+    Dnsruby::Message.new(zone, 'AXFR')
+  end
+
+  # @param options a hash containing values for keys [:name, :serial, :mname]
+  def notify_message(options)
+
+    message = Dnsruby::Message.new(options[:name], 'SOA', 'IN')
+    message.header.opcode = Dnsruby::OpCode::Notify
+
+    mname = options[:mname] || 'default.com'
+
+    message.add_answer(Dnsruby::RR.new_from_hash( {
+        name:    options[:name],
+        type:    'SOA',
+        serial:  serial_value(options[:serial]),
+        mname:   mname,
+        rname:   'admin.' + mname,
+        refresh: 3600,
+        retry:   3600,
+        expire:  3600,
+        minimum: 3600
+    } ))
+    message
+  end
+end
+end