rvagrant 0.8.7.dev

data/lib/vagrant/action/environment.rb

@@ -0,0 +1,50 @@
+module Vagrant
+  class Action
+    # Represents an action environment which is what is passed
+    # to the `call` method of each action. This environment contains
+    # some helper methods for accessing the environment as well
+    # as being a hash, to store any additional options.
+    class Environment < Util::HashWithIndifferentAccess
+      # The {Vagrant::Environment} object represented by this
+      # action environment.
+      attr_reader :env
+
+      def initialize(env)
+        super() do |h,k|
+          # By default, try to find the key as a method on the
+          # environment. Gross eval use here.
+          begin
+            value = eval("h.env.#{k}")
+            h[k] = value
+          rescue Exception
+            nil
+          end
+        end
+
+        @env = env
+        @interrupted = false
+      end
+
+      # Returns a UI object from the environment
+      def ui
+        env.ui
+      end
+
+      # Marks an environment as interrupted (by an outside signal or
+      # anything). This will trigger any middleware sequences using this
+      # environment to halt. This is automatically set by {Action} when
+      # a SIGINT is captured.
+      def interrupt!
+        @interrupted = true
+      end
+
+      # Returns a boolean denoting if environment has been interrupted
+      # with a SIGINT.
+      #
+      # @return [Bool]
+      def interrupted?
+        !!@interrupted
+      end
+    end
+  end
+end

data/lib/vagrant/action/general.rb

@@ -0,0 +1,8 @@
+module Vagrant
+  class Action
+    module General
+      autoload :Package,  'vagrant/action/general/package'
+      autoload :Validate, 'vagrant/action/general/validate'
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+require 'fileutils'
+require 'archive/tar/minitar'
+
+module Vagrant
+  class Action
+    module General
+      # A general packaging (tar) middleware. Given the following options,
+      # it will do the right thing:
+      #
+      #   * package.output - The filename of the outputted package.
+      #   * package.include - An array of files to include in the package.
+      #   * package.directory - The directory which contains the contents to
+      #       compress into the package.
+      #
+      # This middleware always produces the final file in the current working
+      # directory (FileUtils.pwd)
+      class Package
+        include Util
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @env["package.output"] ||= env["config"].package.name
+          @env["package.include"] ||= []
+          @env["package.vagrantfile"] ||= nil
+        end
+
+        def call(env)
+          @env = env
+
+          raise Errors::PackageOutputExists if File.exist?(tar_path)
+          raise Errors::PackageRequiresDirectory if !@env["package.directory"] || !File.directory?(@env["package.directory"])
+
+          verify_files_to_copy
+          compress
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          # Don't delete the tar_path if the error is that the output already
+          # exists, since this will nuke the user's previous file.
+          if !env["vagrant.error"].is_a?(Errors::PackageOutputExists)
+						# Cleanup any packaged files if the packaging failed at some point.
+						File.delete(tar_path) if File.exist?(tar_path)
+					end
+        end
+
+        def files_to_copy
+          package_dir = Pathname.new(@env["package.directory"]).join("include")
+
+          files = @env["package.include"].inject({}) do |acc, file|
+            source = Pathname.new(file)
+            acc[file] = source.relative? ? package_dir.join(source) : package_dir.join(source.basename)
+            acc
+          end
+
+          files[@env["package.vagrantfile"]] = package_dir.join("_Vagrantfile") if @env["package.vagrantfile"]
+          files
+        end
+
+        def verify_files_to_copy
+          files_to_copy.each do |file, _|
+            raise Errors::PackageIncludeMissing, :file => file if !File.exist?(file)
+          end
+        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
+          files_to_copy.each do |from, to|
+            @env.ui.info I18n.t("vagrant.actions.general.package.packaging", :file => from)
+            FileUtils.mkdir_p(to.parent)
+
+            # Copy direcotry contents recursively.
+            if File.directory?(from)
+              FileUtils.cp_r(Dir.glob(from), to.parent)
+            else
+              FileUtils.cp(from, to)
+            end
+          end
+        end
+
+        # Compress the exported file into a package
+        def compress
+          @env.ui.info I18n.t("vagrant.actions.general.package.compressing", :tar_path => 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
+
+                FileUtils.cd(@env["package.directory"])
+                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/general/validate.rb

@@ -0,0 +1,19 @@
+module Vagrant
+  class Action
+    module General
+      # Simply validates the configuration of the current Vagrant
+      # environment.
+      class Validate
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env["config"].validate! if !@env.has_key?("validate") || @env["validate"]
+          @app.call(@env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/vm.rb

@@ -0,0 +1,34 @@
+module Vagrant
+  class Action
+    module VM
+      autoload :Boot,                'vagrant/action/vm/boot'
+      autoload :CheckAccessible,     'vagrant/action/vm/check_accessible'
+      autoload :CheckBox,            'vagrant/action/vm/check_box'
+      autoload :CheckGuestAdditions, 'vagrant/action/vm/check_guest_additions'
+      autoload :CleanMachineFolder,  'vagrant/action/vm/clean_machine_folder'
+      autoload :ClearForwardedPorts, 'vagrant/action/vm/clear_forwarded_ports'
+      autoload :ClearNFSExports,     'vagrant/action/vm/clear_nfs_exports'
+      autoload :ClearSharedFolders,  'vagrant/action/vm/clear_shared_folders'
+      autoload :Customize,           'vagrant/action/vm/customize'
+      autoload :Destroy,             'vagrant/action/vm/destroy'
+      autoload :DestroyUnusedNetworkInterfaces, 'vagrant/action/vm/destroy_unused_network_interfaces'
+      autoload :DiscardState,        'vagrant/action/vm/discard_state'
+      autoload :Export,              'vagrant/action/vm/export'
+      autoload :ForwardPorts,        'vagrant/action/vm/forward_ports'
+      autoload :Halt,                'vagrant/action/vm/halt'
+      autoload :HostName,            'vagrant/action/vm/host_name'
+      autoload :Import,              'vagrant/action/vm/import'
+      autoload :MatchMACAddress,     'vagrant/action/vm/match_mac_address'
+      autoload :Modify,              'vagrant/action/vm/modify'
+      autoload :Network,             'vagrant/action/vm/network'
+      autoload :NFS,                 'vagrant/action/vm/nfs'
+      autoload :Package,             'vagrant/action/vm/package'
+      autoload :PackageVagrantfile,  'vagrant/action/vm/package_vagrantfile'
+      autoload :Provision,           'vagrant/action/vm/provision'
+      autoload :ProvisionerCleanup,  'vagrant/action/vm/provisioner_cleanup'
+      autoload :Resume,              'vagrant/action/vm/resume'
+      autoload :ShareFolders,        'vagrant/action/vm/share_folders'
+      autoload :Suspend,             'vagrant/action/vm/suspend'
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Vagrant
+  class Action
+    module VM
+      class Boot
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env = env
+
+          # Start up the VM and wait for it to boot.
+          boot
+          raise Errors::VMFailedToBoot if !wait_for_boot
+
+          @app.call(env)
+        end
+
+        def boot
+          @env.ui.info I18n.t("vagrant.actions.vm.boot.booting")
+          @env["vm"].vm.start(@env.env.config.vm.boot_mode)
+        end
+
+        def wait_for_boot
+          @env.ui.info I18n.t("vagrant.actions.vm.boot.waiting")
+
+          @env["config"].ssh.max_tries.to_i.times do |i|
+            if @env["vm"].ssh.up?
+              @env.ui.info I18n.t("vagrant.actions.vm.boot.ready")
+              return true
+            end
+
+            # Return true so that the vm_failed_to_boot error doesn't
+            # get shown
+            return true if @env.interrupted?
+
+            sleep 2 if !@env["vagrant.test"]
+          end
+
+          @env.ui.error I18n.t("vagrant.actions.vm.boot.failed")
+          false
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,23 @@
+module Vagrant
+  class Action
+    module VM
+      class CheckAccessible
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env["vm"] && env["vm"].created? && !env["vm"].vm.accessible?
+            # The VM we are attempting to manipulate is inaccessible. This
+            # is a very bad situation and can only be fixed by the user. It
+            # also prohibits us from actually doing anything with the virtual
+            # machine, so we raise an error.
+            raise Errors::VMInaccessible
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Vagrant
+  class Action
+    module VM
+      class CheckBox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          box_name = env["config"].vm.box
+          raise Errors::BoxNotSpecified if !box_name
+
+          if !env.env.boxes.find(box_name)
+            box_url = env["config"].vm.box_url
+            raise Errors::BoxSpecifiedDoesntExist, :name => box_name if !box_url
+
+            env.ui.info I18n.t("vagrant.actions.vm.check_box.not_found", :name => box_name)
+            Vagrant::Box.add(env.env, box_name, box_url)
+            env["boxes"].reload!
+            env.env.reload_config!
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Vagrant
+  class Action
+    module VM
+      # Middleware which verifies that the VM has the proper guest additions
+      # installed and prints a warning if they're not detected or if the
+      # version does not match the installed VirtualBox version.
+      class CheckGuestAdditions
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Use the raw interface for now, while the virtualbox gem
+          # doesn't support guest properties (due to cross platform issues)
+          version = env["vm"].vm.interface.get_guest_property_value("/VirtualBox/GuestAdd/Version")
+          if version.empty?
+            env.ui.warn I18n.t("vagrant.actions.vm.check_guest_additions.not_detected")
+          else
+            # Strip the -OSE/_OSE off from the guest additions
+            version = version.gsub(/[-_]ose/i, '')
+
+            if version != VirtualBox.version
+              env.ui.warn(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
+                                 :guest_version => version,
+                                 :virtualbox_version => VirtualBox.version))
+            end
+          end
+
+          # Continue
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'fileutils'
+
+module Vagrant
+  class Action
+    module VM
+      # Cleans up the VirtualBox machine folder for any ".xml-prev"
+      # files which VirtualBox may have left over. This is a bug in
+      # VirtualBox. As soon as this is fixed, this middleware can and
+      # will be removed.
+      class CleanMachineFolder
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          clean_machine_folder
+          @app.call(env)
+        end
+
+        def clean_machine_folder
+          folder = File.join(VirtualBox::Global.global.system_properties.default_machine_folder, "*")
+
+          # Small safeguard against potentially unwanted rm-rf, since the default
+          # machine folder will typically always be greater than 10 characters long.
+          # For users with it < 10, out of luck?
+          return if folder.length < 10
+
+          Dir[folder].each do |f|
+            next unless File.directory?(f)
+
+            keep = Dir["#{f}/**/*"].find do |d|
+              # Find a file that doesn't have ".xml-prev" as the suffix,
+              # which signals that we want to keep this folder
+              File.file?(d) && !(File.basename(d) =~ /\.vbox-prev$/)
+            end
+
+            FileUtils.rm_rf(f) if !keep
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Vagrant
+  class Action
+    module VM
+      class ClearForwardedPorts
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          proc = lambda do |vm|
+            env.ui.info I18n.t("vagrant.actions.vm.clear_forward_ports.deleting")
+
+            vm.network_adapters.each do |na|
+              na.nat_driver.forwarded_ports.dup.each do |fp|
+                fp.destroy
+              end
+            end
+          end
+
+          env["vm.modify"].call(proc)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require File.expand_path("../nfs_helpers", __FILE__)
+
+module Vagrant
+  class Action
+    module VM
+      class ClearNFSExports
+        include NFSHelpers
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          clear_nfs_exports(env)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end