landrush 1.2.0 → 1.3.0

data/lib/landrush/start_server.rb

@@ -8,4 +8,4 @@ Dir.entries(gem_path).each { |gem_dir| $LOAD_PATH.unshift "#{File.join(ARGV[2],
 
 require_relative 'server'
 
-Landrush::Server.run(ARGV[0], ARGV[1]) if __FILE__ == $PROGRAM_NAME
+Landrush::Server.run(ARGV[0], ARGV[1]) if $PROGRAM_NAME == __FILE__

data/lib/landrush/store.rb

@@ -1,7 +1,11 @@
 require 'pathname'
 require 'json'
+require 'filelock'
 
 module Landrush
+  class ConfigLockError < StandardError
+  end
+
   class Store
     def self.hosts
       @hosts ||= new(Server.working_dir.join('hosts.json'))
@@ -23,52 +27,76 @@ module Landrush
     end
 
     def set(key, value)
-      write(current_config.merge(key => value))
+      with_file_lock do |file|
+        config = current_config(file).merge(key => value)
+        write(config, file)
+      end
     end
 
     def each(*args, &block)
-      current_config.each(*args, &block)
+      with_file_lock do |file|
+        current_config(file).each(*args, &block)
+      end
     end
 
     def delete(key)
-      write(current_config.reject { |k, v| k == key || v == key })
+      with_file_lock do |file|
+        write(current_config(file).reject { |k, v| k == key || v == key }, file)
+      end
     end
 
     def has?(key, value = nil)
-      if value.nil?
-        current_config.key? key
-      else
-        current_config[key] == value
+      with_file_lock do |file|
+        if value.nil?
+          current_config(file).key? key
+        else
+          current_config(file)[key] == value
+        end
       end
     end
 
     def find(search)
-      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     ||
-          key    =~ /^#{search}\./i
+      with_file_lock do |file|
+        search = IPAddr.new(search).reverse if begin
+                                                 IPAddr.new(search)
+                                               rescue StandardError
+                                                 nil
+                                               end
+        current_config(file).keys.detect do |key|
+          key.casecmp(search) == 0   ||
+            search =~ /#{key}$/i     ||
+            key    =~ /^#{search}\./i
+        end
       end
     end
 
     def get(key)
-      current_config[key]
+      with_file_lock do |file|
+        current_config(file)[key]
+      end
     end
 
     def clear!
-      write({})
+      with_file_lock do |file|
+        write({}, file)
+      end
     end
 
     protected
 
-    def current_config
+    def with_file_lock
+      Filelock @backing_file.to_s, wait: 3 do |file|
+        yield file
+      end
+    rescue Filelock::WaitTimeout
+      raise ConfigLockError, 'Unable to lock Landrush config'
+    end
+
+    def current_config(file)
       if backing_file.exist?
         begin
-          JSON.parse(File.read(backing_file))
+          file.rewind
+          JSON.parse(file.read)
         rescue JSON::ParserError
           {}
         end
@@ -77,10 +105,11 @@ module Landrush
       end
     end
 
-    def write(config)
-      File.open(backing_file, 'w') do |f|
-        f.write(JSON.pretty_generate(config))
-      end
+    def write(config, file)
+      file.rewind
+      file.truncate(0)
+      file.write(JSON.pretty_generate(config))
+      file.flush
     end
   end
 end

data/lib/landrush/util/dnsmasq.rb

@@ -0,0 +1,10 @@
+module Landrush
+  module Util
+    class Dnsmasq
+      def self.nm_managed?
+        nm_config = Pathname('/etc/NetworkManager/NetworkManager.conf')
+        File.exist?(nm_config) && File.readlines(nm_config).grep(/^dns=dnsmasq$/).any?
+      end
+    end
+  end
+end

data/lib/landrush/util/process_helper.rb

@@ -2,24 +2,22 @@ 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 }
+      def write_pid(pid, file)
+        file.rewind
+        file.truncate(0)
+        file.write pid
+        file.flush
       end
 
-      def read_pid(pid_file)
-        IO.read(pid_file).to_i
-      rescue
+      def read_pid(file)
+        file.rewind
+        file.read.to_i
+      rescue StandardError
         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
+      def process_status(file)
+        running?(file) ? :running : :stopped
       end
 
       def ensure_path_exits(file_name)
@@ -27,12 +25,14 @@ module Landrush
         FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
       end
 
-      def terminate_process(pid)
+      def terminate_process(file)
+        pid = read_pid(file)
+
         # 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'
+        while running?(file) && attempts > 0
+          sig = attempts >= 2 ? 'KILL' : 'TERM'
 
           puts "Sending #{sig} to process #{pid}..."
           Process.kill(sig, pid)

data/lib/landrush/util/retry.rb

@@ -6,6 +6,7 @@ module Landrush
         n = 0
         while n < opts[:tries]
           return true if yield
+
           sleep opts[:sleep].to_f if opts[:sleep]
           n += 1
         end

data/lib/landrush/version.rb

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

data/test/landrush/action/setup_test.rb

@@ -13,7 +13,7 @@ module Landrush
       end
 
       it 'calls the next app in the chain' do
-        app = -> (e) { e[:called] = true }
+        app = ->(e) { e[:called] = true }
         setup = Landrush::Action::Setup.new(app, env)
 
         setup.call(env)
@@ -26,7 +26,7 @@ module Landrush
 
         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
@@ -34,7 +34,7 @@ module Landrush
 
         setup.call(env)
 
-        Server.running?.must_equal true
+        Server.status.must_equal :running
       end
 
       it "does not attempt to start the server if it's already up" do
@@ -43,12 +43,13 @@ module Landrush
         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
+        original_pid = Server.read_pid(File.open(File.join(Server.working_dir, 'run', 'landrush.pid')))
 
         setup.call(env)
 
-        Server.running?.must_equal true
-        Server.pid.must_equal original_pid
+        Server.status.must_equal :running
+        new_pid = Server.read_pid(File.open(File.join(Server.working_dir, 'run', 'landrush.pid')))
+        new_pid.must_equal original_pid
       end
 
       it 'does nothing if it is not enabled via config' do
@@ -93,7 +94,7 @@ module Landrush
           setup = Landrush::Action::Setup.new(app, env)
           setup.call(env)
 
-          Store.hosts.get('somehost.vagrant.test').must_equal nil
+          assert_nil Store.hosts.get('somehost.vagrant.test')
         end
       end
     end

data/test/landrush/action/teardown_test.rb

@@ -7,7 +7,7 @@ module Landrush
     describe Teardown do
       it 'calls the next app in the chain' do
         env = fake_environment
-        app = -> (e) { e[:called] = true }
+        app = ->(e) { e[:called] = true }
         teardown = Teardown.new(app, env)
 
         teardown.call(env)
@@ -23,7 +23,7 @@ module Landrush
         Store.hosts.set('somehost.vagrant.test', '1.2.3.4')
         teardown.call(env)
 
-        Store.hosts.get('somehost.vagrant.test').must_equal nil
+        assert_nil Store.hosts.get('somehost.vagrant.test')
       end
 
       it 'removes the machine as a dependent VM' do
@@ -45,7 +45,7 @@ module Landrush
         Server.start
         teardown.call(env)
 
-        Server.running?.must_equal false
+        Server.status.must_equal :stopped
       end
 
       it 'leaves the landrush server when other dependent vms exist' do
@@ -60,7 +60,7 @@ module Landrush
         Server.start
         teardown.call(env)
 
-        Server.running?.must_equal true
+        Server.status.must_equal :running
       end
 
       it 'leaves static entries when other dependent vms exist' do
@@ -84,7 +84,7 @@ module Landrush
 
         teardown.call(env)
 
-        Server.running?.must_equal false
+        Server.status.must_equal :stopped
       end
 
       it 'does nothing when landrush is disabled' do

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

@@ -5,7 +5,7 @@ describe Landrush::Cap::Linux::RedirectDns do
 
   describe 'redirect_dns' 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.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

data/test/landrush/cap/host/darwin/configure_visibility_on_host_test.rb

@@ -23,7 +23,7 @@ module Landrush
               # also disable 'sudo'
               ConfigureVisibilityOnHost.stubs(:sudo).returns('')
 
-              ConfigureVisibilityOnHost.configure_visibility_on_host(env, '42.42.42.42', 'vagrant.test')
+              ConfigureVisibilityOnHost.configure_visibility_on_host(env, '42.42.42.42', ['vagrant.test'])
 
               Dir["#{dir}/*"].empty?.must_equal false
               File.exist?(File.join(dir, 'vagrant.test')).must_equal true
@@ -31,7 +31,7 @@ module Landrush
             end
           end
 
-          it 'the config file is named after the configured tld' do
+          it 'multiple tlds can be specified' do
             Dir.mktmpdir('landrush-test-dir-') do |dir|
               # puts "Using #{dir} for testing"
               Dir["#{dir}/*"].empty?.must_equal true
@@ -41,11 +41,15 @@ module Landrush
               # also disable 'sudo'
               ConfigureVisibilityOnHost.stubs(:sudo).returns('')
 
-              ConfigureVisibilityOnHost.configure_visibility_on_host(env, '42.42.42.42', 'foo.bar')
+              tlds = %w[foo.bar acme.com example.com]
 
-              Dir["#{dir}/*"].empty?.must_equal false
-              File.exist?(File.join(dir, 'foo.bar')).must_equal true
-              Pathname(File.join(dir, 'foo.bar')).read.must_equal CONFIG
+              ConfigureVisibilityOnHost.configure_visibility_on_host(env, '42.42.42.42', tlds)
+
+              tlds.each do |tld|
+                Dir["#{dir}/*"].empty?.must_equal false
+                File.exist?(File.join(dir, tld)).must_equal true
+                Pathname(File.join(dir, tld)).read.must_equal CONFIG
+              end
             end
           end
         end

data/test/landrush/cap/host/linux/configure_visibility_on_host_test.rb

@@ -22,7 +22,7 @@ module Landrush
             skip('Only supported on Linux') unless Vagrant::Util::Platform.linux?
             File.exist?(TEST_CONFIG).must_equal false
 
-            Landrush::Cap::Linux::ConfigureVisibilityOnHost.configure_visibility_on_host(Vagrant::Environment.new, TEST_IP, TEST_TLD)
+            Landrush::Cap::Linux::ConfigureVisibilityOnHost.configure_visibility_on_host(Vagrant::Environment.new, TEST_IP, [TEST_TLD])
 
             File.exist?(TEST_CONFIG).must_equal true
             Pathname(TEST_CONFIG).read.must_equal CONFIG

data/test/landrush/cap/host/windows/configure_visibility_on_host_test.rb

@@ -6,6 +6,25 @@ module Landrush
       describe ConfigureVisibilityOnHost do
         TEST_IP = '10.42.42.42'.freeze
 
+        DOT_3_SVC_RUNNING = 'SERVICE_NAME: dot3svc
+        TYPE               : 30  WIN32
+        STATE              : 4  RUNNING
+                                (STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
+        WIN32_EXIT_CODE    : 0  (0x0)
+        SERVICE_EXIT_CODE  : 0  (0x0)
+        CHECKPOINT         : 0x0
+        WAIT_HINT          : 0x0
+'.freeze
+
+        DOT_3_SVC_STOPPED = 'SERVICE_NAME: dot3svc
+        TYPE               : 30  WIN32
+        STATE              : 1  STOPPED
+        WIN32_EXIT_CODE    : 0  (0x0)
+        SERVICE_EXIT_CODE  : 0  (0x0)
+        CHECKPOINT         : 0x0
+        WAIT_HINT          : 0x0
+'.freeze
+
         before do
           @vboxmanage_found = !Vagrant::Util::Which.which('VBoxManage').nil?
           @has_admin_privileges = Landrush::Cap::Windows::ConfigureVisibilityOnHost.admin_mode?
@@ -24,21 +43,33 @@ module Landrush
               network_name = get_network_name(old_network_state, new_network_state)
 
               get_dns_for_name(network_name).must_be_nil
-              Landrush::Cap::Windows::ConfigureVisibilityOnHost.configure_visibility_on_host(fake_environment, TEST_IP, 'landrush.test')
+              Landrush::Cap::Windows::ConfigureVisibilityOnHost.configure_visibility_on_host(fake_environment, TEST_IP, ['landrush.test'])
               get_dns_for_name(network_name).must_equal '127.0.0.1'
-            rescue
+            rescue StandardError
               delete_test_interface network_description
             end
           end
         end
 
+        describe '#wired_autoconfig_service_running?' do
+          it 'service running' do
+            Landrush::Cap::Windows::ConfigureVisibilityOnHost.expects(:wired_autoconfig_service_state).returns(DOT_3_SVC_RUNNING)
+            assert ConfigureVisibilityOnHost.send(:wired_autoconfig_service_running?)
+          end
+
+          it 'service stopped' do
+            Landrush::Cap::Windows::ConfigureVisibilityOnHost.expects(:wired_autoconfig_service_state).returns(DOT_3_SVC_STOPPED)
+            refute ConfigureVisibilityOnHost.send(:wired_autoconfig_service_running?)
+          end
+        end
+
         def network_state
           `netsh interface ip show config`.split(/\n/).reject(&:empty?)
         end
 
         def get_network_name(old_network_state, new_network_state)
           new_network_state.reject! { |line| old_network_state.include? line }
-          new_network_state[0].match(/.*\"(.*)\"$/).captures[0]
+          new_network_state[0].match(/.*"(.*)"$/).captures[0]
         end
 
         # Creates a test interface using VBoxMange and sets a known test IP
@@ -60,7 +91,7 @@ module Landrush
           # TODO: better error handling
           begin
             dns[0].match(/.* (\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3}).*/).captures[0]
-          rescue
+          rescue StandardError
             return nil
           end
         end

data/test/landrush/issues/255.rb

@@ -6,65 +6,65 @@ module Landrush
       describe ReadHostVisibleIpAddress do
         let(:landrush_ip_output) do
           <<YAML
-- name: br-44ba74744d5d
-  ipv4: 172.17.0.1
-  ipv6: fe80::42:e1ff:fe01:ae98
-- name: br-7884014b4104
-  ipv4: 172.19.0.1
-  ipv6: fe80::42:c0ff:fe4b:900c
-- name: br-efce9da0c1fd
-  ipv4: 172.18.0.1
-  ipv6: fe80::42:2ff:fe46:f1d1
-- name: docker0
-  ipv4: 172.16.0.1
-  ipv6: fe80::42:dbff:fe1b:6e92
-- name: docker_gwbridge
-  ipv4: 172.20.0.1
-  ipv6: fe80::42:72ff:fe96:c6df
-- name: enp4s0
-  ipv4: 192.168.88.97
-  ipv6: fe80::323d:9fa0:ef2a:ddf5
-- name: wlp3s0
-  ipv4: 192.168.88.118
-  ipv6: fe80::6b80:15d4:e83c:a59d
-- name: lo
-  ipv4: 127.0.0.1
-  ipv6: ::1/128
-- name: veth050aa01
-  ipv4: ""
-  ipv6: fe80::c83a:8eff:fe7a:3244
-- name: veth1c191f7
-  ipv4: ""
-  ipv6: fe80::b498:f3ff:fea1:3243
-- name: veth38aa771
-  ipv4: ""
-  ipv6: fe80::8c97:e2ff:fe1a:b14f
-- name: veth5f49498
-  ipv4: ""
-  ipv6: fe80::6825:20ff:fef5:a00d
-- name: veth7803c65
-  ipv4: ""
-  ipv6: fe80::34d7:6cff:fe28:54ce
-- name: veth8a09803
-  ipv4: ""
-  ipv6: fe80::b436:30ff:fed1:598e
-- name: veth8bf1652
-  ipv4: ""
-  ipv6: fe80::60a8:67ff:fe85:cce4
-- name: veth95ef8de
-  ipv4: ""
-  ipv6: fe80::9c45:e8ff:fe69:e62f
-- name: vethc75f284
-  ipv4: ""
-  ipv6: fe80::78b2:7fff:fe55:59
-- name: vethe533ef0
-  ipv4: ""
-  ipv6: fe80::b83e:93ff:fe52:aac7
+  - name: br-44ba74744d5d
+    ipv4: 172.17.0.1
+    ipv6: fe80::42:e1ff:fe01:ae98
+  - name: br-7884014b4104
+    ipv4: 172.19.0.1
+    ipv6: fe80::42:c0ff:fe4b:900c
+  - name: br-efce9da0c1fd
+    ipv4: 172.18.0.1
+    ipv6: fe80::42:2ff:fe46:f1d1
+  - name: docker0
+    ipv4: 172.16.0.1
+    ipv6: fe80::42:dbff:fe1b:6e92
+  - name: docker_gwbridge
+    ipv4: 172.20.0.1
+    ipv6: fe80::42:72ff:fe96:c6df
+  - name: enp4s0
+    ipv4: 192.168.88.97
+    ipv6: fe80::323d:9fa0:ef2a:ddf5
+  - name: wlp3s0
+    ipv4: 192.168.88.118
+    ipv6: fe80::6b80:15d4:e83c:a59d
+  - name: lo
+    ipv4: 127.0.0.1
+    ipv6: ::1/128
+  - name: veth050aa01
+    ipv4: ""
+    ipv6: fe80::c83a:8eff:fe7a:3244
+  - name: veth1c191f7
+    ipv4: ""
+    ipv6: fe80::b498:f3ff:fea1:3243
+  - name: veth38aa771
+    ipv4: ""
+    ipv6: fe80::8c97:e2ff:fe1a:b14f
+  - name: veth5f49498
+    ipv4: ""
+    ipv6: fe80::6825:20ff:fef5:a00d
+  - name: veth7803c65
+    ipv4: ""
+    ipv6: fe80::34d7:6cff:fe28:54ce
+  - name: veth8a09803
+    ipv4: ""
+    ipv6: fe80::b436:30ff:fed1:598e
+  - name: veth8bf1652
+    ipv4: ""
+    ipv6: fe80::60a8:67ff:fe85:cce4
+  - name: veth95ef8de
+    ipv4: ""
+    ipv6: fe80::9c45:e8ff:fe69:e62f
+  - name: vethc75f284
+    ipv4: ""
+    ipv6: fe80::78b2:7fff:fe55:59
+  -   name: vethe533ef0
+    ipv4: ""
+    ipv6: fe80::b83e:93ff:fe52:aac7
 YAML
         end
 
         let(:machine) { fake_machine }
-        let(:addresses) { YAML.load(landrush_ip_output) }
+        let(:addresses) { YAML.safe_load(landrush_ip_output) }
 
         def call_cap(machine)
           Landrush::Cap::All::ReadHostVisibleIpAddress.read_host_visible_ip_address(machine)