vagrant 0.8.10 → 0.9.0

data/lib/vagrant/action/env/set.rb

@@ -1,15 +1,18 @@
 module Vagrant
-  class Action
+  module Action
     module Env
       # A middleware which just sets up the environment with some
       # options which are passed to it.
       class Set
-        def initialize(app,env,options=nil)
-          @app = app
-          env.merge!(options || {})
+        def initialize(app, env, options=nil)
+          @app     = app
+          @options = options || {}
         end
 
         def call(env)
+          # Merge the options that were given to us
+          env.merge!(@options)
+
           @app.call(env)
         end
       end

data/lib/vagrant/action/environment.rb

@@ -1,50 +1,12 @@
+require 'vagrant/util/hash_with_indifferent_access'
+
 module Vagrant
-  class Action
+  module 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/package.rb

@@ -2,7 +2,7 @@ require 'fileutils'
 require 'archive/tar/minitar'
 
 module Vagrant
-  class Action
+  module Action
     module General
       # A general packaging (tar) middleware. Given the following options,
       # it will do the right thing:
@@ -19,19 +19,18 @@ module Vagrant
 
         def initialize(app, env)
           @app = app
-          @env = env
-          @env["package.output"] ||= env["config"].package.name
-          @env["package.include"] ||= []
-          @env["package.vagrantfile"] ||= nil
+
+          env["package.files"]  ||= {}
+          env["package.output"] ||= env["global_config"].package.name
         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"])
+          raise Errors::PackageRequiresDirectory if !env["package.directory"] ||
+            !File.directory?(env["package.directory"])
 
-          verify_files_to_copy
           compress
 
           @app.call(env)
@@ -46,31 +45,17 @@ module Vagrant
 					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)
+          include_directory = Pathname.new(@env["package.directory"]).join("include")
+
+          @env["package.files"].each do |from, dest|
+            # We place the file in the include directory
+            to = include_directory.join(dest)
+
+            @env[:ui].info I18n.t("vagrant.actions.general.package.packaging", :file => from)
             FileUtils.mkdir_p(to.parent)
 
             # Copy direcotry contents recursively.
@@ -84,7 +69,7 @@ module Vagrant
 
         # Compress the exported file into a package
         def compress
-          @env.ui.info I18n.t("vagrant.actions.general.package.compressing", :tar_path => tar_path)
+          @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

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module General
       # Simply validates the configuration of the current Vagrant
       # environment.
@@ -10,7 +10,7 @@ module Vagrant
         end
 
         def call(env)
-          @env["config"].validate! if !@env.has_key?("validate") || @env["validate"]
+          @env[:vm].config.validate!(@env[:vm].env) if !@env.has_key?("validate") || @env["validate"]
           @app.call(@env)
         end
       end

data/lib/vagrant/action/runner.rb

@@ -0,0 +1,53 @@
+require 'log4r'
+
+require 'vagrant/util/busy'
+
+# TODO:
+# * env.lock
+
+module Vagrant
+  module Action
+    class Runner
+      @@reported_interrupt = false
+
+      def initialize(registry, globals=nil, &block)
+        @registry     = registry
+        @globals      = globals || {}
+        @lazy_globals = block
+        @logger       = Log4r::Logger.new("vagrant::action::runner")
+      end
+
+      def run(callable_id, options=nil)
+        callable = callable_id
+        callable = Builder.new.use(callable_id) if callable_id.kind_of?(Class)
+        callable = @registry.get(callable_id) if callable_id.kind_of?(Symbol)
+        raise ArgumentError, "Argument to run must be a callable object or registered action." if !callable || !callable.respond_to?(:call)
+
+        # Create the initial environment with the options given
+        environment = Environment.new
+        environment.merge!(@globals)
+        environment.merge!(@lazy_globals.call) if @lazy_globals
+        environment.merge!(options || {})
+
+        # Run the action chain in a busy block, marking the environment as
+        # interrupted if a SIGINT occurs, and exiting cleanly once the
+        # chain has been run.
+        ui = environment[:ui] if environment.has_key?(:ui)
+        int_callback = lambda do
+          if environment[:interrupted]
+            ui.error I18n.t("vagrant.actions.runner.exit_immediately") if ui
+            abort
+          end
+
+          ui.warn I18n.t("vagrant.actions.runner.waiting_cleanup") if ui && !@@reported_interrupt
+          environment[:interrupted] = true
+          @@reported_interrupt = true
+        end
+
+        # We place a process lock around every action that is called
+        @logger.info("Running action: #{callable_id}")
+        Util::Busy.busy(int_callback) { callable.call(environment) }
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class Boot
         def initialize(app, env)
@@ -18,27 +18,27 @@ module Vagrant
         end
 
         def boot
-          @env.ui.info I18n.t("vagrant.actions.vm.boot.booting")
-          @env["vm"].vm.start(@env.env.config.vm.boot_mode)
+          @env[:ui].info I18n.t("vagrant.actions.vm.boot.booting")
+          @env[:vm].driver.start(@env[:vm].config.vm.boot_mode)
         end
 
         def wait_for_boot
-          @env.ui.info I18n.t("vagrant.actions.vm.boot.waiting")
+          @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")
+          @env[:vm].config.ssh.max_tries.to_i.times do |i|
+            if @env[:vm].channel.ready?
+              @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?
+            return true if @env[:interrupted]
 
             sleep 2 if !@env["vagrant.test"]
           end
 
-          @env.ui.error I18n.t("vagrant.actions.vm.boot.failed")
+          @env[:ui].error I18n.t("vagrant.actions.vm.boot.failed")
           false
         end
       end

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class CheckAccessible
         def initialize(app, env)
@@ -7,7 +7,7 @@ module Vagrant
         end
 
         def call(env)
-          if env["vm"] && env["vm"].created? && !env["vm"].vm.accessible?
+          if env[:vm].state == :inaccessible
             # 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

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module Action
     module VM
       class CheckBox
         def initialize(app, env)
@@ -7,24 +7,22 @@ module Vagrant
         end
 
         def call(env)
-          box_name = env["config"].vm.box
+          box_name = env[:vm].config.vm.box
           raise Errors::BoxNotSpecified if !box_name
 
-          if !env.env.boxes.find(box_name)
-            box_url = env["config"].vm.box_url
+          if !env[:box_collection].find(box_name)
+            box_url = env[:vm].config.vm.box_url
             raise Errors::BoxSpecifiedDoesntExist, :name => box_name if !box_url
 
             # Add the box then reload the box collection so that it becomes
             # aware of it.
-            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[:ui].info I18n.t("vagrant.actions.vm.check_box.not_found", :name => box_name)
+            env[:box_collection].add(box_name, box_url)
+            env[:box_collection].reload!
 
-            # Reload the configuration for all our VMs, since this box
-            # may be used for other VMs.
-            env.env.vms.each do |name, vm|
-              vm.env.reload_config!
-            end
+            # Reload the environment and set the VM to be the new loaded VM.
+            env[:vm].env.reload!
+            env[:vm] = env[:vm].env.vms[env[:vm].name]
           end
 
           @app.call(env)

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

@@ -1,5 +1,5 @@
 module Vagrant
-  class Action
+  module 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
@@ -12,20 +12,20 @@ module Vagrant
         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")
+          version = env[:vm].driver.read_guest_additions_version
+          if !version
+            env[:ui].warn I18n.t("vagrant.actions.vm.check_guest_additions.not_detected")
           else
             # Strip the -OSE/_OSE off from the guest additions and the virtual box
             # version since all the matters are that the version _numbers_ match up.
-            guest_version, vb_version = [version, VirtualBox.version].map do |v|
+            guest_version, vb_version = [version, env[:vm].driver.version].map do |v|
               v.gsub(/[-_]ose/i, '')
             end
 
             if guest_version != vb_version
-              env.ui.warn(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
-                                 :guest_version => version,
-                                 :virtualbox_version => VirtualBox.version))
+              env[:ui].warn(I18n.t("vagrant.actions.vm.check_guest_additions.version_mismatch",
+                                   :guest_version => version,
+                                   :virtualbox_version => vb_version))
             end
           end
 

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

@@ -0,0 +1,85 @@
+module Vagrant
+  module Action
+    module VM
+      # Action that checks to make sure there are no forwarded port collisions,
+      # and raises an exception if there is.
+      class CheckPortCollisions
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # For the handlers...
+          @env = env
+
+          # Figure out how we handle port collisions. By default we error.
+          handler  = env[:port_collision_handler] || :error
+
+          # Read our forwarded ports, if we have any, to override what
+          # we have configured.
+          current = {}
+          env[:vm].driver.read_forwarded_ports.each do |nic, name, hostport, guestport|
+            current[name] = hostport.to_i
+          end
+
+          existing = env[:vm].driver.read_used_ports
+          env[:vm].config.vm.forwarded_ports.each do |options|
+            # Use the proper port, whether that be the configured port or the
+            # port that is currently on use of the VM.
+            hostport = options[:hostport].to_i
+            hostport = current[options[:name]] if current.has_key?(options[:name])
+
+            if existing.include?(hostport)
+              # We have a collision! Handle it
+              send("handle_#{handler}".to_sym, options, existing)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        # Handles a port collision by raising an exception.
+        def handle_error(options, existing_ports)
+          raise Errors::ForwardPortCollisionResume
+        end
+
+        # Handles a port collision by attempting to fix it.
+        def handle_correct(options, existing_ports)
+          # We need to keep this for messaging purposes
+          original_hostport = options[:hostport]
+
+          if !options[:auto]
+            # Auto fixing is disabled for this port forward, so we
+            # must throw an error so the user can fix it.
+            raise Errors::ForwardPortCollision, :host_port => options[:hostport].to_s,
+                                                :guest_port => options[:guestport].to_s
+          end
+
+          # Get the auto port range and get rid of the used ports and
+          # ports which are being used in other forwards so we're just
+          # left with available ports.
+          range = @env[:vm].config.vm.auto_port_range.to_a
+          range -= @env[:vm].config.vm.forwarded_ports.collect { |opts| opts[:hostport].to_i }
+          range -= existing_ports
+
+          if range.empty?
+            raise Errors::ForwardPortAutolistEmpty, :vm_name => @env[:vm].name,
+                                                    :host_port => options[:hostport].to_s,
+                                                    :guest_port => options[:guestport].to_s
+          end
+
+          # Set the port up to be the first one and add that port to
+          # the used list.
+          options[:hostport] = range.shift
+          existing_ports << options[:hostport]
+
+          # Notify the user
+          @env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
+                                :host_port => original_hostport.to_s,
+                                :guest_port => options[:guestport].to_s,
+                                :new_port => options[:hostport]))
+        end
+      end
+    end
+  end
+end