vagrantup 0.4.3.dev → 0.5.0

data/lib/vagrant/{actions → action}/vm/network.rb

@@ -1,71 +1,43 @@
 module Vagrant
-  module Actions
+  class Action
     module VM
-      class Network < Base
-        def prepare
-          # Verify that the given network options are valid
-          runner.env.config.vm.network_options.compact.each do |network_options|
-            verify_no_bridge_collision(network_options)
-          end
-        end
-
-        def before_destroy
-          # We need to check if the host only network specified by any
-          # of the adapters would not have any more clients if it was
-          # destroyed. And if so, then destroy the host only network
-          # itself.
-          interfaces = runner.vm.network_adapters.collect do |adapter|
-            adapter.host_interface_object
-          end
-
-          interfaces.compact.uniq.each do |interface|
-            # Destroy the network interface if there is only one
-            # attached VM (which must be this VM)
-            if interface.attached_vms.length == 1
-              logger.info "Destroying unused network interface..."
-              interface.destroy
+      # Networking middleware for Vagrant. This enables host only
+      # networking on VMs if configured as such.
+      class Network
+        include ExceptionCatcher
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+
+          env["config"].vm.network_options.compact.each do |network_options|
+            if !verify_no_bridge_collision(network_options)
+              env.error!(:network_collides)
+              return
             end
           end
         end
 
-        def before_boot
+        def call(env)
+          @env = env
           assign_network if enable_network?
-        end
-
-        def after_boot
-          if enable_network?
-            logger.info "Enabling host only network..."
 
-            runner.system.prepare_host_only_network
+          @app.call(env)
 
-            runner.env.config.vm.network_options.compact.each do |network_options|
-              runner.system.enable_host_only_network(network_options)
+          if !env.error? && enable_network?
+            catch_action_exception(env) do
+              @env.logger.info "Enabling host only network..."
+              @env["vm"].system.prepare_host_only_network
+              @env.env.config.vm.network_options.compact.each do |network_options|
+                @env["vm"].system.enable_host_only_network(network_options)
+              end
             end
           end
         end
 
-        def enable_network?
-          !runner.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
-          logger.info "Preparing host only network..."
-
-          runner.env.config.vm.network_options.compact.each do |network_options|
-            adapter = runner.vm.network_adapters[network_options[:adapter]]
-            adapter.enabled = true
-            adapter.attachment_type = :host_only
-            adapter.host_interface = network_name(network_options)
-            adapter.save
-          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)
-          # First try to find a matching network
           interfaces = VirtualBox::Global.global.host.network_interfaces
           interfaces.each do |ni|
             next if ni.interface_type == :host_only
@@ -76,7 +48,27 @@ module Vagrant
               true if matching_network?(ni, net_options)
             end
 
-            raise ActionException.new(:network_collides) if result
+            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.logger.info "Preparing host only network..."
+
+          @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_interface = network_name(network_options)
+            adapter.save
           end
         end
 
@@ -98,10 +90,10 @@ module Vagrant
             end
           end
 
-          raise ActionException.new(:network_not_found, :name => net_options[:name]) if net_options[:name]
+          return @env.error!(:network_not_found, :name => net_options[:name]) if net_options[:name]
 
           # One doesn't exist, create it.
-          logger.info "Creating new host only network for environment..."
+          @env.logger.info "Creating new host only network for environment..."
 
           ni = interfaces.create
           ni.enable_static(network_ip(net_options[:ip], net_options[:netmask]),

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

@@ -0,0 +1,161 @@
+require File.join(File.dirname(__FILE__), 'nfs_helpers')
+
+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 ExceptionCatcher
+        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
+
+          return if env.error?
+
+          @app.call(env)
+
+          mount_folders if !folders.empty? && !env.error?
+          clear_nfs_exports(env) if env.error?
+        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[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.logger.info "Exporting NFS shared folders..."
+
+          catch_action_exception(@env) do
+            @env["host"].nfs_export(guest_ip, folders)
+          end
+        end
+
+        # Uses the system class to mount the NFS folders.
+        def mount_folders
+          @env.logger.info "Mounting NFS shared folders..."
+
+          catch_action_exception(@env) do
+            @env["vm"].system.mount_nfs(host_ip, folders)
+          end
+        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
+          return @env.error!(:nfs_host_required) if @env["host"].nil?
+          return @env.error!(:nfs_not_supported) if !@env["host"].nfs?
+          return @env.error!(:nfs_no_host_network) 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,99 @@
+module Vagrant
+  class Action
+    module VM
+      class Package
+        include Util
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @env["package.output"] ||= env["config"].package.name
+          @env["package.include"] ||= []
+
+          env.error!(:box_file_exists, :output_file => tar_path) if File.exist?(tar_path)
+        end
+
+        def call(env)
+          @env = env
+
+          return env.error!(:package_requires_export) if !@env["export.temp_dir"]
+          return if !verify_included_files
+          compress
+
+          @app.call(env)
+
+          cleanup if env.error?
+        end
+
+        def cleanup
+          # Cleanup any packaged files if the packaging failed at some point.
+          File.delete(tar_path) if File.exist?(tar_path)
+        end
+
+        def verify_included_files
+          @env["package.include"].each do |file|
+            if !File.exist?(file)
+              @env.error!(:package_include_file_doesnt_exist, :filename => file)
+              return false
+            end
+          end
+
+          true
+        end
+
+        # This method copies the include files (passed in via command line)
+        # to the temporary directory so they are included in a sub-folder within
+        # the actual box
+        def copy_include_files
+          if @env["package.include"].length > 0
+            include_dir = File.join(@env["export.temp_dir"], "include")
+            FileUtils.mkdir_p(include_dir)
+
+            @env["package.include"].each do |f|
+              @env.logger.info "Packaging additional file: #{f}"
+              FileUtils.cp(f, include_dir)
+            end
+          end
+        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
+
+        # Compress the exported file into a package
+        def compress
+          @env.logger.info "Packaging VM into #{tar_path}..."
+          File.open(tar_path, Platform.tar_file_options) do |tar|
+            Archive::Tar::Minitar::Output.open(tar) do |output|
+              begin
+                current_dir = FileUtils.pwd
+
+                copy_include_files
+                create_vagrantfile
+
+                FileUtils.cd(@env["export.temp_dir"])
+                Dir.glob(File.join(".", "**", "*")).each do |entry|
+                  Archive::Tar::Minitar.pack_file(entry, output)
+                end
+              ensure
+                FileUtils.cd(current_dir)
+              end
+            end
+          end
+        end
+
+        # Path to the final box output file
+        def tar_path
+          File.join(FileUtils.pwd, @env["package.output"])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Vagrant
+  class Action
+    module VM
+      class Persist
+        def initialize(app, env)
+          @app = app
+
+          # Error the environment if the dotfile is not valid
+          env.error!(:dotfile_error, :env => env.env) if File.exist?(env.env.dotfile_path) &&
+                                                         !File.file?(env.env.dotfile_path)
+        end
+
+        def call(env)
+          env.logger.info "Persisting the VM UUID (#{env["vm"].uuid})"
+          env.env.update_dotfile
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Vagrant
+  class Action
+    module VM
+      class Provision
+        def initialize(app, env)
+          @app = app
+          @env = env
+
+          load_provisioner if provisioning_enabled?
+        end
+
+        def call(env)
+          @app.call(env)
+
+          if !env.error? && provisioning_enabled?
+            @env.logger.info "Beginning provisioning process..."
+            @provisioner.provision!
+          end
+        end
+
+        def provisioning_enabled?
+          !@env["config"].vm.provisioner.nil?
+        end
+
+        def load_provisioner
+          provisioner = @env["config"].vm.provisioner
+
+          if provisioner.is_a?(Class)
+            @provisioner = provisioner.new(@env)
+            return @env.error!(:provisioner_invalid_class) unless @provisioner.is_a?(Provisioners::Base)
+          elsif provisioner.is_a?(Symbol)
+            # We have a few hard coded provisioners for built-ins
+            mapping = {
+              :chef_solo    => Provisioners::ChefSolo,
+              :chef_server  => Provisioners::ChefServer
+            }
+
+            provisioner_klass = mapping[provisioner]
+            return @env.error!(:provisioner_unknown_type, :provisioner => provisioner.to_s) if provisioner_klass.nil?
+            @provisioner = provisioner_klass.new(@env)
+          end
+
+          @env.logger.info "Provisioning enabled with #{@provisioner.class}"
+          @provisioner.prepare
+          @provisioner
+        end
+      end
+    end
+  end
+end