vagrant-dns 2.2.3 → 2.4.0

data/lib/vagrant-dns/configurator.rb

@@ -1,4 +1,4 @@
-require 'fileutils'
+require "fileutils"
 
 module VagrantDNS
   class Configurator
@@ -20,117 +20,188 @@ module VagrantDNS
       unregister_patterns!
     end
 
-    private
-      def validate_tlds
-        valid, err = VagrantDNS::Config.validate_tlds(vm)
-        if !valid
-          vm.ui.error(err)
-        elsif err
-          vm.ui.warn(err)
-        end
-        valid
+    private def validate_tlds
+      valid, err = VagrantDNS::Config.validate_tlds(vm)
+      if !valid
+        vm.ui.error(err)
+      elsif err
+        vm.ui.warn(err)
       end
+      valid
+    end
 
-      def regenerate_resolvers!
-        FileUtils.mkdir_p(resolver_folder)
+    private def regenerate_resolvers!
+      resolver_folder = self.resolver_folder
+      _proto, ip, port = VagrantDNS::Config.listen.first
+      tlds = register_tlds!
 
-        port = VagrantDNS::Config.listen.first.last
-        tlds = dns_options(vm)[:tlds]
+      resolver_files(ip, port, tlds) do |filename, contents|
+        File.write(File.join(resolver_folder, filename), contents)
+      end
+    end
 
-        tlds.each do |tld|
-          File.open(File.join(resolver_folder, tld), "w") do |f|
-            f << resolver_file(port)
-          end
+    private def register_tlds!
+      add_tlds = dns_options(vm)[:tlds]
+      VagrantDNS::TldRegistry
+        .new(tmp_path)
+        .transaction do |store|
+          store["tlds"] ||= []
+          store["tlds"] |= add_tlds
+          store["tlds"]
         end
+    end
+
+    private def register_patterns!
+      opts = dns_options(vm)
+
+      patterns = opts[:patterns] || default_patterns(opts)
+      if patterns.empty?
+        vm.ui.warn "[vagrant-dns] TLD but no host_name given. No patterns will be configured."
+        return
       end
 
-      def register_patterns!
-        opts     = dns_options(vm)
+      ip = vm_ip(opts)
+      unless ip
+        vm.ui.detail "[vagrant-dns] No patterns will be configured."
+        return
+      end
 
-        patterns = opts[:patterns] || default_patterns(opts)
-        if patterns.empty?
-         vm.ui.warn '[vagrant-dns] TLD but no host_name given. No patterns will be configured.'
-         return
-        end
+      registry = Registry.new(tmp_path)
+      registry.transaction do
+        patterns.each { |pattern| registry[pattern] = ip }
+      end
+    end
 
-        network = opts[:networks].find do |nw|
-          nw.first == :private_network && nw.last[:ip]
+    private def unregister_patterns!
+      opts = dns_options(vm)
+
+      patterns = opts[:patterns] || default_patterns(opts)
+      if patterns.empty?
+        vm.ui.warn "[vagrant-dns] TLD but no host_name given. No patterns will be removed."
+        return
+      end
+
+      registry = Registry.open(tmp_path)
+      return unless registry
+
+      registry.transaction do
+        unless registry.any?
+          vm.ui.warn "[vagrant-dns] Configuration missing or empty. No patterns will be removed."
+          registry.abort
         end
 
-        unless network
-          network = opts[:networks].find do |nw|
-            nw.first == :public_network && nw.last[:ip]
+        patterns.each do |pattern|
+          if (ip = registry.delete(pattern))
+            vm.ui.info "[vagrant-dns] Removing pattern: #{pattern} for ip: #{ip}"
+          else
+            vm.ui.info "[vagrant-dns] Pattern: #{pattern} was not in config."
           end
         end
+      end
+    end
 
-        unless network
-          vm.ui.warn '[vagrant-dns] Could not find any static network IP. No patterns will be configured.'
-          return
-        end
+    private def dns_options(vm)
+      return @dns_options if @dns_options
 
-        ip = network.last[:ip]
+      @dns_options = vm.config.dns.to_hash
+      @dns_options[:host_name] = vm.config.vm.hostname
+      @dns_options[:networks] = vm.config.vm.networks
+      @dns_options
+    end
 
-        registry = Registry.new(tmp_path)
-        registry.transaction do
-          patterns.each do |pattern|
-            registry[pattern] = ip
-          end
-        end
+    private def default_patterns(opts)
+      if opts[:host_name]
+        opts[:tlds].map { |tld| /^.*#{opts[:host_name]}.#{tld}$/ }
+      else
+        []
       end
+    end
 
-      def unregister_patterns!
-        opts     = dns_options(vm)
+    private def vm_ip(opts)
+      user_ip = opts[:ip]
 
-        patterns = opts[:patterns] || default_patterns(opts)
-        if patterns.empty?
-          vm.ui.warn '[vagrant-dns] TLD but no host_name given. No patterns will be removed.'
-          return
-        end
+      if !user_ip && dynamic_ip_network?(opts) || [:dynamic, :dhcp].include?(user_ip)
+        user_ip = DYNAMIC_VM_IP
+      end
+
+      ip =
+        case user_ip
+        when Proc
+          if vm.communicate.ready?
+            user_ip.call(vm, opts.dup.freeze)
+          else
+            vm.ui.info "[vagrant-dns] Postponing running user provided IP script until box has started."
+            return
+          end
+        when Symbol
+          _ip = static_vm_ip(user_ip, opts)
 
-        registry = Registry.new(tmp_path)
-        registry.transaction do
-          unless registry.any?
-            vm.ui.warn '[vagrant-dns] Configuration missing or empty. No patterns will be removed.'
-            registry.abort
+          unless _ip
+            vm.ui.warn "[vagrant-dns] Could not find any static network IP in network type `#{user_ip}'."
+            return
           end
 
-          patterns.each do |pattern|
-            if (ip = registry.delete(pattern))
-              vm.ui.info "[vagrant-dns] Removing pattern: #{pattern} for ip: #{ip}"
-            else
-              vm.ui.info "[vagrant-dns] Pattern: #{pattern} was not in config."
-            end
+          _ip
+        else
+          _ip = static_vm_ip(:private_network, opts)
+          _ip ||= static_vm_ip(:public_network, opts)
+
+          unless _ip
+            vm.ui.warn "[vagrant-dns] Could not find any static network IP."
+            return
           end
+
+          _ip
         end
+
+      # we where unable to find an IP, and there's no user-supplied callback
+      # falling back to dynamic/dhcp style detection
+      if !ip && !user_ip
+        vm.ui.info "[vagrant-dns] Falling back to dynamic IP detection."
+        ip = DYNAMIC_VM_IP.call(vm, opts.dup.freeze)
       end
 
-      def dns_options(vm)
-        dns_options = vm.config.dns.to_hash
-        dns_options[:host_name] = vm.config.vm.hostname
-        dns_options[:networks] = vm.config.vm.networks
-        dns_options
+      if !ip || ip.empty?
+        vm.ui.warn "[vagrant-dns] Failed to identify IP."
+        return
       end
 
-      def default_patterns(opts)
-        if opts[:host_name]
-          opts[:tlds].map { |tld| /^.*#{opts[:host_name]}.#{tld}$/ }
+      ip
+    end
+
+    private def dynamic_ip_network?(opts)
+      opts[:networks].none? { |(_nw_type, nw_config)| nw_config[:ip] }
+    end
+
+    # tries to find an IP in the configured +type+ networks
+    private def static_vm_ip(type, opts)
+      network = opts[:networks].find { |(nw_type, nw_config)| nw_config[:ip] && nw_type == type }
+
+      network.last[:ip] if network
+    end
+
+    DYNAMIC_VM_IP = proc { |vm|
+      vm.guest.capability(:read_ip_address).tap { |ip|
+        if ip
+          vm.ui.info "[vagrant-dns] Identified DHCP IP as '#{ip}'."
         else
-          []
+          vm.ui.warn "[vagrant-dns] Could not identify DHCP IP."
         end
-      end
+      }
+    }
+    private_constant :DYNAMIC_VM_IP
 
-      def resolver_file(port)
-        "# this file is generated by vagrant-dns\n" \
-        "nameserver 127.0.0.1\n" \
-        "port #{port}\n"
-      end
+    private def resolver_files(ip, port, tlds, &block)
+      installer_class = VagrantDNS::Installers.resolve
+      installer_class.resolver_files(ip, port, tlds, &block)
+    end
 
-      def resolver_folder
-        File.join(tmp_path, "resolver")
-      end
+    private def resolver_folder
+      File.join(tmp_path, "resolver").tap { |dir| FileUtils.mkdir_p(dir) }
+    end
 
-      def ensure_deamon_env!
-        FileUtils.mkdir_p(File.join(tmp_path, "daemon"))
-      end
+    private def ensure_deamon_env!
+      FileUtils.mkdir_p(File.join(tmp_path, "daemon"))
+    end
   end
 end

data/lib/vagrant-dns/installers/linux.rb

@@ -0,0 +1,73 @@
+module VagrantDNS
+  module Installers
+    class Linux
+      EXEC_STYLES = %i{sudo}
+      RESOLVED_CONFIG = "vagrant-dns.conf"
+
+      attr_accessor :tmp_path, :install_path, :exec_style
+
+      def initialize(tmp_path, options = {})
+        self.tmp_path     = tmp_path
+        self.install_path = options.fetch(:install_path, "/etc/systemd/resolved.conf.d")
+        self.exec_style   = options.fetch(:exec_style, :sudo)
+      end
+
+      # Generate the resolved config.
+      #
+      # @yield [filename, content]
+      # @yieldparam filename [String] The filename to use for the resolved config file (relative to +install_path+)
+      # @yieldparam content [String] The content for +filename+
+      def self.resolver_files(ip, port, tlds)
+        contents =
+          "# This file is generated by vagrant-dns\n" \
+          "[Resolve]\n" \
+          "DNS=#{ip}:#{port}\n" \
+          "Domains=~#{tlds.join(' ~')}\n"
+
+        yield "vagrant-dns.conf", contents
+      end
+
+      def install!
+        require 'fileutils'
+
+        src = File.join(tmp_path, "resolver", RESOLVED_CONFIG)
+        dest = File.join(install_path, RESOLVED_CONFIG)
+
+        commands = [
+          ['install', '-D', '-m', '0644', '-T', src.shellescape, dest.shellescape],
+          ['systemctl', 'reload-or-restart', 'systemd-resolved.service']
+        ]
+
+        exec(*commands)
+      end
+
+      def uninstall!
+        commands = [
+          ['rm', File.join(install_path, RESOLVED_CONFIG)],
+          ['systemctl', 'reload-or-restart', 'systemd-resolved.service']
+        ]
+
+        exec(*commands)
+      end
+
+      def purge!
+        require 'fileutils'
+        uninstall!
+        FileUtils.rm_r(tmp_path)
+      end
+
+      def exec(*commands)
+        return if !commands || commands.empty?
+
+        case exec_style
+        when :sudo
+          commands.each do |c|
+            system 'sudo', *c
+          end
+        else
+          raise ArgumentError, "Unsupported execution style: #{exec_style}. Use one of #{EXEC_STYLES.map(&:inspect).join(' ')}"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dns/installers/mac.rb

@@ -11,6 +11,22 @@ module VagrantDNS
         self.exec_style   = options.fetch(:exec_style, :osa)
       end
 
+      # Generate the resolved config.
+      #
+      # @yield [filename, content]
+      # @yieldparam filename [String] The filename to use for the resolved config file (relative to +install_path+)
+      # @yieldparam content [String] The content for +filename+
+      def self.resolver_files(ip, port, tlds)
+        tlds.each do |tld|
+          contents =
+            "# This file is generated by vagrant-dns\n" \
+            "nameserver #{ip}\n" \
+            "port #{port}"
+
+          yield tld, contents
+        end
+      end
+
       def install!
         require 'fileutils'
 
@@ -26,8 +42,6 @@ module VagrantDNS
       end
 
       def uninstall!
-        require 'fileutils'
-
         commands = registered_resolvers.map do |r|
           installed_resolver = File.join(install_path, File.basename(r))
           ['rm', '-rf', installed_resolver]

data/lib/vagrant-dns/installers.rb

@@ -0,0 +1,16 @@
+module VagrantDNS
+  module Installers
+    def self.resolve
+      if Vagrant::Util::Platform.darwin?
+        VagrantDNS::Installers::Mac
+      elsif Vagrant::Util::Platform.linux?
+        VagrantDNS::Installers::Linux
+      else
+        raise 'installing and uninstalling is only supported on Linux and macOS at the moment.'
+      end
+    end
+  end
+end
+
+require "vagrant-dns/installers/mac"
+require "vagrant-dns/installers/linux"

data/lib/vagrant-dns/registry.rb

@@ -1,60 +1,19 @@
-require 'yaml/store'
-require 'forwardable'
-
 module VagrantDNS
   # This is the dns pattern registry (aka "config")
   # It basically delegates everything to a YAML::Store but handles the conversion
   # of Regexp dns-patterns into YAML string keys and reverse.
   class Registry
-    extend Forwardable
-
-    def initialize(tmp_path)
-      @store = YAML::Store.new(File.join(tmp_path, "config"), true)
-    end
+    include VagrantDNS::Store
 
-    def_delegators :@store, :transaction, :abort, :commit
-
-    # This method is only valid in a #transaction and it cannot be read-only. It will raise PStore::Error if called at any other time.
-    def [](name)
-      name = name.source if name.respond_to? :source
-      @store[name]
-    end
-
-    # This method is only valid in a #transaction and it cannot be read-only. It will raise PStore::Error if called at any other time.
-    def []=(name, value)
-      name = name.source if name.respond_to? :source
-      @store[name] = value
-    end
+    NAME = "config"
 
-    def delete(name)
-      name = name.source if name.respond_to? :source
-      @store.delete(name)
-    end
-
-    # This method is only valid in a #transaction and it cannot be read-only. It will raise PStore::Error if called at any other time.
-    def root?(name)
-      name = name.source if name.respond_to? :source
-      @store.root?(name)
-    end
-    alias_method :key?, :root?
-
-    # This method is only valid in a #transaction and it cannot be read-only. It will raise PStore::Error if called at any other time.
-    def roots
-      @store.roots.map { |name| Regexp.new(name) }
-    end
-    alias_method :keys, :roots
-
-    # This method is only valid in a #transaction and it cannot be read-only. It will raise PStore::Error if called at any other time.
-    def any?
-      @store.roots.any?
+    def initialize(tmp_path)
+      @store = YAML::Store.new(File.join(tmp_path, NAME), true)
     end
 
-    def to_hash
-      @store.transaction(true) do
-        @store.roots.each_with_object({}) do |name, a|
-          a[Regexp.new(name)] = @store[name]
-        end
-      end
+    # @return [VagrantDNS::Registry,nil] Eitehr an instance or +nil+ if cofig file does not exist.
+    def self.open(tmp_path)
+      new(tmp_path) if File.exist?(File.join(tmp_path, NAME))
     end
   end
 end

data/lib/vagrant-dns/server.rb

@@ -0,0 +1,82 @@
+require 'pp'
+require 'rubydns'
+require 'async/dns/system'
+
+module VagrantDNS
+  class Server
+    attr_reader :registry, :listen, :ttl, :resolver, :passthrough
+
+    def initialize(registry, listen:, ttl:, resolver:, passthrough:)
+      @registry = registry.to_hash
+      @listen = listen
+      @ttl = ttl
+
+      @resolver = if resolver.nil? || resolver == :system
+        RubyDNS::Resolver.new(Async::DNS::System.nameservers)
+      elsif !resolver || resolver.empty?
+        nil
+      else
+        RubyDNS::Resolver.new(resolver)
+      end
+
+      if passthrough && !resolver
+        puts "[Warning] 'passthrough' config has no effect, sice no passthrough resolver is set."
+      end
+
+      @passthrough = !!@resolver && passthrough
+    end
+
+    def run
+      # need those clusures for the +RubyDNS::run_server+ block
+      passthrough = self.passthrough
+      registry = self.registry
+      resolver = self.resolver
+      ttl = self.ttl
+
+      _passthrough = if passthrough
+        proc do |transaction|
+          transaction.passthrough!(resolver) do |response|
+            puts "Passthrough response: #{response.inspect}"
+          end
+        end
+      end
+
+      RubyDNS::run_server(listen) do
+        # match all known patterns first
+        registry.each do |pattern, ip|
+          match(pattern, Resolv::DNS::Resource::IN::A) do |transaction, match_data|
+            transaction.respond!(ip, ttl: ttl)
+          end
+        end
+
+        case passthrough
+        when true
+          # forward everything
+          otherwise(&_passthrough)
+        when false
+          # fail known patterns for non-A queries as NotImp
+          registry.each do |pattern, ip|
+            match(pattern) do |transaction, match_data|
+              transaction.fail!(:NotImp)
+            end
+          end
+
+          # unknown pattern end up as NXDomain
+          otherwise do |transaction|
+            transaction.fail!(:NXDomain)
+          end
+        when :unknown
+          # fail known patterns for non-A queries as NotImp
+          registry.each do |pattern, ip|
+            match(pattern) do |transaction, match_data|
+              transaction.fail!(:NotImp)
+            end
+          end
+
+          # forward only unknown patterns
+          otherwise(&_passthrough)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-dns/service.rb

@@ -20,44 +20,27 @@ module VagrantDNS
       run!("status")
     end
 
-    SERVER = Proc.new do |tmp_path, skip_require_dependencies|
-      unless skip_require_dependencies
-        require 'rubydns'
-        require 'async/dns/system'
-      end
-
-      registry = Registry.new(tmp_path).to_hash
-      std_resolver = RubyDNS::Resolver.new(Async::DNS::System.nameservers)
-      ttl = VagrantDNS::Config.ttl
-
-      RubyDNS::run_server(VagrantDNS::Config.listen) do
-        registry.each do |pattern, ip|
-          match(pattern, Resolv::DNS::Resource::IN::A) do |transaction, match_data|
-            transaction.respond!(ip, ttl: ttl)
-          end
-        end
-
-        otherwise do |transaction|
-          transaction.passthrough!(std_resolver) do |reply, reply_name|
-            puts reply
-            puts reply_name
-          end
-        end
-      end
-    end
-
     def run!(cmd, opts = {})
       # On darwin, when the running Ruby is not compiled for the running OS
       # @see: https://github.com/BerlinVagrant/vagrant-dns/issues/72
       use_issue_72_workround = RUBY_PLATFORM.match?(/darwin/) && !RUBY_PLATFORM.end_with?(`uname -r`[0, 2])
 
       if cmd == "start" && use_issue_72_workround
-        require 'rubydns'
-        require 'async/dns/system'
+        require_relative "./server"
       end
 
       Daemons.run_proc("vagrant-dns", run_options(cmd, opts)) do
-        SERVER.call(tmp_path, use_issue_72_workround)
+        unless use_issue_72_workround
+          require_relative "./server"
+        end
+
+        VagrantDNS::Server.new(
+          Registry.new(tmp_path),
+          listen: VagrantDNS::Config.listen,
+          ttl: VagrantDNS::Config.ttl,
+          passthrough: VagrantDNS::Config.passthrough,
+          resolver: VagrantDNS::Config.passthrough_resolver
+        ).run
       end
     end
 
@@ -67,20 +50,32 @@ module VagrantDNS
     end
 
     def show_config
-      registry = Registry.new(tmp_path).to_hash
+      registry = Registry.open(tmp_path)
+      return unless registry
 
-      if registry.any?
-        registry.each do |pattern, ip|
+      config = registry.to_hash
+      if config.any?
+        config.each do |pattern, ip|
           puts format("%s => %s", pattern.inspect, ip)
         end
       else
-        puts "Configuration missing or empty."
+        puts "Pattern configuration missing or empty."
       end
     end
 
-    private
+    def show_tld_config
+      tld_registry = VagrantDNS::TldRegistry.open(tmp_path)
+      return unless tld_registry
+
+      tlds = tld_registry.transaction { |store| store.fetch("tlds", []) }
+      if !tlds || tlds.empty?
+        puts "No TLDs configured."
+      else
+        puts tlds
+      end
+    end
 
-    def run_options(cmd, extra = {})
+    private def run_options(cmd, extra = {})
       daemon_dir = File.join(tmp_path, "daemon")
       {
         ARGV: [cmd],
@@ -89,7 +84,7 @@ module VagrantDNS
         log_output: true,
         log_dir: daemon_dir,
         **extra
-     }
+      }
     end
   end
 end