tnargav 1.3.5 → 1.3.6

data/plugins/providers/virtualbox/action/package.rb

@@ -0,0 +1,20 @@
+require 'vagrant/action/general/package'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    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)
+          # 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)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/package_vagrantfile.rb

@@ -0,0 +1,33 @@
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    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/plugins/providers/virtualbox/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,35 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    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/plugins/providers/virtualbox/action/prepare_nfs_settings.rb

@@ -0,0 +1,69 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PrepareNFSSettings
+        def initialize(app,env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          using_nfs = false
+          env[:machine].config.vm.synced_folders.each do |id, opts|
+            if opts[:nfs]
+              using_nfs = true
+              break
+            end
+          end
+
+          if using_nfs
+            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
+            env[:nfs_host_ip]    = read_host_ip(env[:machine])
+            env[:nfs_machine_ip] = read_machine_ip(env[:machine])
+
+            raise Vagrant::Errors::NFSNoHostonlyNetwork if !env[:nfs_machine_ip]
+          end
+        end
+
+        # Returns the IP address of the first host only network adapter
+        #
+        # @param [Machine] machine
+        # @return [String]
+        def read_host_ip(machine)
+          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 interface[:ip]
+                end
+              end
+            end
+          end
+
+          nil
+        end
+
+        # Returns the IP address of the guest by looking at the first
+        # enabled host only network.
+        #
+        # @return [String]
+        def read_machine_ip(machine)
+          ips = []
+          machine.config.vm.networks.each do |type, options|
+            if type == :private_network && options[:ip].is_a?(String)
+              ips << options[:ip]
+            end
+          end
+
+          if ips.empty?
+            return nil
+          end
+
+          ips
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/prune_nfs_exports.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class PruneNFSExports
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:host]
+            vms = env[:machine].provider.driver.read_vms
+            env[:host].nfs_prune(vms.values)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/resume.rb

@@ -0,0 +1,25 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          current_state = env[:machine].provider.state.id
+
+          if current_state == :paused
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.unpausing")
+            env[:machine].provider.driver.resume
+          elsif current_state == :saved
+            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
+            env[:action_runner].run(Boot, env)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/sane_defaults.rb

@@ -0,0 +1,91 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    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
+
+          # Enable the host IO cache on the sata controller. Note that
+          # if this fails then its not a big deal, so we don't raise any
+          # errors. The Host IO cache vastly improves disk IO performance
+          # for VMs.
+          command = [
+            "storagectl", env[:machine].id,
+            "--name", "SATA Controller",
+            "--hostiocache", "on"
+          ]
+          attempt_and_log(command, "Enabling the Host I/O cache on the SATA controller...")
+
+          # 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.
+        #
+        # @param [Array] command Command to run
+        # @param [String] log Log message to write.
+        def attempt_and_log(command, log)
+          result = @env[:machine].provider.driver.execute_command(command)
+          @logger.info("#{log} (exit status = #{result.exit_code})")
+        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

data/plugins/providers/virtualbox/action/set_name.rb

@@ -0,0 +1,52 @@
+require "log4r"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class SetName
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::setname")
+          @app = app
+        end
+
+        def call(env)
+          name = env[:machine].provider_config.name
+
+          # If we already set the name before, then don't do anything
+          sentinel = env[:machine].data_dir.join("action_set_name")
+          if !name && sentinel.file?
+            @logger.info("Default name was already set before, not doing it again.")
+            return @app.call(env)
+          end
+
+          # If no name was manually set, then use a default
+          if !name
+            prefix = "#{env[:root_path].basename.to_s}_#{env[:machine].name}"
+            prefix.gsub!(/[^-a-z0-9_]/i, "")
+            name = prefix + "_#{Time.now.to_i}"
+          end
+
+          # Verify the name is not taken
+          vms = env[:machine].provider.driver.read_vms
+          raise Vagrant::Errors::VMNameExists, :name => name if \
+            vms.has_key?(name) && vms[name] != env[:machine].id
+
+          if vms.has_key?(name)
+            @logger.info("Not setting the name because our name is already set.")
+          else
+            @logger.info("Setting the name of the VM: #{name}")
+            env[:ui].info(I18n.t("vagrant.actions.vm.set_name.setting_name"))
+            env[:machine].provider.driver.set_name(name)
+          end
+
+          # Create the sentinel
+          sentinel.open("w") do |f|
+            f.write(Time.now.to_i.to_s)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/setup_package_files.rb

@@ -0,0 +1,51 @@
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class SetupPackageFiles
+        def initialize(app, env)
+          @app = app
+
+          env["package.include"] ||= []
+          env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          files = {}
+          env["package.include"].each do |file|
+            source = Pathname.new(file)
+            dest   = nil
+
+            # If the source is relative then we add the file as-is to the include
+            # directory. Otherwise, we copy only the file into the root of the
+            # include directory. Kind of strange, but seems to match what people
+            # expect based on history.
+            if source.relative?
+              dest = source
+            else
+              dest = source.basename
+            end
+
+            # Assign the mapping
+            files[file] = dest
+          end
+
+          if env["package.vagrantfile"]
+            # Vagrantfiles are treated special and mapped to a specific file
+            files[env["package.vagrantfile"]] = "_Vagrantfile"
+          end
+
+          # Verify the mapping
+          files.each do |from, _|
+            raise Vagrant::Errors::PackageIncludeMissing,
+              :file => from if !File.exist?(from)
+          end
+
+          # Save the mapping
+          env["package.files"] = files
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/plugins/providers/virtualbox/action/share_folders.rb

@@ -0,0 +1,128 @@
+require "pathname"
+
+require "log4r"
+
+require "vagrant/util/platform"
+require "vagrant/util/scoped_hash_override"
+
+module VagrantPlugins
+  module ProviderVirtualBox
+    module Action
+      class ShareFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
+          @app    = app
+        end
+
+        def call(env)
+          @env = env
+
+          prepare_folders
+          create_metadata
+
+          @app.call(env)
+
+          mount_shared_folders
+        end
+
+        # This method returns an actual list of VirtualBox shared
+        # folders to create and their proper path.
+        def shared_folders
+          {}.tap do |result|
+            @env[:machine].config.vm.synced_folders.each do |id, data|
+              data = scoped_hash_override(data, :virtualbox)
+
+              # Ignore NFS shared folders
+              next if data[:nfs]
+
+              # Ignore disabled shared folders
+              next if data[:disabled]
+
+              # This to prevent overwriting the actual shared folders data
+              result[id] = data.dup
+            end
+          end
+        end
+
+        # Prepares the shared folders by verifying they exist and creating them
+        # if they don't.
+        def prepare_folders
+          shared_folders.each do |id, options|
+            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
+
+            if !hostpath.directory? && options[:create]
+              # Host path doesn't exist, so let's create it.
+              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+              begin
+                hostpath.mkpath
+              rescue Errno::EACCES
+                raise Vagrant::Errors::SharedFolderCreateFailed,
+                  :path => hostpath.to_s
+              end
+            end
+          end
+        end
+
+        def create_metadata
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
+
+          folders = []
+          shared_folders.each do |id, data|
+            hostpath = File.expand_path(data[:hostpath], @env[:root_path])
+            hostpath = Vagrant::Util::Platform.cygwin_windows_path(hostpath)
+
+            folders << {
+              :name => id,
+              :hostpath => hostpath,
+              :transient => data[:transient]
+            }
+          end
+
+          @env[:machine].provider.driver.share_folders(folders)
+        end
+
+        def mount_shared_folders
+          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
+
+          # short guestpaths first, so we don't step on ourselves
+          folders = shared_folders.sort_by do |id, data|
+            if data[:guestpath]
+              data[:guestpath].length
+            else
+              # A long enough path to just do this at the end.
+              10000
+            end
+          end
+
+          # Go through each folder and mount
+          folders.each do |id, data|
+            if data[:guestpath]
+              # Guest path specified, so mount the folder to specified point
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
+                                    :guest_path => data[:guestpath]))
+
+              # Dup the data so we can pass it to the guest API
+              data = data.dup
+
+              # Calculate the owner and group
+              ssh_info = @env[:machine].ssh_info
+              data[:owner] ||= ssh_info[:username]
+              data[:group] ||= ssh_info[:username]
+
+              # Mount the actual folder
+              @env[:machine].guest.capability(
+                :mount_virtualbox_shared_folder, id, data[:guestpath], data)
+            else
+              # If no guest path is specified, then automounting is disabled
+              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
+                                    :host_path => data[:hostpath]))
+            end
+          end
+        end
+      end
+    end
+  end
+end