landrush 1.0.0 → 1.1.0.beta.1

data/lib/landrush/action/setup.rb

@@ -15,24 +15,41 @@ module Landrush
         # 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.
-        record_machine_dns_entry if enabled?
-        setup_static_dns if enabled?
+        post_boot_setup if enabled?
       end
 
+      def host_ip_address
+        static_private_network_ip || machine.guest.capability(:read_host_visible_ip_address)
+      end
+
+      private
+
       def pre_boot_setup
         record_dependent_vm
         add_prerequisite_network_interface
-        setup_host_resolver
         configure_server
         start_server
       end
 
+      def post_boot_setup
+        record_machine_dns_entry
+        setup_static_dns
+        setup_host_resolver(env)
+      end
+
       def record_dependent_vm
         DependentVMs.add(machine_hostname)
       end
 
-      def setup_host_resolver
-        ResolverConfig.new(env).ensure_config_exists!
+      def setup_host_resolver(env)
+        if Vagrant::Util::Platform.windows?
+          network_config = WinNetworkConfig.new(env)
+          if network_config.ensure_prerequisites
+            network_config.update_network_adapter(host_ip_address, '127.0.0.1', config.tld)
+          end
+        elsif Vagrant::Util::Platform.darwin?
+          ResolverConfig.new(env).ensure_config_exists!
+        end
       end
 
       def add_prerequisite_network_interface
@@ -54,18 +71,25 @@ module Landrush
 
       def setup_static_dns
         config.hosts.each do |hostname, dns_value|
-          dns_value ||= machine.guest.capability(:read_host_visible_ip_address)
+          dns_value ||= host_ip_address
           unless Store.hosts.has?(hostname, dns_value)
-            info "adding static entry: #{hostname} => #{dns_value}"
+            info "adding static DNS entry: #{hostname} => #{dns_value}"
             Store.hosts.set hostname, dns_value
-            Store.hosts.set(IPAddr.new(dns_value).reverse, hostname)
+            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
         end
       end
 
+      def ip_address?(value)
+        !(value =~ Resolv::IPv4::Regex).nil?
+      end
+
       def record_machine_dns_entry
-        ip_address = machine.config.landrush.host_ip_address ||
-                     machine.guest.capability(:read_host_visible_ip_address)
+        ip_address = machine.config.landrush.host_ip_address || host_ip_address
 
         unless machine_hostname.match(config.tld)
           log :error, "hostname #{machine_hostname} does not match the configured TLD: #{config.tld}"
@@ -82,6 +106,21 @@ module Landrush
       def private_network_exists?
         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 staticlly 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
+      end
     end
   end
 end

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

@@ -0,0 +1,49 @@
+module Landrush
+  module Cap
+    module All
+      module ReadHostVisibleIpAddress
+        def self.filter_addresses(addresses)
+          unless @machine.config.landrush.host_interface_excludes.nil?
+            re = Regexp.union(@machine.config.landrush.host_interface_excludes)
+
+            addresses = addresses.select do |addr|
+              !addr['name'].match(re)
+            end
+          end
+
+          addresses
+        end
+
+        def self.read_host_visible_ip_address(machine)
+          @machine = machine
+
+          addr      = nil
+          addresses = machine.guest.capability(:landrush_ip_get)
+
+          # Short circuit this one first: if an explicit interface is defined, look for it and return it if found.
+          # Technically, we could do a single loop, but execution time is not vital here.
+          # This allows us to be more accurate, especially with logging what's going on.
+          unless machine.config.landrush.host_interface.nil?
+            addr = addresses.detect { |a| a['name'] == machine.config.landrush.host_interface }
+
+            machine.env.ui.warn "[landrush] Unable to find interface #{machine.config.landrush.host_interface}" if addr.nil?
+          end
+
+          if addr.nil?
+            addresses = filter_addresses addresses
+
+            raise 'No addresses found' if addresses.empty?
+
+            addr = addresses.last
+          end
+
+          ip = IPAddr.new(addr['ipv4'])
+
+          machine.env.ui.info "[landrush] Using #{addr['name']} (#{addr['ipv4']})"
+
+          ip.to_s
+        end
+      end
+    end
+  end
+end

data/lib/landrush/config.rb

@@ -6,22 +6,28 @@ module Landrush
     attr_accessor :upstream_servers
     attr_accessor :host_ip_address
     attr_accessor :guest_redirect_dns
+    attr_accessor :host_interface
+    attr_accessor :host_interface_excludes
 
     DEFAULTS = {
-      :enabled => false,
-      :tld => 'vagrant.test',
-      :upstream_servers => [[:udp, '8.8.8.8', 53], [:tcp, '8.8.8.8', 53]],
-      :host_ip_address => nil,
-      :guest_redirect_dns => true
+      :enabled                 => false,
+      :tld                     => 'vagrant.test',
+      :upstream_servers        => [[:udp, '8.8.8.8', 53], [:tcp, '8.8.8.8', 53]],
+      :host_ip_address         => nil,
+      :guest_redirect_dns      => true,
+      :host_interface          => nil,
+      :host_interface_excludes => [/lo[0-9]*/, /docker[0-9]+/, /tun[0-9]+/]
     }.freeze
 
     def initialize
-      @hosts = {}
-      @enabled = UNSET_VALUE
-      @tld = UNSET_VALUE
-      @upstream_servers = UNSET_VALUE
-      @host_ip_address = UNSET_VALUE
-      @guest_redirect_dns = UNSET_VALUE
+      @hosts                   = {}
+      @enabled                 = UNSET_VALUE
+      @tld                     = UNSET_VALUE
+      @upstream_servers        = UNSET_VALUE
+      @host_ip_address         = UNSET_VALUE
+      @guest_redirect_dns      = UNSET_VALUE
+      @host_interface          = UNSET_VALUE
+      @host_interface_excludes = UNSET_VALUE
     end
 
     def enable

data/lib/landrush/plugin.rb

@@ -98,8 +98,8 @@ module Landrush
     end
 
     guest_capability('linux', 'read_host_visible_ip_address') do
-      require_relative 'cap/linux/read_host_visible_ip_address'
-      Cap::Linux::ReadHostVisibleIpAddress
+      require_relative 'cap/all/read_host_visible_ip_address'
+      Cap::All::ReadHostVisibleIpAddress
     end
   end
 end

data/lib/landrush/resolver_config.rb

@@ -29,10 +29,6 @@ module Landrush
       EOS
     end
 
-    def osx?
-      `uname`.chomp == 'Darwin'
-    end
-
     def config_dir
       self.class.config_dir
     end
@@ -46,7 +42,7 @@ module Landrush
     end
 
     def write_config!
-      info "Momentarily using sudo to put the host config in place..."
+      info 'Momentarily using sudo to put the host config in place...'
       system "#{self.class.sudo} mkdir #{config_dir}" unless config_dir.directory?
       Tempfile.open('vagrant_landrush_host_config') do |f|
         f.write(desired_contents)
@@ -58,9 +54,9 @@ module Landrush
 
     def ensure_config_exists!
       if contents_match?
-        info "Host DNS resolver config looks good."
+        info 'Host DNS resolver config looks good.'
       else
-        info "Need to configure the host."
+        info 'Need to configure the host.'
         write_config!
       end
     end

data/lib/landrush/server.rb

@@ -1,12 +1,11 @@
 require 'rubydns'
 require 'ipaddr'
+require 'vagrant/util/platform'
+
 require_relative 'store'
-require_relative 'os'
 
 module Landrush
   class Server
-    include Landrush::OS
-
     Name = Resolv::DNS::Name
     IN   = Resolv::DNS::Resource::IN
 
@@ -31,12 +30,12 @@ module Landrush
       File.join(working_dir, 'log')
     end
 
-    def self.log_file
+    def self.log_file_path
       File.join(log_directory, 'landrush.log')
     end
 
     def self.port
-      if OS.windows?
+      if Vagrant::Util::Platform.windows?
         # On Windows we need to use the default DNS port, since there seems to be no way to configure it otherwise
         @port ||= 53
       else
@@ -66,14 +65,19 @@ module Landrush
 
     # Used to start the Landrush DNS server as a child process using ChildProcess gem
     def self.start
-      ensure_path_exits(log_file)
-
-      if OS.windows?
-        pid = spawn('ruby', __FILE__, port.to_s, working_dir.to_s, :chdir => working_dir.to_path, [:out, :err] => [log_file, "w"], :new_pgroup => true)
+      if Vagrant::Util::Platform.windows?
+        # Need to handle Windows differently. Kernel.spawn fails to work, if the shell creating the process is closed.
+        # See https://github.com/vagrant-landrush/landrush/issues/199
+        info = Process.create(:command_line => "ruby #{__FILE__} #{port} #{working_dir}",
+                              :creation_flags => Process::DETACHED_PROCESS,
+                              :process_inherit => false,
+                              :thread_inherit => true,
+                              :cwd => working_dir.to_path)
+        pid = info.process_id
       else
-        pid = spawn('ruby', __FILE__, port.to_s, working_dir.to_s, :chdir => working_dir.to_path, [:out, :err] => [log_file, "w"], :pgroup => true)
+        pid = spawn('ruby', __FILE__, port.to_s, working_dir.to_s, :chdir => working_dir.to_path, :pgroup => true)
+        Process.detach pid
       end
-      Process.detach pid
 
       write_pid(pid)
     end
@@ -119,7 +123,16 @@ module Landrush
     def self.running?
       pid = read_pid
       return false if pid.nil?
-      !!Process.kill(0, pid) rescue false
+      if Vagrant::Util::Platform.windows?
+        begin
+          Process.get_exitcode(pid).nil?
+        # Need to handle this explicitly since this error gets thrown in case we call get_exitcode with a stale pid
+        rescue SystemCallError => e
+          raise e unless e.class.name.start_with?('Errno::ENXIO')
+        end
+      else
+        !!Process.kill(0, pid) rescue false
+      end
     end
 
     def self.status
@@ -131,7 +144,7 @@ module Landrush
         else
           puts 'Daemon status: unknown'
           puts "#{pid_file} exists, but process is not running"
-          puts "Check log file: #{log_file}"
+          puts "Check log file: #{log_file_path}"
       end
     end
 
@@ -140,10 +153,14 @@ module Landrush
       server.port = port
       server.working_dir = working_dir
 
-      # Start the DNS server
-      RubyDNS.run_server(:listen => interfaces) do
-        @logger.level = Logger::INFO
+      ensure_path_exits(log_file_path)
+      log_file = File.open(log_file_path, 'w')
+      log_file.sync = true
+      @logger = Logger.new(log_file)
+      @logger.level = Logger::INFO
 
+      # Start the DNS server
+      run_dns_server(:listen => interfaces, :logger => @logger) do
         match(/.*/, IN::A) do |transaction|
           host = Store.hosts.find(transaction.name)
           if host
@@ -170,6 +187,20 @@ module Landrush
       end
     end
 
+    def self.run_dns_server(options = {}, &block)
+      server = RubyDNS::RuleBasedServer.new(options, &block)
+
+      EventMachine.run do
+        trap("INT") do
+          EventMachine.stop
+        end
+
+        server.run(options)
+      end
+
+      server.fire(:stop)
+    end
+
     def self.check_a_record(host, transaction)
       value = Store.hosts.get(host)
       if value.nil?
@@ -221,16 +252,11 @@ module Landrush
     end
 
     def self.terminate_process(pid)
-      Process.kill("INT", pid)
-      sleep 0.1
-
-      sleep 1 if running?
-
       # Kill/Term loop - if the daemon didn't die easily, shoot
       # it a few more times.
       attempts = 5
       while running? && attempts > 0
-        sig = (attempts >= 2) ? "KILL" : "TERM"
+        sig = (attempts >= 2) ? 'KILL' : 'TERM'
 
         puts "Sending #{sig} to process #{pid}..."
         Process.kill(sig, pid)

data/lib/landrush/util/retry.rb

@@ -0,0 +1,16 @@
+module Landrush
+  module Util
+    module Retry
+      def retry(opts=nil)
+        opts = {tries: 1}.merge(opts || {})
+        n = 0
+        while n < opts[:tries]
+          return true if yield
+          sleep opts[:sleep].to_f if opts[:sleep]
+          n += 1
+        end
+        false
+      end
+    end
+  end
+end

data/lib/landrush/version.rb

@@ -1,3 +1,3 @@
 module Landrush
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.1.0.beta.1'.freeze
 end

data/lib/landrush/win_network_config.rb

@@ -0,0 +1,185 @@
+# This file needs to be able to execute out of the Vagrant context. Do not require any non core or non relative files
+require 'ipaddr'
+require_relative 'util/retry'
+
+# This class configures the network interface on Windows for use with the Landrush DNS server.
+# It makes use of the netsh executable which is assumed to be available on the Windows host.
+module Landrush
+  class WinNetworkConfig
+    include Landrush::Util::Retry
+
+    # Windows registry path under which network interface configuration is stored
+    INTERFACES = 'SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces'.freeze
+
+    def initialize(env={})
+      @env = env
+    end
+
+    # Checks that all required tools are on the PATH and that the Wired AutoConfig service is started
+    def ensure_prerequisites
+      return false unless command_found('netsh')
+      return false unless command_found('net')
+      return false unless command_found('reg')
+
+      unless wired_autoconfig_service_running?
+        info('starting \'Wired AutoConfig\' service')
+        if self.class.admin_mode?
+          `net start dot3svc`
+        else
+          require 'win32ole'
+          shell = WIN32OLE.new('Shell.Application')
+          shell.ShellExecute('net', 'start dot3svc', nil, 'runas', 1)
+        end
+        service_has_started = self.retry(tries: 5, sleep: 1) do
+          wired_autoconfig_service_running?
+        end
+        unless service_has_started
+          info('Unable to start \'Wired AutoConfig\' service. Unable to configure DNS on host. Try manual configuration.')
+          return false
+        end
+        info('\'Wired AutoConfig\' service has started.')
+      end
+      true
+    end
+
+    # Does the actual update of the network configuration
+    def update_network_adapter(ip, name_server, domain)
+      # Need to defer loading to ensure cross OS compatibility
+      require 'win32/registry'
+      ensure_admin_privileges(__FILE__.to_s, ip, name_server, domain)
+
+      network_name = get_network_name(ip)
+      if network_name.nil?
+        info("unable to determine network interface for #{ip}. DNS on host cannot be configured. Try manual configuration.")
+        return
+      else
+        info("adding Landrush'es DNS server to network '#{network_name}' using DNS IP '#{ip}'' and search domain '#{domain}'")
+      end
+      network_guid = get_guid(network_name)
+      if network_guid.nil?
+        info("unable to determine network GUID for #{ip}. DNS on host cannot be configured. Try manual configuration.")
+        return
+      end
+      interface_path = INTERFACES + "\\{#{network_guid}}"
+      Win32::Registry::HKEY_LOCAL_MACHINE.open(interface_path, Win32::Registry::KEY_ALL_ACCESS) do |reg|
+        reg['NameServer'] = name_server
+        reg['Domain'] = domain
+      end
+    end
+
+    # If this registry query succeeds we assume we have Admin rights
+    # http://stackoverflow.com/questions/8268154/run-ruby-script-in-elevated-mode/27954953
+    def self.admin_mode?
+      (`reg query HKU\\S-1-5-19 2>&1` =~ /ERROR/).nil?
+    end
+
+    private
+
+    # Given a network name (as displayed on 'Control Panel\Network and Internet\Network Connections'),
+    # determines the GUID of this network interface using 'netsh'.
+    #
+    # To make this work the "Wired Autoconfig" service must be started (go figure).
+    #
+    # Output of netsh command which is being processed:
+    #
+    # There are 4 interfaces on the system:
+    #
+    # Name             : Ethernet
+    # Description      : Intel(R) Ethernet Connection (3) I218-LM
+    # GUID             : fd9270f6-aff6-4f24-bc4a-1f90c032d5c3
+    # Physical Address : 50-7B-9D-AB-25-1D
+    # \n\n
+    # ...
+    def get_guid(network_name)
+      cmd_out = `netsh lan show interfaces`
+      interface_details = cmd_out.split(/\n\n/).select { |settings| settings.match(/#{Regexp.quote(network_name)}/m) }
+      return nil if interface_details.empty?
+      interface_details[0].split(/\n/)[2].match(/.*:(.*)/).captures[0].strip
+    end
+
+    # Given an IP determines the network name, if any. Uses netsh which generates output like this:
+    #
+    # ...
+    # \n\n
+    # Configuration for interface "Ethernet 2"
+    #    DHCP enabled:                         Yes
+    #    IP Address:                           10.10.10.1
+    #    Subnet Prefix:                        10.10.10.0/24 (mask 255.255.255.0)
+    #    InterfaceMetric:                      10
+    #    DNS servers configured through DHCP:  None
+    #    Register with which suffix:           Primary only
+    #    WINS servers configured through DHCP: None
+    # \n\n
+    # ...
+    def get_network_name(ip)
+      cmd_out = `netsh interface ip show config`
+      network_details = cmd_out.split(/\n\n/).select do |settings|
+        begin
+          lines = settings.split(/\n/).reject(&:empty?)
+          subnet = lines[3]
+          next false unless subnet =~ /Subnet Prefix/
+
+          mask = IPAddr.new(subnet.match(%r{.* (\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3}/\d{1,3}).*}).captures[0])
+          address = IPAddr.new(ip)
+
+          mask.include?(address)
+        rescue
+          false
+        end
+      end
+      return nil if network_details[0].nil?
+      network_details[0].split(/\n/)[0].match(/Configuration for interface "(.*)"/).captures[0].strip
+    end
+
+    # Makes sure that we have admin privileges and if nor starts a new shell with the required
+    # privileges
+    def ensure_admin_privileges(file, *args)
+      unless self.class.admin_mode?
+        require 'win32ole'
+        shell = WIN32OLE.new('Shell.Application')
+        shell.ShellExecute('ruby', "#{file} #{args.join(' ')}", nil, 'runas', 1)
+        # need to exit current execution, changes will occur in new environment
+        exit
+      end
+    end
+
+    def info(msg)
+      @env[:ui].info("[landrush] #{msg}") unless @env.nil?
+    end
+
+    def wired_autoconfig_service_running?
+      cmd_out = `net start`
+      cmd_out =~ /Wired AutoConfig/m
+    end
+
+    def command_found(cmd)
+      if which(cmd).nil?
+        info("Cannot find '#{cmd}' on the PATH. Unable to configure DNS. Try manual configuration.")
+        false
+      else
+        true
+      end
+    end
+
+    # Cross-platform way of finding an executable in the $PATH.
+    #
+    #   which('ruby') #=> /usr/bin/ruby
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+      nil
+    end
+  end
+end
+
+# Only run the following code when this file is the main file being run
+# instead of having been required or loaded by another file
+if __FILE__ == $0
+  config = Landrush::WinNetworkConfig.new nil
+  config.update_network_adapter(ARGV[0], ARGV[1], ARGV[2])
+end

data/lib/landrush.rb

@@ -4,12 +4,17 @@ rescue LoadError
   raise 'The Vagrant landrush plugin must be run within Vagrant.'
 end
 
+# Only load the gem on Windows since it replaces some methods in Ruby's Process class
+# Also load before Process.uid is called the first time by Vagrant
+require 'win32/process' if Vagrant::Util::Platform.windows?
+
 require 'rubydns'
-require 'ipaddr'
 
 require 'landrush/dependent_vms'
 require 'landrush/plugin'
 require 'landrush/resolver_config'
+require 'landrush/win_network_config'
 require 'landrush/server'
 require 'landrush/store'
 require 'landrush/version'
+require 'landrush-ip'