landrush 0.5.0 → 0.6.0

data/README.md

@@ -24,7 +24,7 @@ Enable the plugin in your `Vagrantfile`:
 
     config.landrush.enable
 
-Bring up a machine that has a private network IP address and a hostname (see the `Vagrantfile` for an example)
+Bring up a machine that has a hostname set (see the `Vagrantfile` for an example)
 
     $ vagrant up
 

data/examples/Vagrantfile

@@ -17,8 +17,6 @@ Vagrant.configure("2") do |config|
 
   config.landrush.enable
 
-  config.vm.network :private_network, ip: '172.16.32.111'
-
   config.vm.hostname = "myhost.vagrant.dev"
 
   config.landrush.host 'static1.example.com', '1.2.3.4'

data/lib/landrush/action/common.rb

@@ -0,0 +1,61 @@
+module Landrush
+  module Action
+    module Common
+      SUPPORTED_PROVIDERS = {
+        'VagrantPlugins::ProviderVirtualBox::Provider' => :virtualbox,
+        'HashiCorp::VagrantVMwarefusion::Provider'     => :vmware_fusion,
+        'Landrush::FakeProvider'                       => :fake_provider,
+      }
+
+      def self.included(base)
+        base.send :attr_reader, :app, :env
+      end
+
+      def initialize(app, env)
+        @app = app
+      end
+
+      def handle_action_stack(env)
+        @env = env
+
+        yield
+
+        app.call(env)
+      end
+
+      def virtualbox?
+        provider == :virtualbox
+      end
+
+      def vmware?
+        provider == :vmware_fusion
+      end
+
+      def provider
+        SUPPORTED_PROVIDERS.fetch(machine.provider.class.name) { |key|
+          raise "The landrush plugin does not support the #{key} provider yet!"
+        }
+      end
+
+      def global_config
+        env[:global_config]
+      end
+
+      def machine
+        env[:machine]
+      end
+
+      def machine_hostname
+        machine.config.vm.hostname
+      end
+
+      def enabled?
+        global_config.landrush.enabled?
+      end
+
+      def info(msg)
+        env[:ui].info "[landrush] #{msg}"
+      end
+    end
+  end
+end

data/lib/landrush/action/install_prerequisites.rb

@@ -1,25 +1,18 @@
 module Landrush
   module Action
     class InstallPrerequisites
-      def initialize(app, env)
-        @app = app
-      end
+      include Common
 
       def call(env)
-        if env[:global_config].landrush.enabled?
-          @machine = env[:machine]
-          @machine.ui.info('setting up prerequisites')
-
-          install_prerequisites
+        handle_action_stack(env) do
+          install_prerequisites if enabled?
         end
-
-        @app.call(env)
       end
 
       def install_prerequisites
-        unless @machine.guest.capability(:iptables_installed)
-          @machine.ui.info('iptables not installed, installing it')
-          @machine.guest.capability(:install_iptables)
+        unless machine.guest.capability(:iptables_installed)
+          info 'iptables not installed, installing it'
+          machine.guest.capability(:install_iptables)
         end
       end
     end

data/lib/landrush/action/redirect_dns.rb

@@ -1,32 +1,25 @@
 module Landrush
   module Action
     class RedirectDns
-      SUPPORTED_PROVIDERS = {
-        'VagrantPlugins::ProviderVirtualBox::Provider' => :virtualbox,
-        'HashiCorp::VagrantVMwarefusion::Provider' => :vmware_fusion,
-      }
-
-      def initialize(app, env)
-        @app = app
-      end
+      include Common
 
       def call(env)
-        if env[:global_config].landrush.enabled?
-          @machine = env[:machine]
+        handle_action_stack(env) do
+          redirect_dns if enabled?
+        end
+      end
 
-          @machine.ui.info "setting up machine's DNS to point to our server"
-          @machine.guest.capability(:redirect_dns, host: _target_host, port: 10053)
+      def redirect_dns
+        info "setting up machine's DNS to point to our server"
+        machine.guest.capability(:redirect_dns, host: _target_host, port: 10053)
 
-          @machine.config.vm.networks.each do |type, options|
-            @machine.ui.info "network: #{type.inspect}, #{options.inspect}"
-          end
+        machine.config.vm.networks.each do |type, options|
+          info "network: #{type.inspect}, #{options.inspect}"
         end
-
-        @app.call(env)
       end
 
       def _target_host
-        case _provider
+        case provider
         when :virtualbox then
           '10.0.2.2'
         when :vmware_fusion then
@@ -34,12 +27,6 @@ module Landrush
         end
       end
 
-      def _provider
-        SUPPORTED_PROVIDERS.fetch(@machine.provider.class.name) { |key|
-          raise "I don't support the #{key} provider yet!"
-        }
-      end
-
       # Poor man's gateway; strip the last octet and jam a 1 on there.
       def _gateway_for_ip(ip)
         ip.split('.').tap(&:pop).push(1).join('.')

data/lib/landrush/action/setup.rb

@@ -1,41 +1,62 @@
 module Landrush
   module Action
     class Setup
-      def initialize(app, env)
-        @app = app
-      end
+      include Common
 
       def call(env)
-        if env[:global_config].landrush.enabled?
-          DependentVMs.add(env[:machine])
-          start_server_if_necessary(env)
-          setup_machine_dns(env)
-          setup_static_dns(env)
+        handle_action_stack(env) do
+          pre_boot_setup if enabled?
         end
-        @app.call(env)
+
+        # 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?
       end
 
-      def start_server_if_necessary(env)
-        if Server.running?
-          env[:ui].info "[landrush] dns server already running"
-        else
-          env[:ui].info "[landrush] starting dns server"
-          Server.start
-        end
+      def pre_boot_setup
+        record_dependent_vm
+        add_prerequisite_network_interface
+        start_server
+        setup_static_dns
+      end
+
+      def record_dependent_vm
+        DependentVMs.add(machine_hostname)
       end
 
-      def setup_machine_dns(env)
-        hostname, ip_address = Util.host_and_ip(env[:machine])
-        env[:ui].info "[landrush] adding machine entry: #{hostname} => #{ip_address}"
-        Store.hosts.set(hostname, ip_address)
+      def add_prerequisite_network_interface
+        return unless virtualbox? && !private_network_exists?
+
+        info 'virtualbox requires an additional private network; adding it'
+        machine.config.vm.network :private_network, type: :dhcp
       end
 
-      def setup_static_dns(env)
-        env[:global_config].landrush.hosts.each do |hostname, ip_address|
-          env[:ui].info "[landrush] adding static entry: #{hostname} => #{ip_address}"
+      def start_server
+        return if Server.running?
+
+        info 'starting dns server'
+        Server.start
+      end
+
+      def setup_static_dns
+        global_config.landrush.hosts.each do |hostname, ip_address|
+          info "adding static entry: #{hostname} => #{ip_address}"
           Store.hosts.set hostname, ip_address
         end
       end
+
+      def record_machine_dns_entry
+        ip_address = machine.guest.capability(:read_host_visible_ip_address)
+
+        info "adding machine entry: #{machine_hostname} => #{ip_address}"
+
+        Store.hosts.set(machine_hostname, ip_address)
+      end
+
+      def private_network_exists?
+        machine.config.vm.networks.any? { |type, _| type == :private_network }
+      end
     end
   end
 end

data/lib/landrush/action/teardown.rb

@@ -1,48 +1,42 @@
 module Landrush
   module Action
     class Teardown
-      def initialize(app, env)
-        @app = app
-      end
+      include Common
 
       def call(env)
-        @env = env
-        teardown if env[:global_config].landrush.enabled?
-        @app.call(@env)
+        handle_action_stack(env) do
+          teardown if enabled?
+        end
       end
 
       def teardown
         teardown_machine_dns
-        DependentVMs.remove(@env[:machine])
+        DependentVMs.remove(machine_hostname)
 
         if DependentVMs.none?
           teardown_static_dns
           teardown_server
         else
           info "there are #{DependentVMs.count} VMs left, leaving DNS server and static entries"
+          info DependentVMs.list.map { |dvm| " - #{dvm}" }.join("\n")
         end
       end
 
       def teardown_machine_dns
-        hostname = Util.hostname(@env[:machine])
-        info "removing machine entry: #{hostname}"
-        Store.hosts.delete(hostname)
+        info "removing machine entry: #{machine_hostname}"
+        Store.hosts.delete(machine_hostname)
       end
 
       def teardown_static_dns
-        @env[:global_config].landrush.hosts.each do |hostname, _|
-          info "removing static entry: #{hostname}"
-          Store.hosts.delete hostname
+        global_config.landrush.hosts.each do |static_hostname, _|
+          info "removing static entry: #{static_hostname}"
+          Store.hosts.delete static_hostname
         end
       end
 
       def teardown_server
         Server.stop
       end
-
-      def info(msg)
-        @env[:ui].info "[landrush] #{msg}"
-      end
     end
   end
 end

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

@@ -0,0 +1,36 @@
+module Landrush
+  module Cap
+    module Linux
+      module ReadHostVisibleIpAddress
+        #
+        # !!!!!!!!!!!!
+        # !!  NOTE  !!
+        # !!!!!!!!!!!!
+        #
+        # This is a fragile heuristic: we are simply assuming the IP address of
+        # the last interface non-localhost IP address is the host-visible one.
+        #
+        # For VMWare, the interface that Vagrant uses is host accessible, so we
+        # expect this to be the same as `read_ip_address`.
+        #
+        # For VirtualBox, the Vagrant interface is not host visible, so we add
+        # our own private_network, which we expect this to return for us.
+        #
+        # If the Vagrantfile sets up any sort of fancy networking, this has the
+        # potential to fail, which will break things.
+        #
+        # TODO: Find a better heuristic for this implementation.
+        #
+        def self.read_host_visible_ip_address(machine)
+          command = "ifconfig  | grep 'inet addr:' | grep -v '127.0.0.1' | cut -d: -f2 | awk '{ print $1 }'"
+          result  = ""
+          machine.communicate.execute(command) do |type, data|
+            result << data if type == :stdout
+          end
+
+          result.chomp.split("\n").last
+        end
+      end
+    end
+  end
+end

data/lib/landrush/config.rb

@@ -30,13 +30,10 @@ module Landrush
     end
 
     def validate(machine)
-      if @enabled
-        unless Util.hostname(machine).to_s.length > 0
+      if enabled?
+        unless machine.config.vm.hostname.to_s.length > 0
           return { 'landrush' => ['you must specify a hostname so we can make a DNS entry for it'] }
         end
-        unless Util.ip_address(machine)
-          return { 'landrush' => ['you must specify a private network or else DNS makes no sense'] }
-        end
       end
       {}
     end

data/lib/landrush/dependent_vms.rb

@@ -13,12 +13,12 @@ module Landrush
       (dir.directory? ? dir.children : []).each(&block)
     end
 
-    def self.add(machine)
-      FileUtils.touch(file_for(machine))
+    def self.add(hostname)
+      FileUtils.touch(file_for(hostname))
     end
 
-    def self.remove(machine)
-      file_for(machine).tap { |f| f.delete if f.exist? }
+    def self.remove(hostname)
+      file_for(hostname).tap { |f| f.delete if f.exist? }
     end
 
     def self.list
@@ -29,8 +29,8 @@ module Landrush
       dir.rmtree
     end
 
-    def self.file_for(machine)
-      dir.join(Util.hostname(machine))
+    def self.file_for(hostname)
+      dir.join(hostname)
     end
 
     def self.dir

data/lib/landrush/plugin.rb

@@ -13,19 +13,17 @@ module Landrush
     end
 
     action_hook 'landrush_setup', :machine_action_up do |hook|
+      require_relative 'action/common'
       require_relative 'action/setup'
       require_relative 'action/install_prerequisites'
       require_relative 'action/redirect_dns'
 
-      register_boot_hooks = lambda { |boot_action|
-        hook.before(boot_action, pre_boot_actions)
-        hook.after(boot_action, post_boot_actions)
-      }
-
-      register_boot_hooks.call(VagrantPlugins::ProviderVirtualBox::Action::Boot)
+      hook.before(VagrantPlugins::ProviderVirtualBox::Action::Network, pre_boot_actions)
+      hook.after(Vagrant::Action::Builtin::WaitForCommunicator, post_boot_actions)
 
       if defined?(HashiCorp::VagrantVMwarefusion)
-        register_boot_hooks.call(HashiCorp::VagrantVMwarefusion::Action::Boot)
+        hook.before(HashiCorp::VagrantVMwarefusion::Action::Network, pre_boot_actions)
+        hook.after(HashiCorp::VagrantVMwarefusion::Action::Boot, post_boot_actions)
       end
     end
 
@@ -43,11 +41,13 @@ module Landrush
     end
 
     action_hook 'landrush_teardown', :machine_action_halt 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_destroy do |hook|
+      require_relative 'action/common'
       require_relative 'action/teardown'
       hook.after(Vagrant::Action::Builtin::GracefulHalt, Action::Teardown)
     end
@@ -76,5 +76,10 @@ module Landrush
       require_relative 'cap/linux/add_iptables_rule'
       Cap::Linux::AddIptablesRule
     end
+
+    guest_capability('linux', 'read_host_visible_ip_address') do
+      require_relative 'cap/linux/read_host_visible_ip_address'
+      Cap::Linux::ReadHostVisibleIpAddress
+    end
   end
 end

data/lib/landrush/store.rb

@@ -20,7 +20,9 @@ module Landrush
 
     def find(search)
       current_config.keys.detect do |key|
-        search == key || search.match(/\.#{key}$/)
+        key == search             ||
+          search =~ /#{key}$/     ||
+          key    =~ /^#{search}\./
       end
     end
 

data/lib/landrush/version.rb

@@ -1,3 +1,3 @@
 module Landrush
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/landrush.rb

@@ -21,7 +21,6 @@ require 'landrush/plugin'
 require 'landrush/resolver_config'
 require 'landrush/server'
 require 'landrush/store'
-require 'landrush/util'
 require 'landrush/version'
 
 require 'ext/rexec'

data/test/landrush/action/setup_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'landrush/action/common'
 require 'landrush/action/setup'
 
 module Landrush
@@ -14,16 +15,6 @@ module Landrush
         env[:called].must_equal true
       end
 
-      it "stores the machine's hostname => ip address" do
-        app = Proc.new {}
-        setup = Setup.new(app, nil)
-        env = fake_environment_with_machine('somehost.vagrant.dev', '1.2.3.4')
-
-        setup.call(env)
-
-        Store.hosts.get('somehost.vagrant.dev').must_equal '1.2.3.4'
-      end
-
       it "records the booting host as a dependent VM" do
         app = Proc.new {}
         setup = Setup.new(app, nil)
@@ -66,7 +57,30 @@ module Landrush
         env[:global_config].landrush.disable
         setup.call(env)
 
-        Store.hosts.get('somehost.vagrant.dev').must_equal nil
+        DependentVMs.list.must_equal []
+      end
+
+      describe 'after boot' do
+        it "stores the machine's hostname => ip address" do
+          app = Proc.new {}
+          setup = Setup.new(app, nil)
+          env = fake_environment_with_machine('somehost.vagrant.dev', '1.2.3.4')
+
+          setup.call(env)
+
+          Store.hosts.get('somehost.vagrant.dev').must_equal '1.2.3.4'
+        end
+
+        it "does nothing if it is not enabled via config" do
+          app = Proc.new {}
+          setup = Setup.new(app, nil)
+          env = fake_environment_with_machine('somehost.vagrant.dev', '1.2.3.4')
+
+          env[:global_config].landrush.disable
+          setup.call(env)
+
+          Store.hosts.get('somehost.vagrant.dev').must_equal nil
+        end
       end
     end
   end

data/test/landrush/action/teardown_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'landrush/action/common'
 require 'landrush/action/teardown'
 
 module Landrush
@@ -30,7 +31,7 @@ module Landrush
         teardown = Teardown.new(app, nil)
         env = fake_environment_with_machine('somehost.vagrant.dev', '1.2.3.4')
 
-        DependentVMs.add(env[:machine])
+        DependentVMs.add('somehost.vagrant.dev')
         teardown.call(env)
 
         DependentVMs.list.must_equal []
@@ -51,8 +52,7 @@ module Landrush
         app = Proc.new {}
         teardown = Teardown.new(app, nil)
         env = fake_environment_with_machine('somehost.vagrant.dev', '1.2.3.4')
-        other_machine = fake_machine('otherhost.vagrant.dev', '2.3.4.5')
-        DependentVMs.add(other_machine)
+        DependentVMs.add('otherhost.vagrant.dev')
 
         Server.start
         teardown.call(env)
@@ -64,8 +64,7 @@ module Landrush
         app = Proc.new {}
         teardown = Teardown.new(app, nil)
         env = fake_environment_with_machine('somehost.vagrant.dev', '1.2.3.4')
-        other_machine = fake_machine('otherhost.vagrant.dev', '1.2.3.4')
-        DependentVMs.add(other_machine)
+        DependentVMs.add('otherhost.vagrant.dev')
 
         fake_static_entry(env, 'static.vagrant.dev', '3.4.5.6')
 

data/test/landrush/dependent_vms_test.rb

@@ -8,24 +8,20 @@ module Landrush
       end
 
       it "reports true once a machine has been added" do
-        env = fake_environment_with_machine('recordme.example.dev', '1.2.3.4')
-        DependentVMs.add(env[:machine])
+        DependentVMs.add('recordme.example.dev')
         DependentVMs.any?.must_equal true
       end
 
       it "reports false if a machine has been added then removed" do
-        env = fake_environment_with_machine('recordme.example.dev', '1.2.3.4')
-        DependentVMs.add(env[:machine])
-        DependentVMs.remove(env[:machine])
+        DependentVMs.add('recordme.example.dev')
+        DependentVMs.remove('recordme.example.dev')
         DependentVMs.any?.must_equal false
       end
 
       it "reports true if not all machines have been removed" do
-        first_env = fake_environment_with_machine('recordme.example.dev', '1.2.3.4')
-        second_env = fake_environment_with_machine('alsome.example.dev', '2.3.4.5')
-        DependentVMs.add(first_env[:machine])
-        DependentVMs.add(second_env[:machine])
-        DependentVMs.remove(first_env[:machine])
+        DependentVMs.add('recordme.example.dev')
+        DependentVMs.add('alsome.example.dev')
+        DependentVMs.remove('recordme.example.dev')
         DependentVMs.any?.must_equal true
       end
     end

data/test/landrush/store_test.rb

@@ -66,6 +66,15 @@ module Landrush
         @store.set('somehost.vagrant.dev', 'here')
         @store.find('somehost.vagrant.dev').must_equal 'somehost.vagrant.dev'
       end
+
+      it "returns for prefix searches as well" do
+        @store.set('somehost.vagrant.dev', 'here')
+
+        @store.find('somehost').must_equal 'somehost.vagrant.dev'
+        @store.find('somehost.vagrant').must_equal 'somehost.vagrant.dev'
+        @store.find('somehost.vagr').must_equal nil
+        @store.find('someh').must_equal nil
+      end
     end
   end
 end

data/test/test_helper.rb

@@ -18,16 +18,54 @@ def fake_environment_with_machine(hostname, ip)
   { machine: machine, ui: FakeUI, global_config: env.config_global }
 end
 
-def fake_machine(hostname, ip, env = Vagrant::Environment.new)
-  provider_cls = Class.new do
-    def initialize(machine)
+class RecordingCommunicator
+  attr_reader :commands, :responses
+
+  def initialize
+    @commands = Hash.new([])
+    @responses = Hash.new('')
+  end
+
+  def stub_command(command, response)
+    responses[command] = response
+  end
+
+  def sudo(command)
+    puts "SUDO: #{command}"
+    commands[:sudo] << command
+    responses[command]
+  end
+
+  def execute(command, &block)
+    commands[:execute] << command
+    responses[command].split("\n").each do |line|
+      block.call(:stdout, "#{line}\n")
     end
-  end 
+  end
+
+  def test(command)
+    commands[:test] << command
+    true
+  end
+
+  def ready?
+    true
+  end
+end
 
+class Landrush::FakeProvider
+  def initialize(machine)
+  end
+
+  def ssh_info
+  end
+end
+
+def fake_machine(hostname, ip, env = Vagrant::Environment.new)
   machine = Vagrant::Machine.new(
     'fake_machine',
     'fake_provider',
-    provider_cls,
+    Landrush::FakeProvider,
     'provider_config',
     {}, # provider_options
     env.config_global,
@@ -36,9 +74,15 @@ def fake_machine(hostname, ip, env = Vagrant::Environment.new)
     env
   )
 
+  machine.instance_variable_set("@communicator", RecordingCommunicator.new)
+  machine.communicate.stub_command(
+    "ifconfig  | grep 'inet addr:' | grep -v '127.0.0.1' | cut -d: -f2 | awk '{ print $1 }'",
+    "#{ip}\n"
+  )
+
   machine.config.landrush.enable
   machine.config.vm.hostname = hostname
-  machine.config.vm.network :private_network, ip: ip
+
 
   machine
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: landrush
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-02 00:00:00.000000000 Z
+date: 2013-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubydns
@@ -91,6 +91,7 @@ files:
 - landrush.gemspec
 - lib/ext/rexec.rb
 - lib/landrush.rb
+- lib/landrush/action/common.rb
 - lib/landrush/action/install_prerequisites.rb
 - lib/landrush/action/redirect_dns.rb
 - lib/landrush/action/setup.rb
@@ -99,6 +100,7 @@ files:
 - lib/landrush/cap/debian/iptables_installed.rb
 - lib/landrush/cap/linux/add_iptables_rule.rb
 - lib/landrush/cap/linux/configured_dns_server.rb
+- lib/landrush/cap/linux/read_host_visible_ip_address.rb
 - lib/landrush/cap/linux/redirect_dns.rb
 - lib/landrush/command.rb
 - lib/landrush/config.rb
@@ -107,7 +109,6 @@ files:
 - lib/landrush/resolver_config.rb
 - lib/landrush/server.rb
 - lib/landrush/store.rb
-- lib/landrush/util.rb
 - lib/landrush/version.rb
 - test/landrush/action/setup_test.rb
 - test/landrush/action/teardown_test.rb
@@ -136,7 +137,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -227825973048311947
+      hash: 901975285541024268
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -145,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -227825973048311947
+      hash: 901975285541024268
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23

data/lib/landrush/util.rb

@@ -1,25 +0,0 @@
-module Landrush
-  module Util
-    def self.host_and_ip(machine)
-      [hostname(machine), ip_address(machine)]
-    end
-
-    def self.hostname(machine)
-      return nil unless machine
-
-      machine.config.vm.hostname
-    end
-
-    def self.ip_address(machine)
-      return nil unless machine
-
-      machine.config.vm.networks.each do |type, options|
-        if type == :private_network && options[:ip].is_a?(String)
-          return options[:ip]
-        end
-      end
-
-      nil
-    end
-  end
-end