vagrantup 1.0.7 → 1.1.0

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/{lib/vagrant/command/ssh.rb → plugins/commands/ssh/command.rb}

@@ -1,8 +1,8 @@
 require 'optparse'
 
-module Vagrant
-  module Command
-    class SSH < Base
+module VagrantPlugins
+  module CommandSSH
+    class Command < Vagrant.plugin("2", :command)
       def execute
         options = {}
 
@@ -37,53 +37,29 @@ module Vagrant
 
         # Execute the actual SSH
         with_target_vms(argv, :single_target => true) do |vm|
-          # Basic checks that are required for proper SSH
-          raise Errors::VMNotCreatedError if !vm.created?
-          raise Errors::VMInaccessible if !vm.state == :inaccessible
-          raise Errors::VMNotRunningError if vm.state != :running
-
           if options[:command]
-            ssh_execute(vm, 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]
             }
 
-            ssh_connect(vm, opts)
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-
-      protected
+            @logger.debug("Invoking `ssh` action on machine")
+            vm.action(:ssh, :ssh_opts => opts)
 
-      def ssh_execute(vm, command=nil)
-        exit_status = 0
-
-        @logger.debug("Executing command: #{command}")
-        exit_status = vm.channel.execute(command, :error_check => false) do |type, data|
-          # Determine the proper channel to send the output onto depending
-          # on the type of data we are receiving.
-          channel = type == :stdout ? :out : :error
-
-          # Print the SSH output as it comes in, but don't prefix it and don't
-          # force a new line so that the output is properly preserved
-          vm.ui.info(data.to_s,
-                     :prefix => false,
-                     :new_line => false,
-                     :channel => channel)
+            # 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
-
-        # Exit with the exit status we got from executing the command
-        exit exit_status
-      end
-
-      def ssh_connect(vm, opts)
-        @logger.debug("`exec` into ssh prompt")
-        vm.ssh.exec(opts)
       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/{lib/vagrant/command/ssh_config.rb → plugins/commands/ssh_config/command.rb}

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