vagrant 0.4.2 → 0.5.0

data/.gitignore

@@ -1,11 +0,0 @@
-pkg/*
-Vagrantfile
-.vagrant
-.bundle
-*.lock
-cookbooks/*
-_site/*
-!templates/*
-*.org
-.yardoc/
-doc/

data/Gemfile

@@ -1,18 +0,0 @@
-source "http://rubygems.org"
-
-# Gems required for the lib to even run
-gem "virtualbox", :git => "git://github.com/mitchellh/virtualbox.git"
-gem "net-ssh", ">= 2.0.19"
-gem "net-scp", ">= 1.0.2"
-gem "json", ">= 1.2.4"
-gem "archive-tar-minitar", "= 0.5.2"
-gem "mario", "~> 0.0.6"
-
-# Gems required for testing only. To install run
-# gem bundle test
-group :test do
-  gem "contest", ">= 0.1.2"
-  gem "mocha"
-  gem "ruby-debug", ">= 0.10.3" if RUBY_VERSION < '1.9'
-  gem "jeweler", "~> 1.4.0"
-end

data/Rakefile

@@ -1,41 +0,0 @@
-require 'rake/testtask'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "vagrant"
-    gemspec.summary = "Vagrant is a tool for building and distributing virtualized development environments."
-    gemspec.description = "Vagrant is a tool for building and distributing virtualized development environments."
-    gemspec.email = ["mitchell.hashimoto@gmail.com", "john.m.bender@gmail.com"]
-    gemspec.homepage = "http://github.com/mitchellh/vagrant"
-    gemspec.authors = ["Mitchell Hashimoto", "John Bender"]
-
-    gemspec.add_dependency('virtualbox', '~> 0.7.3')
-    gemspec.add_dependency('net-ssh', '>= 2.0.19')
-    gemspec.add_dependency('net-scp', '>= 1.0.2')
-    gemspec.add_dependency('json', '>= 1.2.0')
-    gemspec.add_dependency('archive-tar-minitar', '= 0.5.2')
-    gemspec.add_dependency('mario', '~> 0.0.6')
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
-end
-
-task :default => :test
-
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.pattern = 'test/**/*_test.rb'
-end
-
-begin
-  require 'yard'
-  YARD::Rake::YardocTask.new do |t|
-    t.options = ['--main', 'README.md', '--markup', 'markdown']
-    t.options += ['--title', 'Vagrant Developer Documentation']
-  end
-rescue LoadError
-  puts "Yard not available. Install it with: gem install yard"
-  puts "if you wish to be able to generate developer documentation."
-end

data/VERSION

@@ -1 +0,0 @@
-0.4.2

data/lib/vagrant/actions/base.rb

@@ -1,130 +0,0 @@
-module Vagrant
-  module Actions
-    # Base class for any command actions.
-    #
-    # Actions are the smallest unit of functionality found within
-    # Vagrant. Vagrant composes many actions together to execute
-    # its complex tasks while keeping the individual pieces of a
-    # task as discrete reusable actions. Actions are ran exclusively
-    # by an {Runner action runner} which is simply a subclass of {Runner}.
-    #
-    # Actions work by implementing any or all of the following methods
-    # which a {Runner} executes:
-    #
-    # * `prepare` - Called once for each action before any action has `execute!`
-    #   called. This is meant for basic setup.
-    # * `execute!` - This is where the meat of the action typically goes;
-    #   the main code which executes the action.
-    # * `cleanup` - This is called exactly once for each action after every
-    #   other action is completed. It is meant for cleaning up any resources.
-    # * `rescue` - This is called if an exception occurs in _any action_. This
-    #   gives every other action a chance to clean itself up.
-    #
-    # For details of each step of an action, read the specific function call
-    # documentation below.
-    class Base
-      # The {Runner runner} which is executing the action
-      attr_reader :runner
-
-      # Any options which are passed into the initializer as a hash.
-      attr_reader :options
-
-      # Included so subclasses don't need to include it themselves.
-      include Vagrant::Util
-
-      # A helper method for logging which simply gets the logger from
-      # the runner. Since actions tend to log quite a bit, this
-      # removes the need to prefix `logger` with `@runner` over and
-      # over.
-      def logger
-        runner.env.logger
-      end
-
-      # Initialization of the action, passing any arguments which may have
-      # been given to the {Runner runner}. This method can be used by subclasses
-      # to save any of the configuration options which are passed in.
-      def initialize(runner, options=nil)
-        @runner = runner
-        @options = options || {}
-      end
-
-      # This method is called once per action, allowing the action
-      # to setup any callbacks, add more events, etc. Prepare is
-      # called in the order the actions are defined, and the action
-      # itself has no control over this.
-      #
-      # Examples of its usage:
-      #
-      # Perhaps we need an additional action only if a configuration is set:
-      #
-      #     def prepare
-      #       @vm.actions << FooAction if Vagrant.config[:foo] == :bar
-      #     end
-      #
-      def prepare; end
-
-      # This method is called once, after preparing, to execute the
-      # actual task. This method is responsible for calling any
-      # callbacks. Adding new actions here will have unpredictable
-      # effects and should never be done.
-      #
-      # Examples of its usage:
-      #
-      #     def execute!
-      #       @vm.invoke_callback(:before_oven, "cookies")
-      #       # Do lots of stuff here
-      #       @vm.invoke_callback(:after_oven, "more", "than", "one", "option")
-      #     end
-      #
-      def execute!; end
-
-      # This method is called after all actions have finished executing.
-      # It is meant as a place where final cleanup code can be done, knowing
-      # that all other actions are finished using your data.
-      def cleanup; end
-
-      # This method is only called if some exception occurs in the chain
-      # of actions. If an exception is raised in any action in the current
-      # chain, then every action part of that chain has {#rescue} called
-      # before raising the exception further. This method should be used to
-      # perform any cleanup necessary in the face of errors.
-      #
-      # **Warning:** Since this method is called when an exception is already
-      # raised, be _extra careful_ when implementing this method to handle
-      # all your own exceptions, otherwise it'll mask the initially raised
-      # exception.
-      def rescue(exception); end
-
-      # The following two methods are used for declaring action dependencies.
-      # For example, you require that the reload action be in place before
-      # a your new FooAction you might do the following
-      #
-      # def follows; [Reload] end
-
-      # This method is called when the runner is determining the actions that
-      # must precede a given action. You would say "This action follows [Action1, Action2]"
-      def follows; [] end
-
-      # This method is called when the runner is determining the actions that
-      # must follow a given action. You would say "This action precedes [Action3, Action4]
-      def precedes; [] end
-    end
-
-    # An exception which occured within an action. This should be used instead of
-    # {Vagrant::Util#error_and_exit error_and_exit}, since it allows the {Runner} to call
-    # {Base#rescue rescue} on all the actions and properly exit. Any message
-    # passed into the {ActionException} is then shown and and vagrant exits.
-    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/actions/box/add.rb

@@ -1,23 +0,0 @@
-module Vagrant
-  module Actions
-    module Box
-      # A meta-action which adds a box by downloading and unpackaging it.
-      # This action downloads and unpackages a box with a given URI. This
-      # is a _meta action_, meaning it simply adds more actions to the
-      # action chain, and those actions do the work.
-      #
-      # This is the action called by {Box#add}.
-      class Add < Base
-        def prepare
-          if File.exists?(@runner.directory)
-            raise ActionException.new(:box_add_already_exists, :box_name => @runner.name)
-          end
-
-          @runner.add_action(Download)
-          @runner.add_action(Unpackage)
-          @runner.add_action(Verify)
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Vagrant
-  module Actions
-    module Box
-      # Action to destroy a box. This action is not reversible and expects
-      # to be called by a {Box} object.
-      class Destroy < Base
-        def execute!
-          logger.info "Deleting box directory..."
-          FileUtils.rm_rf(@runner.directory)
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-module Vagrant
-  module Actions
-    module Box
-      # An action which acts on a box by downloading the box file from
-      # the given URI into a temporary location. This action parses a
-      # given URI and handles downloading it via one of the many Vagrant
-      # downloads (such as {Vagrant::Downloaders::File}).
-      #
-      # This action cleans itself up by removing the downloaded box file.
-      class Download < Base
-        BASENAME = "box"
-        BUFFERSIZE = 1048576 # 1 MB
-
-        attr_reader :downloader
-
-        def prepare
-          # Check the URI given and prepare a downloader
-          [Downloaders::HTTP, Downloaders::File].each do |dler|
-            if dler.match?(@runner.uri)
-              logger.info "Downloading via #{dler}..."
-              @downloader = dler.new(@runner.env)
-            end
-          end
-
-          raise ActionException.new(:box_download_unknown_type) unless @downloader
-
-          # Prepare the downloader
-          @downloader.prepare(@runner.uri)
-        end
-
-        def execute!
-          with_tempfile do |tempfile|
-            download_to(tempfile)
-            @runner.temp_path = tempfile.path
-          end
-        end
-
-        def cleanup
-          if @runner.temp_path && File.exist?(@runner.temp_path)
-            logger.info "Cleaning up downloaded box..."
-            File.unlink(@runner.temp_path)
-          end
-        end
-
-        def rescue(exception)
-          cleanup
-        end
-
-        def with_tempfile
-          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(@runner.env.tmp_path, BASENAME + Time.now.to_i.to_s)
-        end
-
-        def download_to(f)
-          logger.info "Copying box to temporary location..."
-          downloader.download!(@runner.uri, f)
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-module Vagrant
-  module Actions
-    module Box
-      # This action unpackages a downloaded box file into its final
-      # box destination within the vagrant home folder.
-      class Unpackage < Base
-        def execute!
-          @runner.invoke_around_callback(:unpackage) do
-            setup_box_dir
-            decompress
-          end
-        end
-
-        def rescue(exception)
-          if File.directory?(box_dir)
-            logger.info "An error occurred, rolling back box unpackaging..."
-            FileUtils.rm_rf(box_dir)
-          end
-        end
-
-        def setup_box_dir
-          if File.directory?(box_dir)
-            error_and_exit(:box_already_exists, :box_name => @runner.name)
-          end
-
-          FileUtils.mkdir_p(box_dir)
-        end
-
-        def box_dir
-          @runner.directory
-        end
-
-        def decompress
-          Dir.chdir(box_dir) do
-            logger.info "Extracting box to #{box_dir}..."
-            Archive::Tar::Minitar.unpack(@runner.temp_path, box_dir)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Vagrant
-  module Actions
-    module Box
-      # This action verifies that a given box is valid. This works by attempting
-      # to read/interpret the appliance file (OVF). If the reading succeeds, then
-      # the box is assumed to be valid.
-      class Verify < Base
-        def execute!
-          logger.info "Verifying box..."
-          reload_configuration
-          verify_appliance
-        end
-
-        def reload_configuration
-          # We have to reload the environment config since we _just_ added the
-          # box. We do this by setting the current box to the recently added box,
-          # then reloading
-          @runner.env.config.vm.box = @runner.name
-          @runner.env.load_box!
-          @runner.env.load_config!
-        end
-
-        def verify_appliance
-          # We now try to read the applince. If it succeeds, we return true.
-          VirtualBox::Appliance.new(@runner.ovf_file)
-        rescue Exception
-          raise ActionException.new(:box_verification_failed)
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/actions/collection.rb

@@ -1,36 +0,0 @@
-module Vagrant
-  module Actions
-    class Collection < Array
-      def dependencies!
-        each_with_index do |action, i|
-          action.follows.each do |klass|
-            unless self[0..i].klasses.include?(klass)
-              raise DependencyNotSatisfiedException.new("#{action.class} action must follow #{klass}")
-            end	
-          end
-          
-          action.precedes.each do |klass|
-            unless self[i..length].klasses.include?(klass)
-              raise DependencyNotSatisfiedException.new("#{action.class} action must precede #{klass}")
-            end
-          end
-        end
-      end
-
-      def duplicates?
-        klasses.uniq.size != size
-      end
-
-      def duplicates!
-        raise DuplicateActionException.new if duplicates?
-      end
-    
-      def klasses
-        map { |o| o.class }
-      end
-    end
-
-    class DuplicateActionException < Exception; end
-    class DependencyNotSatisfiedException < Exception; end
-  end
-end    

data/lib/vagrant/actions/runner.rb

@@ -1,131 +0,0 @@
-module Vagrant
-  module Actions
-    # Base class for any class which will act as a runner
-    # for actions. A runner handles queueing up and executing actions,
-    # and executing the methods of an action in the proper order. The
-    # action runner also handles invoking callbacks that actions may
-    # request.
-    #
-    # # Executing Actions
-    #
-    # Actions can be executed by adding them and executing them all
-    # at once:
-    #
-    #     runner = Vagrant::Actions::Runner.new
-    #     runner.add_action(FooAction)
-    #     runner.add_action(BarAction)
-    #     runner.add_action(BazAction)
-    #     runner.execute!
-    #
-    # Single actions have a shorthand to be executed:
-    #
-    #     Vagrant::Actions::Runner.execute!(FooAction)
-    #
-    # Arguments may be passed into added actions by adding them after
-    # the action class:
-    #
-    #     runner.add_action(FooAction, "many", "arguments", "may", "follow")
-    #
-    class Runner
-      include Vagrant::Util
-
-      class << self
-        # Executes a specific action, optionally passing in any arguments to that
-        # action. This method is shorthand to initializing a runner, adding a single
-        # action, and executing it.
-        def execute!(action_klass, *args)
-          runner = new
-          runner.add_action(action_klass, *args)
-          runner.execute!
-        end
-      end
-
-      # Returns an array of all the actions in queue. Because this
-      # will persist accross calls (calling {#actions} twice will yield
-      # exactly the same object), to clear or modify it, use the ruby
-      # array methods which act on `self`, such as `Array#clear`.
-      #
-      # @return [Array]
-      def actions
-        @actions ||= Actions::Collection.new
-      end
-
-      # Returns the first action instance which matches the given class.
-      #
-      # @param [Class] action_klass The action to search for in the queue
-      # @return [Object]
-      def find_action(action_klass)
-        actions.find { |a| a.is_a?(action_klass) }
-      end
-
-      # Add an action to the list of queued actions to execute. This method
-      # appends the given action class to the end of the queue. Any arguments
-      # given after the class are passed into the class constructor.
-      def add_action(action_klass, *args)
-        actions << action_klass.new(self, *args)
-      end
-
-      # Execute the actions in queue. This method can also optionally be used
-      # to execute a single action on an instance. The syntax for executing a
-      # single method on an instance is the same as the {execute!} class method.
-      def execute!(single_action=nil, *args)
-        if single_action
-          actions.clear
-          add_action(single_action, *args)
-        end
-
-        actions.duplicates!
-        actions.dependencies!
-
-        # Call the prepare method on each once its
-        # initialized, then call the execute! method
-        begin
-          [:prepare, :execute!, :cleanup].each do |method|
-            actions.each do |action|
-              action.send(method)
-            end
-          end
-        rescue Exception => e
-          # Run the rescue code to do any emergency cleanup
-          actions.each do |action|
-            action.rescue(e)
-          end
-
-          # If its an ActionException, error and exit the message
-          if e.is_a?(ActionException)
-            error_and_exit(e.key, e.data)
-            return
-          end
-
-          # Finally, reraise the exception
-          raise
-        end
-
-        # Clear the actions
-        actions.clear
-      end
-
-      # Invokes an "around callback" which invokes before_name and
-      # after_name for the given callback name, yielding a block between
-      # callback invokations.
-      def invoke_around_callback(name, *args)
-        invoke_callback("before_#{name}".to_sym, *args)
-        yield
-        invoke_callback("after_#{name}".to_sym, *args)
-      end
-
-      # Invokes a single callback. This method will go through each action
-      # and call the method given in the parameter `name` if the action
-      # responds to it.
-      def invoke_callback(name, *args)
-        # Attempt to call the method for the callback on each of the
-        # actions
-        results = []
-        actions.each do |action|
-          results << action.send(name, *args) if action.respond_to?(name)
-        end
-        results
-      end
-    end
-  end
-end