smart_proxy_dhcp_dnsmasq 0.4 → 0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97a5371cbd074b39c66bd23b907b1b31730beb0b
-  data.tar.gz: 47b63b6d25aca90f3dcf03d442efca03493084d8
+  metadata.gz: 64fb30133ada0a818bdf665a6488a4373f317144
+  data.tar.gz: 60dd83f0e023802e77b59d54ba75bdd1ec40e75c
 SHA512:
-  metadata.gz: 5495631faaeaa74b84b6123fe2fb33f7f6bee3ec3f8b1a26e6901f70eee55bd31050b68ca50eb4afb94a46b5729ac8b636923a55c85365928280327ad8f9cf4d
-  data.tar.gz: 54d43f53f1a2d9d6bc1026d71dd5521060161da1d4d3ed13b27c365c8d0dbad0f019e179d377a241878aecee473fc28cb77c25b14d37328639a3a9abb7cd1793
+  metadata.gz: 11665804f753f83922fbbabd1551b08c415b5910439f4a00319115794bbf4dd97cb472e1f75be48f5c091ab9cc3e1464c840956ecdb7bdec7da26698a4065e90
+  data.tar.gz: eb8ae2512a23f5924d15dd0a7b89c50b555fdbfe809f45daab0e8e3f6368a5aa8523fa85d59978c947ba3688c95cb5fe17546ed1e054001370fcc6ac5965e42e

data/README.md

@@ -10,6 +10,14 @@ for how to install Smart Proxy plugins
 
 This plugin is compatible with Smart Proxy 1.15 or higher.
 
+You need to add two lines to your dnsmasq configuration to use this plugin;
+```
+dhcp-optsfile=<target_dir>/dhcpopts.conf
+dhcp-hostsfile=<target_dir>/dhcphosts
+```
+
+Dnsmasq will also require write privileges to the configuration file and folder specified.
+
 ## Configuration
 
 To enable this DNS provider, edit `/etc/foreman-proxy/settings.d/dhcp.yml` and set:
@@ -18,10 +26,10 @@ To enable this DNS provider, edit `/etc/foreman-proxy/settings.d/dhcp.yml` and s
 
 Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dhcp_dnsmasq.yml` and include:
 
-* `config_files`: The path to the configuration files to load, changes will be written to the last one unless a `write_config_file` is provided.
-* `lease_file`: The path to the lease file. (*optional if `dhcp-leasefile` is set in one of the config files*)
+* `config`: The path to the configuration directory to load, changes will be written to host-specific configuration files inside
+* `target_dir`: The path of where dhcp files should be written, must have write permissions for the proxy user.
+* `lease_file`: The path to the lease file. (*optional, will be auto-discovered if `dhcp-leasefile` is set in one of the config files*)
 * `reload_cmd`: The command to use for reloading the dnsmasq configuration.
-* `write_config_file`: The file to write any new changes to, the smart-proxy will only be able to remove any reservations made in this file.
 
 For best results, the write config should point to a file in a dnsmasq `conf-dir` which only the smart-proxy uses.
 

data/config/dhcp_dnsmasq.yml

@@ -3,21 +3,25 @@
 # Configuration file for 'dhcp_dnsmasq' dhcp provider
 #
 
-# Configuration files to parse, writing any additional entries will be done to
-# the last of the files unless a specific write file is provided;
-#
-#:write_config_file: /etc/dnsmasq.d/hosts.conf
-:config_files:
-  - /etc/dnsmasq.conf
-  - /etc/dnsmasq.d/foreman.conf
+# This pluing requires that the following options are set in your dnsmasq
+# configuration;
+#   dhcp-optsfile=<target_dir>/dhcpopts.conf
+#   dhcp-hostsfile=<target_dir>/dhcphosts # NB: this line should not end in a slash
+
+# Configuration files and directories to parse
+:config: /etc/dnsmasq.conf
+# Directory to write dhcp files into
+:target_dir: /var/lib/foreman-proxy/dhcp/
+# Dnsmasq DHCP lease file location
 :lease_file: /var/lib/dnsmasq/dhcp.leases
+# Command to reload / SIGHUP dnsmasq
 :reload_cmd: systemctl reload dnsmasq
 
 # Example configuration for an OpenWRT router;
-#:config_files:
+#:config:
 #  - /tmp/etc/dnsmasq.conf
-#  - /etc/dnsmasq.d/reservations.conf
+#  - /tmp/dnsmasq.d/
+#  - /etc/dnsmasq.conf
+#:target_dir: /etc/foreman-proxy/dnsmasq_dhcp/
 #:lease_file: /tmp/dhcp.leases
 #:reload_cmd: /etc/init.d/dnsmasq reload
-#
-# This also requires that the conf-dir option is set in /etc/dnsmasq.conf

data/lib/smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_configuration.rb

@@ -6,17 +6,21 @@ module ::Proxy::DHCP::Dnsmasq
     end
 
     def load_dependency_injection_wirings(container, settings)
-      write_config = settings[:write_config_file] || settings[:config_files].last
-
       container.dependency :memory_store, ::Proxy::MemoryStore
+
       container.dependency :subnet_service, (lambda do
-        ::Proxy::DHCP::Dnsmasq::SubnetService.new(settings[:config_files], settings[:lease_file],
+        ::Proxy::DHCP::Dnsmasq::SubnetService.new(
+          settings[:config], settings[:target_dir], settings[:lease_file],
           container.get_dependency(:memory_store),
           container.get_dependency(:memory_store), container.get_dependency(:memory_store),
-          container.get_dependency(:memory_store), container.get_dependency(:memory_store))
+          container.get_dependency(:memory_store), container.get_dependency(:memory_store)
+        )
       end)
       container.dependency :dhcp_provider, (lambda do
-        Proxy::DHCP::Dnsmasq::Record.new(settings[:config_files], write_config, settings[:reload_cmd], container.get_dependency(:subnet_service))
+        Proxy::DHCP::Dnsmasq::Record.new(
+          settings[:target_dir],
+          settings[:reload_cmd], container.get_dependency(:subnet_service)
+        )
       end)
     end
   end

data/lib/smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_main.rb

@@ -4,62 +4,107 @@ require 'dhcp_common/server'
 
 module Proxy::DHCP::Dnsmasq
   class Record < ::Proxy::DHCP::Server
-    attr_reader :config_files, :write_config_file, :reload_cmd, :subnet_service
+    attr_reader :config_dir, :reload_cmd, :subnet_service
 
-    def initialize(config_files, write_config_file, reload_cmd, subnet_service)
-      @config_files = config_files
-      @write_config_file = write_config_file
+    def initialize(target_dir, reload_cmd, subnet_service)
+      @config_dir = target_dir
       @reload_cmd = reload_cmd
       @subnet_service = subnet_service
+      @optsfile_content = []
+
+      Dir.mkdir @config_dir unless Dir.exist? @config_dir
 
       subnet_service.load!
 
       super('localhost', nil, subnet_service)
     end
 
-    def add_record(options={})
+    def add_record(options = {})
+      logger.debug "Adding record; #{options}"
       record = super(options)
       options = record.options
 
-      open(@write_config_file, 'a') do |file|
-        file.puts "dhcp-host=set:#{record.mac},#{record.mac},#{record.ip},#{record.name}"
-        file.puts "dhcp-boot=tag:#{record.mac},#{options[:filename]},#{options[:nextServer]}" if\
-          options[:filename] && options[:nextServer]
-      end
-
-      subnet_service.add_host(record)
+      tags = []
+      tags << ensure_bootfile(options[:filename]) if options[:filename]
+      tags << ensure_tftpserver(options[:nextServer]) if options[:nextServer]
+      tagstring = ",set:#{tags.join(',set:')}" unless tags.empty?
 
-      raise Proxy::DHCP::Error, 'Failed to reload configuration' unless system(@reload_cmd)
+      hostspath = File.join(@config_dir, 'dhcphosts')
+      Dir.mkdir hostspath unless Dir.exist? hostspath
+      File.write(File.join(hostspath, "#{sanitize_string record.mac}.conf"),
+                 "#{record.mac}#{tagstring},#{record.ip},#{record.name}\n")
+      subnet_service.add_host(record.subnet_address, record)
 
+      try_reload_cmd
       record
     end
 
     def del_record(record)
-      # TODO: Removal of leases, to prevent DHCP record collisions
+      logger.debug "Deleting record; #{record}"
+      # TODO: Removal of leases, to prevent DHCP record collisions?
       return record if record.is_a? ::Proxy::DHCP::Lease
 
-      found = false
-      tmppath = nil
-      Tempfile.open('reservations') do |output|
-        tmppath = output.path.freeze
-        open(@write_config_file, 'r').each_line do |line|
-          output.puts line unless line.start_with?("dhcp-host=#{record.mac}") || \
-                                  line.start_with?("dhcp-host=set:#{record.mac}") || \
-                                  line.start_with?("dhcp-boot=tag:#{record.mac}")
-
-          found = true if line.start_with?("dhcp-host=#{record.mac}") || \
-                          line.start_with?("dhcp-host=set:#{record.mac}")
-        end
-      end
-      FileUtils.mv(tmppath, @write_config_file) if found
+      path = File.join(@config_dir, 'dhcphosts', "#{sanitize_string record.mac}.conf")
+      File.unlink(path) if File.exist? path
 
       subnet_service.delete_host(record)
 
-      raise Proxy::DHCP::Error, 'Failed to reload configuration' unless system(@reload_cmd)
-
+      try_reload_cmd
       record
-    ensure
-      File.unlink(tmppath) if tmppath && File.exists?(tmppath)
+    end
+
+    def find_record_by_mac(subnet_address, mac_address)
+      get_subnet(subnet_address)
+      service.find_host_by_mac(subnet_address, mac_address) ||
+        service.find_host_by_mac(subnet_address, mac_address.downcase) ||
+        service.find_lease_by_mac(subnet_address, mac_address) ||
+        service.find_lease_by_mac(subnet_address, mac_address.downcase)
+    end
+
+    private
+
+    def try_reload_cmd
+      logger.debug 'Reloading DHCP configuration...'
+      raise Proxy::DHCP::Error, 'Failed to reload configuration' \
+        unless system(@reload_cmd)
+    end
+
+    def optsfile_content
+      path = File.join(@config_dir, 'dhcpopts.conf').freeze
+
+      @optsfile_content = open(path).readlines \
+        if File.exist?(path) && @optsfile_content.empty?
+      @optsfile_content
+    end
+
+    def append_optsfile(line)
+      path = File.join(@config_dir, 'dhcpopts.conf').freeze
+      logger.debug "Appending #{line} to dhcpopts.conf"
+
+      optsfile_content << line
+      File.write(path, optsfile_content.join("\n") + "\n")
+    end
+
+    def sanitize_string(string)
+      string.downcase.gsub(/[^0-9a-z]/, '_')
+    end
+
+    def ensure_bootfile(filename)
+      tagname = "bf_#{sanitize_string(filename)}"
+
+      append_optsfile "tag:#{tagname},option:bootfile-name,#{filename}" \
+        unless optsfile_content.find { |l| l.start_with? "tag:#{tagname}" }
+
+      tagname
+    end
+
+    def ensure_tftpserver(address)
+      tagname = "ns_#{sanitize_string(address)}"
+
+      append_optsfile "tag:#{tagname},option:tftp-server,#{address}" \
+        unless optsfile_content.find { |l| l.start_with? "tag:#{tagname}" }
+
+      tagname
     end
   end
 end

data/lib/smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_plugin.rb

@@ -6,9 +6,13 @@ module Proxy::DHCP::Dnsmasq
     plugin :dhcp_dnsmasq, ::Proxy::DHCP::Dnsmasq::VERSION
 
     requires :dhcp, '>= 1.15'
-    default_settings :config_files => [ '/etc/dnsmasq.d/foreman.conf' ],
+    default_settings :config=> '/etc/dnsmasq.conf',
+                     :target_dir => '/var/lib/foreman-proxy/dhcp/',
+                     :lease_file => '/var/lib/dnsmasq/dhcp.leases',
                      :reload_cmd => 'systemctl reload dnsmasq'
 
+    validate_readable :lease_file
+
     load_classes ::Proxy::DHCP::Dnsmasq::PluginConfiguration
     load_dependency_injection_wirings ::Proxy::DHCP::Dnsmasq::PluginConfiguration
   end

data/lib/smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_subnet_service.rb

@@ -7,10 +7,11 @@ module Proxy::DHCP::Dnsmasq
   class SubnetService < ::Proxy::DHCP::SubnetService
     include Proxy::Log
 
-    attr_reader :config_file, :lease_file
+    attr_reader :config_dir, :lease_file
 
-    def initialize(config_files, lease_file, leases_by_ip, leases_by_mac, reservations_by_ip, reservations_by_mac, reservations_by_name)
-      @config_files = config_files
+    def initialize(config, target_dir, lease_file, leases_by_ip, leases_by_mac, reservations_by_ip, reservations_by_mac, reservations_by_name)
+      @config_paths = [config].flatten
+      @target_dir = target_dir
       @lease_file = lease_file
 
       super(leases_by_ip, leases_by_mac, reservations_by_ip, reservations_by_mac, reservations_by_name)
@@ -30,7 +31,7 @@ module Proxy::DHCP::Dnsmasq
       @inotify.watch(File.dirname(lease_file), :modify, :moved_to) do |ev|
         next unless ev.absolute_name == lease_file
 
-        leases = load_leases(subnet_service)
+        leases = load_leases
 
         # FIXME: Proper method for this
         m.synchronize do
@@ -42,8 +43,16 @@ module Proxy::DHCP::Dnsmasq
     end
 
     def parse_config_for_subnet
-      configuration = { }
-      @config_files.each do |file|
+      configuration = {}
+      files = []
+      @config_paths.each do |path|
+        files << path if File.exist? path
+        files += Dir["#{path}/*"] if Dir.exist? path
+      end
+
+      logger.debug "Starting parse of DHCP subnets from #{files}"
+      files.each do |file|
+        logger.debug "  Parsing #{file}..."
         open(file, 'r').each_line do |line|
           line.strip!
           next if line.empty? || line.start_with?('#') || !line.include?('=')
@@ -62,31 +71,30 @@ module Proxy::DHCP::Dnsmasq
             range_to = data.pop
             range_from = data.pop
 
-            case ttl[-1]
-            when 'h'
-              ttl = ttl[0..-2].to_i * 60 * 60
-            when 'm'
-              ttl = ttl[0..-2].to_i * 60
-            else
-              ttl = ttl.to_i
-            end
-
-            configuration.merge! address: IPAddr.new("#{range_from}/#{mask}").to_s,
-                                 mask: mask,
-                                 range: [ range_from, range_to ],
-                                 ttl: ttl
+            ttl = case ttl[-1]
+                  when 'h'
+                    ttl[0..-2].to_i * 60 * 60
+                  when 'm'
+                    ttl[0..-2].to_i * 60
+                  else
+                    ttl.to_i
+                  end
+
+            configuration.merge! \
+              address: IPAddr.new("#{range_from}/#{mask}").to_s,
+              mask: mask,
+              range: [range_from, range_to],
+              ttl: ttl
           when 'dhcp-option'
             data = value.split(',')
 
             configuration[:options] = {} unless configuration.key? :options
 
-            until data.empty? || /\A\d+\z/ === data.first
-              data.shift
-            end
+            data.shift until data.empty? || /\A\d+\z/ === data.first
             next if data.empty?
 
             code = data.shift.to_i
-            option = ::Proxy::DHCP::Standard.select { |k, v| v[:code] == code }.first.first
+            option = ::Proxy::DHCP::Standard.select { |_k, v| v[:code] == code }.first.first
 
             data = data.first unless ::Proxy::DHCP::Standard[option][:is_list]
             configuration[:options][option] = data
@@ -94,14 +102,24 @@ module Proxy::DHCP::Dnsmasq
         end
       end
 
+      # TODO: Multiple subnets
+      logger.debug "Adding subnet with configuration; #{configuration}"
       @ttl = configuration[:ttl]
       ::Proxy::DHCP::Subnet.new(configuration[:address], configuration[:mask], configuration[:options])
     end
 
     # Expects subnet_service to have subnet data
-    def parse_config_for_dhcp_reservations(files = @config_files)
+    def parse_config_for_dhcp_reservations
       to_ret = {}
+      files = []
+      @config_paths.each do |path|
+        files << path if File.exist? path
+        files += Dir[File.join(path), '*'] if Dir.exist? path
+      end
+
+      logger.debug "Starting parse of DHCP reservations from #{files}"
       files.each do |file|
+        logger.debug "  Parsing #{file}..."
         open(file, 'r').each_line do |line|
           line.strip!
           next if line.empty? || line.start_with?('#') || !line.include?('=')
@@ -112,7 +130,7 @@ module Proxy::DHCP::Dnsmasq
             data = value.split(',')
             data.shift while data.first.start_with? 'set:'
 
-            mac, ip, hostname = data[0,3]
+            mac, ip, hostname = data[0, 3]
 
             # TODO: Possible ttl on end
 
@@ -122,7 +140,7 @@ module Proxy::DHCP::Dnsmasq
               ip,
               mac,
               subnet,
-#             :source_file => file # TODO: Needs to overload the comparison
+              # :source_file => file # TODO: Needs to overload the comparison
             )
           when 'dhcp-boot'
             data = value.split(',')
@@ -140,56 +158,104 @@ module Proxy::DHCP::Dnsmasq
           end
         end
       end
+      dhcpoptions = {}
+
+      dhcpopts_path = File.join(@target_dir, 'dhcpopts.conf')
+      logger.debug "Parsing DHCP options from #{dhcpopts_path}"
+      if File.exist? dhcpopts_path
+        open(dhcpopts_path, 'r').each_line do |line|
+          data = line.strip.split(',')
+          next if data.empty? || !data.first.start_with?('tag:')
+
+          tag = data.first[4..-1]
+          data.shift
+
+          dhcpoptions[tag] = data.last
+        end
+      end
+
+      logger.debug "Parsing provisioned DHCP reservations from #{@target_dir}"
+      Dir[File.join(@target_dir, 'dhcphosts', '*')].each do |file|
+        logger.debug "  Parsing #{file}..."
+        open(file, 'r').each_line do |line|
+          data = line.strip.split(',')
+          next if data.empty? || data.first.start_with?('#')
+
+          mac = data.first
+          data.shift
+
+          options = { :deletable => true }
+          while data.first.start_with? 'set:'
+            tag = data.first[4..-1]
+            data.shift
+
+            value = dhcpoptions[tag]
+            next if value.nil?
+
+            options[:nextServer] = value if tag.start_with? 'ns'
+            options[:filename] = value if tag.start_with? 'bf'
+          end
+
+          ip, name = data
+          subnet = find_subnet(ip)
+
+          to_ret[mac] = ::Proxy::DHCP::Reservation.new(
+            name, ip, mac, subnet, options
+          )
+        end
+      end
+
       to_ret.values
-    rescue Exception => e
+    rescue StandardError => e
       logger.error msg = "Unable to parse reservations: #{e}"
-      raise Proxy::DHCP::Error, msg
+      raise Proxy::DHCP::Error, e, msg
     end
 
     def load_subnet_data
       reservations = parse_config_for_dhcp_reservations
       reservations.each do |record|
         if dupe = find_host_by_mac(record.subnet_address, record.mac)
-          delete_host(dupe)
+          logger.debug "Found duplicate #{dupe} when adding record #{record}, skipping"
+          next
+          # delete_host(dupe)
         end
 
+        logger.debug "Adding host #{record}"
         add_host(record.subnet_address, record)
       end
 
       leases = [] # load_leases # FIXME: Will cause collisions if added
       leases.each do |lease|
         if dupe = find_lease_by_mac(lease.subnet_address, lease.mac)
-          delete_lease(dupe)
+          logger.debug "Removing duplicate #{dupe} when adding lease #{lease}, skipping"
+          next
+          # delete_lease(dupe)
         end
         if dupe = find_lease_by_ip(lease.subnet_address, lease.ip)
-          delete_lease(dupe)
+          logger.debug "Removing duplicate #{dupe} when adding lease #{lease}, skipping"
+          next
+          # delete_lease(dupe)
         end
 
+        logger.debug "Adding lease #{lease}"
         add_lease(lease.subnet_address, lease)
       end
     end
 
     # Expects subnet_service to have subnet data
     def load_leases
-      leases = []
-      open(@lease_file, 'r').each_line do |line|
-        timestamp, mac, ip, hostname, client_id = line.split
-
+      open(@lease_file, 'r').readlines.map do |line|
+        timestamp, mac, ip, _hostname, _client_id = line.split
         timestamp = timestamp.to_i
 
         subnet = find_subnet(ip)
-        leases << ::Proxy::DHCP::Lease.new(
-          hostname,
-          ip,
-          mac,
-          subnet,
-          timestamp - (@ttl or 24*60*60),
+        ::Proxy::DHCP::Lease.new(
+          nil, ip, mac, subnet,
+          timestamp - (@ttl || 24 * 60 * 60),
           timestamp,
-          'active',
-          deleteable: false,
+          'active'
         )
       end
-      leases
     end
   end
 end

data/lib/smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module DHCP
     module Dnsmasq
-      VERSION = '0.4'
+      VERSION = '0.6'.freeze
     end
   end
 end

data/test/dhcp_dnsmasq_default_settings_test.rb

@@ -5,7 +5,9 @@ require 'smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_plugin'
 class DnsDnsmasqDefaultSettingsTest < Test::Unit::TestCase
   def test_default_settings
     Proxy::DHCP::Dnsmasq::Plugin.load_test_settings({})
-    assert_equal ["/etc/dnsmasq.d/foreman.conf"], Proxy::DHCP::Dnsmasq::Plugin.settings.config_files
-    assert_equal "systemctl reload dnsmasq", Proxy::DHCP::Dnsmasq::Plugin.settings.reload_cmd
+    assert_equal '/etc/dnsmasq.conf', Proxy::DHCP::Dnsmasq::Plugin.settings.config
+    assert_equal '/var/lib/foreman-proxy/dhcp/', Proxy::DHCP::Dnsmasq::Plugin.settings.target_dir
+    assert_equal '/var/lib/dnsmasq/dhcp.leases', Proxy::DHCP::Dnsmasq::Plugin.settings.lease_file
+    assert_equal 'systemctl reload dnsmasq', Proxy::DHCP::Dnsmasq::Plugin.settings.reload_cmd
   end
 end

data/test/dhcp_dnsmasq_production_wiring_test.rb

@@ -10,17 +10,20 @@ class DHCPDnsmasqProductionWiringTest < Test::Unit::TestCase
 
   def test_dns_provider_initialization_default
     Proxy::DHCP::Dnsmasq::SubnetService.any_instance.expects(:load!).returns(true)
+    Dir.expects(:exist?).with('/etc/dnsmasq.d/dhcp').returns(true)
 
-    @config.load_dependency_injection_wirings(@container,
-                                              :config_files => ['/etc/dnsmasq.conf'],
-                                              :lease_file => '/tmp/dhcp.leases',
-                                              :reload_cmd => 'systemctl reload dnsmasq')
+    @config.load_dependency_injection_wirings(
+      @container,
+      :config => '/etc/dnsmasq.conf',
+      :target_dir => '/etc/dnsmasq.d/dhcp',
+      :lease_file => '/tmp/dhcp.leases',
+      :reload_cmd => 'systemctl reload dnsmasq'
+    )
 
     provider = @container.get_dependency(:dhcp_provider)
 
     assert_not_nil provider
-    assert_equal ['/etc/dnsmasq.conf'], provider.config_files
-    assert_equal '/etc/dnsmasq.conf', provider.write_config_file
+    assert_equal '/etc/dnsmasq.d/dhcp', provider.config_dir
     assert_equal 'systemctl reload dnsmasq', provider.reload_cmd
   end
 end

data/test/dhcp_dnsmasq_record_handling_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+require 'smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_main'
+
+class DHCPDnsmasqRecordHandlingTest < Test::Unit::TestCase
+  def setup
+    @subnet_service = mock
+    @subnet_service.expects(:load!).returns(true)
+    Dir.stubs(:exist?).returns(true)
+
+    @server = ::Proxy::DHCP::Dnsmasq::Record.new('/etc/dnsmasq.d/', '/bin/true', @subnet_service)
+    @server.instance_eval('@optsfile_content = []')
+  end
+
+  def test_add_record
+    subnet = ::Proxy::DHCP::Subnet.new('10.0.0.0', '255.0.0.0')
+    @subnet_service.stubs(:find_subnet).with('10.0.0.0').returns(subnet)
+    @subnet_service.stubs(:find_hosts_by_ip).returns(nil)
+    @subnet_service.stubs(:find_host_by_mac).returns(nil)
+    @subnet_service.stubs(:find_lease_by_ip).returns(nil)
+    @subnet_service.stubs(:find_lease_by_mac).returns(nil)
+
+    File.expects(:write).with(
+      '/etc/dnsmasq.d/dhcphosts/00_01_02_03_04_05.conf',
+      "00:01:02:03:04:05,set:bf_bootfile,set:ns_10_0_0_2,10.0.0.1,hostname\n"
+    )
+    @server.expects(:append_optsfile)
+           .with('tag:bf_bootfile,option:bootfile-name,bootfile').returns(true)
+    @server.expects(:append_optsfile)
+           .with('tag:ns_10_0_0_2,option:tftp-server,10.0.0.2').returns(true)
+    @subnet_service.expects(:add_host).returns(true)
+    @server.expects(:try_reload_cmd).returns(nil)
+
+    @server.add_record(
+      'hostname' => 'hostname',
+      'ip' => '10.0.0.1',
+      'network' => '10.0.0.0',
+      'mac' => '00:01:02:03:04:05',
+      filename: 'bootfile',
+      nextServer: '10.0.0.2'
+    )
+  end
+
+  def test_del_record
+    subnet = ::Proxy::DHCP::Subnet.new('10.0.0.0', '255.0.0.0')
+    host = ::Proxy::DHCP::Reservation.new('10.0.0.0', '255.0.0.0', '00:01:02:03:04:05', subnet)
+    @subnet_service.expects(:delete_host).with(host).returns(true)
+
+    File.expects(:exist?).with('/etc/dnsmasq.d/dhcphosts/00_01_02_03_04_05.conf').returns(true)
+    File.expects(:unlink).with('/etc/dnsmasq.d/dhcphosts/00_01_02_03_04_05.conf').returns(true)
+    @server.expects(:try_reload_cmd).returns(nil)
+
+    @server.del_record(host)
+  end
+end

data/test/dhcp_dnsmasq_subnet_service_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+require 'smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_subnet_service'
+
+class DHCPDnsmasqSubnetServiceTest < Test::Unit::TestCase
+  def setup
+    @subnet_service = mock()
+    Dir.stubs(:exist?).returns(true)
+  end
+
+  def test_initialize
+    subnet = ::Proxy::DHCP::Subnet.new('10.0.0.0', '255.255.255.0')
+    host = ::Proxy::DHCP::Reservation.new('test', '10.0.0.10', 'ba:be:fa:ce:ca:fe', subnet)
+    lease = ::Proxy::DHCP::Lease.new('test', '10.0.0.10', 'ba:be:fa:ce:ca:fe', subnet, Time.now, Time.now + 1000, 'active')
+
+    initializer = Proxy::DHCP::Dnsmasq::SubnetService.new(
+      'config/file', 'config/dir', 'lease/file',
+      ::Proxy::MemoryStore.new, ::Proxy::MemoryStore.new,
+      ::Proxy::MemoryStore.new, ::Proxy::MemoryStore.new,
+      ::Proxy::MemoryStore.new
+    )
+
+    initializer.expects(:add_subnet).with(subnet)
+    initializer.expects(:add_host)
+#    initializer.expects(:add_lease)
+
+    initializer.expects(:parse_config_for_subnet).returns(subnet)
+    initializer.expects(:parse_config_for_dhcp_reservations).returns([host])
+#    initializer.expects(:load_leases).returns([lease])
+#    initializer.expects(:add_watch)
+
+    initializer.load!
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dhcp_dnsmasq
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.6'
 platform: ruby
 authors:
 - Alexander Olofsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-17 00:00:00.000000000 Z
+date: 2017-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -71,7 +71,8 @@ files:
 - lib/smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_version.rb
 - test/dhcp_dnsmasq_default_settings_test.rb
 - test/dhcp_dnsmasq_production_wiring_test.rb
-- test/dhcp_dnsmasq_record_default_test.rb
+- test/dhcp_dnsmasq_record_handling_test.rb
+- test/dhcp_dnsmasq_subnet_service_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ace13/smart_proxy_dhcp_dnsmasq
 licenses:
@@ -93,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: dnsmasq DHCP provider plugin for Foreman's smart proxy
@@ -101,4 +102,5 @@ test_files:
 - test/test_helper.rb
 - test/dhcp_dnsmasq_default_settings_test.rb
 - test/dhcp_dnsmasq_production_wiring_test.rb
-- test/dhcp_dnsmasq_record_default_test.rb
+- test/dhcp_dnsmasq_record_handling_test.rb
+- test/dhcp_dnsmasq_subnet_service_test.rb

data/test/dhcp_dnsmasq_record_default_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-require 'smart_proxy_dhcp_dnsmasq/dhcp_dnsmasq_subnet_service'
-
-class DHCPDnsmasqSubnetServiceTest < Test::Unit::TestCase
-  def setup
-    @subnet_service = mock()
-  end
-
-  def test_initialize
-    subnet = ::Proxy::DHCP::Subnet.new('10.0.0.0','255.255.255.0') 
-    host = ::Proxy::DHCP::Reservation.new('test','10.0.0.10','ba:be:fa:ce:ca:fe',subnet)
-    lease = ::Proxy::DHCP::Lease.new('test','10.0.0.10','ba:be:fa:ce:ca:fe',subnet,Time.now,Time.now + 1000,'active')
-
-    initializer = Proxy::DHCP::Dnsmasq::SubnetService.new('config/file', 'lease/file', ::Proxy::MemoryStore.new, ::Proxy::MemoryStore.new, ::Proxy::MemoryStore.new, ::Proxy::MemoryStore.new, ::Proxy::MemoryStore.new)
-
-    initializer.expects(:add_subnet).with(subnet)
-    initializer.expects(:add_host)
-    initializer.expects(:add_lease)
-
-    initializer.expects(:parse_config_for_subnet).returns(subnet)
-    initializer.expects(:parse_config_for_dhcp_reservations).returns([ host ])
-    initializer.expects(:load_leases).returns([ lease ])
-    initializer.expects(:add_watch)
-    initializer.load!
-  end
-end