vagrant 0.4.2 → 0.5.0

data/README.md

@@ -1,6 +1,7 @@
 # Vagrant
 
 * Website: [http://vagrantup.com](http://vagrantup.com)
+* Source: [http://github.com/mitchellh/vagrant](http://github.com/mitchellh/vagrant)
 * IRC: `#vagrant` on Freenode
 * Mailng list: [Google Groups](http://groups.google.com/group/vagrant-up)
 

data/config/default.rb

@@ -3,6 +3,7 @@ Vagrant::Config.run do |config|
   config.vagrant.log_output = STDOUT
   config.vagrant.dotfile_name = ".vagrant"
   config.vagrant.home = "~/.vagrant"
+  config.vagrant.host = :detect
 
   config.ssh.username = "vagrant"
   config.ssh.host = "localhost"
@@ -11,9 +12,11 @@ Vagrant::Config.run do |config|
   config.ssh.max_tries = 10
   config.ssh.timeout = 30
   config.ssh.private_key_path = File.join(PROJECT_ROOT, 'keys', 'vagrant')
+  config.ssh.forward_agent = false
 
   config.vm.auto_port_range = (2200..2250)
   config.vm.box_ovf = "box.ovf"
+  config.vm.box_url = nil
   config.vm.base_mac = "0800279C2E42"
   config.vm.forward_port("ssh", 22, 2222, :auto => true)
   config.vm.disk_image_format = 'VMDK'
@@ -33,11 +36,8 @@ Vagrant::Config.run do |config|
   config.unison.crontab_entry_file = "/tmp/vagrant-unison-crontab"
   config.unison.log_file = "/tmp/v-unison-log-%s"
 
-  # TODO fix these
-  # config.vm.sync_opts = "-terse -group -owner -batch -silent"
-  # config.vm.sync_script = "/tmp/sync"
-  # config.vm.sync_crontab_entry_file = "/tmp/crontab-entry"
+  config.nfs.map_uid = :auto
+  config.nfs.map_gid = :auto
 
-  config.package.name = 'vagrant'
-  config.package.extension = '.box'
+  config.package.name = 'package.box'
 end

data/lib/vagrant.rb

@@ -11,6 +11,9 @@ end
 require File.expand_path("util/glob_loader", libdir)
 
 # Load them up
-Vagrant::GlobLoader.glob_require(libdir, %w{util/stacked_proc_runner
-  actions/base downloaders/base actions/collection actions/runner config
-  provisioners/base provisioners/chef systems/base commands/base commands/box})
+Vagrant::GlobLoader.glob_require(libdir, %w{util util/stacked_proc_runner
+  downloaders/base config provisioners/base provisioners/chef systems/base
+  commands/base commands/box action/exception_catcher hosts/base})
+
+# Initialize the built-in actions
+Vagrant::Action.builtin!

data/lib/vagrant/action.rb

@@ -0,0 +1,77 @@
+module Vagrant
+  # Manages action running and registration. Every Vagrant environment
+  # has an instance of {Action} to allow for running in the context of
+  # the environment.
+  class Action
+    include Util
+
+    class << self
+      # Returns the list of registered actions.
+      def actions
+        @actions ||= {}
+      end
+
+      # Registers an action and associates it with a symbol. This
+      # symbol can then be referenced in other action builds and
+      # callbacks can be registered on that symbol.
+      #
+      # @param [Symbol] key
+      def register(key, callable)
+        actions[key] = callable
+      end
+
+      # Retrieves a registered action by key.
+      def [](key)
+        actions[key]
+      end
+    end
+
+    # The environment to run the actions in.
+    attr_reader :env
+
+    # Initializes the action with the given environment which the actions
+    # will be run in.
+    #
+    # @param [Environment] env
+    def initialize(env)
+      @env = env
+    end
+
+    # Runs the given callable object in the context of the environment.
+    # If a symbol is given as the `callable` parameter, then it is looked
+    # up in the registered actions list which are registered with {register}.
+    #
+    # @param [Object] callable An object which responds to `call`.
+    def run(callable, options=nil)
+      callable = Builder.new.use(callable) if callable.kind_of?(Class)
+      callable = self.class.actions[callable] if callable.kind_of?(Symbol)
+
+      action_environment = Action::Environment.new(env)
+      action_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.
+      int_callback = lambda do
+        if action_environment.interrupted?
+          env.logger.info "Exiting immediately!"
+          abort
+        end
+
+        env.logger.info "Waiting for cleanup before exiting..."
+        action_environment.error!(:interrupt)
+      end
+
+      Busy.busy(int_callback) { callable.call(action_environment) }
+      exit if action_environment.interrupted?
+
+      if action_environment.error?
+        # Erroneous environment resulted. Properly display error
+        # message.
+        key, options = action_environment.error
+        error_and_exit(key, options)
+        return false
+      end
+    end
+  end
+end

data/lib/vagrant/action/action_exception.rb

@@ -0,0 +1,16 @@
+module Vagrant
+  class Action
+    class ActionException < Exception
+      attr_reader :key
+      attr_reader :data
+
+      def initialize(key, data = {})
+        @key = key
+        @data = data
+
+        message = Vagrant::Util::Translator.t(key, data)
+        super(message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Vagrant
+  class Action
+    module Box
+      class Destroy
+        def initialize(app, env)
+          @app = app
+          @env = env
+        end
+
+        def call(env)
+          env.logger.info "Deleting box directory..."
+          FileUtils.rm_rf(env["box"].directory)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+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]
+        end
+
+        def call(env)
+          @env = env
+
+          download if instantiate_downloader
+          return if env.error?
+
+          @app.call(@env)
+
+          cleanup
+        end
+
+        def instantiate_downloader
+          @env["download.classes"].each do |klass|
+            if klass.match?(@env["box"].uri)
+              @env.logger.info "Downloading with #{klass}..."
+              @downloader = klass.new(@env)
+            end
+          end
+
+          if !@downloader
+            @env.error!(:box_download_unknown_type)
+            return false
+          end
+
+          @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 cleanup
+          if temp_path && File.exist?(temp_path)
+            @env.logger.info "Cleaning up downloaded box..."
+            File.unlink(temp_path)
+          end
+        end
+
+        def with_tempfile
+          @env.logger.info "Creating tempfile for storing box file..."
+          File.open(box_temp_path, Platform.tar_file_options) do |tempfile|
+            yield tempfile
+          end
+        end
+
+        def box_temp_path
+          File.join(@env.env.tmp_path, BASENAME + Time.now.to_i.to_s)
+        end
+
+        def download_to(f)
+          @env.logger.info "Copying box to temporary location..."
+          @downloader.download!(@env["box"].uri, f)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+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
+
+          return if !setup_box_directory
+          decompress
+
+          @app.call(@env)
+
+          cleanup if @env.error?
+        end
+
+        def cleanup
+          if File.directory?(box_directory)
+            FileUtils.rm_rf(box_directory)
+          end
+        end
+
+        def setup_box_directory
+          if File.directory?(@env["box"].directory)
+            @env.error!(:box_already_exists, :box_name => @env["box"].name)
+            return false
+          end
+
+          FileUtils.mkdir_p(@env["box"].directory)
+          @box_directory = @env["box"].directory
+          true
+        end
+
+        def decompress
+          Dir.chdir(@env["box"].directory) do
+            @env.logger.info "Extracting box to #{@env["box"].directory}..."
+            Archive::Tar::Minitar.unpack(@env["download.temp_path"], @env["box"].directory)
+          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.logger.info "Verifying box..."
+            VirtualBox::Appliance.new(env["box"].ovf_file)
+          rescue Exception
+            return env.error!(:box_verification_failed)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/action/builder.rb

@@ -0,0 +1,151 @@
+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 its 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)
+        # Prepend the error halt task so errneous environments are halted
+        # before the chain even begins.
+        items = stack.dup.unshift([Env::ErrorHalt, [], nil])
+
+        # Convert each middleware into a lambda which takes the next
+        # middleware.
+        items = items.collect do |item|
+          klass, args, block = item
+
+          lambda do |app|
+            if klass.is_a?(Class)
+              # A middleware klass which is to be instantiated with the
+              # app, env, and any arguments given
+              klass.new(app, env, *args, &block)
+            elsif klass.respond_to?(:call)
+              # Make it a lambda which calls the item then forwards
+              # up the chain
+              lambda do |e|
+                klass.call(e)
+                app.call(e)
+              end
+            else
+              raise "Invalid middleware: #{item.inspect}"
+            end
+          end
+        end
+
+        # Append the final step and convert into flattened call chain.
+        items << lambda { |env| }
+        items[0...-1].reverse.inject(items.last) { |a,e| e.call(a) }
+      end
+
+      # Runs the builder stack with the given environment.
+      def call(env)
+        to_app(env).call(env)
+      end
+    end
+  end
+end