vagrant-fixed-ssh 1.0.7

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

@@ -0,0 +1,21 @@
+module Vagrant
+  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
+          @options = options || {}
+        end
+
+        def call(env)
+          # Merge the options that were given to us
+          env.merge!(@options)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/environment.rb

@@ -0,0 +1,12 @@
+require 'vagrant/util/hash_with_indifferent_access'
+
+module Vagrant
+  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
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Vagrant
+  module Action
+    module General
+      # Checks that virtualbox is installed and ready to be used.
+      class CheckVirtualbox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # Certain actions may not actually have a VM, and thus no
+          # driver, so we have to be clever about obtaining an instance
+          # of the driver.
+          driver = nil
+          driver = env[:vm].driver if env[:vm]
+          driver = Driver::VirtualBox.new(nil) if !driver
+
+          # Verify that it is ready to go! This will raise an exception
+          # if anything goes wrong.
+          driver.verify!
+
+          # Carry on.
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'fileutils'
+require 'archive/tar/minitar'
+
+module Vagrant
+  module 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["package.files"]  ||= {}
+          env["package.output"] ||= env["global_config"].package.name
+        end
+
+        def call(env)
+          @env = env
+
+          raise Errors::PackageOutputDirectory if File.directory?(tar_path)
+          raise Errors::PackageOutputExists if File.exist?(tar_path)
+          raise Errors::PackageRequiresDirectory if !env["package.directory"] ||
+            !File.directory?(env["package.directory"])
+
+          compress
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          # There are certain exceptions that we don't delete the file for.
+          ignore_exc = [Errors::PackageOutputDirectory, Errors::PackageOutputExists]
+          ignore_exc.each do |exc|
+            return if env["vagrant.error"].is_a?(exc)
+          end
+
+          # Cleanup any packaged files if the packaging failed at some point.
+          File.delete(tar_path) if File.exist?(tar_path)
+        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
+          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.
+            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.expand_path(@env["package.output"], FileUtils.pwd)
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,53 @@
+module Vagrant
+  module 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].driver.start(@env[:vm].config.vm.boot_mode)
+        end
+
+        def wait_for_boot
+          @env[:ui].info I18n.t("vagrant.actions.vm.boot.waiting")
+
+          @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]
+
+            # If the VM is not starting or running, something went wrong
+            # and we need to show a useful error.
+            state = @env[:vm].state
+            raise Errors::VMFailedToRun if state != :starting && state != :running
+
+            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
+  module Action
+    module VM
+      class CheckAccessible
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          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
+            # 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,33 @@
+module Vagrant
+  module Action
+    module VM
+      class CheckBox
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          box_name = env[:vm].config.vm.box
+          raise Errors::BoxNotSpecified if !box_name
+
+          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)
+            env[:box_collection].add(box_name, box_url)
+            env[:box_collection].reload!
+
+            # 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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Vagrant
+  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
+      # 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].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, 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 => vb_version))
+            end
+          end
+
+          # Continue
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require "vagrant/util/is_port_open"
+
+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
+        include Util::IsPortOpen
+
+        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) || is_port_open?("127.0.0.1", 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