landrush 1.1.2 → 1.2.0

data/lib/landrush/start_server.rb

@@ -0,0 +1,11 @@
+# This file gets execute outside the Vagrant (bundled) environment.
+# For that reason we have to put the gems we need ourself onto the LOADPATH.
+# The caller of this file will pass the Vagrant gem dir as first argument which
+# we use as base to find the required gems
+
+gem_path = ARGV[2]
+Dir.entries(gem_path).each { |gem_dir| $LOAD_PATH.unshift "#{File.join(ARGV[2], gem_dir)}/lib" }
+
+require_relative 'server'
+
+Landrush::Server.run(ARGV[0], ARGV[1]) if __FILE__ == $PROGRAM_NAME

data/lib/landrush/store.rb

@@ -43,7 +43,11 @@ module Landrush
     end
 
     def find(search)
-      search = IPAddr.new(search).reverse if (IPAddr.new(search) rescue nil)
+      search = IPAddr.new(search).reverse if begin
+                                                IPAddr.new(search)
+                                              rescue
+                                                nil
+                                              end
       current_config.keys.detect do |key|
         key.casecmp(search) == 0   ||
           search =~ /#{key}$/i     ||
@@ -74,7 +78,7 @@ module Landrush
     end
 
     def write(config)
-      File.open(backing_file, "w") do |f|
+      File.open(backing_file, 'w') do |f|
         f.write(JSON.pretty_generate(config))
       end
     end

data/lib/landrush/util/path.rb

@@ -0,0 +1,32 @@
+module Landrush
+  module Util
+    class Path
+      def self.embedded_vagrant_ruby
+        bin_dir = embedded_vagrant_bin_dir
+        ruby_bin = bin_dir + separator + 'ruby'
+        ruby_bin if File.exist?(ruby_bin)
+      end
+
+      def self.ensure_ruby_on_path
+        bin_dir = embedded_vagrant_bin_dir
+        ENV['PATH'] = bin_dir + File::PATH_SEPARATOR + ENV['PATH'] if File.exist?(bin_dir)
+      end
+
+      def self.embedded_vagrant_bin_dir
+        vagrant_binary = Vagrant::Util::Which.which('vagrant')
+        vagrant_binary = File.realpath(vagrant_binary) if File.symlink?(vagrant_binary)
+        # in a Vagrant installation the Ruby executable is in ../embedded/bin relative to the vagrant executable
+        File.dirname(File.dirname(vagrant_binary)) + separator + 'embedded' + separator + 'bin'
+      end
+
+      def self.separator
+        # we don't use File.join here, since even on Cygwin we want a Windows path - see https://github.com/vagrant-landrush/landrush/issues/237
+        if Vagrant::Util::Platform.windows?
+          '\\'
+        else
+          '/'
+        end
+      end
+    end
+  end
+end

data/lib/landrush/util/process_helper.rb

@@ -0,0 +1,46 @@
+module Landrush
+  module Util
+    # A module containing helper classes for dealing with pid files
+    module ProcessHelper
+      def write_pid(pid, pid_file)
+        ensure_path_exits(pid_file)
+        File.open(pid_file, 'w') { |f| f << pid.to_s }
+      end
+
+      def read_pid(pid_file)
+        IO.read(pid_file).to_i
+      rescue
+        nil
+      end
+
+      def delete_pid_file(pid_file)
+        FileUtils.rm(pid_file) if File.exist? pid_file
+      end
+
+      def process_status(pid_file)
+        return running? ? :running : :unknown if File.exist? pid_file
+        :stopped
+      end
+
+      def ensure_path_exits(file_name)
+        dirname = File.dirname(file_name)
+        FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+      end
+
+      def terminate_process(pid)
+        # 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
+    end
+  end
+end

data/lib/landrush/util/retry.rb

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

data/lib/landrush/version.rb

@@ -1,3 +1,3 @@
 module Landrush
-  VERSION = '1.1.2'.freeze
+  VERSION = '1.2.0'.freeze
 end

data/test/landrush/action/setup_test.rb

@@ -7,29 +7,30 @@ module Landrush
     describe Setup do
       let(:env) { fake_environment }
       let(:app) { proc {} }
+
       before do
         env[:machine].config.landrush.host_redirect_dns = false
       end
 
-      it "calls the next app in the chain" do
+      it 'calls the next app in the chain' do
         app = -> (e) { e[:called] = true }
-        setup = Setup.new(app, nil)
+        setup = Landrush::Action::Setup.new(app, env)
 
         setup.call(env)
 
         env[:called].must_equal true
       end
 
-      it "records the booting host as a dependent VM" do
-        setup = Setup.new(app, nil)
+      it 'records the booting host as a dependent VM' do
+        setup = Landrush::Action::Setup.new(app, env)
 
         setup.call(env)
 
-        DependentVMs.list.must_equal %w[somehost.vagrant.test]
+        DependentVMs.list.must_equal %w(somehost.vagrant.test)
       end
 
       it "starts the landrush server if it's not already started" do
-        setup = Setup.new(app, nil)
+        setup = Landrush::Action::Setup.new(app, env)
 
         setup.call(env)
 
@@ -37,8 +38,10 @@ module Landrush
       end
 
       it "does not attempt to start the server if it's already up" do
-        setup = Setup.new(app, nil)
+        setup = Landrush::Action::Setup.new(app, env)
 
+        Server.working_dir = File.join(env[:home_path], 'data', 'landrush')
+        Server.gems_dir = env[:gems_path].to_s + '/gems'
         Server.start
         original_pid = Server.pid
 
@@ -48,8 +51,8 @@ module Landrush
         Server.pid.must_equal original_pid
       end
 
-      it "does nothing if it is not enabled via config" do
-        setup = Setup.new(app, nil)
+      it 'does nothing if it is not enabled via config' do
+        setup = Landrush::Action::Setup.new(app, env)
 
         env[:machine].config.landrush.disable
         setup.call(env)
@@ -57,16 +60,8 @@ module Landrush
         DependentVMs.list.must_equal []
       end
 
-      it "for single private network IP host visible IP can be retrieved w/o starting the VM" do
-        setup = Setup.new(app, nil)
-        env[:machine].config.vm.network :private_network, ip: '42.42.42.42'
-
-        setup.call(env)
-        Store.hosts.get('somehost.vagrant.test').must_equal '42.42.42.42'
-      end
-
-      it "for multiple private network IPs host visible IP cant be retrieved if host_ip_address is set" do
-        setup = Setup.new(app, nil)
+      it 'for multiple private network IPs host visible IP cant be retrieved if host_ip_address is set' do
+        setup = Landrush::Action::Setup.new(app, env)
 
         env[:machine].config.vm.network :private_network, ip: '42.42.42.41'
         env[:machine].config.vm.network :private_network, ip: '42.42.42.42'
@@ -75,8 +70,8 @@ module Landrush
         Store.hosts.get('somehost.vagrant.test').must_equal '42.42.42.42'
       end
 
-      it "is possible to add cnames via the config.landrush.host configuration option" do
-        setup = Setup.new(app, nil)
+      it 'is possible to add cnames via the config.landrush.host configuration option' do
+        setup = Landrush::Action::Setup.new(app, env)
 
         env[:machine].config.landrush.host 'foo', 'bar'
         setup.call(env)
@@ -86,17 +81,16 @@ module Landrush
 
       describe 'after boot' do
         it "stores the machine's hostname => ip address" do
-          setup = Setup.new(app, nil)
+          setup = Landrush::Action::Setup.new(app, env)
 
           setup.call(env)
 
           Store.hosts.get('somehost.vagrant.test').must_equal '1.2.3.4'
         end
 
-        it "does nothing if it is not enabled via config" do
-          setup = Setup.new(app, nil)
-
+        it 'does nothing if it is not enabled via config' do
           env = fake_environment(enabled: false)
+          setup = Landrush::Action::Setup.new(app, env)
           setup.call(env)
 
           Store.hosts.get('somehost.vagrant.test').must_equal nil

data/test/landrush/action/teardown_test.rb

@@ -5,10 +5,10 @@ require 'landrush/action/teardown'
 module Landrush
   module Action
     describe Teardown do
-      it "calls the next app in the chain" do
+      it 'calls the next app in the chain' do
         env = fake_environment
         app = -> (e) { e[:called] = true }
-        teardown = Teardown.new(app, nil)
+        teardown = Teardown.new(app, env)
 
         teardown.call(env)
 
@@ -17,8 +17,8 @@ module Landrush
 
       it "clears the machine's hostname => ip address" do
         app = proc {}
-        teardown = Teardown.new(app, nil)
         env = fake_environment
+        teardown = Teardown.new(app, env)
 
         Store.hosts.set('somehost.vagrant.test', '1.2.3.4')
         teardown.call(env)
@@ -26,10 +26,10 @@ module Landrush
         Store.hosts.get('somehost.vagrant.test').must_equal nil
       end
 
-      it "removes the machine as a dependent VM" do
+      it 'removes the machine as a dependent VM' do
         app = proc {}
-        teardown = Teardown.new(app, nil)
         env = fake_environment
+        teardown = Teardown.new(app, env)
 
         DependentVMs.add('somehost.vagrant.test')
         teardown.call(env)
@@ -37,10 +37,10 @@ module Landrush
         DependentVMs.list.must_equal []
       end
 
-      it "stops the landrush server when there are no dependent machines left" do
+      it 'stops the landrush server when there are no dependent machines left' do
         app = proc {}
-        teardown = Teardown.new(app, nil)
         env = fake_environment
+        teardown = Teardown.new(app, env)
 
         Server.start
         teardown.call(env)
@@ -48,22 +48,26 @@ module Landrush
         Server.running?.must_equal false
       end
 
-      it "leaves the landrush server when other dependent vms exist" do
+      it 'leaves the landrush server when other dependent vms exist' do
         app = proc {}
-        teardown = Teardown.new(app, nil)
         env = fake_environment
+        teardown = Teardown.new(app, env)
+
         DependentVMs.add('otherhost.vagrant.test')
 
+        Server.working_dir = File.join(env[:home_path], 'data', 'landrush')
+        Server.gems_dir = env[:gems_path].to_s + '/gems'
         Server.start
         teardown.call(env)
 
         Server.running?.must_equal true
       end
 
-      it "leaves static entries when other dependent vms exist" do
+      it 'leaves static entries when other dependent vms exist' do
         app = proc {}
-        teardown = Teardown.new(app, nil)
         env = fake_environment
+        teardown = Teardown.new(app, env)
+
         DependentVMs.add('otherhost.vagrant.test')
 
         fake_static_entry(env, 'static.vagrant.test', '3.4.5.6')
@@ -75,23 +79,22 @@ module Landrush
 
       it "leaves the server alone if it's not running" do
         app = proc {}
-        teardown = Teardown.new(app, nil)
         env = fake_environment
+        teardown = Teardown.new(app, env)
 
         teardown.call(env)
 
         Server.running?.must_equal false
       end
 
-      it "does nothing when landrush is disabled" do
+      it 'does nothing when landrush is disabled' do
         # somewhat unrealistic since this entry shouldn't be there if it was
         # disabled in the first place, but oh well
         Store.hosts.set('somehost.vagrant.test', '1.2.3.4')
 
         app = proc {}
-        teardown = Teardown.new(app, nil)
-
         env = fake_environment
+        teardown = Teardown.new(app, env)
         env[:machine].config.landrush.disable
 
         teardown.call(env)

data/test/landrush/cap/guest/all/read_host_visible_ip_address_test.rb

@@ -35,7 +35,6 @@ module Landrush
 
             expected = addresses.last['ipv4']
 
-            # call_cap(machine).must_equal expected
             call_cap(machine).must_equal expected
           end
 
@@ -81,6 +80,41 @@ module Landrush
 
             call_cap(machine).must_equal expected
           end
+
+          # Now, let's explicitly test the IPv4/IPv6 selection support, starting with the default (IPv4)
+          it 'should return the last non-empty IPv4 address' do
+            machine.config.landrush.host_interface          = nil
+            machine.config.landrush.host_interface_excludes = [/exclude[0-9]+/, /include[0-9]+/]
+
+            expected = addresses.detect { |a| a['name'] == 'ipv6empty2' }
+            expected = expected['ipv4']
+
+            call_cap(machine).must_equal expected
+          end
+
+          # Test IPv6 selection
+          it 'should return the last non-empty IPv6 address' do
+            machine.config.landrush.host_interface          = nil
+            machine.config.landrush.host_interface_class    = :ipv6
+            machine.config.landrush.host_interface_excludes = [/exclude[0-9]+/, /include[0-9]+/]
+
+            expected = addresses.detect { |a| a['name'] == 'ipv4empty2' }
+            expected = expected['ipv6']
+
+            call_cap(machine).must_equal expected
+          end
+
+          # Test ANY selection
+          it 'should return the last non-empty address of either class' do
+            machine.config.landrush.host_interface          = nil
+            machine.config.landrush.host_interface_class    = :any
+            machine.config.landrush.host_interface_excludes = [/exclude[0-9]+/, /include[0-9]+/]
+
+            expected = addresses.detect { |a| a['name'] == 'ipv4empty2' }
+            expected = expected['ipv6']
+
+            call_cap(machine).must_equal expected
+          end
         end
       end
     end

data/test/landrush/cap/guest/linux/configured_dns_servers_test.rb

@@ -4,30 +4,30 @@ describe Landrush::Cap::Linux::ConfiguredDnsServers do
   let(:machine) { fake_machine }
 
   before do
-    Landrush::Cap::Linux::ConfiguredDnsServers.instance_variable_set("@dns_servers", nil)
+    Landrush::Cap::Linux::ConfiguredDnsServers.instance_variable_set('@dns_servers', nil)
   end
 
   describe 'configured_dns_servers' do
     it 'parses out a single resolv.conf dns server' do
-      machine.communicate.stubs(:sudo).yields(:stdout, "nameserver 12.23.34.45")
+      machine.communicate.stubs(:sudo).yields(:stdout, 'nameserver 12.23.34.45')
 
       dns_servers = Landrush::Cap::Linux::ConfiguredDnsServers.configured_dns_servers(machine)
 
-      dns_servers.must_equal(["12.23.34.45"])
+      dns_servers.must_equal(['12.23.34.45'])
     end
 
     it 'parses out multiple the resolv.conf dns servers' do
       machine.communicate.stubs(:sudo).yields(:stdout, [
-        "nameserver 12.23.34.45",
-        "nameserver    45.34.23.12"
+        'nameserver 12.23.34.45',
+        'nameserver 45.34.23.12'
       ].join("\n"))
 
       dns_servers = Landrush::Cap::Linux::ConfiguredDnsServers.configured_dns_servers(machine)
 
       dns_servers.must_equal([
-        "12.23.34.45",
-        "45.34.23.12"
-      ])
+                               '12.23.34.45',
+                               '45.34.23.12'
+                             ])
     end
   end
 end

data/test/landrush/cap/guest/linux/redirect_dns_test.rb

@@ -7,10 +7,10 @@ describe Landrush::Cap::Linux::RedirectDns do
     it 'fetches the dns servers from the machine, and adds one iptables rule per server' do
       machine.guest.stubs(:capability).with(:configured_dns_servers).returns(%w(1.2.3.4 4.5.6.7))
 
-      machine.guest.expects(:capability).with(:add_iptables_rule, "OUTPUT -t nat -p tcp -d 1.2.3.4 --dport 53 -j DNAT --to-destination 2.3.4.5:4321").once
-      machine.guest.expects(:capability).with(:add_iptables_rule, "OUTPUT -t nat -p udp -d 1.2.3.4 --dport 53 -j DNAT --to-destination 2.3.4.5:4321").once
-      machine.guest.expects(:capability).with(:add_iptables_rule, "OUTPUT -t nat -p tcp -d 4.5.6.7 --dport 53 -j DNAT --to-destination 2.3.4.5:4321").once
-      machine.guest.expects(:capability).with(:add_iptables_rule, "OUTPUT -t nat -p udp -d 4.5.6.7 --dport 53 -j DNAT --to-destination 2.3.4.5:4321").once
+      machine.guest.expects(:capability).with(:add_iptables_rule, 'OUTPUT -t nat -p tcp -d 1.2.3.4 --dport 53 -j DNAT --to-destination 2.3.4.5:4321').once
+      machine.guest.expects(:capability).with(:add_iptables_rule, 'OUTPUT -t nat -p udp -d 1.2.3.4 --dport 53 -j DNAT --to-destination 2.3.4.5:4321').once
+      machine.guest.expects(:capability).with(:add_iptables_rule, 'OUTPUT -t nat -p tcp -d 4.5.6.7 --dport 53 -j DNAT --to-destination 2.3.4.5:4321').once
+      machine.guest.expects(:capability).with(:add_iptables_rule, 'OUTPUT -t nat -p udp -d 4.5.6.7 --dport 53 -j DNAT --to-destination 2.3.4.5:4321').once
 
       Landrush::Cap::Linux::RedirectDns.redirect_dns(
         machine,