vagrant-fixed-ssh 1.0.7

data/lib/vagrant/action.rb

@@ -0,0 +1,63 @@
+require 'vagrant/action/builder'
+
+module Vagrant
+  module Action
+    autoload :Builtin,     'vagrant/action/builtin'
+    autoload :Environment, 'vagrant/action/environment'
+    autoload :Runner,      'vagrant/action/runner'
+    autoload :Warden,      'vagrant/action/warden'
+
+    module Box
+      autoload :Destroy,   'vagrant/action/box/destroy'
+      autoload :Download,  'vagrant/action/box/download'
+      autoload :Package,   'vagrant/action/box/package'
+      autoload :Unpackage, 'vagrant/action/box/unpackage'
+      autoload :Verify,    'vagrant/action/box/verify'
+    end
+
+    module Env
+      autoload :Set, 'vagrant/action/env/set'
+    end
+
+    module General
+      autoload :CheckVirtualbox, 'vagrant/action/general/check_virtualbox'
+      autoload :Package,  'vagrant/action/general/package'
+      autoload :Validate, 'vagrant/action/general/validate'
+    end
+
+    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 :CheckPortCollisions, 'vagrant/action/vm/check_port_collisions'
+      autoload :CleanMachineFolder,  'vagrant/action/vm/clean_machine_folder'
+      autoload :ClearForwardedPorts, 'vagrant/action/vm/clear_forwarded_ports'
+      autoload :ClearNetworkInterfaces, 'vagrant/action/vm/clear_network_interfaces'
+      autoload :ClearSharedFolders,  'vagrant/action/vm/clear_shared_folders'
+      autoload :Customize,           'vagrant/action/vm/customize'
+      autoload :DefaultName,         'vagrant/action/vm/default_name'
+      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 :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 :PruneNFSExports,     'vagrant/action/vm/prune_nfs_exports'
+      autoload :Resume,              'vagrant/action/vm/resume'
+      autoload :SaneDefaults,        'vagrant/action/vm/sane_defaults'
+      autoload :ShareFolders,        'vagrant/action/vm/share_folders'
+      autoload :SetupPackageFiles,   'vagrant/action/vm/setup_package_files'
+      autoload :Suspend,             'vagrant/action/vm/suspend'
+    end
+  end
+end

data/lib/vagrant/action/box/destroy.rb

@@ -0,0 +1,25 @@
+require 'fileutils'
+
+module Vagrant
+  module Action
+    module Box
+      class Destroy
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          # Delete the existing box
+          env[:ui].info I18n.t("vagrant.actions.box.destroy.destroying", :name => env[:box_name])
+          FileUtils.rm_rf(env[:box_directory])
+
+          # Reload the box collection
+          env[:box_collection].reload!
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/box/download.rb

@@ -0,0 +1,84 @@
+module Vagrant
+  module Action
+    module Box
+      class Download
+        BASENAME = "box"
+
+        include Util
+
+        attr_reader :temp_path
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @env["download.classes"] ||= []
+          @env["download.classes"] += [Downloaders::HTTP, Downloaders::File]
+          @downloader = nil
+        end
+
+        def call(env)
+          @env = env
+
+          download if instantiate_downloader
+          @app.call(@env)
+
+          recover(env) # called in both cases to cleanup workspace
+        end
+
+        def instantiate_downloader
+          # Assign to a temporary variable since this is easier to type out,
+          # since it is used so many times.
+          classes = @env["download.classes"]
+
+          # Find the class to use.
+          classes.each_index do |i|
+            klass = classes[i]
+
+            # Use the class if it matches the given URI or if this
+            # is the last class...
+            if classes.length == (i + 1) || klass.match?(@env["box_url"])
+              @env[:ui].info I18n.t("vagrant.actions.box.download.with", :class => klass.to_s)
+              @downloader = klass.new(@env[:ui])
+              break
+            end
+          end
+
+          # This line should never be reached, but we'll keep this here
+          # just in case for now.
+          raise Errors::BoxDownloadUnknownType if !@downloader
+
+          @downloader.prepare(@env["box_url"])
+          true
+        end
+
+        def download
+          with_tempfile do |tempfile|
+            download_to(tempfile)
+            @temp_path = @env["download.temp_path"] = tempfile.path
+          end
+        end
+
+        def recover(env)
+          if temp_path && File.exist?(temp_path)
+            env[:ui].info I18n.t("vagrant.actions.box.download.cleaning")
+            File.unlink(temp_path)
+          end
+        end
+
+        def with_tempfile
+          File.open(box_temp_path, Platform.tar_file_options) do |tempfile|
+            yield tempfile
+          end
+        end
+
+        def box_temp_path
+          @env[:tmp_path].join(BASENAME + Time.now.to_i.to_s)
+        end
+
+        def download_to(f)
+          @downloader.download!(@env["box_url"], f)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'vagrant/action/general/package'
+
+module Vagrant
+  module Action
+    module Box
+      # Packages a box which has already been unpackaged (such as
+      # for the `vagrant box repackage` command) by leveraging the
+      # general packager middleware.
+      class Package < General::Package
+        # Alias instead of calling super for testability
+        alias_method :general_call, :call
+        def call(env)
+          env["package.directory"] = env["box_directory"]
+          general_call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/box/unpackage.rb

@@ -0,0 +1,61 @@
+require 'fileutils'
+require 'archive/tar/minitar'
+
+module Vagrant
+  module Action
+    module Box
+      # Unpackages a downloaded box to a given directory with a given
+      # name.
+      #
+      # # Required Variables
+      #
+      # * `download.temp_path` - A location for the downloaded box. This is
+      #   set by the {Download} action.
+      # * `box` - A {Vagrant::Box} object.
+      #
+      class Unpackage
+        attr_reader :box_directory
+
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env = env
+
+          setup_box_directory
+          decompress
+
+          @app.call(@env)
+        end
+
+        def recover(env)
+          if box_directory && File.directory?(box_directory)
+            FileUtils.rm_rf(box_directory)
+          end
+        end
+
+        def setup_box_directory
+          if File.directory?(@env["box_directory"])
+            raise Errors::BoxAlreadyExists, :name => @env["box_name"]
+          end
+
+          FileUtils.mkdir_p(@env["box_directory"])
+          @box_directory = @env["box_directory"]
+        end
+
+        def decompress
+          Dir.chdir(@env["box_directory"]) do
+            @env[:ui].info I18n.t("vagrant.actions.box.unpackage.extracting")
+            begin
+              Archive::Tar::Minitar.unpack(@env["download.temp_path"], @env["box_directory"].to_s)
+            rescue SystemCallError
+              raise Errors::BoxUnpackageFailure
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/box/verify.rb

@@ -0,0 +1,23 @@
+module Vagrant
+  module Action
+    module Box
+      class Verify
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          @env[:ui].info I18n.t("vagrant.actions.box.verify.verifying")
+
+          driver = Driver::VirtualBox.new(nil)
+          if !driver.verify_image(env["box_directory"].join("box.ovf").to_s)
+            raise Errors::BoxVerificationFailed
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builder.rb

@@ -0,0 +1,128 @@
+module Vagrant
+  module Action
+    # Action builder which provides a nice DSL for building up
+    # a middleware sequence for Vagrant actions. This code is based
+    # heavily off of `Rack::Builder` and `ActionDispatch::MiddlewareStack`
+    # in Rack and Rails, respectively.
+    #
+    # Usage
+    #
+    # Building an action sequence is very easy:
+    #
+    #     app = Vagrant::Action::Builder.new do
+    #       use MiddlewareA
+    #       use MiddlewareB
+    #     end
+    #
+    #     Vagrant::Action.run(app)
+    #
+    class Builder
+      # Initializes the builder. An optional block can be passed which
+      # will be evaluated in the context of the instance.
+      def initialize(&block)
+        instance_eval(&block) if block_given?
+      end
+
+      # Returns a mergeable version of the builder. If `use` is called with
+      # the return value of this method, then the stack will merge, instead
+      # of being treated as a separate single middleware.
+      def flatten
+        lambda do |env|
+          self.call(env)
+        end
+      end
+
+      # Adds a middleware class to the middleware stack. Any additional
+      # args and a block, if given, are saved and passed to the initializer
+      # of the middleware.
+      #
+      # @param [Class] middleware The middleware class
+      def use(middleware, *args, &block)
+        # Prepend with a environment setter if args are given
+        if !args.empty? && args.first.is_a?(Hash) && middleware != Env::Set
+          self.use(Env::Set, args.shift, &block)
+        end
+
+        if middleware.kind_of?(Builder)
+          # Merge in the other builder's stack into our own
+          self.stack.concat(middleware.stack)
+        else
+          self.stack << [middleware, args, block]
+        end
+
+        self
+      end
+
+      # Inserts a middleware at the given index or directly before the
+      # given middleware object.
+      def insert(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        stack.insert(index, [middleware, args, block])
+      end
+
+      alias_method :insert_before, :insert
+
+      # Inserts a middleware after the given index or middleware object.
+      def insert_after(index, middleware, *args, &block)
+        index = self.index(index) unless index.is_a?(Integer)
+        raise "no such middleware to insert after: #{index.inspect}" unless index
+        insert(index + 1, middleware, *args, &block)
+      end
+
+      # Replaces the given middlware object or index with the new
+      # middleware.
+      def replace(index, middleware, *args, &block)
+        if index.is_a?(Integer)
+          delete(index)
+          insert(index, middleware, *args, &block)
+        else
+          insert_before(index, middleware, *args, &block)
+          delete(index)
+        end
+      end
+
+      # Deletes the given middleware object or index
+      def delete(index)
+        index = self.index(index) unless index.is_a?(Integer)
+        stack.delete_at(index)
+      end
+
+      # Runs the builder stack with the given environment.
+      def call(env)
+        to_app(env).call(env)
+      end
+
+      protected
+
+      # Returns the numeric index for the given middleware object.
+      #
+      # @param [Object] object The item to find the index for
+      # @return [Integer]
+      def index(object)
+        stack.each_with_index do |item, i|
+          return i if item[0] == object
+        end
+
+        nil
+      end
+
+      # Returns the current stack of middlewares. You probably won't
+      # need to use this directly, and it's recommended that you don't.
+      #
+      # @return [Array]
+      def stack
+        @stack ||= []
+      end
+
+      # Converts the builder stack to a runnable action sequence.
+      #
+      # @param [Vagrant::Action::Environment] env The action environment
+      # @return [Object] A callable object
+      def to_app(env)
+        # Wrap the middleware stack with the Warden to provide a consistent
+        # and predictable behavior upon exceptions.
+        Warden.new(stack.dup, env)
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin.rb

@@ -0,0 +1,171 @@
+module Vagrant
+  module Action
+    # A registry object containing the built-in middleware stacks.
+    class Builtin < Registry
+      def initialize
+        # Properly initialize the registry object
+        super
+
+        # Register all the built-in stacks
+        register_builtin!
+      end
+
+      protected
+
+      def register_builtin!
+        # We do this so that the blocks below have a variable to access the
+        # outer registry.
+        registry = self
+
+        # provision - Provisions a running VM
+        register(:provision) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::Provision
+          end
+        end
+
+        # start - Starts a VM, assuming it already exists on the
+        # environment.
+        register(:start) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::CleanMachineFolder
+            use VM::ClearForwardedPorts
+            use VM::CheckPortCollisions, :port_collision_handler => :correct
+            use VM::ForwardPorts
+            use VM::Provision
+            use VM::PruneNFSExports
+            use VM::NFS
+            use VM::ClearSharedFolders
+            use VM::ShareFolders
+            use VM::HostName
+            use VM::ClearNetworkInterfaces
+            use VM::Network
+            use VM::SaneDefaults
+            use VM::Customize
+            use VM::Boot
+            use VM::CheckGuestAdditions
+          end
+        end
+
+        # halt - Halts the VM, attempting gracefully but then forcing
+        # a restart if fails.
+        register(:halt) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::DiscardState
+            use VM::Halt
+          end
+        end
+
+        # suspend - Suspends the VM
+        register(:suspend) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::Suspend
+          end
+        end
+
+        # resume - Resume a VM
+        register(:resume) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::CheckPortCollisions
+            use VM::Resume
+          end
+        end
+
+        # reload - Halts then restarts the VM
+        register(:reload) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use registry.get(:halt)
+            use registry.get(:start)
+          end
+        end
+
+        # up - Imports, prepares, then starts a fresh VM.
+        register(:up) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use VM::CheckBox
+            use VM::Import
+            use VM::DefaultName
+            use VM::MatchMACAddress
+            use registry.get(:start)
+          end
+        end
+
+        # destroy - Halts, cleans up, and destroys an existing VM
+        register(:destroy) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::CheckAccessible
+            use registry.get(:halt), :force => true
+            use VM::ProvisionerCleanup
+            use VM::PruneNFSExports
+            use VM::Destroy
+            use VM::CleanMachineFolder
+            use VM::DestroyUnusedNetworkInterfaces
+          end
+        end
+
+        # package - Export and package the VM
+        register(:package) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use General::Validate
+            use VM::SetupPackageFiles
+            use VM::CheckAccessible
+            use registry.get(:halt)
+            use VM::ClearForwardedPorts
+            use VM::ClearSharedFolders
+            use VM::Export
+            use VM::PackageVagrantfile
+            use VM::Package
+          end
+        end
+
+        # box_add - Download and add a box.
+        register(:box_add) do
+          Builder.new do
+            use General::CheckVirtualbox
+            use Box::Download
+            use Box::Unpackage
+            use Box::Verify
+          end
+        end
+
+        # box_remove - Removes/deletes a box.
+        register(:box_remove) do
+          Builder.new do
+            use Box::Destroy
+          end
+        end
+
+        # box_repackage - Repackages a box.
+        register(:box_repackage) do
+          Builder.new do
+            use Box::Package
+          end
+        end
+      end
+    end
+  end
+end