vagrant-fixed-ssh 1.0.7

data/lib/vagrant/action/vm/nfs.rb

@@ -0,0 +1,196 @@
+require 'digest/md5'
+require 'fileutils'
+require 'pathname'
+
+require 'log4r'
+
+module Vagrant
+  module Action
+    module VM
+      # Enables NFS based shared folders. `nfsd` must already be installed
+      # on the host machine, and NFS client must already be installed on
+      # the guest machine.
+      #
+      # This is a two part process:
+      #
+      #   1. Adds an entry to `/etc/exports` on the host machine using
+      #      the host class to export the proper folder to the proper
+      #      machine.
+      #   2. After boot, runs `mount` on the guest to mount the shared
+      #      folder.
+      #
+      class NFS
+        def initialize(app,env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
+          @app = app
+          @env = env
+
+          verify_settings if nfs_enabled?
+        end
+
+        def call(env)
+          @env = env
+
+          extract_folders
+
+          if !folders.empty?
+            prepare_folders
+            export_folders
+          end
+
+          @app.call(env)
+
+          mount_folders if !folders.empty?
+        end
+
+        # Returns the folders which are to be synced via NFS.
+        def folders
+          @folders ||= {}
+        end
+
+        # Removes the NFS enabled shared folders from the configuration,
+        # so they will no longer be mounted by the actual shared folder
+        # task.
+        def extract_folders
+          # Load the NFS enabled shared folders
+          @folders = {}
+          @env[:vm].config.vm.shared_folders.each do |key, opts|
+            if opts[:nfs]
+              # Duplicate the options, set the hostpath, and set disabled on the original
+              # options so the ShareFolders middleware doesn't try to mount it.
+              folder = opts.dup
+              hostpath = Pathname.new(opts[:hostpath]).expand_path(@env[:root_path])
+
+              if !hostpath.directory? && opts[:create]
+                # Host path doesn't exist, so let's create it.
+                @logger.debug("Host path doesn't exist, creating: #{hostpath}")
+
+                begin
+                  FileUtils.mkpath(hostpath)
+                rescue Errno::EACCES
+                  raise Errors::SharedFolderCreateFailed, :path => hostpath.to_s
+                end
+              end
+
+              # Set the hostpath now that it exists.
+              folder[:hostpath] = hostpath.to_s
+
+              # Assign the folder to our instance variable for later use
+              @folders[key] = folder
+
+              # Disable the folder so that regular shared folders don't try to
+              # mount it.
+              opts[:disabled] = true
+            end
+          end
+        end
+
+        # Prepares the settings for the NFS folders, such as setting the
+        # options on the NFS folders.
+        def prepare_folders
+          @folders = @folders.inject({}) do |acc, data|
+            key, opts = data
+            opts[:map_uid] = prepare_permission(:uid, opts)
+            opts[:map_gid] = prepare_permission(:gid, opts)
+            opts[:nfs_version] ||= 3
+
+            # The poor man's UUID. An MD5 hash here is sufficient since
+            # we need a 32 character "uuid" to represent the filesystem
+            # of an export. Hashing the host path is safe because two of
+            # the same host path will hash to the same fsid.
+            opts[:uuid]    = Digest::MD5.hexdigest(opts[:hostpath])
+
+            acc[key] = opts
+            acc
+          end
+        end
+
+        # Prepares the UID/GID settings for a single folder.
+        def prepare_permission(perm, opts)
+          key = "map_#{perm}".to_sym
+          return nil if opts.has_key?(key) && opts[key].nil?
+
+          # The options on the hash get priority, then the default
+          # values
+          value = opts.has_key?(key) ? opts[key] : @env[:vm].config.nfs.send(key)
+          return value if value != :auto
+
+          # Get UID/GID from folder if we've made it this far
+          # (value == :auto)
+          stat = File.stat(opts[:hostpath])
+          return stat.send(perm)
+        end
+
+        # Uses the host class to export the folders via NFS. This typically
+        # involves adding a line to `/etc/exports` for this VM, but it is
+        # up to the host class to define the specific behavior.
+        def export_folders
+          @env[:ui].info I18n.t("vagrant.actions.vm.nfs.exporting")
+          @env[:host].nfs_export(@env[:vm].uuid, guest_ip, folders)
+        end
+
+        # Uses the system class to mount the NFS folders.
+        def mount_folders
+          @env[:ui].info I18n.t("vagrant.actions.vm.nfs.mounting")
+
+          # Only mount the folders which have a guest path specified
+          mount_folders = {}
+          folders.each do |name, opts|
+            if opts[:guestpath]
+              mount_folders[name] = opts.dup
+            end
+          end
+
+          @env[:vm].guest.mount_nfs(host_ip, mount_folders)
+        end
+
+        # Returns the IP address of the first host only network adapter
+        #
+        # @return [String]
+        def host_ip
+          @env[:vm].driver.read_network_interfaces.each do |adapter, opts|
+            if opts[:type] == :hostonly
+              @env[:vm].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 guest_ip
+          @env[:vm].config.vm.networks.each do |type, args|
+            if type == :hostonly && args[0].is_a?(String)
+              return args[0]
+            end
+          end
+
+          nil
+        end
+
+        # Checks if there are any NFS enabled shared folders.
+        def nfs_enabled?
+          @env[:vm].config.vm.shared_folders.each do |key, opts|
+            return true if opts[:nfs]
+          end
+
+          false
+        end
+
+        # Verifies that the host is set and supports NFS.
+        def verify_settings
+          raise Errors::NFSHostRequired if @env[:host].nil?
+          raise Errors::NFSNotSupported if !@env[:host].nfs?
+          raise Errors::NFSNoHostNetwork if !guest_ip
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/package.rb

@@ -0,0 +1,23 @@
+require 'vagrant/action/general/package'
+
+module Vagrant
+  module Action
+    module VM
+      # A subclass of {General::Package} which simply makes sure that
+      # the package directory is set to the directory which the VM
+      # was exported to.
+      class Package < 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/lib/vagrant/action/vm/package_vagrantfile.rb

@@ -0,0 +1,36 @@
+require 'vagrant/util/template_renderer'
+
+module Vagrant
+  module Action
+    module VM
+      # Puts a generated Vagrantfile into the package directory so that
+      # it can be included in the package.
+      class PackageVagrantfile
+        # For TemplateRenderer
+        include Util
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+        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["vm"].driver.read_mac_address
+            }))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/provision.rb

@@ -0,0 +1,61 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module VM
+      class Provision
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant::action::vm::provision")
+          @app = app
+
+          env["provision.enabled"] = true if !env.has_key?("provision.enabled")
+        end
+
+        def call(env)
+          @env = env
+
+          provisioners = nil
+
+          # We set this here so that even if this value is changed in the future,
+          # it stays constant to what we expect here in this moment.
+          enabled = env["provision.enabled"]
+          # Instantiate and prepare the provisioners. Preparation must happen here
+          # so that shared folders and such can properly take effect.
+          provisioners = enabled_provisioners
+          provisioners.map { |p| p.prepare }
+
+          @app.call(env)
+
+          if enabled
+            # Take prepared provisioners and run the provisioning
+            provisioners.each do |instance|
+              @env[:ui].info I18n.t("vagrant.actions.vm.provision.beginning",
+                                    :provisioner => instance.class)
+              instance.provision!
+            end
+          end
+        end
+
+        def enabled_provisioners
+          enabled = []
+          @env[:vm].config.vm.provisioners.each do |provisioner|
+            if @env["provision.types"]
+              # If we've specified types of provisioners to enable, then we
+              # only use those provisioners, and skip any that we haven't
+              # specified.
+              if !@env["provision.types"].include?(provisioner.shortcut.to_s)
+                @logger.debug("Skipping provisioner: #{provisioner.shortcut}")
+                next
+              end
+            end
+
+            enabled << provisioner.provisioner.new(@env, provisioner.config)
+          end
+
+          # Return the enable provisioners
+          enabled
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/provisioner_cleanup.rb

@@ -0,0 +1,26 @@
+module Vagrant
+  module Action
+    module VM
+      class ProvisionerCleanup
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          enabled_provisioners.each do |instance|
+            instance.cleanup
+          end
+
+          @app.call(env)
+        end
+
+        def enabled_provisioners
+          @env[:vm].config.vm.provisioners.map do |provisioner|
+            provisioner.provisioner.new(@env, provisioner.config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/prune_nfs_exports.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Action
+    module VM
+      class PruneNFSExports
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:host]
+            valid_ids = env[:vm].driver.read_vms
+            env[:host].nfs_prune(valid_ids)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm/resume.rb

@@ -0,0 +1,20 @@
+module Vagrant
+  module Action
+    module VM
+      class Resume
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:vm].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/lib/vagrant/action/vm/sane_defaults.rb

@@ -0,0 +1,78 @@
+require "log4r"
+
+module Vagrant
+  module Action
+    module VM
+      # This middleware enforces some sane defaults on the virtualbox
+      # VM which help with performance, stability, and in some cases
+      # behavior.
+      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[:vm].uuid,
+            "--name", "SATA Controller",
+            "--hostiocache", "on"
+          ]
+          attempt_and_log(command, "Enabling the Host I/O cache on the SATA controller...")
+
+          enable_dns_proxy = true
+          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 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
+              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1")
+              enable_dns_proxy = false
+            end
+          rescue Errno::ENOENT; end
+
+          # Enable/disable the NAT DNS proxy as necessary
+          if enable_dns_proxy
+            command = [
+              "modifyvm", env[:vm].uuid,
+              "--natdnsproxy1", "on"
+            ]
+            attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
+          else
+            command = [ "modifyvm", env[:vm].uuid, "--natdnsproxy1", "off" ]
+            attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
+            command = [ "modifyvm", env[:vm].uuid, "--natdnshostresolver1", "off" ]
+            attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
+          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[:vm].driver.execute_command(command)
+          @logger.info("#{log} (exit status = #{result.exit_code})")
+        end
+      end
+    end
+  end
+end