rvagrant 0.8.7.dev

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

@@ -0,0 +1,37 @@
+module Vagrant
+  class Action
+    module VM
+      # This class allows other actions on the virtual machine object
+      # to be consolidated under a single write lock. This vastly speeds
+      # up modification of virtual machines. This should be used whereever
+      # possible when dealing with virtual machine modifications.
+      class Modify
+        include Util::StackedProcRunner
+
+        def initialize(app, env)
+          @app = app
+
+          # Initialize the proc_stack, which should already be empty
+          # but just making sure here.
+          proc_stack.clear
+
+          # Create the lambda in the environment which is to be called
+          # to add new procs to the modification sequence.
+          env["vm.modify"] = lambda do |*procs|
+            procs.each { |p| push_proc(&p) }
+          end
+        end
+
+        def call(env)
+          # Run the procs we have saved up, save the machine, and reload
+          # to verify we get the new settings
+          run_procs!(env["vm"].vm)
+          env["vm"].vm.save
+          env["vm"].reload!
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+module Vagrant
+  class Action
+    module VM
+      # Networking middleware for Vagrant. This enables host only
+      # networking on VMs if configured as such.
+      class Network
+        def initialize(app, env)
+          @app = app
+          @env = env
+
+          if enable_network? && Util::Platform.windows? && Util::Platform.bit64?
+            raise Errors::NetworkNotImplemented
+          end
+
+          env["config"].vm.network_options.compact.each do |network_options|
+            raise Errors::NetworkCollision if !verify_no_bridge_collision(network_options)
+          end
+        end
+
+        def call(env)
+          @env = env
+          assign_network if enable_network?
+
+          @app.call(env)
+
+          if enable_network?
+            @env.ui.info I18n.t("vagrant.actions.vm.network.enabling")
+
+            # Prepare for new networks...
+            options = @env.env.config.vm.network_options.compact
+            options.each do |network_options|
+              @env["vm"].system.prepare_host_only_network(network_options)
+            end
+
+            # Then enable the networks...
+            options.each do |network_options|
+              @env["vm"].system.enable_host_only_network(network_options)
+            end
+          end
+        end
+
+        # Verifies that there is no collision with a bridged network interface
+        # for the given network options.
+        def verify_no_bridge_collision(net_options)
+          interfaces = VirtualBox::Global.global.host.network_interfaces
+          interfaces.each do |ni|
+            next if ni.interface_type == :host_only
+
+            result = if net_options[:name]
+              true if net_options[:name] == ni.name
+            else
+              true if matching_network?(ni, net_options)
+            end
+
+            return false if result
+          end
+
+          true
+        end
+
+        def enable_network?
+          !@env.env.config.vm.network_options.compact.empty?
+        end
+
+        # Enables and assigns the host only network to the proper
+        # adapter on the VM, and saves the adapter.
+        def assign_network
+          @env.ui.info I18n.t("vagrant.actions.vm.network.preparing")
+
+          @env.env.config.vm.network_options.compact.each do |network_options|
+            adapter = @env["vm"].vm.network_adapters[network_options[:adapter]]
+            adapter.enabled = true
+            adapter.attachment_type = :host_only
+            adapter.host_only_interface = network_name(network_options)
+            adapter.mac_address = network_options[:mac].gsub(':', '') if network_options[:mac]
+            adapter.save
+          end
+        end
+
+        # Returns the name of the proper host only network, or creates
+        # it if it does not exist. Vagrant determines if the host only
+        # network exists by comparing the netmask and the IP.
+        def network_name(net_options)
+          # First try to find a matching network
+          interfaces = VirtualBox::Global.global.host.network_interfaces
+          interfaces.each do |ni|
+            # Ignore non-host only interfaces which may also match,
+            # since they're not valid options.
+            next if ni.interface_type != :host_only
+
+            if net_options[:name]
+              return ni.name if net_options[:name] == ni.name
+            else
+              return ni.name if matching_network?(ni, net_options)
+            end
+          end
+
+          raise Errors::NetworkNotFound, :name => net_options[:name] if net_options[:name]
+
+          # One doesn't exist, create it.
+          @env.ui.info I18n.t("vagrant.actions.vm.network.creating")
+
+          ni = interfaces.create
+          ni.enable_static(network_ip(net_options[:ip], net_options[:netmask]),
+                           net_options[:netmask])
+          ni.name
+        end
+
+        # Tests if a network matches the given options by applying the
+        # netmask to the IP of the network and also to the IP of the
+        # virtual machine and see if they match.
+        def matching_network?(interface, net_options)
+          interface.network_mask == net_options[:netmask] &&
+            apply_netmask(interface.ip_address, interface.network_mask) ==
+            apply_netmask(net_options[:ip], net_options[:netmask])
+        end
+
+        # Applies a netmask to an IP and returns the corresponding
+        # parts.
+        def apply_netmask(ip, netmask)
+          ip = split_ip(ip)
+          netmask = split_ip(netmask)
+
+          ip.map do |part|
+            part & netmask.shift
+          end
+        end
+
+        # Splits an IP and converts each portion into an int.
+        def split_ip(ip)
+          ip.split(".").map do |i|
+            i.to_i
+          end
+        end
+
+        # Returns a "network IP" which is a "good choice" for the IP
+        # for the actual network based on the netmask.
+        def network_ip(ip, netmask)
+          parts = apply_netmask(ip, netmask)
+          parts[3] += 1;
+          parts.join(".")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+require File.expand_path("../nfs_helpers", __FILE__)
+
+module Vagrant
+  class 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
+        include NFSHelpers
+
+        def initialize(app,env)
+          @app = app
+          @env = env
+
+          verify_settings if nfs_enabled?
+        end
+
+        def call(env)
+          @env = env
+
+          extract_folders
+
+          if !folders.empty?
+            prepare_folders
+            clear_nfs_exports(env)
+            export_folders
+          end
+
+          @app.call(env)
+
+          mount_folders if !folders.empty?
+        end
+
+        def recover(env)
+          clear_nfs_exports(env) if env["vm"].created?
+        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["config"].vm.shared_folders.inject({}) do |acc, data|
+            key, opts = data
+
+            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.
+              acc[key] = opts.dup
+              acc[key][:hostpath] = File.expand_path(opts[:hostpath], @env.env.root_path)
+              opts[:disabled] = true
+            end
+
+            acc
+          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[:nfs] = {} if !opts.is_a?(Hash)
+            opts[:map_uid] = prepare_permission(:uid, opts)
+            opts[:map_gid] = prepare_permission(:gid, opts)
+
+            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["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(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
+          am_folders = folders.select { |name, folder| folder[:guestpath] }
+          am_folders = Hash[*am_folders.flatten] if am_folders.is_a?(Array)
+          @env["vm"].system.mount_nfs(host_ip, Hash[am_folders])
+        end
+
+        # Returns the IP address of the first host only network adapter
+        #
+        # @return [String]
+        def host_ip
+          interface = @env["vm"].vm.network_adapters.find do |adapter|
+            adapter.host_interface_object
+          end
+
+          return nil if !interface
+          interface.host_interface_object.ip_address
+        end
+
+        # Returns the IP address of the guest by looking at the first
+        # enabled host only network.
+        #
+        # @return [String]
+        def guest_ip
+          @env["config"].vm.network_options[1][:ip]
+        end
+
+        # Checks if there are any NFS enabled shared folders.
+        def nfs_enabled?
+          @env["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 @env["config"].vm.network_options.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Vagrant
+  class Action
+    module VM
+      module NFSHelpers
+        def clear_nfs_exports(env)
+          env["host"].nfs_cleanup if env["host"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'vagrant/action/general/package'
+
+module Vagrant
+  class 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,33 @@
+module Vagrant
+  class Action
+    module VM
+      # Puts a generated Vagrantfile into the package directory so that
+      # it can be included in the package.
+      class PackageVagrantfile
+        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"].vm.network_adapters.first.mac_address
+            }))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Vagrant
+  class Action
+    module VM
+      class Provision
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @env["provision.enabled"] = true if !@env.has_key?("provision.enabled")
+        end
+
+        def call(env)
+          # 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)
+
+          # 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
+
+        def enabled_provisioners
+          @env["config"].vm.provisioners.map do |provisioner|
+            provisioner.provisioner.new(@env, provisioner.config)
+          end
+        end
+      end
+    end
+  end
+end