vagrantup 1.0.7 → 1.1.0

data/lib/vagrant/util/string_block_editor.rb

@@ -0,0 +1,75 @@
+module Vagrant
+  module Util
+    # This class modifies strings by creating and managing Vagrant-owned
+    # "blocks" via wrapping them in specially formed comments.
+    #
+    # This is useful when modifying a file that someone else owns and adding
+    # automatic entries into it. Example: /etc/exports or some other
+    # configuration file.
+    #
+    # Vagrant marks ownership of a block in the string by wrapping it in
+    # VAGRANT-BEGIN and VAGRANT-END comments with a unique ID. Example:
+    #
+    #     foo
+    #     # VAGRANT-BEGIN: id
+    #     some contents
+    #     created by vagrant
+    #     # VAGRANT-END: id
+    #
+    # The goal of this class is to be able to insert and remove these
+    # blocks without modifying anything else in the string.
+    #
+    # The strings usually come from files but it is up to the caller to
+    # manage the file resource.
+    class StringBlockEditor
+      # The current string value. This is the value that is modified by
+      # the methods below.
+      #
+      # @return [String]
+      attr_reader :value
+
+      def initialize(string)
+        @value = string
+      end
+
+      # This returns the keys (or ids) that are in the string.
+      #
+      # @return [<Array<String>]
+      def keys
+        regexp = /^#\s*VAGRANT-BEGIN:\s*(.+?)$\r?\n?(.*)$\r?\n?^#\s*VAGRANT-END:\s(\1)$/m
+        @value.scan(regexp).map do |match|
+          match[0]
+        end
+      end
+
+      # This deletes the block with the given key if it exists.
+      def delete(key)
+        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$.*^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
+        @value.gsub!(regexp, "")
+      end
+
+      # This gets the value of the block with the given key.
+      def get(key)
+        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$\r?\n?(.*?)\r?\n?^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
+        match  = regexp.match(@value)
+        return nil if !match
+        match[1]
+      end
+
+      # This inserts a block with the given key and value.
+      #
+      # @param [String] key
+      # @param [String] value
+      def insert(key, value)
+        # Insert the new block into the value
+        new_block = <<BLOCK
+# VAGRANT-BEGIN: #{key}
+#{value.strip}
+# VAGRANT-END: #{key}
+BLOCK
+
+        @value << new_block
+      end
+    end
+  end
+end

data/lib/vagrant/util/subprocess.rb

@@ -29,8 +29,28 @@ module Vagrant
       def execute
         # Get the timeout, if we have one
         timeout = @options[:timeout]
+
+        # Get the working directory
         workdir = @options[:workdir] || Dir.pwd
 
+        # Get what we're interested in being notified about
+        notify  = @options[:notify] || []
+        notify  = [notify] if !notify.is_a?(Array)
+        if notify.empty? && block_given?
+          # If a block is given, subscribers must be given, otherwise the
+          # block is never called. This is usually NOT what you want, so this
+          # is an error.
+          message = "A list of notify subscriptions must be given if a block is given"
+          raise ArgumentError, message
+        end
+
+        # Let's get some more useful booleans that we access a lot so
+        # we're not constantly calling an `include` check
+        notify_table = {}
+        notify_table[:stderr] = notify.include?(:stderr)
+        notify_table[:stdout] = notify.include?(:stdout)
+        notify_stdin  = notify.include?(:stdin)
+
         # Build the ChildProcess
         @logger.info("Starting process: #{@command.inspect}")
         process = ChildProcess.build(*@command)
@@ -55,10 +75,10 @@ module Vagrant
           Dir.chdir(workdir) do
             process.start
           end
-        rescue ChildProcess::LaunchError
+        rescue ChildProcess::LaunchError => ex
           # Raise our own version of the error so that users of the class
           # don't need to be aware of ChildProcess
-          raise LaunchError
+          raise LaunchError.new(ex.message)
         end
 
         # Make sure the stdin does not buffer
@@ -80,14 +100,17 @@ module Vagrant
 
         @logger.debug("Selecting on IO")
         while true
-          results = IO.select([stdout, stderr], [process.io.stdin], nil, timeout || 5)
-          readers, writers = results
+          writers = notify_stdin ? [process.io.stdin] : []
+          results = IO.select([stdout, stderr], writers, nil, timeout || 0.1)
+          results ||= []
+          readers = results[0]
+          writers = results[1]
 
           # Check if we have exceeded our timeout
           raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
 
           # Check the readers to see if they're ready
-          if !readers.empty?
+          if readers && !readers.empty?
             readers.each do |r|
               # Read from the IO object
               data = read_io(r)
@@ -96,10 +119,10 @@ module Vagrant
               next if data.empty?
 
               io_name = r == stdout ? :stdout : :stderr
-              @logger.debug("#{io_name}: #{data}")
+              @logger.debug("#{io_name}: #{data.chomp}")
 
               io_data[io_name] += data
-              yield io_name, data if block_given?
+              yield io_name, data if block_given? && notify_table[io_name]
             end
           end
 
@@ -109,7 +132,7 @@ module Vagrant
           break if process.exited?
 
           # Check the writers to see if they're ready, and notify any listeners
-          if !writers.empty?
+          if writers && !writers.empty?
             yield :stdin, process.io.stdin if block_given?
           end
         end
@@ -136,9 +159,9 @@ module Vagrant
           next if extra_data == ""
 
           # Log it out and accumulate
-          @logger.debug(extra_data)
           io_name = io == stdout ? :stdout : :stderr
           io_data[io_name] += extra_data
+          @logger.debug("#{io_name}: #{extra_data.chomp}")
 
           # Yield to any listeners any remaining data
           yield io_name, extra_data if block_given?
@@ -176,7 +199,7 @@ module Vagrant
               # We have to do this since `readpartial` will actually block
               # until data is available, which can cause blocking forever
               # in some cases.
-              results = IO.select([io], nil, nil, 1)
+              results = IO.select([io], nil, nil, 0.1)
               break if !results || results[0].empty?
 
               # Read!

data/lib/vagrant/util/which.rb

@@ -0,0 +1,43 @@
+require "vagrant/util/platform"
+
+module Vagrant
+  module Util
+    class Which
+      # Cross-platform way of finding an executable in the PATH.
+      #
+      #   which('ruby') #=> /usr/bin/ruby
+      #
+      # This code is adapted from the following post by mislav:
+      #   http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      #
+      # @param [String] cmd The command to search for in the PATH.
+      # @return [String] The full path to the executable or `nil` if not found.
+      def self.which(cmd)
+        exts = nil
+
+        if !Platform.windows? || ENV['PATHEXT'].nil?
+          # If the PATHEXT variable is empty, we're on *nix and need to find
+          # the exact filename
+          exts = ['']
+        elsif File.extname(cmd).length != 0
+          # On Windows: if filename contains an extension, we must match that
+          # exact filename
+          exts = ['']
+        else
+          # On Windows: otherwise try to match all possible executable file
+          # extensions (.EXE .COM .BAT etc.)
+          exts = ENV['PATHEXT'].split(';')
+        end
+
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = "#{path}#{File::SEPARATOR}#{cmd}#{ext}"
+            return exe if File.executable? exe
+          end
+        end
+
+        return nil
+      end
+    end
+  end
+end

data/lib/vagrant/version.rb

@@ -2,5 +2,5 @@ module Vagrant
   # This will always be up to date with the current version of Vagrant,
   # since it is used to generate the gemspec and is also the source of
   # the version for `vagrant -v`
-  VERSION = "1.0.7"
+  VERSION = "1.1.0"
 end

data/plugins/README.md

@@ -0,0 +1,5 @@
+# Vagrant Core Plugins
+
+These are plugins that ship with Vagrant. Vagrant core uses its own
+plugin system to power a lot of the core pieces that ship with Vagrant.
+Each plugin will have its own README which explains its specific role.

data/plugins/commands/box/command/add.rb

@@ -0,0 +1,46 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Add < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box add <name> <url> [--provider provider] [-h]"
+            o.separator ""
+
+            o.on("-f", "--force", "Overwrite an existing box if it exists.") do |f|
+              options[:force] = f
+            end
+
+            o.on("--provider provider", String,
+                 "The provider that backs the box.") do |p|
+              options[:provider] = p
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+          # Get the provider if one was set
+          provider = nil
+          provider = options[:provider].to_sym if options[:provider]
+
+          @env.action_runner.run(Vagrant::Action.action_box_add, {
+            :box_name     => argv[0],
+            :box_provider => provider,
+            :box_url      => argv[1],
+            :box_force    => options[:force]
+          })
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/list.rb

@@ -0,0 +1,41 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class List < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant box list"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+
+          boxes = @env.boxes.all.sort
+          if boxes.empty?
+            return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), :prefix => false)
+          end
+
+          # Find the longest box name
+          longest_box = boxes.max_by { |x| x[0].length }
+          longest_box_length = longest_box[0].length
+
+          # Go through each box and output the information about it. We
+          # ignore the "v1" param for now since I'm not yet sure if its
+          # important for the user to know what boxes need to be upgraded
+          # and which don't, since we plan on doing that transparently.
+          boxes.each do |name, provider, _v1|
+            @env.ui.info("#{name.ljust(longest_box_length)} (#{provider})", :prefix => false)
+          end
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/remove.rb

@@ -0,0 +1,37 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Remove < Vagrant.plugin("2", :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box remove <name> <provider>"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+          b = nil
+          begin
+            b = @env.boxes.find(argv[0], argv[1].to_sym)
+          rescue Vagrant::Errors::BoxUpgradeRequired
+            @env.boxes.upgrade(argv[0])
+            retry
+          end
+
+          raise Vagrant::Errors::BoxNotFound, :name => argv[0] if !b
+          @env.ui.info(I18n.t("vagrant.commands.box.removing",
+                              :name => argv[0],
+                              :provider => argv[1]))
+          b.destroy!
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/repackage.rb

@@ -0,0 +1,43 @@
+require "fileutils"
+require 'optparse'
+require "pathname"
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Repackage < Vagrant.plugin("2", :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant box repackage <name> <provider>"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+          box_name     = argv[0]
+          box_provider = argv[1].to_sym
+
+          # Verify the box exists that we want to repackage
+          box = nil
+          begin
+            box = @env.boxes.find(box_name, box_provider)
+          rescue Vagrant::Errors::BoxUpgradeRequired
+            @env.boxes.upgrade(box_name)
+            retry
+          end
+
+          raise Vagrant::Errors::BoxNotFound, :name => box_name if !box
+
+          # Repackage the box
+          output_path = Pathname.new(File.expand_path(@env.config_global.package.name, FileUtils.pwd))
+          box.repackage(output_path)
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/box/command/root.rb

@@ -0,0 +1,75 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandBox
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:add) do
+            require File.expand_path("../add", __FILE__)
+            Add
+          end
+
+          @subcommands.register(:list) do
+            require File.expand_path("../list", __FILE__)
+            List
+          end
+
+          @subcommands.register(:remove) do
+            require File.expand_path("../remove", __FILE__)
+            Remove
+          end
+
+          @subcommands.register(:repackage) do
+            require File.expand_path("../repackage", __FILE__)
+            Repackage
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the box commands.
+            return help
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant box <command> [<args>]"
+            opts.separator ""
+            opts.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              opts.separator "     #{key}"
+            end
+
+            opts.separator ""
+            opts.separator "For help on any individual command run `vagrant box COMMAND -h`"
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+      end
+    end
+  end
+end