landrush 1.1.2 → 1.2.0

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

@@ -0,0 +1,14 @@
+module Landrush
+  module Cap
+    module Suse
+      module InstallIptables
+        def self.install_iptables(machine)
+          machine.communicate.tap do |c|
+            c.sudo('zypper -q clean')
+            c.sudo('zypper -n -q install iptables')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Landrush
+  module Cap
+    module Suse
+      module IptablesInstalled
+        def self.iptables_installed(machine)
+          machine.communicate.test('rpm -qa | grep iptables')
+        end
+      end
+    end
+  end
+end

data/lib/landrush/cap/host/suse/dnsmasq_installed.rb

@@ -0,0 +1,11 @@
+module Landrush
+  module Cap
+    module Suse
+      module DnsmasqInstalled
+        def self.dnsmasq_installed(_env, *_args)
+          system('rpm -qa | grep dnsmasq > /dev/null 2>&1')
+        end
+      end
+    end
+  end
+end

data/lib/landrush/cap/host/suse/install_dnsmasq.rb

@@ -0,0 +1,14 @@
+module Landrush
+  module Cap
+    module Suse
+      module InstallDnsmasq
+        class << self
+          def install_dnsmasq(_env)
+            system('sudo zypper -q clean > /dev/null 2>&1')
+            system('sudo zypper -n -q install dnsmasq > /dev/null 2>&1')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/landrush/cap/host/suse/restart_dnsmasq.rb

@@ -0,0 +1,21 @@
+module Landrush
+  module Cap
+    module Suse
+      module RestartDnsmasq
+        class << self
+          SED_COMMAND = <<-EOF.gsub(/^ +/, '')
+          sudo sed -i.orig '1 i\
+          # Added by landrush, a vagrant plugin \\
+          nameserver 127.0.0.1 \\
+          ' /etc/resolv.conf
+          EOF
+
+          def restart_dnsmasq(_env)
+            system(SED_COMMAND) unless system("cat /etc/resolv.conf | grep 'nameserver 127.0.0.1' > /dev/null 2>&1")
+            system('sudo systemctl restart dnsmasq')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/landrush/cap/host/windows/configure_visibility_on_host.rb

@@ -180,6 +180,6 @@ 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
+if __FILE__ == $PROGRAM_NAME
   Landrush::Cap::Windows::ConfigureVisibilityOnHost.configure_visibility_on_host(nil, ARGV[0], ARGV[1])
 end

data/lib/landrush/command.rb

@@ -3,33 +3,27 @@ module Landrush
     DAEMON_COMMANDS = %w(start stop restart status).freeze
 
     def self.synopsis
-      "manages DNS for both guest and host"
+      'manages DNS for both guest and host'
     end
 
     def execute
       # Make sure we use the right data directory for Landrush
       Server.working_dir = File.join(@env.data_dir, 'landrush')
+      Server.gems_dir = File.join(@env.gems_path, 'gems')
+      Server.ui = @env.ui
 
       ARGV.shift # flush landrush from ARGV
       command = ARGV.first || 'help'
       if DAEMON_COMMANDS.include?(command)
         Server.send(command)
       elsif command == 'dependentvms' || command == 'vms'
-        if DependentVMs.any?
-          @env.ui.info(DependentVMs.list.map { |dvm| " - #{dvm}" }.join("\n"))
-        else
-          @env.ui.info("No dependent VMs")
-        end
+        dependent_vms
       elsif command == 'ls' || command == 'list'
-        Landrush::Store.hosts.each do |key, value|
-          printf "%-30s %s\n", key, value
-        end
+        store_ls
       elsif command == 'set'
-        host, ip = ARGV[1, 2]
-        Landrush::Store.hosts.set(host, ip)
+        store_set
       elsif command == 'del' || command == 'rm'
-        key = ARGV[1]
-        Landrush::Store.hosts.delete(key)
+        store_del
       elsif command == 'help'
         @env.ui.info(help)
       else
@@ -40,7 +34,7 @@ module Landrush
     end
 
     def boom(msg)
-      raise Vagrant::Errors::CLIInvalidOptions, :help => usage(msg)
+      raise Vagrant::Errors::CLIInvalidOptions, help: usage(msg)
     end
 
     def usage(msg); <<-EOS.gsub(/^      /, '')
@@ -62,12 +56,43 @@ module Landrush
           list vms currently dependent on the landrush server
         set { <host> <ip> | <alias> <host> }
           adds the given host-to-ip or alias-to-hostname mapping.
-          existing host ip addresses will be overwritten
-        rm, del { <host> | <alias> }
-          delete the given hostname or alias from the server
+          Existing host ip addresses will be overwritten
+        rm, del { <host> | <alias> | --all }
+          delete the given hostname or alias from the server.
+          --all removes all entries
         help
           you're lookin at it!
       EOS
     end
+
+    private
+
+    def dependent_vms
+      if DependentVMs.any?
+        @env.ui.info(DependentVMs.list.map { |dvm| " - #{dvm}" }.join("\n"))
+      else
+        @env.ui.info('No dependent VMs')
+      end
+    end
+
+    def store_del
+      key = ARGV[1]
+      if key == '--all'
+        Landrush::Store.hosts.clear!
+      else
+        Landrush::Store.hosts.delete(key)
+      end
+    end
+
+    def store_set
+      host, ip = ARGV[1, 2]
+      Landrush::Store.hosts.set(host, ip)
+    end
+
+    def store_ls
+      Landrush::Store.hosts.each do |key, value|
+        printf "%-30s %s\n", key, value
+      end
+    end
   end
 end

data/lib/landrush/config.rb

@@ -7,18 +7,23 @@ module Landrush
     attr_accessor :host_ip_address
     attr_accessor :guest_redirect_dns
     attr_accessor :host_interface
+    attr_accessor :host_interface_class
     attr_accessor :host_interface_excludes
     attr_accessor :host_redirect_dns
 
+    INTERFACE_CLASSES = [:any, :ipv4, :ipv6].freeze
+    INTERFACE_CLASS_INVALID = "Invalid interface class, should be one of: #{INTERFACE_CLASSES.join(', ')}".freeze
+
     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,
-      :host_interface            => nil,
-      :host_interface_excludes   => [/lo[0-9]*/, /docker[0-9]+/, /tun[0-9]+/],
-      :host_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]+/],
+      host_interface_class:    :ipv4,
+      host_redirect_dns:       true
     }.freeze
 
     def initialize
@@ -30,6 +35,7 @@ module Landrush
       @guest_redirect_dns        = UNSET_VALUE
       @host_interface            = UNSET_VALUE
       @host_interface_excludes   = UNSET_VALUE
+      @host_interface_class      = UNSET_VALUE
       @host_redirect_dns         = UNSET_VALUE
     end
 
@@ -53,14 +59,12 @@ module Landrush
       @host_redirect_dns
     end
 
-    def host(hostname, ip_address=nil)
+    def host(hostname, ip_address = nil)
       @hosts[hostname] = ip_address
     end
 
-    def upstream(ip, port=53, protocol=nil)
-      if @upstream_servers == UNSET_VALUE
-        @upstream_servers = []
-      end
+    def upstream(ip, port = 53, protocol = nil)
+      @upstream_servers = [] if @upstream_servers == UNSET_VALUE
 
       if !protocol
         @upstream_servers.push [:udp, ip, port]
@@ -84,9 +88,20 @@ module Landrush
       end
     end
 
-    def validate(machine)
+    def validate(_machine)
       errors = _detected_errors
+      errors.concat validate_host_interface_class
+
       { 'landrush' => errors }
     end
+
+    def validate_host_interface_class
+      @host_interface_class = @host_interface_class.intern if @host_interface_class.is_a? String
+
+      return [] if INTERFACE_CLASSES.include? @host_interface_class
+
+      # TODO: Should really be using I18n; makes testing a lot cleaner too.
+      [INTERFACE_CLASS_INVALID, fields: 'host_interface_class']
+    end
   end
 end

data/lib/landrush/plugin.rb

@@ -87,6 +87,21 @@ module Landrush
       Cap::Redhat::InstallIptables
     end
 
+    guest_capability('suse', 'add_iptables_rule') do
+      require_relative 'cap/guest/suse/add_iptables_rule'
+      Cap::Suse::AddIptablesRule
+    end
+
+    guest_capability('suse', 'iptables_installed') do
+      require_relative 'cap/guest/suse/iptables_installed'
+      Cap::Suse::IptablesInstalled
+    end
+
+    guest_capability('suse', 'install_iptables') do
+      require_relative 'cap/guest/suse/install_iptables'
+      Cap::Suse::InstallIptables
+    end
+
     guest_capability('linux', 'configured_dns_servers') do
       require_relative 'cap/guest/linux/configured_dns_servers'
       Cap::Linux::ConfiguredDnsServers
@@ -166,5 +181,20 @@ module Landrush
       require_relative 'cap/host/redhat/restart_dnsmasq'
       Cap::Redhat::RestartDnsmasq
     end
+
+    host_capability('suse', 'dnsmasq_installed') do
+      require_relative 'cap/host/suse/dnsmasq_installed'
+      Cap::Suse::DnsmasqInstalled
+    end
+
+    host_capability('suse', 'install_dnsmasq') do
+      require_relative 'cap/host/suse/install_dnsmasq'
+      Cap::Suse::InstallDnsmasq
+    end
+
+    host_capability('suse', 'restart_dnsmasq') do
+      require_relative 'cap/host/suse/restart_dnsmasq'
+      Cap::Suse::RestartDnsmasq
+    end
   end
 end

data/lib/landrush/server.rb

@@ -1,29 +1,56 @@
 require 'rubydns'
 require 'ipaddr'
-require 'vagrant/util/platform'
-
+require 'win32/process' unless (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM).nil? # only require on Windows
 require_relative 'store'
+require_relative 'util/path'
+require_relative 'util/process_helper'
 
 module Landrush
   class Server
+    extend Landrush::Util::ProcessHelper
+
     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'
+    class << self
+      attr_reader :gems_dir
+
+      def gems_dir=(gems_dir)
+        @gems_dir = Pathname(gems_dir)
+      end
+
+      attr_reader :ui
+      attr_writer :ui
+
+      def 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 integration 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
-      @working_dir
-    end
 
-    def self.working_dir=(working_dir)
-      @working_dir = Pathname(working_dir).tap(&:mkpath)
+      def working_dir=(working_dir)
+        @working_dir = Pathname(working_dir).tap(&:mkpath)
+      end
+
+      def port
+        @port unless @port.nil?
+        if (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM).nil?
+          # Default Landrush port for non Windows OS
+          100_53
+        else
+          # On Windows we need to use the default DNS port, since there seems to be no way to configure it otherwise
+          53
+        end
+      end
+
+      attr_writer :port
     end
 
     def self.log_directory
@@ -34,22 +61,9 @@ module Landrush
       File.join(log_directory, 'landrush.log')
     end
 
-    def self.port
-      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
-        @port ||= 100_53
-      end
-    end
-
-    def self.port=(port)
-      @port = port
-    end
-
     def self.upstream_servers
       # Doing collect to cast protocol to symbol because JSON store doesn't know about symbols
-      @upstream_servers ||= Store.config.get('upstream').collect {|i| [i[0].to_sym, i[1], i[2]]}
+      @upstream_servers ||= Store.config.get('upstream').collect { |i| [i[0].to_sym, i[1], i[2]] }
     end
 
     def self.interfaces
@@ -65,7 +79,14 @@ module Landrush
 
     # Used to start the Landrush DNS server as a child process using ChildProcess gem
     def self.start
-      ensure_ruby_on_path
+      # On a machine with just Vagrant installed there might be no other Ruby except the
+      # one bundled with Vagrant. Let's make sure the embedded bin directory containing
+      # the Ruby executable is added to the PATH.
+      Landrush::Util::Path.ensure_ruby_on_path
+
+      ruby_bin = Landrush::Util::Path.embedded_vagrant_ruby.nil? ? 'ruby' : Landrush::Util::Path.embedded_vagrant_ruby
+      start_server_script = Pathname(__dir__).join('start_server.rb').to_s
+      @ui.detail("[landrush] '#{ruby_bin} #{start_server_script} #{port} #{working_dir} #{gems_dir}'") unless @ui.nil?
       if Vagrant::Util::Platform.windows?
         # Need to handle Windows differently. Kernel.spawn fails to work, if
         # the shell creating the process is closed.
@@ -79,31 +100,33 @@ module Landrush
         # inherited by default, but if any filehandle is passed to
         # a spawned process then all files that are
         # set as inheritable will get inherited. In another project this
-        # created a problem (see:
-        # https://github.com/dustymabe/vagrant-sshfs/issues/41).
+        # created a problem (see: https://github.com/dustymabe/vagrant-sshfs/issues/41).
         #
         # Today we don't pass any filehandles, so it isn't a problem.
         # Future self, make sure this doesn't become a problem.
-
-        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)
+        info = Process.create(command_line:    "#{ruby_bin} #{start_server_script} #{port} #{working_dir} #{gems_dir}",
+                              creation_flags:  Process::DETACHED_PROCESS,
+                              process_inherit: false,
+                              thread_inherit:  true,
+                              cwd:             working_dir.to_path)
         pid = info.process_id
       else
         # Fix https://github.com/vagrant-landrush/landrush/issues/249)
         # by turning of filehandle inheritance with :close_others => true
         # and by explicitly closing STDIN, STDOUT, and STDERR
-
-        pid = spawn('ruby', __FILE__, port.to_s, working_dir.to_s,
-                    :in => :close, :out => :close, :err => :close,
-                    :close_others => true, :chdir => working_dir.to_path,
-                    :pgroup => true)
+        pid = spawn(ruby_bin, start_server_script, port.to_s, working_dir.to_s, gems_dir.to_s,
+                    in:           :close,
+                    out:          :close,
+                    err:          :close,
+                    close_others: true,
+                    chdir:        working_dir.to_path,
+                    pgroup:       true)
         Process.detach pid
       end
 
-      write_pid(pid)
+      write_pid(pid, pid_file)
+      # As of Vagrant 1.8.6 this additonal sleep is needed, otherwise the child process dies!?
+      sleep 1
     end
 
     def self.stop
@@ -115,7 +138,7 @@ module Landrush
         return
       end
 
-      pid = read_pid
+      pid = read_pid(pid_file)
 
       # Check if the daemon is already stopped...
       unless running?
@@ -132,7 +155,7 @@ module Landrush
       end
 
       # Otherwise the daemon has been stopped.
-      delete_pid_file
+      delete_pid_file(pid_file)
     end
 
     def self.restart
@@ -141,11 +164,13 @@ module Landrush
     end
 
     def self.pid
-      IO.read(pid_file).to_i rescue nil
+      IO.read(pid_file).to_i
+    rescue
+      nil
     end
 
     def self.running?
-      pid = read_pid
+      pid = read_pid(pid_file)
       return false if pid.nil?
       if Vagrant::Util::Platform.windows?
         begin
@@ -155,20 +180,24 @@ module Landrush
           raise e unless e.class.name.start_with?('Errno::ENXIO')
         end
       else
-        !!Process.kill(0, pid) rescue false
+        begin
+          !!Process.kill(0, pid)
+        rescue
+          false
+        end
       end
     end
 
     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_path}"
+      case process_status(pid_file)
+      when :running
+        puts "Daemon status: running pid=#{read_pid(pid_file)}"
+      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_path}"
       end
     end
 
@@ -184,7 +213,7 @@ module Landrush
       @logger.level = Logger::INFO
 
       # Start the DNS server
-      run_dns_server(:listen => interfaces, :logger => @logger) do
+      run_dns_server(listen: interfaces, logger: @logger) do
         match(/.*/, IN::A) do |transaction|
           host = Store.hosts.find(transaction.name)
           if host
@@ -215,7 +244,7 @@ module Landrush
       server = RubyDNS::RuleBasedServer.new(options, &block)
 
       EventMachine.run do
-        trap("INT") do
+        trap('INT') do
           EventMachine.stop
         end
 
@@ -227,94 +256,23 @@ module Landrush
 
     def self.check_a_record(host, transaction)
       value = Store.hosts.get(host)
-      if value.nil?
-        return
-      end
+      return if value.nil?
 
-      if (IPAddr.new(value) rescue nil)
+      if begin
+            IPAddr.new(value)
+          rescue
+            nil
+          end
         name = transaction.name =~ /#{host}/ ? transaction.name : host
-        transaction.respond!(value, :ttl => 0, :name => name)
+        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)
-      # 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
-
-    # On a machine with just Vagrant installed there might be no other Ruby except the
-    # one bundled with Vagrant. Let's make sure the embedded bin directory containing
-    # the Ruby executable is added to the PATH.
-    def self.ensure_ruby_on_path
-      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
-      # 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?
-        separator = '\\'
-      else
-        separator = '/'
-      end
-      embedded_bin_dir = File.dirname(File.dirname(vagrant_binary)) + separator + 'embedded' + separator + 'bin'
-      ENV['PATH'] = embedded_bin_dir + File::PATH_SEPARATOR + ENV['PATH'] if File.exist?(embedded_bin_dir)
-    end
-
-    private_class_method :write_pid, :read_pid, :delete_pid_file, :pid_file, :process_status, :ensure_path_exits,
-                         :terminate_process, :ensure_ruby_on_path
   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