vagrant-dns 2.2.3 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79dfdc20901e6817d9acb8d2833a1be00655cd974b2d9d6afbffc5ddea2d3ff2
-  data.tar.gz: 6c4fa0e10842aee72a453b368bb535a0d450f64b2c0eb88e1479d1a4d83f2984
+  metadata.gz: b96bd995237133ab779883dc28ed8ac0ed8b2cb15b71c81c755bef68f93fc6bb
+  data.tar.gz: 9ddc6a521a68af235a6626672e6d7089e330bfcc0445b2126e01f8f45f4ebf32
 SHA512:
-  metadata.gz: 7b55bfad4178e4dfb15fff551de3fde4ab324520ce4d4e1e2cab3acc13b67b3e9d194be2af2e0281922b9f03061540472decda0f5ca94173f1600add4fbdd9ae
-  data.tar.gz: 0cbd95cb993d9cc857838629ad7eaeb6c5708c53b337b246c685468783a3e0864bc7f1ff6e9b8afe675add2b173ef09e4e9def27d038915e503be59440d794b4
+  metadata.gz: dee69e1a9fb66bdb817a310a2e2daf049bab4c032f907f7220825feffac480dbdeb4356c412c59dd7bd2369f40b030e8b21576e0c21d7bfd6dd6d3460fc69d74
+  data.tar.gz: d58f43351a8a12aa3f79e6bdb7c047f312b38714767a0c4d0e03c5e2e4a484c9bd11a57aec95d775f37e425ed6cda027af49b8c8cd66f38a84b5fb92bd8439bd

data/.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+
+[{*.rb,Gemfile,Vagrantfile}]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+indent_style = space
+indent_size = 2

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.7.7

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 2.4.0 (2023-04-11)
+
+* DHCP support. [GH-51]
+* Non-A-queries (like IPv6 AAAA- or TXT records) matching a configured pattern will be answered with a `NOTIMP` error. [GH-76]
+* Upstream / passthrough DNS servers are now configurable, defaulting to the system config (existing behavior). [GH-76]
+* Passthrough behavior is now configurable (`true`/`false`/`:unknown`). [GH-77]
+
+## 2.3.0 (2023-01-14)
+
+* 🎉 Linux Support. Many thanks @mattiasb [GH-75]
+* Managed TLDs are now stored in separate config file, which can be inspected via `vagrant dns --list-ltds`.
+
 ## 2.2.3
 
 ### Fixes:
@@ -18,7 +30,7 @@
 
 ## 2.2.0
 
-### New Feautres:
+### New Features:
 
 * Add global config for time-to-live via `VagrantDNS::Config.ttl`
 
@@ -29,16 +41,16 @@
 
 ### Breaking Changes:
 
-* Removes the global and vm config  `ipv4only`. It was nver been used.
+* Removes the global and vm config  `ipv4only`. It was never used.
 
 ### Changes:
 
-* Resources will now respond with a low TTL (time-to-live) of 5 minutes (300 seconds) instead of the old 24 hours by default. Use `VagrantDNS::Config.ttl = 86400` to reset to the old behaviour.
+* Resources will now respond with a low TTL (time-to-live) of 5 minutes (300 seconds) instead of the old 24 hours by default. Use `VagrantDNS::Config.ttl = 86400` to reset to the old behavior.
 * Internal changes on how the dns pattern config is read and written. (Now using `YAML::Store`)
 * Acceptance tests run against vagrant v2.1.4
 * Acceptance tests run against Ubuntu 18.04
 
-### New Feautres:
+### New Features:
 
 * Adds a check for the VMs configured TLDs to not be included in the [Public Suffix List](https://publicsuffix.org/)
 
@@ -79,7 +91,7 @@
 * Add support for boxes with `public_network` and static IP.
 * Breaking: No longer falls back to `127.0.0.1` when no IP could be found.
 * Log messages will now be tagged with the related box (vm) and `[vagrant-dns]`
-* Develepment targets Vagrant 1.9.3
+* Development targets Vagrant 1.9.3
 
 ## 1.0.0
 

data/DEVELOPMENT.md

@@ -2,7 +2,8 @@
 
 TODO: Expand this section :)
 
-The `Gemfile` uses two environment variables, `TEST_RUBY_VERSION` and `TEST_VAGRANT_VERSION` to control which version of ruby and vagrant are used during local development.
+The `Gemfile` uses the `TEST_VAGRANT_VERSION` environment variable to control which version of vagrant is used during local development.
+To adjust the ruby version used, change the contents of the `.ruby-version` file, even if you don't use a ruby version manager.
 
 ## Running Acceptance Tests
 
@@ -19,5 +20,20 @@ bundle exec rake -D acceptance
 bundle exec rake acceptance:setup:virtualbox
 
 # Run tests
-rake acceptance:virtualbox
+bundle exec rake acceptance:virtualbox
+```
+
+### On other providers
+
+1. If it's not a default provider, add it to to `Gemfile` as a dependency and re-run `bundle install`.
+2. Add a box provider name to box URL mapping to the `TEST_BOXES` hash in `tasks/acceptance.rake`
+3. Run the `acceptance` rake task like above, replacing `virtualbox` with your provider.
+
+
+### VMware IPs
+
+VMware uses IPs from its bridges for DHCP and static private networks. Check IP and net masks using:
+
+```console
+ifconfig -X bridge | grep 'inet ' | grep -v '127.0.0.1' | awk '{ print $2 "\t" $4 }'
 ```

data/Gemfile

@@ -1,5 +1,5 @@
 source 'https://rubygems.org'
-ruby(ENV['TEST_RUBY_VERSION'] || '~> 2.7.3')
+ruby(File.read(File.expand_path('.ruby-version', __dir__))[/\d+\.\d+\.\d+.*/])
 
 ENV['TEST_VAGRANT_VERSION'] ||= 'v2.3.4'
 
@@ -7,6 +7,9 @@ ENV['TEST_VAGRANT_VERSION'] ||= 'v2.3.4'
 # during acceptance tests.
 group :plugins do
   gemspec
+  # source "https://gems.hashicorp.com/" do
+  #   gem "vagrant-vmware-desktop"
+  # end
 end
 
 group :test, :development do

data/PLATFORM_SUPPORT.md

@@ -1,13 +1,15 @@
 Platform Support
 ================
 
-Vagrant-DNS only supports OS X at the moment. This has 2 main reasons:
+Vagrant-DNS was originally developed for macOS (or Mac OS X back in the time). This had 2 main reasons:
 
-1) All main developers are on OS X and have no good idea how to properly implement such a system for other OSes. Also, OS X makes it incredibly easy to do what vagrant-dns does.
+1) All main developers are on macOS and have no good idea how to properly implement such a system for other OSes. Also, macOS makes it incredibly easy to do what vagrant-dns does.
 
 2) We spoke to multiple Linux and Windows-Developers and found that a half-baked implementation of people not invested at the respective platform as a _convenient development_ platform is only harmful and might at worst mess with users systems in unintended ways. None of them have supplied us with a proper way to implement this.
 
-That said, we will happily accept any patches and want to encourage platform support beyond OS X, including ensuring further development of those solutions. Some of the groundwork for this has been layed. It might not be 100% finished, but we happily apply any changes necessary.
+Vagrant-DNS just recently gained support for Linux, more specificity systemd with resolved.
+
+That said, we will happily accept any patches and want to encourage platform support beyond macOS, including ensuring further development of those solutions. Some of the groundwork for this has been layed. It might not be 100% finished, but we happily apply any changes necessary.
 
 This document aims to be a guide to implementing support for other platforms.
 
@@ -23,10 +25,10 @@ Design Goals
 
 Vagrant-DNS should not require superuser access for anything except reconfiguring the hosts DNS system. This is why there is a seperate "install" step that registers the Vagrant-DNS server to your system (for the configured TLDs). (Re)starts of the server (happening at startup of the machine) need to happen without superuser access.
 
-Mac OS X
-========
+macOS
+=====
 
-As a reference, here is how this works on OS X:
+As a reference, here is how this works on macOS:
 
 * `install` places a symlink in `/etc/resolver/{tld}` that links to a corresponding file in `.vagrant.d` with content similar to this one:
 
@@ -40,10 +42,19 @@ From then on, OS X will resolve all requests to that top level domain using the
 Linux
 =====
 
-To help anyone that attempts a Linux implementation, here is what has already been tried.
+With `systemd-resolved`, we finally got a mechanism that resembles the macOS approach, with some subtile differences.
+
+* `install` creates a single file `vagrant-dns.conf`, even when multiple top level domains are configured:
+
+```
+[Resolve]
+DNS=127.0.0.1:5300
+Domains=~test ~othertld
+```
+
+This file is then copied into `/etc/systemd/resolved.conf.d/`. The macOS strategy of adding symlinks from config files to a file within `/home/<user>/` doesn't work since the user that runs systemd-resolved doesn't have permission to read there.
 
-* Editing resolv.conf: Linux resolv.conf (in contrast to, say OpenBSD) does not allow you to set a port number for the DNS server. Also, its size is limited to 3 servers and the file is often under OS control, so messing around with it might not be advisable.
-* Setting up dnsmasq: this is certainly an option, but we couldn't find out how invasive this was, which Linux flavors might already come with dnsmasq configurations and how not to shoot other people in the foot with it. User help is needed.
+This makes zombie configurations likely. For example when `vagrant-dns` is not correctly uninstalled using its `uninstall` command, its `resolved` configuration will point to a non-existing server, potentially causing troubles.
 
 (Open)BSD
 =========

data/README.md

@@ -12,11 +12,11 @@ Alternatively, you can install an older version of vagrant-dns like this: `vagra
 
 ## Usage
 
-In addition to your networking config, configure a toplevel domain and a `hostname` for your machine. Optionally, configure a set of free matching patterns. Global configuration options can be given through the `VagrantDNS::Config` object:
+In addition to your networking config, configure a top-level domain and a `hostname` for your machine. Optionally, configure a set of free matching patterns. Global configuration options can be given through the `VagrantDNS::Config` object:
 
 ```ruby
 Vagrant.configure("2") do |config|
-  #...
+  # ...
 
   config.dns.tld = "test"
 
@@ -37,7 +37,9 @@ Then, register the DNS server as a resolver:
 $ vagrant dns --install
 ```
 
-On OS X, this will create a file `/etc/resolver/test`, which tells OS X to resolve the TLD `.test` by using the nameserver given in this file. You will have to rerun --install every time a tld is added.
+This command will write out a configuration file that tells the operating system to resolve the `.test` TLD via the `vagrant-dns` DNS server. On OS X, this config file is located at `/etc/resolver/test` while on Linux it's at `/etc/systemd/resolved.conf.d/vagrant-dns.conf`.
+
+You will have to rerun --install every time a tld is added.
 
 You can delete this file by running:
 
@@ -45,7 +47,7 @@ You can delete this file by running:
 $ vagrant dns --uninstall
 ```
 
-To also delete the created config file for this TLD (`~/.vagrant.d/tmp/dns/resolver/test` in our example) run:
+To also delete the created config file for this TLD (`~/.vagrant.d/tmp/dns/resolver/test` or `~/.vagrant.d/tmp/dns/resolver/vagrant-dns.conf` in our example) run:
 
 
 ```bash
@@ -60,26 +62,45 @@ $ vagrant dns --start
 
 And test it:
 
+**OS X:**
+
 ```bash
 $ scutil --dns
-...
+[ … ]
 resolver #8
   domain   : test
   nameserver[0] : 127.0.0.1
   port     : 5300
-...
+[ … ]
+
 $ dscacheutil -q host -a name test.machine.test
 name: test.machine.test
 ip_address: 33.33.33.10
 ```
 
-You can now reach the server under the given domain.
+**Linux**:
+
+```bash
+$ resolvectl status
+Global
+       Protocols: LLMNR=resolve -mDNS -DNSOverTLS DNSSEC=no/unsupported
+resolv.conf mode: stub
+      DNS Domain: ~test
+[ … ]
+
+$ resolvectl query test.machine.test
+test.machine.test: 33.33.33.10
+
+-- Information acquired via protocol DNS in 10.1420s.
+-- Data is authenticated: no; Data was acquired via local or encrypted transport: no
+```
 
 **Note:** Mac OS X is quite different from Linux regarding DNS resolution. As a result, do not use
 `dig` or `nslookup`, but `dscacheutil` instead. Read [this article](http://apple.stackexchange.com/a/70583)
 for more information.
 
-Finally, stop the server using:
+
+You can now reach the server under the given domain.
 
 ```bash
 $ vagrant dns --stop
@@ -127,12 +148,20 @@ We can use [multivm](https://www.vagrantup.com/docs/multi-machine/) configuratio
 *  Execute : `vagrant dns --install`
 *  Test via: `ping worker2.mysite.box` or `worker1.mysite.box`
 
-
 ## VM options
 
 * `vm.dns.tld`: Set the tld for the given virtual machine. No default.
-* `vm.dns.tlds`: Set multiple tlds. Default: `[tld]`
+* `vm.dns.tlds`: Set multiple TLDs. Default: `[tld]`
 * `vm.dns.patterns`: A list of domain patterns to match. Defaults to `[/^.*{host_name}.{tld}$/]`
+* `vm.dns.ip`: Optional, overwrite of the default static IP detection. Valid values are:
+  - `Proc`: A Proc which return value will get used as IP. Eg: `proc { |vm, opts| }` (See DHCP section for full sample)
+  - `Symbol`: Forces the use of the named static network: 
+    + `:private_network`: Use static ip of a configured private network (`config.vm.network "private_network", ip: "192.168.50.4"`)
+    + `:public_network`: Use static ip of a configured public network (`config.vm.network "public_network", ip: "192.168.0.17"`)
+    + `:dynamic`, `:dhcp`: Force reading the guest IP using vagrants build-in `read_ip_address` capability.
+  - Default:
+      If there is no network with a statically defined IP, and no `ip` override is given, use the build-in `read_ip_address` capability.
+      Else, check `:private_network`, if none found check `:public_network`
 
 ## Global Options
 
@@ -141,12 +170,19 @@ We can use [multivm](https://www.vagrantup.com/docs/multi-machine/) configuratio
 * `VagrantDNS::Config.auto_run`: (re)start and reconfigure the server every time a machine is started. On by default.
 * `VagrantDNS::Config.check_public_suffix`: Check if you are going to configure a [Public Suffix](https://publicsuffix.org/) (like a Top Level Domain) in a VMs `tld(s)` config, which could mess up your local dev machines DNS config. Possible configuration values are:
   - `false`: Disables the feature.
-  - `"warn"`: Check and print a warning. (Still creates a resolver config and potentionally messes up your DNS) **At the moment, this is the default** because lots of projetcs used to use `"dev"` as a TLD, but this got registered by google and is now a public suffix.
+  - `"warn"`: Check and print a warning. (Still creates a resolver config and potentially messes up your DNS) **At the moment, this is the default** because lots of projects used to use `"dev"` as a TLD, but this got registered by google and is now a public suffix.
   - `"error"`: Check and prevent the box from starting. (Does not create the resolver config, it will also prevent the box from starting.)
- 
+* `VagrantDNS::Config.passthrough`: Configure how to deal with non-matching DNS queries. Will be set to `false` if no `passthrough_resolver` could be detected, or none is set.
+  - `true`: (default) Every non-matching query is passed through to the upstream DNS server (see `passthrough_resolver`)
+  - `false`: Disable passthrough. Every non-A-query to a matching pattern fails with `NotImp`. Every other query fails with `NXDomain`.
+  - `:unknown`: Only forward queries for which there's no matching pattern. Every non-A-query to a matching pattern fails with `NotImp`. Every other query will be passed through.
+* `VagrantDNS::Config.passthrough_resolver`: By default, DNS queries not matching any patterns will be passed to an upstream DNS server.
+  - `:system`: (Default) pass through to the system configured default DNS server
+  - `[[:udp, "1.1.1.1", 53], [:tcp, "1.1.1.1", 53]]`: an Array of Arrays describing the DNS server(s) to use. (Protocol, IP, Port)
+
 ## Using custom domains from inside the VM (VirtualBox only)
 
-If you need to be able to resolve custom domains managed by this plugin from inside your virtual machine, add the following 
+If you need to be able to resolve custom domains managed by this plugin from inside your virtual machine (and you're using VirtualBox), add the following
 setting to your `Vagrantfile`:
 
 ```ruby
@@ -168,10 +204,35 @@ setting, however, the NAT engine will act as a DNS proxy
 (see [Virtualbox docs](https://www.virtualbox.org/manual/ch09.html#nat-adv-dns)). That way, queries for your custom domains
 from inside the guest will also be handled by the DNS server run by the plugin.
 
+## DHCP / Dynamic IP
+
+When configuring your VM with a DHCP network, vagrant-dns tries to identify the guest IP using vagrants build-in `read_ip_address` capability.
+
+For more fine-grained control use the `ip` config.
+Here is an example using the VM's default way of communication and using the `hostname` command on it:
+
+```ruby
+Vagrant.configure("2") do |config|
+  # ...
+
+  # - `vm` is the vagrant virtual machine instance and can be used to communicate with it
+  # - `opts` is the vagrant-dns options hash (everything configured via `config.dns.*`)
+  config.dns.ip = -> (vm, opts) do
+    # note: the block handed to `execute` might get called multiple times, hence this closure
+    ip = nil
+    vm.communicate.execute("hostname -I | cut -d ' ' -f 1") do |type, data|
+      ip = data.strip if type == :stdout
+    end
+    ip
+  end
+end
+```
+
+__NOTES__: In order to obtain the IP in this way, the vagrant box needs to be up and running. You will get a log output (`Postponing running user provided IP script until box has started.`) when you try to run `vagrant dns`  on a non-running box.
+
 ## Issues
 
+* macOS and systemd-resolved enabled Linux only (please read: [Platform Support](https://github.com/BerlinVagrant/vagrant-dns/blob/master/PLATFORM_SUPPORT.md) before ranting about this).
 * `A` records only
 * No IPv6 support
-* OS X only (please read: [Platform
-  Support](https://github.com/BerlinVagrant/vagrant-dns/blob/master/PLATFORM_SUPPORT.md) before ranting about this).
 * Not automatically visible inside the box (special configuration of your guest system or provider needed)

data/lib/vagrant-dns/command.rb

@@ -59,6 +59,11 @@ module VagrantDNS
           options[:build_config] = false
         end
 
+        opts.on("--list-tlds", "-L", "Show the current TopLevelDomains registered. This works in conjunction with --start --stop --restart --status.") do
+          options[:show_tld_config] = true
+          options[:build_config] = false
+        end
+
         opts.on("--with-sudo", "In conjunction with `--install`, `--uninstall`, `--purge`: Run using `sudo` instead of `osascript`. Useful for automated scripts running as sudoer.") do
           options[:installer_opts] = { exec_style: :sudo }
         end
@@ -76,25 +81,23 @@ module VagrantDNS
       build_config(vms, options)        if options[:build_config]
       manage_service(vms, options)
       manage_installation(vms, options) if options[:manage_installation]
-      show_config(vms, options)         if options[:show_config]
+      show_config(vms, options)         if options[:show_config] || options[:show_tld_config]
     end
 
     protected
 
     def manage_installation(vms, options)
-      if Vagrant::Util::Platform.darwin?
-        installer_options = options.fetch(:installer_opts, {})
-        installer = VagrantDNS::Installers::Mac.new(tmp_path, installer_options)
-
-        if options[:install]
-          installer.install!
-        elsif options[:uninstall]
-          installer.uninstall!
-        elsif options[:purge]
-          installer.purge!
-        end
-      else
-        raise 'installing and uninstalling is only supported on Mac OS X at the moment.'
+      installer_class = VagrantDNS::Installers.resolve
+
+      installer_options = options.fetch(:installer_opts, {})
+      installer = installer_class.new(tmp_path, installer_options)
+
+      if options[:install]
+        installer.install!
+      elsif options[:uninstall]
+        installer.uninstall!
+      elsif options[:purge]
+        installer.purge!
       end
     end
 
@@ -114,7 +117,8 @@ module VagrantDNS
 
     def show_config(vms, options)
       service = VagrantDNS::Service.new(tmp_path)
-      service.show_config
+      service.show_tld_config if options[:show_tld_config]
+      service.show_config if options[:show_config]
     end
 
     def build_config(vms, options)

data/lib/vagrant-dns/config.rb

@@ -1,9 +1,10 @@
-require 'logger'
+require "logger"
 
 module VagrantDNS
   class Config < Vagrant.plugin(2, :config)
     class << self
-      attr_accessor :listen, :ttl, :logger, :auto_run, :check_public_suffix
+      attr_writer :listen, :ttl, :passthrough, :passthrough_resolver
+      attr_accessor :logger, :auto_run, :check_public_suffix
 
       def listen
         @listen ||= [[:udp, "127.0.0.1", 5300]]
@@ -13,6 +14,15 @@ module VagrantDNS
         @ttl ||= 300
       end
 
+      def passthrough
+        return true if @passthrough.nil?
+        @passthrough
+      end
+
+      def passthrough_resolver
+        @passthrough_resolver ||= :system
+      end
+
       def auto_run
         return true if @auto_run.nil?
         @auto_run
@@ -37,7 +47,7 @@ module VagrantDNS
         failed_tlds = vm.config.dns.tlds.select { |tld| list.find(tld, default: false) }
 
         err = if failed_tlds.any?
-          "tlds include a public suffix: #{failed_tlds.join(', ')}"
+          "tlds include a public suffix: #{failed_tlds.join(", ")}"
         end
 
         if err && check_public_suffix.to_s == "error"
@@ -50,7 +60,7 @@ module VagrantDNS
       end
     end
 
-    attr_accessor :records
+    attr_accessor :records, :ip
     attr_reader :tlds, :patterns
 
     def pattern=(pattern)
@@ -68,11 +78,7 @@ module VagrantDNS
 
     # explicit hash, to get symbols in hash keys
     def to_hash
-      {
-        :patterns => patterns,
-        :records => records,
-        :tlds => tlds
-      }
+      { patterns: patterns, records: records, tlds: tlds, ip: ip }
     end
 
     def validate(machine)
@@ -96,4 +102,3 @@ module VagrantDNS
     end
   end
 end
-