vagrant-veertu 0.0.12

data/lib/vagrant-veertu/action/network_fix_ipv6.rb

@@ -0,0 +1,81 @@
+require "ipaddr"
+require "socket"
+
+require "log4r"
+
+require "vagrant/util/presence"
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      # This middleware works around a bug in VirtualBox where booting
+      # a VM with an IPv6 host-only network will someties lose the
+      # route to that machine.
+      class NetworkFixIPv6
+        include Vagrant::Util::Presence
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::plugins::veertu::network")
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          # Determine if we have an IPv6 network
+          has_v6 = false
+          env[:machine].config.vm.networks.each do |type, options|
+            next if type != :private_network
+            options = scoped_hash_override(options, :veertu)
+            next if options[:ip].to_s.strip == ""
+
+            if IPAddr.new(options[:ip]).ipv6?
+              has_v6 = true
+              break
+            end
+          end
+
+          # Call up
+          @app.call(env)
+
+          # If we have no IPv6, forget it
+          return if !has_v6
+
+          host_only_interfaces(env).each do |interface|
+            next if !present?(interface[:ipv6])
+            next if interface[:status] != "Up"
+
+            ip = IPAddr.new(interface[:ipv6])
+            ip |= ("1" * (128 - interface[:ipv6_prefix].to_i)).to_i(2)
+
+            @logger.info("testing IPv6: #{ip}")
+
+            begin
+              UDPSocket.new(Socket::AF_INET6).connect(ip.to_s, 80)
+            rescue Errno::EHOSTUNREACH
+              @logger.info("IPv6 host unreachable. Fixing: #{ip}")
+              env[:machine].provider.driver.reconfig_host_only(interface)
+            end
+          end
+        end
+
+        # The list of interface names for host-only adapters.
+        # @return [Array<String>]
+        def host_only_interface_names(env)
+          env[:machine].provider.driver.read_network_interfaces
+            .map { |_, i| i[:hostonly] if i[:type] == :hostonly }.compact
+        end
+
+        # The list of host_only_interfaces that are tied to a host-only adapter.
+        # @return [Array]
+        def host_only_interfaces(env)
+          iface_names = self.host_only_interface_names(env)
+          env[:machine].provider.driver.read_host_only_interfaces
+            .select { |interface| iface_names.include?(interface[:name]) }
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/package.rb

@@ -0,0 +1,44 @@
+require 'fileutils'
+
+require 'vagrant/action/general/package'
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class Package < Vagrant::Action::General::Package
+        # Doing this so that we can test that the parent is properly
+        # called in the unit tests.
+        alias_method :general_call, :call
+        def call(env)
+          # Setup the temporary directory
+          @temp_dir = env[:tmp_path].join(Time.now.to_i.to_s)
+          env["export.temp_dir"] = @temp_dir
+          FileUtils.mkpath(env["export.temp_dir"])
+
+          # Just match up a couple environmental variables so that
+          # the superclass will do the right thing. Then, call the
+          # superclass
+          env["package.directory"] = env["export.temp_dir"]
+
+          general_call(env)
+
+          # Always call recover to clean up the temp dir
+          clean_temp_dir
+        end
+
+        def recover(env)
+          clean_temp_dir
+          super
+        end
+
+        protected
+
+        def clean_temp_dir
+          if @temp_dir && File.exist?(@temp_dir)
+            FileUtils.rm_rf(@temp_dir)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/package_vagrantfile.rb

@@ -0,0 +1,33 @@
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class PackageVagrantfile
+        # For TemplateRenderer
+        include Vagrant::Util
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env = env
+          create_vagrantfile
+          @app.call(env)
+        end
+
+        # This method creates the auto-generated Vagrantfile at the root of the
+        # box. This Vagrantfile contains the MAC address so that the user doesn't
+        # have to worry about it.
+        def create_vagrantfile
+          File.open(File.join(@env["export.temp_dir"], "Vagrantfile"), "w") do |f|
+            f.write(TemplateRenderer.render("package_Vagrantfile", {
+              base_mac: @env[:machine].provider.driver.read_mac_address
+            }))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,35 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Get the forwarded ports used by other virtual machines and
+          # consider those in use as well.
+          env[:port_collision_extra_in_use] = env[:machine].provider.driver.read_used_ports
+
+          # Build the remap for any existing collision detections
+          remap = {}
+          env[:port_collision_remap] = remap
+          env[:machine].provider.driver.read_forwarded_ports.each do |_nic, name, hostport, _guestport|
+            env[:machine].config.vm.networks.each do |type, options|
+              next if type != :forwarded_port
+
+              # If the ID matches the name of the forwarded port, then
+              # remap.
+              if options[:id] == name
+                remap[options[:host]] = hostport
+                break
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/prepare_nfs_settings.rb

@@ -0,0 +1,119 @@
+require "vagrant/action/builtin/mixin_synced_folders"
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class PrepareNFSSettings
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @machine = env[:machine]
+
+          @app.call(env)
+
+          opts = {
+            cached: !!env[:synced_folders_cached],
+            config: env[:synced_folders_config],
+            disable_usable_check: !!env[:test],
+          }
+          folders = synced_folders(env[:machine], **opts)
+
+          if folders.key?(:nfs)
+            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
+            add_ips_to_env!(env)
+          end
+        end
+
+        # Extracts the proper host and guest IPs for NFS mounts and stores them
+        # in the environment for the SyncedFolder action to use them in
+        # mounting.
+        #
+        # The ! indicates that this method modifies its argument.
+        def add_ips_to_env!(env)
+          adapter, host_ip = find_host_only_adapter
+          machine_ip       = read_static_machine_ips || read_dynamic_machine_ip(adapter)
+
+          raise Vagrant::Errors::NFSNoHostonlyNetwork if !host_ip || !machine_ip
+
+          env[:nfs_host_ip]    = host_ip
+          env[:nfs_machine_ip] = machine_ip
+        end
+
+        # Finds first host only network adapter and returns its adapter number
+        # and IP address
+        #
+        # @return [Integer, String] adapter number, ip address of found host-only adapter
+        def find_host_only_adapter
+          @machine.provider.driver.read_network_interfaces.each do |adapter, opts|
+            if opts[:type] == :hostonly
+              @machine.provider.driver.read_host_only_interfaces.each do |interface|
+                if interface[:name] == opts[:hostonly]
+                  return adapter, interface[:ip]
+                end
+              end
+            end
+          end
+
+          nil
+        end
+
+        # Returns the IP address(es) of the guest by looking for static IPs
+        # given to host only adapters in the Vagrantfile
+        #
+        # @return [Array]<String> Configured static IPs
+        def read_static_machine_ips
+          ips = []
+          @machine.config.vm.networks.each do |type, options|
+            if type == :private_network && options[:type] != :dhcp && options[:ip].is_a?(String)
+              ips << options[:ip]
+            end
+          end
+
+          if ips.empty?
+            return nil
+          end
+
+          ips
+        end
+
+        # Returns the IP address of the guest by looking at vbox guest property
+        # for the appropriate guest adapter.
+        #
+        # For DHCP interfaces, the guest property will not be present until the
+        # guest completes
+        #
+        # @param [Integer] adapter number to read IP for
+        # @return [String] ip address of adapter
+        def read_dynamic_machine_ip(adapter)
+          return nil unless adapter
+
+          # vbox guest properties are 0-indexed, while showvminfo network
+          # interfaces are 1-indexed. go figure.
+          guestproperty_adapter = adapter - 1
+
+          # we need to wait for the guest's IP to show up as a guest property.
+          # retry thresholds are relatively high since we might need to wait
+          # for DHCP, but even static IPs can take a second or two to appear.
+          retryable(retry_options.merge(on: Vagrant::Errors::VirtualBoxGuestPropertyNotFound)) do
+            @machine.provider.driver.read_guest_ip(guestproperty_adapter)
+          end
+        rescue Vagrant::Errors::VirtualBoxGuestPropertyNotFound
+          # this error is more specific with a better error message directing
+          # the user towards the fact that it's probably a reportable bug
+          raise Vagrant::Errors::NFSNoGuestIP
+        end
+
+        # Separating these out so we can stub out the sleep in tests
+        def retry_options
+          {tries: 15, sleep: 1}
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/prepare_nfs_valid_ids.rb

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class PrepareNFSValidIds
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          env[:nfs_valid_ids] = env[:machine].provider.driver.read_vms.values
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/resume.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].state.id
+
+          if current_state == :paused or current_state == :stopped
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:machine].provider.driver.resume
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-veertu/action/sane_defaults.rb

@@ -0,0 +1,89 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVeertu
+    module Action
+      class SaneDefaults
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::sanedefaults")
+          @app = app
+        end
+
+        def call(env)
+          # Set the env on an instance variable so we can access it in
+          # helpers.
+          @env = env
+
+          # Use rtcuseutc so that the VM sees UTC time.
+          #command = ["modifyvm", env[:machine].id, "--rtcuseutc", "on"]
+          #attempt_and_log(command, "Enabling rtcuseutc...")
+
+          if env[:machine].provider_config.auto_nat_dns_proxy
+            @logger.info("Automatically figuring out whether to enable/disable NAT DNS proxy...")
+
+            # Enable/disable the NAT DNS proxy as necessary
+            #if enable_dns_proxy?
+            #  #command = ["modifyvm", env[:machine].id, "--natdnsproxy1", "on"]
+            #  #attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
+            #else
+            #  command = ["modifyvm", env[:machine].id, "--natdnsproxy1", "off" ]
+            #  attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
+            #  command = ["modifyvm", env[:machine].id, "--natdnshostresolver1", "off" ]
+            #  attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
+            #end
+          else
+            @logger.info("NOT trying to automatically manage NAT DNS proxy.")
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        # This is just a helper method that executes a single command, logs
+        # the given string to the log, and also includes the exit status in
+        # the log message.
+        #
+        # We assume every command is idempotent and pass along the `retryable`
+        # flag. This is because VeertuManage is janky about running simultaneously
+        # on the same box, and if we up multiple boxes at the same time, a bunch
+        # of modifyvm commands get fired
+        #
+        # @param [Array] command Command to run
+        # @param [String] log Log message to write.
+        def attempt_and_log(command, log)
+          begin
+            @env[:machine].provider.driver.execute_command(
+              command + [retryable: true])
+          rescue Vagrant::Errors::VBoxManageError => e
+            @logger.info("#{log} (error = #{e.inspect})")
+          end
+        end
+
+        # This uses some heuristics to determine if the NAT DNS proxy should
+        # be enabled or disabled. See the comments within the function body
+        # itself to see the checks it does.
+        #
+        # @return [Boolean]
+        def enable_dns_proxy?
+          begin
+            contents = File.read("/etc/resolv.conf")
+
+            if contents =~ /^nameserver 127\.0\.(0|1)\.1$/
+              # The use of both natdnsproxy and natdnshostresolver break on
+              # Ubuntu 12.04 and 12.10 that uses resolvconf with localhost. When used
+              # VirtualBox will give the client dns server 10.0.2.3, while
+              # not binding to that address itself. Therefore disable this
+              # feature if host uses the resolvconf server 127.0.0.1 or
+              # 127.0.1.1
+              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1 or 127.0.1.1")
+              return false
+            end
+          rescue Errno::ENOENT; end
+
+          return true
+        end
+      end
+    end
+  end
+end