landrush 0.19.0 → 1.0.0

data/Rakefile

@@ -1,12 +1,30 @@
 require 'bundler/gem_tasks'
+require 'rake'
 require 'rake/testtask'
+require 'rake/clean'
 require 'rubocop/rake_task'
+require 'cucumber/rake/task'
+require 'fileutils'
 
+CLOBBER.include('pkg')
+CLEAN.include('build')
+
+task :init do
+  FileUtils.mkdir_p 'build'
+end
+task :features => :init
+
+# Default test task
+desc 'Run all unit tests'
 Rake::TestTask.new do |t|
   t.pattern = 'test/**/*_test.rb'
   t.libs << 'test'
 end
 
+# Cucumber acceptance test task
+Cucumber::Rake::Task.new(:features)
+task :features => :init
+
 task default: [
   :rubocop,
   :test

data/features/dns_resolution.feature

@@ -0,0 +1,26 @@
+Feature: dns_resolution
+  Landrush should make a virtual machine's IP address DNS-resolvable.
+
+  Scenario Outline: booting a box
+    Given a file named "Vagrantfile" with:
+    """
+    Vagrant.configure('2') do |config|
+      config.vm.box = '<box>'
+      config.vm.hostname = 'my-host.landrush-acceptance-test'
+      config.vm.network :private_network, ip: '10.10.10.123'
+
+      config.vm.synced_folder '.', '/vagrant', disabled: true
+
+      config.landrush.enabled = true
+      config.landrush.tld = 'landrush-acceptance-test'
+    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
+    And the hostname "my-host.landrush-acceptance-test" should resolve to "10.10.10.123" on the guest
+
+    Examples:
+      | box             | provider   |
+      | debian/jessie64 | virtualbox |
+      #| ubuntu/wily64   | virtualbox |

data/features/step_definitions/dns.rb

@@ -0,0 +1,19 @@
+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("vagrant ssh -c \"dig +short '#{host}' A\"")
+  expect(last_command_started).to have_output(/^#{ip}$/)
+end

data/features/support/env.rb

@@ -0,0 +1,16 @@
+require 'aruba/cucumber'
+require 'komenda'
+
+Aruba.configure do |config|
+  config.exit_timeout = 300
+  config.activate_announcer_on_command_failure = [:stdout, :stderr]
+  config.working_directory = 'build/aruba'
+end
+
+After do |_scenario|
+  Komenda.run('bundle exec vagrant landrush stop', fail_on_fail: true)
+
+  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
+end

data/landrush.gemspec

@@ -28,6 +28,5 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'rubydns', '1.0.2'
-  spec.add_dependency 'rexec'
+  spec.add_dependency 'rubydns', '0.8.5'
 end

data/lib/landrush.rb

@@ -4,16 +4,6 @@ rescue LoadError
   raise 'The Vagrant landrush plugin must be run within Vagrant.'
 end
 
-module Landrush
-  def self.working_dir
-    @working_dir ||= Pathname(File.expand_path('~/.vagrant.d/data/landrush')).tap(&:mkpath)
-  end
-
-  def self.working_dir=(working_dir)
-    @working_dir = Pathname(working_dir).tap(&:mkpath)
-  end
-end
-
 require 'rubydns'
 require 'ipaddr'
 
@@ -23,5 +13,3 @@ require 'landrush/resolver_config'
 require 'landrush/server'
 require 'landrush/store'
 require 'landrush/version'
-
-require 'ext/rexec'

data/lib/landrush/action/common.rb

@@ -6,8 +6,8 @@ module Landrush
         'VagrantPlugins::ProviderLibvirt::Provider'    => :libvirt,
         'HashiCorp::VagrantVMwarefusion::Provider'     => :vmware_fusion,
         'VagrantPlugins::Parallels::Provider'          => :parallels,
-        'Landrush::FakeProvider'                       => :fake_provider,
-      }
+        'Landrush::FakeProvider'                       => :fake_provider
+      }.freeze
 
       def self.included(base)
         base.send :attr_reader, :app, :env
@@ -42,11 +42,11 @@ module Landrush
       end
 
       def provider
-        provider_name = SUPPORTED_PROVIDERS.fetch(machine.provider.class.name) { |key|
+        provider_name = SUPPORTED_PROVIDERS.fetch(machine.provider.class.name) do |key|
           raise "The landrush plugin does not support the #{key} provider yet!"
-        }
+        end
 
-        if provider_name == :parallels and 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
 

data/lib/landrush/action/redirect_dns.rb

@@ -9,7 +9,7 @@ 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.
-        redirect_dns if enabled? and guest_redirect_dns?
+        redirect_dns if enabled? && guest_redirect_dns?
       end
 
       def redirect_dns

data/lib/landrush/action/setup.rb

@@ -4,6 +4,10 @@ module Landrush
       include Common
 
       def call(env)
+        # 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')
+
         handle_action_stack(env) do
           pre_boot_setup if enabled?
         end
@@ -44,23 +48,14 @@ module Landrush
 
       def start_server
         return if Server.running?
-        # We need to avoid forking with libvirt provider since the forked process
-        # would try to reuse the libvirt connection and fail.
-        if libvirt?
-          require 'open3'
-          Kernel.puts '[landrush] Starting landrush in background...'
-          _stdout, stderr, status = Open3.capture3('vagrant landrush start')
-          Kernel.puts stderr unless status
-        else
-          info 'starting dns server'
-          Server.start
-        end
+        info 'starting dns server'
+        Server.start
       end
 
       def setup_static_dns
         config.hosts.each do |hostname, dns_value|
           dns_value ||= machine.guest.capability(:read_host_visible_ip_address)
-          if !Store.hosts.has?(hostname, dns_value)
+          unless Store.hosts.has?(hostname, dns_value)
             info "adding static entry: #{hostname} => #{dns_value}"
             Store.hosts.set hostname, dns_value
             Store.hosts.set(IPAddr.new(dns_value).reverse, hostname)
@@ -72,12 +67,12 @@ module Landrush
         ip_address = machine.config.landrush.host_ip_address ||
                      machine.guest.capability(:read_host_visible_ip_address)
 
-        if not machine_hostname.match(config.tld)
+        unless machine_hostname.match(config.tld)
           log :error, "hostname #{machine_hostname} does not match the configured TLD: #{config.tld}"
           log :error, "You will not be able to access #{machine_hostname} from the host"
         end
 
-        if !Store.hosts.has?(machine_hostname, ip_address)
+        unless Store.hosts.has?(machine_hostname, ip_address)
           info "adding machine entry: #{machine_hostname} => #{ip_address}"
           Store.hosts.set(machine_hostname, ip_address)
           Store.hosts.set(IPAddr.new(ip_address).reverse, machine_hostname)

data/lib/landrush/action/teardown.rb

@@ -4,6 +4,10 @@ module Landrush
       include Common
 
       def call(env)
+        # 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')
+
         handle_action_stack(env) do
           teardown if enabled?
         end
@@ -27,7 +31,7 @@ module Landrush
       end
 
       def teardown_static_dns
-        config.hosts.each do |static_hostname, dns_value|
+        config.hosts.each do |static_hostname|
           if Store.hosts.has? static_hostname
             info "removing static entry: #{static_hostname}"
             Store.hosts.delete static_hostname

data/lib/landrush/cap/debian/install_iptables.rb

@@ -3,10 +3,10 @@ module Landrush
     module Debian
       module InstallIptables
         def self.install_iptables(machine)
-          machine.communicate.tap { |c|
+          machine.communicate.tap do |c|
             c.sudo('apt-get update')
             c.sudo('apt-get install -y iptables')
-          }
+          end
         end
       end
     end

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

@@ -18,4 +18,3 @@ module Landrush
     end
   end
 end
-

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

@@ -21,4 +21,3 @@ module Landrush
     end
   end
 end
-

data/lib/landrush/cap/redhat/install_iptables.rb

@@ -3,10 +3,10 @@ module Landrush
     module Redhat
       module InstallIptables
         def self.install_iptables(machine)
-          machine.communicate.tap { |c|
+          machine.communicate.tap do |c|
             c.sudo('yum clean all')
             c.sudo('yum install -y -q iptables')
-          }
+          end
         end
       end
     end

data/lib/landrush/command.rb

@@ -1,17 +1,19 @@
 module Landrush
   class Command < Vagrant.plugin('2', :command)
-    DAEMON_COMMANDS = %w(start stop restart status)
+    DAEMON_COMMANDS = %w(start stop restart status).freeze
 
     def self.synopsis
       "manages DNS for both guest and host"
     end
 
     def execute
-      ARGV.shift # flush landrush from ARGV, RExec wants to use it for daemon commands
+      # Make sure we use the right data directory for Landrush
+      Server.working_dir = File.join(@env.data_dir, 'landrush')
 
+      ARGV.shift # flush landrush from ARGV
       command = ARGV.first || 'help'
       if DAEMON_COMMANDS.include?(command)
-        Server.daemonize
+        Server.send(command)
       elsif command == 'dependentvms' || command == 'vms'
         if DependentVMs.any?
           @env.ui.info(DependentVMs.list.map { |dvm| " - #{dvm}" }.join("\n"))
@@ -19,14 +21,11 @@ module Landrush
           @env.ui.info("No dependent VMs")
         end
       elsif command == 'ls' || command == 'list'
-        IO.popen("/usr/bin/pr -2 -t -a", "w") do |io|
-          Landrush::Store.hosts.each do |key, value|
-            io.puts "#{key}"
-            io.puts "#{value}"
-          end
+        Landrush::Store.hosts.each do |key, value|
+          printf "%-30s %s\n", key, value
         end
       elsif command == 'set'
-        host, ip = ARGV[1,2]
+        host, ip = ARGV[1, 2]
         Landrush::Store.hosts.set(host, ip)
       elsif command == 'del' || command == 'rm'
         key = ARGV[1]
@@ -70,6 +69,5 @@ module Landrush
           you're lookin at it!
       EOS
     end
-
   end
 end

data/lib/landrush/config.rb

@@ -13,7 +13,7 @@ module Landrush
       :upstream_servers => [[:udp, '8.8.8.8', 53], [:tcp, '8.8.8.8', 53]],
       :host_ip_address => nil,
       :guest_redirect_dns => true
-    }
+    }.freeze
 
     def initialize
       @hosts = {}

data/lib/landrush/dependent_vms.rb

@@ -22,7 +22,7 @@ module Landrush
     end
 
     def self.list
-      self.map { |path| path.basename.to_s }
+      map { |path| path.basename.to_s }
     end
 
     def self.clear!
@@ -34,7 +34,7 @@ module Landrush
     end
 
     def self.dir
-      Landrush.working_dir.join('dependent_vms').tap(&:mkpath)
+      Server.working_dir.join('dependent_vms').tap(&:mkpath)
     end
   end
 end

data/lib/landrush/os.rb

@@ -0,0 +1,19 @@
+module Landrush
+  module OS
+    def self.windows?
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+    end
+
+    def self.mac?
+      (/darwin/ =~ RUBY_PLATFORM) != nil
+    end
+
+    def self.unix?
+      !windows?
+    end
+
+    def self.linux?
+      unix? && !mac?
+    end
+  end
+end

data/lib/landrush/plugin.rb

@@ -12,7 +12,7 @@ module Landrush
       Config
     end
 
-    landrush_setup = -> (hook) {
+    landrush_setup = lambda do |hook|
       require_relative 'action/common'
       require_relative 'action/setup'
       require_relative 'action/install_prerequisites'
@@ -34,7 +34,7 @@ module Landrush
       if defined?(VagrantPlugins::Parallels)
         hook.before(VagrantPlugins::Parallels::Action::Network, pre_boot_actions)
       end
-    }
+    end
 
     action_hook 'landrush_setup', :machine_action_up, &landrush_setup
     action_hook 'landrush_setup', :machine_action_reload, &landrush_setup
@@ -52,11 +52,11 @@ module Landrush
       end
     end
 
-    landrush_teardown = -> (hook) {
+    landrush_teardown = lambda do |hook|
       require_relative 'action/common'
       require_relative 'action/teardown'
       hook.after(Vagrant::Action::Builtin::GracefulHalt, Action::Teardown)
-    }
+    end
 
     action_hook 'landrush_teardown', :machine_action_halt, &landrush_teardown
     action_hook 'landrush_teardown', :machine_action_destroy, &landrush_teardown

data/lib/landrush/resolver_config.rb

@@ -2,7 +2,7 @@ require 'tempfile'
 
 module Landrush
   class ResolverConfig
-    class << self;
+    class << self
       attr_writer :sudo, :config_dir
     end
 
@@ -14,10 +14,6 @@ module Landrush
       @config_dir ||= Pathname('/etc/resolver')
     end
 
-    def config_dir
-      self.class.config_dir
-    end
-
     def initialize(env={})
       @env = env
     end

data/lib/landrush/server.rb

@@ -1,13 +1,47 @@
 require 'rubydns'
-require 'rexec/daemon'
+require 'ipaddr'
+require_relative 'store'
+require_relative 'os'
 
 module Landrush
-  class Server < RExec::Daemon::Base
+  class Server
+    include Landrush::OS
+
     Name = Resolv::DNS::Name
     IN   = Resolv::DNS::Resource::IN
 
+    def self.working_dir
+      # TODO, https://github.com/vagrant-landrush/landrush/issues/178
+      # Due to the fact that the whole server is just a bunch of static methods,
+      # there is no initalize method to ensure that the working directory is
+      # set prior to making calls to this method. Things work, since at the appropriate
+      # Vagrant plugin integrtion points (e.g. setup.rb) we set the working dir based
+      # on the enviroment passed to us.
+      if @working_dir.nil?
+        raise 'The Server\s working directory needs to be explicitly set prior to calling this method'
+      end
+      @working_dir
+    end
+
+    def self.working_dir=(working_dir)
+      @working_dir = Pathname(working_dir).tap(&:mkpath)
+    end
+
+    def self.log_directory
+      File.join(working_dir, 'log')
+    end
+
+    def self.log_file
+      File.join(log_directory, 'landrush.log')
+    end
+
     def self.port
-      @port ||= 10053
+      if OS.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
+        @port ||= 100_53
+      end
     end
 
     def self.port=(port)
@@ -21,8 +55,8 @@ module Landrush
 
     def self.interfaces
       [
-        [:udp, "0.0.0.0", port],
-        [:tcp, "0.0.0.0", port]
+        [:udp, '0.0.0.0', port],
+        [:tcp, '0.0.0.0', port]
       ]
     end
 
@@ -30,38 +64,85 @@ module Landrush
       @upstream ||= RubyDNS::Resolver.new(upstream_servers)
     end
 
-    def self.pid
-      RExec::Daemon::ProcessFile.recall(self)
+    # 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)
+      else
+        pid = spawn('ruby', __FILE__, port.to_s, working_dir.to_s, :chdir => working_dir.to_path, [:out, :err] => [log_file, "w"], :pgroup => true)
+      end
+      Process.detach pid
+
+      write_pid(pid)
+    end
+
+    def self.stop
+      puts 'Stopping daemon...'
+
+      # Check if the pid file exists...
+      unless File.file?(pid_file)
+        puts "Pid file #{pid_file} not found. Is the daemon running?"
+        return
+      end
+
+      pid = read_pid
+
+      # Check if the daemon is already stopped...
+      unless running?
+        puts "Pid #{pid} is not running. Has daemon crashed?"
+        return
+      end
+
+      terminate_process pid
+
+      # If after doing our best the daemon is still running (pretty odd)...
+      if running?
+        puts 'Daemon appears to be still running!'
+        return
+      end
+
+      # Otherwise the daemon has been stopped.
+      delete_pid_file
     end
 
-    # For RExec
-    def self.working_directory
-      Landrush.working_dir
+    def self.restart
+      stop
+      start
     end
 
-    def self.running?
-      RExec::Daemon::ProcessFile.status(self) == :running
+    def self.pid
+      IO.read(pid_file).to_i rescue nil
     end
 
-    def self.prefork
-      super
+    def self.running?
+      pid = read_pid
+      return false if pid.nil?
+      !!Process.kill(0, pid) rescue false
     end
 
-    def self.check_a_record (host, transaction)
-      value = Store.hosts.get(host)
-      if (IPAddr.new(value) rescue nil)
-        name = transaction.name =~ /#{host}/ ? transaction.name : host
-        transaction.respond!(value, {:ttl => 0, :name => name})
-      else
-        transaction.respond!(Name.create(value), resource_class: IN::CNAME, ttl: 0)
-        check_a_record(value, transaction)
+    def self.status
+      case process_status
+        when :running
+          puts "Daemon status: running pid=#{read_pid}"
+        when :stopped
+          puts 'Daemon status: stopped'
+        else
+          puts 'Daemon status: unknown'
+          puts "#{pid_file} exists, but process is not running"
+          puts "Check log file: #{log_file}"
       end
     end
 
-    def self.run
+    def self.run(port, working_dir)
       server = self
-      RubyDNS::run_server(:listen => interfaces) do
-        self.logger.level = Logger::INFO
+      server.port = port
+      server.working_dir = working_dir
+
+      # Start the DNS server
+      RubyDNS.run_server(:listen => interfaces) do
+        @logger.level = Logger::INFO
 
         match(/.*/, IN::A) do |transaction|
           host = Store.hosts.find(transaction.name)
@@ -83,9 +164,90 @@ module Landrush
 
         # Default DNS handler
         otherwise do |transaction|
+          # @logger.info "Passing on to upstream: #{transaction.to_s}"
           transaction.passthrough!(server.upstream)
         end
       end
     end
+
+    def self.check_a_record(host, transaction)
+      value = Store.hosts.get(host)
+      if value.nil?
+        return
+      end
+
+      if (IPAddr.new(value) rescue nil)
+        name = transaction.name =~ /#{host}/ ? transaction.name : host
+        transaction.respond!(value, :ttl => 0, :name => name)
+      else
+        transaction.respond!(Name.create(value), resource_class: IN::CNAME, ttl: 0)
+        check_a_record(value, transaction)
+      end
+    end
+
+    # private methods
+    def self.write_pid(pid)
+      ensure_path_exits(pid_file)
+      File.open(pid_file, 'w') {|f| f << pid.to_s}
+    end
+
+    def self.read_pid
+      IO.read(pid_file).to_i rescue nil
+    end
+
+    def self.delete_pid_file
+      if File.exist? pid_file
+        FileUtils.rm(pid_file)
+      end
+    end
+
+    def self.pid_file
+      File.join(working_dir, 'run', 'landrush.pid')
+    end
+
+    def self.process_status
+      if File.exist? pid_file
+        return running? ? :running : :unknown
+      else
+        return :stopped
+      end
+    end
+
+    def self.ensure_path_exits(file_name)
+      dirname = File.dirname(file_name)
+      unless File.directory?(dirname)
+        FileUtils.mkdir_p(dirname)
+      end
+    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"
+
+        puts "Sending #{sig} to process #{pid}..."
+        Process.kill(sig, pid)
+
+        attempts -= 1
+        sleep 1
+      end
+    end
+
+    private_class_method :write_pid, :read_pid, :delete_pid_file, :pid_file, :process_status, :ensure_path_exits,
+                         :terminate_process
   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
+  # TODO, Add some argument checks
+  Landrush::Server.run(ARGV[0], ARGV[1])
+end