rvagrant 0.8.7.dev

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

@@ -0,0 +1,21 @@
+require 'fileutils'
+
+module Vagrant
+  class Action
+    module Box
+      class Destroy
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          env.ui.info I18n.t("vagrant.actions.box.destroy.destroying", :name => env["box"].name)
+          FileUtils.rm_rf(env["box"].directory)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Vagrant
+  class 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
+          @env["download.classes"].each do |klass|
+            if klass.match?(@env["box"].uri)
+              @env.ui.info I18n.t("vagrant.actions.box.download.with", :class => klass.to_s)
+              @downloader = klass.new(@env)
+            end
+          end
+
+          raise Errors::BoxDownloadUnknownType if !@downloader
+
+          @downloader.prepare(@env["box"].uri)
+          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.env.tmp_path.join(BASENAME + Time.now.to_i.to_s)
+        end
+
+        def download_to(f)
+          @downloader.download!(@env["box"].uri, f)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'vagrant/action/general/package'
+
+module Vagrant
+  class 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,55 @@
+require 'fileutils'
+require 'archive/tar/minitar'
+
+module Vagrant
+  class 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
+          raise Errors::BoxAlreadyExists, :name => @env["box"].name if File.directory?(@env["box"].directory)
+
+          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")
+            Archive::Tar::Minitar.unpack(@env["download.temp_path"], @env["box"].directory.to_s)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Vagrant
+  class Action
+    module Box
+      class Verify
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          begin
+            env.ui.info I18n.t("vagrant.actions.box.verify.verifying")
+            VirtualBox::Appliance.new(env["box"].ovf_file.to_s)
+          rescue Exception
+            raise Errors::BoxVerificationFailed
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builder.rb

@@ -0,0 +1,124 @@
+module Vagrant
+  class 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 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
+
+      # 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)
+        if middleware.kind_of?(Builder)
+          # Prepend with a environment setter if args are given
+          self.use(Env::Set, *args, &block) if !args.empty? && args.first.is_a?(Hash)
+
+          # 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
+
+      # Swaps out the given middlware object or index with the new
+      # middleware.
+      def swap(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
+
+      # 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
+
+      # 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
+
+      # Runs the builder stack with the given environment.
+      def call(env)
+        to_app(env).call(env)
+      end
+    end
+  end
+end

data/lib/vagrant/action/builtin.rb

@@ -0,0 +1,108 @@
+module Vagrant
+  class Action
+    # Registers the builtin actions. These are locked away in a
+    # method so that their definition can be deferred until after
+    # all the necessary Vagrant libraries are loaded. Hopefully
+    # in the future this will no longer be necessary with autoloading.
+    def self.builtin!
+      # provision - Provisions a running VM
+      register(:provision, Builder.new do
+        use VM::Provision
+      end)
+
+      # start - Starts a VM, assuming it already exists on the
+      # environment.
+      register(:start, Builder.new do
+        use VM::CleanMachineFolder
+        use VM::ClearForwardedPorts
+        use VM::ForwardPorts
+        use VM::Provision
+        use VM::NFS
+        use VM::ClearSharedFolders
+        use VM::ShareFolders
+        use VM::HostName
+        use VM::Network
+        use VM::Customize
+        use VM::Modify
+        use VM::Boot
+      end)
+
+      # halt - Halts the VM, attempting gracefully but then forcing
+      # a restart if fails.
+      register(:halt, Builder.new do
+        use VM::DiscardState
+        use VM::Halt
+      end)
+
+      # suspend - Suspends the VM
+      register(:suspend, Builder.new do
+        use VM::Suspend
+      end)
+
+      # resume - Resume a VM
+      register(:resume, Builder.new do
+        use VM::Resume
+      end)
+
+      # reload - Halts then restarts the VM
+      register(:reload, Builder.new do
+        use Action[:halt]
+        use Action[:start]
+      end)
+
+      # up - Imports, prepares, then starts a fresh VM.
+      register(:up, Builder.new do
+        use VM::CheckBox
+        use VM::Import
+        use VM::MatchMACAddress
+        use VM::CheckGuestAdditions
+        use Action[:start]
+      end)
+
+      # destroy - Halts, cleans up, and destroys an existing VM
+      register(:destroy, Builder.new do
+        use Action[:halt], :force => true
+        use VM::ProvisionerCleanup
+        use VM::ClearNFSExports
+        use VM::Destroy
+        use VM::CleanMachineFolder
+        use VM::DestroyUnusedNetworkInterfaces
+      end)
+
+      # package - Export and package the VM
+      register(:package, Builder.new do
+        use Action[:halt]
+        use VM::ClearForwardedPorts
+        use VM::ClearSharedFolders
+        use VM::Modify
+        use VM::Export
+        use VM::PackageVagrantfile
+        use VM::Package
+      end)
+
+      # box_add - Download and add a box.
+      register(:box_add, Builder.new do
+        use Box::Download
+        use Box::Unpackage
+        use Box::Verify
+      end)
+
+      # box_remove - Removes/deletes a box.
+      register(:box_remove, Builder.new do
+        use Box::Destroy
+      end)
+
+      # box_repackage - Repackages a box.
+      register(:box_repackage, Builder.new do
+        use Box::Package
+      end)
+
+      # Other callbacks. There will be more of these in the future. For
+      # now, these are limited to what are needed internally.
+      register(:before_action_run, Builder.new do
+        use General::Validate
+        use VM::CheckAccessible
+      end)
+    end
+  end
+end

data/lib/vagrant/action/env.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  class Action
+    module Env
+      autoload :Set, 'vagrant/action/env/set'
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Vagrant
+  class 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 || {})
+        end
+
+        def call(env)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end