nixme-vagrant 0.7.2

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,104 @@
+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::Customize
+        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::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::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::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
+      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

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,109 @@
+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)
+          # Cleanup any packaged files if the packaging failed at some point.
+          File.delete(tar_path) if File.exist?(tar_path)
+        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