vagrant-fixed-ssh 1.0.7

data/lib/vagrant/command.rb

@@ -0,0 +1,24 @@
+module Vagrant
+  module Command
+    autoload :Base,      'vagrant/command/base'
+
+    autoload :Box,          'vagrant/command/box'
+    autoload :BoxAdd,       'vagrant/command/box_add'
+    autoload :BoxRemove,    'vagrant/command/box_remove'
+    autoload :BoxRepackage, 'vagrant/command/box_repackage'
+    autoload :BoxList,      'vagrant/command/box_list'
+    autoload :Destroy,      'vagrant/command/destroy'
+    autoload :Gem,          'vagrant/command/gem'
+    autoload :Halt,         'vagrant/command/halt'
+    autoload :Init,         'vagrant/command/init'
+    autoload :Package,      'vagrant/command/package'
+    autoload :Provision,    'vagrant/command/provision'
+    autoload :Reload,       'vagrant/command/reload'
+    autoload :Resume,       'vagrant/command/resume'
+    autoload :SSH,          'vagrant/command/ssh'
+    autoload :SSHConfig,    'vagrant/command/ssh_config'
+    autoload :Status,       'vagrant/command/status'
+    autoload :Suspend,      'vagrant/command/suspend'
+    autoload :Up,           'vagrant/command/up'
+  end
+end

data/lib/vagrant/command/base.rb

@@ -0,0 +1,167 @@
+require 'log4r'
+
+require "vagrant/util/safe_puts"
+
+module Vagrant
+  module Command
+    # Base class for any CLI commands.
+    #
+    # This class provides documentation on the interface as well as helper
+    # functions that a command has.
+    class Base
+      include Util::SafePuts
+
+      def initialize(argv, env)
+        @argv = argv
+        @env  = env
+        @logger = Log4r::Logger.new("vagrant::command::#{self.class.to_s.downcase}")
+      end
+
+      # This is what is called on the class to actually execute it. Any
+      # subclasses should implement this method and do any option parsing
+      # and validation here.
+      def execute; end
+
+      protected
+
+      # Parses the options given an OptionParser instance.
+      #
+      # This is a convenience method that properly handles duping the
+      # originally argv array so that it is not destroyed.
+      #
+      # This method will also automatically detect "-h" and "--help"
+      # and print help. And if any invalid options are detected, the help
+      # will be printed, as well.
+      #
+      # If this method returns `nil`, then you should assume that help
+      # was printed and parsing failed.
+      def parse_options(opts=nil)
+        # Creating a shallow copy of the arguments so the OptionParser
+        # doesn't destroy the originals.
+        argv = @argv.dup
+
+        # Default opts to a blank optionparser if none is given
+        opts ||= OptionParser.new
+
+        # Add the help option, which must be on every command.
+        opts.on_tail("-h", "--help", "Print this help") do
+          safe_puts(opts.help)
+          return nil
+        end
+
+        opts.parse!(argv)
+        return argv
+      rescue OptionParser::InvalidOption
+        raise Errors::CLIInvalidOptions, :help => opts.help.chomp
+      end
+
+      # Yields a VM for each target VM for the command.
+      #
+      # This is a convenience method for easily implementing methods that
+      # take a target VM (in the case of multi-VM) or every VM if no
+      # specific VM name is specified.
+      #
+      # @param [String] name The name of the VM. Nil if every VM.
+      # @param [Boolean] single_target If true, then an exception will be
+      #   raised if more than one target is found.
+      def with_target_vms(names=nil, options=nil)
+        # Using VMs requires a Vagrant environment to be properly setup
+        raise Errors::NoEnvironmentError if !@env.root_path
+
+        # Setup the options hash
+        options ||= {}
+
+        # Require that names be an array
+        names ||= []
+        names = [names] if !names.is_a?(Array)
+
+        # First determine the proper array of VMs.
+        vms = []
+        if names.length > 0
+          names.each do |name|
+            raise Errors::MultiVMEnvironmentRequired if !@env.multivm?
+
+            if name =~ /^\/(.+?)\/$/
+              # This is a regular expression name, so we convert to a regular
+              # expression and allow that sort of matching.
+              regex = Regexp.new($1.to_s)
+
+              @env.vms.each do |name, vm|
+                vms << vm if name =~ regex
+              end
+
+              raise Errors::VMNoMatchError if vms.empty?
+            else
+              # String name, just look for a specific VM
+              vms << @env.vms[name.to_sym]
+              raise Errors::VMNotFoundError, :name => name if !vms[0]
+            end
+          end
+        else
+          vms = @env.vms_ordered
+        end
+
+        # Make sure we're only working with one VM if single target
+        raise Errors::MultiVMTargetRequired if options[:single_target] && vms.length != 1
+
+        # If we asked for reversed ordering, then reverse it
+        vms.reverse! if options[:reverse]
+
+        # Go through each VM and yield it!
+        vms.each do |old_vm|
+          # We get a new VM from the environment here to avoid potentially
+          # stale VMs (if there was a config reload on the environment
+          # or something).
+          vm = @env.vms[old_vm.name]
+          yield vm
+        end
+      end
+
+      # This method will split the argv given into three parts: the
+      # flags to this command, the subcommand, and the flags to the
+      # subcommand. For example:
+      #
+      #     -v status -h -v
+      #
+      # The above would yield 3 parts:
+      #
+      #     ["-v"]
+      #     "status"
+      #     ["-h", "-v"]
+      #
+      # These parts are useful because the first is a list of arguments
+      # given to the current command, the second is a subcommand, and the
+      # third are the commands given to the subcommand.
+      #
+      # @return [Array] The three parts.
+      def split_main_and_subcommand(argv)
+        # Initialize return variables
+        main_args   = nil
+        sub_command = nil
+        sub_args    = []
+
+        # We split the arguments into two: One set containing any
+        # flags before a word, and then the rest. The rest are what
+        # get actually sent on to the subcommand.
+        argv.each_index do |i|
+          if !argv[i].start_with?("-")
+            # We found the beginning of the sub command. Split the
+            # args up.
+            main_args   = argv[0, i]
+            sub_command = argv[i]
+            sub_args    = argv[i + 1, argv.length - i + 1]
+
+            # Break so we don't find the next non flag and shift our
+            # main args.
+            break
+          end
+        end
+
+        # Handle the case that argv was empty or didn't contain any subcommand
+        main_args = argv.dup if main_args.nil?
+
+        return [main_args, sub_command, sub_args]
+      end
+    end
+  end
+end

data/lib/vagrant/command/box.rb

@@ -0,0 +1,58 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class Box < Base
+      def initialize(argv, env)
+        super
+
+        @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+        @subcommands = Registry.new
+        @subcommands.register(:add)       { Vagrant::Command::BoxAdd }
+        @subcommands.register(:remove)    { Vagrant::Command::BoxRemove }
+        @subcommands.register(:repackage) { Vagrant::Command::BoxRepackage }
+        @subcommands.register(:list)      { Vagrant::Command::BoxList }
+      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

data/lib/vagrant/command/box_add.rb

@@ -0,0 +1,37 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class BoxAdd < Base
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant box add <name> <url>"
+          opts.separator ""
+
+          opts.on("-f", "--force", "Overwrite an existing box if it exists.") do |f|
+            options[:force] = f
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+        raise Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 2
+
+        # If we're force adding, then be sure to destroy any existing box if it
+        # exists.
+        if options[:force]
+          existing = @env.boxes.find(argv[0])
+          existing.destroy if existing
+        end
+
+        @env.boxes.add(argv[0], argv[1])
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/lib/vagrant/command/box_list.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class BoxList < Base
+      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.sort
+        if boxes.empty?
+          return @env.ui.warn(I18n.t("vagrant.commands.box.no_installed_boxes"), :prefix => false)
+        end
+        boxes.each { |b| @env.ui.info(b.name, :prefix => false) }
+
+        # Success, exit status 0
+        0
+       end
+    end
+  end
+end

data/lib/vagrant/command/box_remove.rb

@@ -0,0 +1,27 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class BoxRemove < Base
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant box remove <name>"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+        raise Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+        b = @env.boxes.find(argv[0])
+        raise Errors::BoxNotFound, :name => argv[0] if !b
+        b.destroy
+
+        # Success, exit status 0
+        0
+       end
+    end
+  end
+end

data/lib/vagrant/command/box_repackage.rb

@@ -0,0 +1,27 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class BoxRepackage < Base
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant box repackage <name>"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+        raise Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+        b = @env.boxes.find(argv[0])
+        raise Errors::BoxNotFound, :name => argv[0] if !b
+        b.repackage
+
+        # Success, exit status 0
+        0
+       end
+    end
+  end
+end

data/lib/vagrant/command/destroy.rb

@@ -0,0 +1,64 @@
+require 'optparse'
+
+module Vagrant
+  module Command
+    class Destroy < Base
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant destroy [vm-name]"
+          opts.separator ""
+
+          opts.on("-f", "--force", "Destroy without confirmation.") do |f|
+            options[:force] = f
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'Destroy' each target VM...")
+        with_target_vms(argv, :reverse => true) do |vm|
+          if vm.created?
+            # Boolean whether we should actually go through with the destroy
+            # or not. This is true only if the "--force" flag is set or if the
+            # user confirms it.
+            do_destroy = false
+
+            if options[:force]
+              do_destroy = true
+            else
+              choice = nil
+              begin
+                choice = @env.ui.ask(I18n.t("vagrant.commands.destroy.confirmation",
+                                            :name => vm.name))
+              rescue Errors::UIExpectsTTY
+                # We raise a more specific error but one which basically
+                # means the same thing.
+                raise Errors::DestroyRequiresForce
+              end
+              do_destroy = choice.upcase == "Y"
+            end
+
+            if do_destroy
+              @logger.info("Destroying: #{vm.name}")
+              vm.destroy
+            else
+              @logger.info("Not destroying #{vm.name} since confirmation was declined.")
+              @env.ui.success(I18n.t("vagrant.commands.destroy.will_not_destroy",
+                                     :name => vm.name), :prefix => false)
+            end
+          else
+            @logger.info("Not destroying #{vm.name}, since it isn't created.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+          end
+        end
+
+        # Success, exit status 0
+        0
+       end
+    end
+  end
+end

data/lib/vagrant/command/gem.rb

@@ -0,0 +1,39 @@
+require "rubygems"
+require "rubygems/gem_runner"
+
+require "vagrant/util/safe_puts"
+
+module Vagrant
+  module Command
+    class Gem < Base
+      include Util::SafePuts
+
+      def execute
+        # Bundler sets up its own custom gem load paths such that our
+        # own gems are never loaded. Therefore, give an error if a user
+        # tries to install gems while within a Bundler-managed environment.
+        if defined?(Bundler)
+          require 'bundler/shared_helpers'
+          if Bundler::SharedHelpers.in_bundle?
+            raise Errors::GemCommandInBundler
+          end
+        end
+
+        # If the user needs some help, we add our own little message at the
+        # top so that they're aware of what `vagrant gem` is doing, really.
+        if @argv.empty? || @argv.include?("-h") || @argv.include?("--help")
+          @env.ui.info(I18n.t("vagrant.commands.gem.help_preamble"),
+                       :prefix => false)
+          safe_puts
+        end
+
+        # We just proxy the arguments onto a real RubyGems command
+        # but change `GEM_HOME` so that the gems are installed into
+        # our own private gem folder.
+        ENV["GEM_HOME"] = @env.gems_path.to_s
+        ::Gem.clear_paths
+        ::Gem::GemRunner.new.run(@argv.dup)
+      end
+    end
+  end
+end