landrush 1.1.2 → 1.2.0

data/features/commands.feature

@@ -0,0 +1,35 @@
+Feature: Landrush reload
+  Landrush DNS server should restart on a 'vagrant reload'
+
+  Scenario Outline: booting a box and restarting it
+    Given a file named "Vagrantfile" with:
+    """
+    Vagrant.configure("2") do |config|
+      config.vm.box = '<box>'
+      config.vm.synced_folder '.', '/vagrant', disabled: true
+      config.landrush.enabled = true
+    end
+    """
+    When I successfully run `bundle exec vagrant up --provider <provider>`
+    Then Landrush is running
+
+    When I successfully run `bundle exec vagrant landrush set foo 1.2.3.4`
+    And I successfully run `bundle exec vagrant landrush set bar 4.3.1.1`
+    And I successfully run `bundle exec vagrant landrush ls`
+    Then stdout from "bundle exec vagrant landrush ls" should match /^foo.*1.2.3.4$/
+    Then stdout from "bundle exec vagrant landrush ls" should match /^bar.*4.3.2.1$/
+
+    When I successfully run `bundle exec vagrant landrush rm --all`
+    And I successfully run `bundle exec vagrant landrush ls`
+    Then stdout from "bundle exec vagrant landrush ls" should match /^foo.*1.2.3.4$/
+    Then stdout from "bundle exec vagrant landrush ls" should match /^bar.*4.3.2.1$/
+
+    When I successfully run `bundle exec vagrant reload`
+    Then Landrush is running
+
+    When I successfully run `bundle exec vagrant landrush stop`
+    Then Landrush is not running
+
+    Examples:
+      | box             | provider   |
+      | debian/jessie64 | virtualbox |

data/features/dns_resolution.feature

@@ -16,9 +16,9 @@ Feature: dns_resolution
     end
     """
     When I successfully run `bundle exec vagrant up --provider <provider>`
-    Then the hostname "my-host.landrush-acceptance-test" should resolve to "10.10.10.123" on the internal DNS server
-    And the hostname "my-host.landrush-acceptance-test" should resolve to "10.10.10.123" on the host
+    Then the hostname "my-host.landrush-acceptance-test" should resolve to "10.10.10.123" on the host
     And the hostname "my-host.landrush-acceptance-test" should resolve to "10.10.10.123" on the guest
+    And the hostname "my-host.landrush-acceptance-test" should resolve to "10.10.10.123" on the internal DNS server
 
     When I successfully run `bundle exec vagrant landrush set my-static-host.landrush-acceptance-test 42.42.42.42`
     Then the hostname "my-static-host.landrush-acceptance-test" should resolve to "42.42.42.42" on the internal DNS server
@@ -30,6 +30,7 @@ Feature: dns_resolution
     And the hostname "my-static-cname-host.landrush-acceptance-test" should resolve to "42.42.42.42" on the host
 
     Examples:
-      | box             | provider   |
-      | debian/jessie64 | virtualbox |
-      #| ubuntu/wily64   | virtualbox |
+      | box                           | provider   |
+      | debian/jessie64               | virtualbox |
+      #| opensuse/openSUSE-42.1-x86_64 | virtualbox |
+      #| ubuntu/wily64                 | virtualbox |

data/features/step_definitions/landrush_custom_steps.rb

@@ -0,0 +1,48 @@
+require 'landrush/server'
+
+Then(/^the hostname "([^"]+)" should resolve to "([^"]+)" on the internal DNS server$/) do |host, ip|
+  port = Landrush::Server.port
+  resolver = Resolv::DNS.new(nameserver_port: [['localhost', port]], search: ['local'], ndots: 1)
+  ip_resolved = resolver.getaddress(host).to_s
+  expect(ip_resolved).to eq(ip)
+end
+
+Then(/^the hostname "([^"]+)" should resolve to "([^"]+)" on the host$/) do |host, ip|
+  addrinfo = Addrinfo.getaddrinfo(host, nil, Socket::AF_INET)
+  ip_resolved = addrinfo.first.ip_address
+  expect(ip_resolved).to eq(ip)
+end
+
+Then(/^the hostname "([^"]+)" should resolve to "([^"]+)" on the guest/) do |host, ip|
+  run("bundle exec vagrant ssh -c \"dig +short '#{host}' A\"")
+  expect(last_command_started).to have_output(/^#{ip}$/)
+end
+
+Then(/^the host visible IP address of the guest is the IP of interface "([^"]+)"/) do |interface|
+  cmd = "bundle exec vagrant ssh -c \"ip addr list #{interface} | grep 'inet ' | cut -d' ' -f6| cut -d/ -f1\""
+  run(cmd)
+  expect(last_command_started).to have_output(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/)
+
+  ip = last_command_started.output.split("\n").last
+
+  run('bundle exec vagrant landrush list')
+
+  expect(last_command_started).to have_output(/#{ip}$/)
+end
+
+Then(/^Landrush is( not)? running$/) do |negated|
+  run('bundle exec vagrant landrush status')
+  if negated
+    expect(last_command_started).to have_output(/Daemon status: stopped/)
+  else
+    expect(last_command_started).to have_output(/Daemon status: running pid=[0-9]+/)
+  end
+end
+
+Then(%r{^stdout from "([^"]*)" should( not)? match /(.*)/$}) do |cmd, negated, regexp|
+  if negated
+    aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd)).send(:stdout) !~ /#{regexp}/
+  else
+    aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd)).send(:stdout) =~ /#{regexp}/
+  end
+end

data/features/support/env.rb

@@ -1,15 +1,39 @@
 require 'aruba/cucumber'
 require 'komenda'
+require 'fileutils'
+require 'find'
 
 Aruba.configure do |config|
-  config.exit_timeout = 300
+  config.exit_timeout = 3600
   config.activate_announcer_on_command_failure = [:stdout, :stderr]
   config.working_directory = 'build/aruba'
 end
 
+Before do |_scenario|
+  # Making sure that all tests run in a pristine environment
+  # Create the Vagrant home directory for the tests
+  vagrant_home = File.join(File.dirname(__FILE__), '..', '..', 'build', 'vagrant.d')
+  # Make sure the Vagrant home directory is "clean".
+  # We keep the boxes directory to not have to re-download the boxes each time
+  ENV['VAGRANT_HOME'] = vagrant_home
+  Dir.new(ENV['VAGRANT_HOME']).entries.reject { |file| 'boxes'.eql?(file) || '.'.eql?(file) || '..'.eql?(file) }
+     .each { |file| FileUtils.rmtree(File.join(ENV['VAGRANT_HOME'], file)) }
+
+  # Actual gems are in ~/vagrant.d/gems/gems
+  gems_path = File.join(vagrant_home, 'gems', 'gems')
+  FileUtils.mkdir_p gems_path
+
+  # Find the path to the Bundler gems
+  bundler_gem_path = File.join(Bundler.rubygems.find_name('bundler').first.base_dir, 'gems')
+
+  # Copy the gems to the Vagrant gems dir
+  FileUtils.cp_r bundler_gem_path, gems_path, verbose: false
+end
+
 After do |_scenario|
   Komenda.run('bundle exec vagrant landrush stop', fail_on_fail: true)
 
+  # If there is a Vagrantfile from previous run, delete it
   if File.exist?(File.join(aruba.config.working_directory, 'Vagrantfile'))
     Komenda.run('bundle exec vagrant destroy -f', cwd: aruba.config.working_directory, fail_on_fail: true)
   end

data/landrush.gemspec

@@ -19,16 +19,16 @@ Gem::Specification.new do |spec|
     and down, and you can configure static entries to be returned from the
     server as well. See the README for more documentation.
   DESCRIP
-  spec.summary       = %q{a vagrant plugin providing consistent DNS visible on host and guests}
+  spec.summary       = 'a vagrant plugin providing consistent DNS visible on host and guests'
   spec.homepage      = 'https://github.com/vagrant-landrush/landrush'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
   spec.add_dependency 'rubydns', '0.8.5'
   spec.add_dependency 'win32-process'
-  spec.add_dependency 'landrush-ip', '~> 0.2.3'
+  spec.add_dependency 'landrush-ip', '~> 0.2.5'
 end

data/lib/landrush/action/common.rb

@@ -1,5 +1,6 @@
 module Landrush
   module Action
+    # A module containing shared functionality for Vagrant middleware classes
     module Common
       SUPPORTED_PROVIDERS = {
         'VagrantPlugins::ProviderVirtualBox::Provider' => :virtualbox,
@@ -16,14 +17,7 @@ module Landrush
 
       def initialize(app, env)
         @app = app
-      end
-
-      def handle_action_stack(env)
         @env = env
-
-        yield
-
-        app.call(env)
       end
 
       def virtualbox?
@@ -47,7 +41,7 @@ module Landrush
           raise "The landrush plugin does not support the #{key} provider yet!"
         end
 
-        if provider_name == :parallels && Gem::Version.new(VagrantPlugins::Parallels::VERSION) < Gem::Version.new("1.0.3")
+        if provider_name == :parallels && Gem::Version.new(VagrantPlugins::Parallels::VERSION) < Gem::Version.new('1.0.3')
           raise "The landrush plugin supports the Parallels provider v1.0.3 and later. Please, update your 'vagrant-parallels' plugin."
         end
 
@@ -73,9 +67,7 @@ module Landrush
       end
 
       def read_machine_hostname
-        if machine.config.vm.hostname
-          return machine.config.vm.hostname
-        end
+        return machine.config.vm.hostname if machine.config.vm.hostname
 
         "#{Pathname.pwd.basename}.#{config.tld}"
       end

data/lib/landrush/action/install_prerequisites.rb

@@ -4,9 +4,8 @@ module Landrush
       include Common
 
       def call(env)
-        handle_action_stack(env) do
-          install_prerequisites if enabled?
-        end
+        install_prerequisites if enabled?
+        app.call(env)
       end
 
       def install_prerequisites

data/lib/landrush/action/redirect_dns.rb

@@ -4,7 +4,7 @@ module Landrush
       include Common
 
       def call(env)
-        handle_action_stack(env) {}
+        app.call(env)
 
         # This is after the middleware stack returns, which, since we're right
         # before the Network action, should mean that all interfaces are good

data/lib/landrush/action/setup.rb

@@ -7,11 +7,11 @@ module Landrush
         # Make sure we use the right data directory for Landrush
         # Seems Vagrant only makes home_path available in this case, compared to custom commands where there is also data_dir
         Server.working_dir = File.join(env[:home_path], 'data', 'landrush')
+        Server.gems_dir = File.join(env[:gems_path].to_s, 'gems')
+        Server.ui = env[:ui]
 
-        handle_action_stack(env) do
-          pre_boot_setup if enabled?
-        end
-
+        pre_boot_setup if enabled?
+        app.call(env)
         # This is after the middleware stack returns, which, since we're right
         # before the Network action, should mean that all interfaces are good
         # to go.
@@ -19,21 +19,25 @@ module Landrush
       end
 
       def host_ip_address
-        static_private_network_ip || machine.guest.capability(:read_host_visible_ip_address)
+        if private_network_ips.include? machine.config.landrush.host_ip_address
+          machine.config.landrush.host_ip_address
+        else
+          machine.guest.capability(:read_host_visible_ip_address)
+        end
       end
 
       private
 
       def pre_boot_setup
-        record_dependent_vm
         add_prerequisite_network_interface
-        configure_server
-        start_server
       end
 
       def post_boot_setup
+        record_dependent_vm
+        configure_server
         record_machine_dns_entry
         setup_static_dns
+        start_server
         return unless machine.config.landrush.host_redirect_dns?
         env[:host].capability(:configure_visibility_on_host, host_ip_address, config.tld)
       end
@@ -62,15 +66,13 @@ module Landrush
       def setup_static_dns
         config.hosts.each do |hostname, dns_value|
           dns_value ||= host_ip_address
-          unless Store.hosts.has?(hostname, dns_value)
-            info "adding static DNS entry: #{hostname} => #{dns_value}"
-            Store.hosts.set hostname, dns_value
-            if ip_address?(dns_value)
-              reverse_dns = IPAddr.new(dns_value).reverse
-              info "adding static reverse DNS entry: #{reverse_dns} => #{dns_value}"
-              Store.hosts.set(reverse_dns, hostname)
-            end
-          end
+          next if Store.hosts.has?(hostname, dns_value)
+          info "adding static DNS entry: #{hostname} => #{dns_value}"
+          Store.hosts.set hostname, dns_value
+          next unless ip_address?(dns_value)
+          reverse_dns = IPAddr.new(dns_value).reverse
+          info "adding static reverse DNS entry: #{reverse_dns} => #{dns_value}"
+          Store.hosts.set(reverse_dns, hostname)
         end
       end
 
@@ -97,19 +99,12 @@ module Landrush
         machine.config.vm.networks.any? { |type, _| type == :private_network }
       end
 
-      # machine.config.vm.networks is an array of two elements. The first containing the type as symbol, the second is a
-      # hash containing other config data which varies between types
-      def static_private_network_ip
-        # select all statically defined private network ip
-        private_networks = machine.config.vm.networks.select {|network| :private_network == network[0] && !network[1][:ip].nil?}
-                                  .map {|network| network[1][:ip]}
-        if machine.config.landrush.host_ip_address.nil?
-          private_networks[0] if private_networks.length == 1
-        elsif private_networks.include? machine.config.landrush.host_ip_address
-          machine.config.landrush.host_ip_address
-        end
-        # If there is more than one private network or there is no match between config.landrush.host_ip_address
-        # and the discovered addresses we will pass on to read_host_visible_ip_address capability
+      # @return [Array<String] IPv4 addresses of all private networks
+      def private_network_ips
+        # machine.config.vm.networks is an array of two elements. The first containing the type as symbol, the second is a
+        # hash containing other config data which varies between types
+        machine.config.vm.networks.select { |network| :private_network == network[0] && !network[1][:ip].nil? }
+               .map { |network| network[1][:ip] }
       end
     end
   end

data/lib/landrush/action/teardown.rb

@@ -8,26 +8,23 @@ module Landrush
         # Seems Vagrant only makes home_path available in this case, compared to custom commands where there is also data_dir
         Server.working_dir = File.join(env[:home_path], 'data', 'landrush')
 
-        handle_action_stack(env) do
-          teardown if enabled?
-        end
+        teardown if enabled?
+        app.call(env)
       end
 
       def teardown
         teardown_machine_dns
         DependentVMs.remove(machine_hostname)
 
-        if DependentVMs.none?
-          teardown_static_dns
-          teardown_server
-        end
+        return unless DependentVMs.none?
+        teardown_static_dns
+        teardown_server
       end
 
       def teardown_machine_dns
-        if Store.hosts.has? machine_hostname
-          info "removing machine entry: #{machine_hostname}"
-          Store.hosts.delete(machine_hostname)
-        end
+        return unless Store.hosts.has? machine_hostname
+        info "removing machine entry: #{machine_hostname}"
+        Store.hosts.delete(machine_hostname)
       end
 
       def teardown_static_dns

data/lib/landrush/cap/guest/all/read_host_visible_ip_address.rb

@@ -14,11 +14,26 @@ module Landrush
           addresses
         end
 
+        def self.filter_preferred_addresses(addresses)
+          if @machine.config.landrush.host_interface_class == :any
+            addresses = addresses.select do |addr|
+              (addr.key?('ipv4') && !addr['ipv4'].empty?) ||
+                (addr.key?('ipv6') && !addr['ipv6'].empty?)
+            end
+          else
+            key = @machine.config.landrush.host_interface_class.to_s
+
+            addresses = addresses.select do |addr|
+              (addr.key?(key) && !addr[key].empty?)
+            end
+          end
+
+          addresses
+        end
+
         def self.read_host_visible_ip_address(machine)
           @machine = machine
 
-          @machine.guest.capability(:landrush_ip_install) unless @machine.guest.capability(:landrush_ip_installed)
-
           addr      = nil
           addresses = machine.guest.capability(:landrush_ip_get)
 
@@ -33,15 +48,24 @@ module Landrush
 
           if addr.nil?
             addresses = filter_addresses addresses
+            raise 'No addresses found' if addresses.empty?
 
+            addresses = filter_preferred_addresses addresses
             raise 'No addresses found' if addresses.empty?
 
             addr = addresses.last
           end
 
-          ip = IPAddr.new(addr['ipv4'])
+          # Keep preferring IPv4 over IPv6.
+          key = if machine.config.landrush.host_interface_class == :any
+                  addr['ipv4'].empty? ? 'ipv6' : 'ipv4'
+                else
+                  machine.config.landrush.host_interface_class.to_s
+                end
+
+          ip = IPAddr.new(addr[key])
 
-          machine.env.ui.info "[landrush] Using #{addr['name']} (#{addr['ipv4']})"
+          machine.env.ui.info "[landrush] Using #{addr['name']} (#{addr[key]})"
 
           ip.to_s
         end

data/lib/landrush/cap/guest/linux/add_iptables_rule.rb

@@ -10,7 +10,7 @@ module Landrush
           machine.communicate.sudo(command) do |data, type|
             if [:stderr, :stdout].include?(type)
               color = (type == :stdout) ? :green : :red
-              machine.env.ui.info(data.chomp, :color => color, :prefix => false)
+              machine.env.ui.info(data.chomp, color: color, prefix: false)
             end
           end
         end

data/lib/landrush/cap/guest/linux/redirect_dns.rb

@@ -2,9 +2,9 @@ module Landrush
   module Cap
     module Linux
       module RedirectDns
-        def self.redirect_dns(machine, target={})
+        def self.redirect_dns(machine, target = {})
           dns_servers = machine.guest.capability(:configured_dns_servers)
-          %w[tcp udp].each do |proto|
+          %w(tcp udp).each do |proto|
             dns_servers.each do |dns_server|
               machine.guest.capability(
                 :add_iptables_rule,

data/lib/landrush/cap/guest/suse/add_iptables_rule.rb

@@ -0,0 +1,20 @@
+module Landrush
+  module Cap
+    module Suse
+      module AddIptablesRule
+        def self.add_iptables_rule(machine, rule)
+          _run(machine, %(/usr/sbin/iptables -C #{rule} 2> /dev/null || /usr/sbin/iptables -A #{rule}))
+        end
+
+        def self._run(machine, command)
+          machine.communicate.sudo(command) do |data, type|
+            if [:stderr, :stdout].include?(type)
+              color = (type == :stdout) ? :green : :red
+              machine.env.ui.info(data.chomp, color: color, prefix: false)
+            end
+          end
+        end
+      end
+    end
+  end
+end