tnargav 1.2.2

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

@@ -0,0 +1,28 @@
+require 'optparse'
+
+require_relative "base"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class List < Base
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant plugin list [-h]"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length > 0
+
+          # List the installed plugins
+          action(Action.action_list)
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandPlugin
+    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(:install) do
+            require_relative "install"
+            Install
+          end
+
+          @subcommands.register(:license) do
+            require_relative "license"
+            License
+          end
+
+          @subcommands.register(:list) do
+            require_relative "list"
+            List
+          end
+
+          @subcommands.register(:uninstall) do
+            require_relative "uninstall"
+            Uninstall
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the sub-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 |o|
+            o.banner = "Usage: vagrant plugin <command> [<args>]"
+            o.separator ""
+            o.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|
+              o.separator "     #{key}"
+            end
+
+            o.separator ""
+            o.separator "For help on any individual command run `vagrant plugin COMMAND -h`"
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/command/uninstall.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+
+require_relative "base"
+
+module VagrantPlugins
+  module CommandPlugin
+    module Command
+      class Uninstall < Base
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant plugin uninstall <name> [-h]"
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 1
+
+          # Uninstall the gem
+          action(Action.action_uninstall, :plugin_name => argv[0])
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/gem_helper.rb

@@ -0,0 +1,74 @@
+require "rubygems"
+require "rubygems/config_file"
+require "rubygems/gem_runner"
+
+require "log4r"
+
+module VagrantPlugins
+  module CommandPlugin
+    # This class provides methods to help with calling out to the
+    # `gem` command but using the RubyGems API.
+    class GemHelper
+      def initialize(gem_home)
+        @gem_home = gem_home.to_s
+        @logger   = Log4r::Logger.new("vagrant::plugins::plugincommand::gemhelper")
+      end
+
+      # This will yield the given block with the proper ENV setup so
+      # that RubyGems only sees the gems in the Vagrant-managed gem
+      # path.
+      def with_environment
+        old_gem_home = ENV["GEM_HOME"]
+        old_gem_path = ENV["GEM_PATH"]
+        ENV["GEM_HOME"] = @gem_home
+        ENV["GEM_PATH"] = @gem_home
+        @logger.debug("Set GEM_* to: #{ENV["GEM_HOME"]}")
+
+        # Clear paths so that it reads the new GEM_HOME setting
+        Gem.paths = ENV
+
+        # Set a custom configuration to avoid loading ~/.gemrc loads and
+        # /etc/gemrc and so on.
+        old_config = Gem.configuration
+        Gem.configuration = NilGemConfig.new
+
+        # Clear the sources so that installation uses custom sources
+        old_sources = Gem.sources
+        Gem.sources = Gem.default_sources
+        Gem.sources << "http://gems.hashicorp.com"
+
+        # Use a silent UI so that we have no output
+        Gem::DefaultUserInteraction.use_ui(Gem::SilentUI.new) do
+          return yield
+        end
+      ensure
+        # Restore the old GEM_* settings
+        ENV["GEM_HOME"] = old_gem_home
+        ENV["GEM_PATH"] = old_gem_path
+
+        # Reset everything
+        Gem.configuration = old_config
+        Gem.paths   = ENV
+        Gem.sources = old_sources.to_a
+      end
+
+      # This is pretty hacky but it is a custom implementatin of
+      # Gem::ConfigFile so that we don't load any gemrc files.
+      class NilGemConfig < Gem::ConfigFile
+        def initialize
+          # We _can not_ `super` here because that can really mess up
+          # some other configuration state. We need to just set everything
+          # directly.
+
+          @api_keys       = {}
+          @args           = []
+          @backtrace      = false
+          @bulk_threshold = 1000
+          @hash           = {}
+          @update_sources = true
+          @verbose        = true
+        end
+      end
+    end
+  end
+end

data/plugins/commands/plugin/plugin.rb

@@ -0,0 +1,22 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandPlugin
+    class Plugin < Vagrant.plugin("2")
+      name "plugin command"
+      description <<-DESC
+      This command helps manage and install plugins within the
+      Vagrant environment.
+DESC
+
+      command("plugin") do
+        require File.expand_path("../command/root", __FILE__)
+        Command::Root
+      end
+    end
+
+    autoload :Action, File.expand_path("../action", __FILE__)
+    autoload :GemHelper, File.expand_path("../gem_helper", __FILE__)
+    autoload :StateFile, File.expand_path("../state_file", __FILE__)
+  end
+end

data/plugins/commands/plugin/state_file.rb

@@ -0,0 +1,57 @@
+require "json"
+
+module VagrantPlugins
+  module CommandPlugin
+    # This is a helper to deal with the plugin state file that Vagrant
+    # uses to track what plugins are installed and activated and such.
+    class StateFile
+      def initialize(path)
+        @path = path
+
+        @data = {}
+        @data = JSON.parse(@path.read) if @path.exist?
+        @data["installed"] ||= []
+      end
+
+      # Add a plugin that is installed to the state file.
+      #
+      # @param [String] name The name of the plugin
+      def add_plugin(name)
+        if !@data["installed"].include?(name)
+          @data["installed"] << name
+        end
+
+        save!
+      end
+
+      # This returns a list of installed plugins according to the state
+      # file. Note that this may _not_ directly match over to actually
+      # installed gems.
+      #
+      # @return [Array<String>]
+      def installed_plugins
+        @data["installed"]
+      end
+
+      # Remove a plugin that is installed from the state file.
+      #
+      # @param [String] name The name of the plugin.
+      def remove_plugin(name)
+        @data["installed"].delete(name)
+        save!
+      end
+
+      # This saves the state back into the state file.
+      def save!
+        # Scrub some fields
+        @data["installed"].sort!
+        @data["installed"].uniq!
+
+        # Save
+        @path.open("w+") do |f|
+          f.write(JSON.dump(@data))
+        end
+      end
+    end
+  end
+end

data/plugins/commands/provision/command.rb

@@ -0,0 +1,34 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandProvision
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        options = {}
+        options[:provision_types] = nil
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant provision [vm-name] [--provision-with x,y,z]"
+
+          o.on("--provision-with x,y,z", Array,
+                    "Enable only certain provisioners, by type.") do |list|
+            options[:provision_types] = list.map { |type| type.to_sym }
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Go over each VM and provision!
+        @logger.debug("'provision' each target VM...")
+        with_target_vms(argv) do |machine|
+          machine.action(:provision, options)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/provision/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandProvision
+    class Plugin < Vagrant.plugin("2")
+      name "provision command"
+      description <<-DESC
+      The `provision` command provisions your virtual machine based on the
+      configuration of the Vagrantfile.
+      DESC
+
+      command("provision") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/reload/command.rb

@@ -0,0 +1,37 @@
+require 'optparse'
+
+require "vagrant"
+
+require Vagrant.source_root.join("plugins/commands/up/start_mixins")
+
+module VagrantPlugins
+  module CommandReload
+    class Command < Vagrant.plugin("2", :command)
+      # We assume that the `up` plugin exists and that we'll have access
+      # to this.
+      include VagrantPlugins::CommandUp::StartMixins
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant reload [vm-name]"
+          o.separator ""
+          build_start_options(o, options)
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'reload' each target VM...")
+        with_target_vms(argv) do |machine|
+          machine.action(:reload, options)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/reload/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandReload
+    class Plugin < Vagrant.plugin("2")
+      name "reload command"
+      description <<-DESC
+      The `reload` command will halt, reconfigure your machine based on
+      the Vagrantfile, and bring it back up.
+      DESC
+
+      command("reload") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/resume/command.rb

@@ -0,0 +1,25 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandResume
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant resume [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'resume' each target VM...")
+        with_target_vms(argv) do |machine|
+          machine.action(:resume)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/resume/plugin.rb

@@ -0,0 +1,17 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandResume
+    class Plugin < Vagrant.plugin("2")
+      name "resume command"
+      description <<-DESC
+      The `resume` command resumes a suspend virtual machine.
+      DESC
+
+      command("resume") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/ssh/command.rb

@@ -0,0 +1,63 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandSSH
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant ssh [vm-name] [-c command] [-- extra ssh args]"
+
+          o.separator ""
+
+          o.on("-c", "--command COMMAND", "Execute an SSH command directly.") do |c|
+            options[:command] = c
+          end
+
+          o.on("-p", "--plain", "Plain mode, leaves authentication up to user.") do |p|
+            options[:plain_mode] = p
+          end
+        end
+
+        # Parse out the extra args to send to SSH, which is everything
+        # after the "--"
+        split_index = @argv.index("--")
+        if split_index
+          options[:ssh_args] = @argv.drop(split_index + 1)
+          @argv              = @argv.take(split_index)
+        end
+
+        # Parse the options and return if we don't have any target.
+        argv = parse_options(opts)
+        return if !argv
+
+        # Execute the actual SSH
+        with_target_vms(argv, :single_target => true) do |vm|
+          if options[:command]
+            @logger.debug("Executing single command on remote machine: #{options[:command]}")
+            env = vm.action(:ssh_run, :ssh_run_command => options[:command])
+
+            # Exit with the exit status of the command or a 0 if we didn't
+            # get one.
+            exit_status = env[:ssh_run_exit_status] || 0
+            return exit_status
+          else
+            opts = {
+              :plain_mode => options[:plain_mode],
+              :extra_args => options[:ssh_args]
+            }
+
+            @logger.debug("Invoking `ssh` action on machine")
+            vm.action(:ssh, :ssh_opts => opts)
+
+            # We should never reach this point, since the point of `ssh`
+            # is to exec into the proper SSH shell, but we'll just return
+            # an exit status of 0 anyways.
+            return 0
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/ssh/plugin.rb

@@ -0,0 +1,17 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandSSH
+    class Plugin < Vagrant.plugin("2")
+      name "ssh command"
+      description <<-DESC
+      The `ssh` command allows you to SSH in to your running virtual machine.
+      DESC
+
+      command("ssh") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/ssh_config/command.rb

@@ -0,0 +1,49 @@
+require 'optparse'
+
+require "vagrant/util/safe_puts"
+
+module VagrantPlugins
+  module CommandSSHConfig
+    class Command < Vagrant.plugin("2", :command)
+      include Vagrant::Util::SafePuts
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant ssh-config [vm-name] [--host name]"
+          o.separator ""
+
+          o.on("--host COMMAND", "Name the host for the config..") do |h|
+            options[:host] = h
+          end
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        with_target_vms(argv, :single_target => true) do |machine|
+          ssh_info = machine.ssh_info
+          raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
+
+          variables = {
+            :host_key => options[:host] || machine.name || "vagrant",
+            :ssh_host => ssh_info[:host],
+            :ssh_port => ssh_info[:port],
+            :ssh_user => ssh_info[:username],
+            :private_key_path => ssh_info[:private_key_path],
+            :forward_agent => ssh_info[:forward_agent],
+            :forward_x11   => ssh_info[:forward_x11]
+          }
+
+          # Render the template and output directly to STDOUT
+          template = "commands/ssh_config/config"
+          safe_puts(Vagrant::Util::TemplateRenderer.render(template, variables))
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/ssh_config/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandSSHConfig
+    class Plugin < Vagrant.plugin("2")
+      name "ssh-config command"
+      description <<-DESC
+      The `ssh-config` command dumps an OpenSSH compatible configuration
+      that can be used to quickly SSH into your virtual machine.
+      DESC
+
+      command("ssh-config") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/status/command.rb

@@ -0,0 +1,39 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandStatus
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant status [machine-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        state = nil
+        results = []
+        with_target_vms(argv) do |machine|
+          state = machine.state if !state
+          results << "#{machine.name.to_s.ljust(25)}#{machine.state.short_description} (#{machine.provider_name})"
+        end
+
+        message = nil
+        if results.length == 1
+          message = state.long_description
+        else
+          message = I18n.t("vagrant.commands.status.listing")
+        end
+
+        @env.ui.info(I18n.t("vagrant.commands.status.output",
+                            :states => results.join("\n"),
+                            :message => message),
+                     :prefix => false)
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/status/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandStatus
+    class Plugin < Vagrant.plugin("2")
+      name "status command"
+      description <<-DESC
+      The `status` command shows what the running state (running/saved/..)
+      is of all your virtual machines in this environment.
+      DESC
+
+      command("status") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/suspend/command.rb

@@ -0,0 +1,25 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandSuspend
+    class Command < Vagrant.plugin("2", :command)
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant suspend [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'suspend' each target VM...")
+        with_target_vms(argv) do |vm|
+          vm.action(:suspend)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end