landrush 0.3.1 → 0.4.0

data/README.md

@@ -44,9 +44,9 @@ Linux guests using iptables should automatically have their DNS traffic redirect
 
 I'm currently developing this on OS X 10.8, and there's a nice trick you can pull to unobtrusibly add a secondary DNS server only for specific domains.
 
-All you do is drop a file in `/etc/resolvers/$DOMAIN` with information on how to connect to the DNS server you'd like to use for that domain.
+All you do is drop a file in `/etc/resolver/$DOMAIN` with information on how to connect to the DNS server you'd like to use for that domain.
 
-So what I do is name all of my vagrant servers with the pattern `$host.vagrant.dev` and then drop a file called `/etc/resolvers/vagrant.dev` with these contents:
+So what I do is name all of my vagrant servers with the pattern `$host.vagrant.dev` and then drop a file called `/etc/resolver/vagrant.dev` with these contents:
 
 ```
 # Use landrush server for this domain
@@ -54,6 +54,15 @@ nameserver 127.0.0.1
 port 10053
 ```
 
+Once you have done this, you can run `scutil --dns` to confirm that the DNS resolution is working -- you should see something like:
+```
+resolver #8
+  domain   : vagrant.dev
+  nameserver[0] : 127.0.0.1
+  port     : 10053
+```
+
+
 This gives us automatic access to the landrush hosts without having to worry about it getting in the way of our normal DNS config.
 
 ## Work in Progress - Lots to do!

data/lib/landrush/action/install_prerequisites.rb

@@ -0,0 +1,29 @@
+module Landrush
+  module Action
+    class InstallPrerequisites
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        if env[:global_config].landrush.enabled?
+          @machine = env[:machine]
+          @machine.ui.info('setting up prerequisites')
+
+          install_prerequisites
+        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)
+        end
+      end
+    end
+  end
+end
+
+

data/lib/landrush/action/redirect_dns.rb

@@ -1,33 +1,48 @@
 module Landrush
   module Action
     class RedirectDns
+      SUPPORTED_PROVIDERS = {
+        'VagrantPlugins::ProviderVirtualBox::Provider' => :virtualbox,
+        'HashiCorp::VagrantVMwarefusion::Provider' => :vmware_fusion,
+      }
+
       def initialize(app, env)
         @app = app
       end
 
       def call(env)
-        @machine = env[:machine]
+        if env[:global_config].landrush.enabled?
+          @machine = env[:machine]
+
+          @machine.ui.info "setting up machine's DNS to point to our server"
+          @machine.guest.capability(:redirect_dns, host: _target_host, port: 10053)
 
-        @machine.ui.info "setting up machine's DNS to point to our server"
+          @machine.config.vm.networks.each do |type, options|
+            @machine.ui.info "network: #{type.inspect}, #{options.inspect}"
+          end
+        end
 
-        redirect_dns('10.0.2.3', 53, '10.0.2.2', 10053)
+        @app.call(env)
       end
 
-      def redirect_dns(original_server, original_port, target_server, target_port)
-        %w[tcp udp].each do |protocol|
-          rule = "OUTPUT -t nat -d #{original_server} -p #{protocol} --dport #{original_port} -j DNAT --to-destination #{target_server}:#{target_port}"
-          command = %Q(iptables -C #{rule} 2> /dev/null || iptables -A #{rule})
-          _run_command(command)
+      def _target_host
+        case _provider
+        when :virtualbox then
+          '10.0.2.2'
+        when :vmware_fusion then
+          _gateway_for_ip(@machine.guest.capability(:configured_dns_server))
         end
       end
 
-      def _run_command(command)
-        @machine.communicate.sudo(command) do |data, type|
-          if [:stderr, :stdout].include?(type)
-            color = (type == :stdout) ? :green : :red
-            @machine.env.ui.info(data.chomp, :color => color, :prefix => false)
-          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('.')
       end
     end
   end

data/lib/landrush/action/setup.rb

@@ -11,7 +11,6 @@ module Landrush
           start_server_if_necessary(env)
           setup_machine_dns(env)
           setup_static_dns(env)
-          env[:machine].config.vm.provision :landrush
         end
         @app.call(env)
       end

data/lib/landrush/action/teardown.rb

@@ -6,41 +6,43 @@ module Landrush
       end
 
       def call(env)
-        if env[:global_config].landrush.enabled?
-          teardown_static_dns(env)
-          teardown_machine_dns(env)
-
-          DependentVMs.remove(env[:machine])
-          stop_server_if_necessary(env)
-        end
-        @app.call(env)
+        @env = env
+        teardown if env[:global_config].landrush.enabled?
+        @app.call(@env)
       end
 
-      def stop_server_if_necessary(env)
-        if Server.running?
-          if DependentVMs.none?
-            env[:ui].info "[landrush] no dependent vms left, stopping dns server"
-            Server.stop
-          else
-            env[:ui].info "[landrush] there are dependent vms left, leaving dns server"
-          end
+      def teardown
+        teardown_machine_dns
+        DependentVMs.remove(@env[:machine])
+
+        if DependentVMs.none?
+          teardown_static_dns
+          teardown_server
         else
-          env[:ui].info "[landrush] dns server already stopped"
+          info "there are #{DependentVMs.count} VMs left, leaving DNS server and static entries"
         end
       end
 
-      def teardown_machine_dns(env)
-        hostname = Util.hostname(env[:machine])
-        env[:ui].info "[landrush] removing machine entry: #{hostname}"
+      def teardown_machine_dns
+        hostname = Util.hostname(@env[:machine])
+        info "removing machine entry: #{hostname}"
         Store.hosts.delete(hostname)
       end
 
-      def teardown_static_dns(env)
-        env[:global_config].landrush.hosts.each do |hostname, _|
-          env[:ui].info "[landrush] removing static entry: #{hostname}"
+      def teardown_static_dns
+        @env[:global_config].landrush.hosts.each do |hostname, _|
+          info "removing static entry: #{hostname}"
           Store.hosts.delete 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/debian/install_iptables.rb

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

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

@@ -0,0 +1,11 @@
+module Landrush
+  module Cap
+    module Debian
+      module IptablesInstalled
+        def self.iptables_installed(machine)
+          machine.communicate.test('dpkg -s iptables')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Landrush
+  module Cap
+    module Linux
+      module AddIptablesRule
+        def self.add_iptables_rule(machine, rule)
+          _run(machine, %Q(iptables -C #{rule} 2> /dev/null || iptables -A #{rule}))
+        end
+
+        def self._run(machine, command)
+          machine.communicate.sudo(command) do |data, type|
+            if [:stderr, :stdout].include?(type)
+              color = (type == :stdout) ? :green : :red
+              machine.env.ui.info(data.chomp, :color => color, :prefix => false)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,17 @@
+module Landrush
+  module Cap
+    module Linux
+      module ConfiguredDnsServer
+        def self.configured_dns_server(machine)
+          return @dns_server if @dns_server
+          machine.communicate.sudo('cat /etc/resolv.conf | grep ^nameserver') do |type, data|
+            if type == :stdout
+              @dns_server = data.scan(/\d+\.\d+\.\d+\.\d+/).first
+            end
+          end
+          @dns_server
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Landrush
+  module Cap
+    module Linux
+      module RedirectDns
+        def self.redirect_dns(machine, target={})
+          %w[tcp udp].each do |proto|
+            machine.guest.capability(
+              :add_iptables_rule,
+              _redirect_dns_rule(proto, _current(machine), target.fetch(:host), target.fetch(:port))
+            )
+          end
+        end
+
+        def self._current(machine)
+          machine.guest.capability(:configured_dns_server)
+        end
+
+        def self._redirect_dns_rule(protocol, original_server, target_server, target_port)
+          "OUTPUT -t nat -p #{protocol} -d #{original_server} --dport 53 -j DNAT --to-destination #{target_server}:#{target_port}"
+        end
+      end
+    end
+  end
+end
+

data/lib/landrush/config.rb

@@ -28,5 +28,17 @@ module Landrush
         result.hosts = @hosts.merge(other.hosts)
       end
     end
+
+    def validate(machine)
+      if @enabled
+        unless Util.hostname(machine).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
   end
 end

data/lib/landrush/plugin.rb

@@ -14,9 +14,32 @@ module Landrush
 
     action_hook 'landrush_setup', :machine_action_up do |hook|
       require_relative 'action/setup'
+      require_relative 'action/install_prerequisites'
       require_relative 'action/redirect_dns'
-      hook.before(VagrantPlugins::ProviderVirtualBox::Action::Boot, Action::Setup)
-      hook.after(VagrantPlugins::ProviderVirtualBox::Action::Boot, Action::RedirectDns)
+
+      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)
+
+      if defined?(HashiCorp::VagrantVMwarefusion)
+        register_boot_hooks.call(HashiCorp::VagrantVMwarefusion::Action::Boot)
+      end
+    end
+
+    def self.pre_boot_actions
+      Vagrant::Action::Builder.new.tap do |b|
+        b.use Action::Setup
+      end
+    end
+
+    def self.post_boot_actions
+      Vagrant::Action::Builder.new.tap do |b|
+        b.use Action::InstallPrerequisites
+        b.use Action::RedirectDns
+      end
     end
 
     action_hook 'landrush_teardown', :machine_action_halt do |hook|
@@ -28,5 +51,30 @@ module Landrush
       require_relative 'action/teardown'
       hook.after(Vagrant::Action::Builtin::GracefulHalt, Action::Teardown)
     end
+
+    guest_capability('debian', 'iptables_installed') do
+      require_relative 'cap/debian/iptables_installed'
+      Cap::Debian::IptablesInstalled
+    end
+
+    guest_capability('debian', 'install_iptables') do
+      require_relative 'cap/debian/install_iptables'
+      Cap::Debian::InstallIptables
+    end
+
+    guest_capability('linux', 'configured_dns_server') do
+      require_relative 'cap/linux/configured_dns_server'
+      Cap::Linux::ConfiguredDnsServer
+    end
+
+    guest_capability('linux', 'redirect_dns') do
+      require_relative 'cap/linux/redirect_dns'
+      Cap::Linux::RedirectDns
+    end
+
+    guest_capability('linux', 'add_iptables_rule') do
+      require_relative 'cap/linux/add_iptables_rule'
+      Cap::Linux::AddIptablesRule
+    end
   end
 end

data/lib/landrush/version.rb

@@ -1,3 +1,3 @@
 module Landrush
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/test/landrush/action/teardown_test.rb

@@ -51,9 +51,8 @@ module Landrush
         app = Proc.new {}
         teardown = Teardown.new(app, nil)
         env = fake_environment_with_machine('somehost.vagrant.dev', '1.2.3.4')
-
-        other_env = fake_environment_with_machine('otherhost.vagrant.dev', '1.2.3.4')
-        DependentVMs.add(other_env[:machine])
+        other_machine = fake_machine('otherhost.vagrant.dev', '2.3.4.5')
+        DependentVMs.add(other_machine)
 
         Server.start
         teardown.call(env)
@@ -61,6 +60,20 @@ module Landrush
         Server.running?.must_equal true
       end
 
+      it "leaves static entries when other dependent vms exist" do
+        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)
+
+        fake_static_entry(env, 'static.vagrant.dev', '3.4.5.6')
+
+        teardown.call(env)
+
+        Store.hosts.get('static.vagrant.dev').must_equal '3.4.5.6'
+      end
+
       it "leaves the server alone if it's not running" do
         app = Proc.new {}
         teardown = Teardown.new(app, nil)

data/test/test_helper.rb

@@ -13,13 +13,17 @@ def fake_environment(extras={})
 end
 
 def fake_environment_with_machine(hostname, ip)
+  env = Vagrant::Environment.new
+  machine = fake_machine(hostname, ip, env)
+  { 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)
     end
   end 
 
-  env = Vagrant::Environment.new
-
   machine = Vagrant::Machine.new(
     'fake_machine',
     'fake_provider',
@@ -33,11 +37,15 @@ def fake_environment_with_machine(hostname, ip)
   )
 
   machine.config.landrush.enable
-
   machine.config.vm.hostname = hostname
   machine.config.vm.network :private_network, ip: ip
 
-  { machine: machine, ui: FakeUI, global_config: env.config_global }
+  machine
+end
+
+def fake_static_entry(env, hostname, ip)
+  env[:global_config].landrush.host(hostname, ip)
+  Landrush::Store.hosts.set(hostname, ip)
 end
 
 class MiniTest::Spec

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: landrush
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-24 00:00:00.000000000 Z
+date: 2013-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubydns
@@ -91,9 +91,15 @@ files:
 - landrush.gemspec
 - lib/ext/rexec.rb
 - lib/landrush.rb
+- lib/landrush/action/install_prerequisites.rb
 - lib/landrush/action/redirect_dns.rb
 - lib/landrush/action/setup.rb
 - lib/landrush/action/teardown.rb
+- lib/landrush/cap/debian/install_iptables.rb
+- 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/redirect_dns.rb
 - lib/landrush/command.rb
 - lib/landrush/config.rb
 - lib/landrush/dependent_vms.rb