vagrantup 1.0.7 → 1.1.0

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

data/plugins/commands/suspend/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandSuspend
+    class Plugin < Vagrant.plugin("2")
+      name "suspend command"
+      description <<-DESC
+      The `suspend` command suspends execution and puts it to sleep.
+      The command `resume` returns it to running status.
+      DESC
+
+      command("suspend") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/plugins/commands/up/command.rb

@@ -0,0 +1,45 @@
+require 'optparse'
+
+require "vagrant"
+
+require File.expand_path("../start_mixins", __FILE__)
+
+module VagrantPlugins
+  module CommandUp
+    class Command < Vagrant.plugin("2", :command)
+      include StartMixins
+
+      def execute
+        options = {}
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant up [vm-name] [--[no-]provision] [--provider provider] [-h]"
+          o.separator ""
+
+          build_start_options(o, options)
+
+          o.on("--provider provider", String,
+               "Back the machine with a specific provider.") do |provider|
+            options[:provider] = provider
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Go over each VM and bring it up
+        @logger.debug("'Up' each target VM...")
+        with_target_vms(argv, :provider => options[:provider]) do |machine|
+          @env.ui.info(I18n.t(
+            "vagrant.commands.up.upping",
+            :name => machine.name,
+            :provider => machine.provider_name))
+          machine.action(:up, options)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/up/plugin.rb

@@ -0,0 +1,17 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandUp
+    class Plugin < Vagrant.plugin("2")
+      name "up command"
+      description <<-DESC
+      The `up` command brings the virtual environment up and running.
+      DESC
+
+      command("up") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/{lib/vagrant/command → plugins/commands/up}/start_mixins.rb

@@ -1,5 +1,5 @@
-module Vagrant
-  module Command
+module VagrantPlugins
+  module CommandUp
     module StartMixins
       # This adds the standard `start` command line flags to the given
       # OptionParser, storing the result in the `options` dictionary.
@@ -8,17 +8,17 @@ module Vagrant
       # @param [Hash] options
       def build_start_options(parser, options)
         # Setup the defaults
-        options["provision.enabled"] = true
-        options["provision.types"] = nil
+        options[:provision_enabled] = true
+        options[:provision_types] = nil
 
         # Add the options
         parser.on("--[no-]provision", "Enable or disable provisioning") do |p|
-          options["provision.enabled"] = p
+          options[:provision_enabled] = p
         end
 
         parser.on("--provision-with x,y,z", Array,
                 "Enable only certain provisioners, by type.") do |list|
-          options["provision.types"] = list
+          options[:provision_types] = list.map { |type| type.to_sym }
         end
       end
     end

data/{lib/vagrant/communication/ssh.rb → plugins/communicators/ssh/communicator.rb}

@@ -1,3 +1,6 @@
+require 'logger'
+require 'pathname'
+require 'stringio'
 require 'timeout'
 
 require 'log4r'
@@ -8,33 +11,38 @@ require 'vagrant/util/ansi_escape_code_remover'
 require 'vagrant/util/file_mode'
 require 'vagrant/util/platform'
 require 'vagrant/util/retryable'
+require 'vagrant/util/ssh'
 
-module Vagrant
-  module Communication
-    # Provides communication with the VM via SSH.
-    class SSH < Base
-      include Util::ANSIEscapeCodeRemover
-      include Util::Retryable
+module VagrantPlugins
+  module CommunicatorSSH
+    # This class provides communication with the VM via SSH.
+    class Communicator < Vagrant.plugin("2", :communicator)
+      include Vagrant::Util::ANSIEscapeCodeRemover
+      include Vagrant::Util::Retryable
 
-      def initialize(vm)
-        @vm     = vm
-        @logger = Log4r::Logger.new("vagrant::communication::ssh")
+      def self.match?(machine)
+        # All machines are currently expected to have SSH.
+        true
+      end
+
+      def initialize(machine)
+        @machine = machine
+        @logger  = Log4r::Logger.new("vagrant::communication::ssh")
         @connection = nil
       end
 
       def ready?
         @logger.debug("Checking whether SSH is ready...")
 
-        Timeout.timeout(@vm.config.ssh.timeout) do
-          connect
-        end
+        # Attempt to connect. This will raise an exception if it fails.
+        connect
 
         # If we reached this point then we successfully connected
         @logger.info("SSH is ready!")
         true
-      rescue Timeout::Error, Errors::SSHConnectionRefused, Net::SSH::Disconnect => e
-        # The above errors represent various reasons that SSH may not be
-        # ready yet. Return false.
+      rescue Vagrant::Errors::VagrantError => e
+        # We catch a `VagrantError` which would signal that something went
+        # wrong expectedly in the `connect`, which means we didn't connect.
         @logger.info("SSH not up: #{e.inspect}")
         return false
       end
@@ -42,7 +50,7 @@ module Vagrant
       def execute(command, opts=nil, &block)
         opts = {
           :error_check => true,
-          :error_class => Errors::VagrantError,
+          :error_class => Vagrant::Errors::VagrantError,
           :error_key   => :ssh_bad_exit_status,
           :command     => command,
           :sudo        => false
@@ -72,21 +80,40 @@ module Vagrant
         execute(command, opts, &block)
       end
 
+      def download(from, to=nil)
+        @logger.debug("Downloading: #{from} to #{to}")
+
+        scp_connect do |scp|
+          scp.download!(from, to)
+        end
+      end
+
+      def test(command, opts=nil)
+        opts = { :error_check => false }.merge(opts || {})
+        execute(command, opts) == 0
+      end
+
       def upload(from, to)
         @logger.debug("Uploading: #{from} to #{to}")
 
-        # Do an SCP-based upload...
-        connect do |connection|
-          # Open file read only to fix issue #1036
-          scp = Net::SCP.new(connection)
-          scp.upload!(File.open(from, "r"), to)
+        scp_connect do |scp|
+          if File.directory?(from)
+            # Recurisvely upload directories
+            scp.upload!(from, to, :recursive => true)
+          else
+            # Open file read only to fix issue [GH-1036]
+            scp.upload!(File.open(from, "r"), to)
+          end
         end
-      rescue Net::SCP::Error => e
-        # If we get the exit code of 127, then this means SCP is unavailable.
-        raise Errors::SCPUnavailable if e.message =~ /\(127\)/
-
-          # Otherwise, just raise the error up
-          raise
+      rescue RuntimeError => e
+        # Net::SCP raises a runtime error for this so the only way we have
+        # to really catch this exception is to check the message to see if
+        # it is something we care about. If it isn't, we re-raise.
+        raise if e.message !~ /Permission denied/
+
+        # Otherwise, it is a permission denied, so let's raise a proper
+        # exception
+        raise Vagrant::Errors::SCPPermissionDenied, :path => from.to_s
       end
 
       protected
@@ -113,21 +140,25 @@ module Vagrant
           end
         end
 
-        ssh_info = @vm.ssh.info
+        # Get the SSH info for the machine, raise an exception if the
+        # provider is saying that SSH is not ready.
+        ssh_info = @machine.ssh_info
+        raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
 
         # Build the options we'll use to initiate the connection via Net::SSH
         opts = {
-          :port                  => ssh_info[:port],
+          :auth_methods          => ["none", "publickey", "hostbased", "password"],
+          :config                => false,
+          :forward_agent         => ssh_info[:forward_agent],
           :keys                  => [ssh_info[:private_key_path]],
           :keys_only             => true,
-          :user_known_hosts_file => [],
           :paranoid              => false,
-          :config                => false,
-          :forward_agent         => ssh_info[:forward_agent]
+          :port                  => ssh_info[:port],
+          :user_known_hosts_file => []
         }
 
         # Check that the private key permissions are valid
-        @vm.ssh.check_key_permissions(ssh_info[:private_key_path])
+        Vagrant::Util::SSH.check_key_permissions(Pathname.new(ssh_info[:private_key_path]))
 
         # Connect to SSH, giving it a few tries
         connection = nil
@@ -136,27 +167,68 @@ module Vagrant
           # errors that are generally fixed from a retry and don't
           # necessarily represent immediate failure cases.
           exceptions = [
+            Errno::EADDRINUSE,
             Errno::ECONNREFUSED,
+            Errno::ECONNRESET,
             Errno::EHOSTUNREACH,
             Net::SSH::Disconnect,
             Timeout::Error
           ]
 
-          @logger.info("Connecting to SSH: #{ssh_info[:host]}:#{ssh_info[:port]}")
-          connection = retryable(:tries => @vm.config.ssh.max_tries, :on => exceptions) do
-            Net::SSH.start(ssh_info[:host], ssh_info[:username], opts)
+          retries = @machine.config.ssh.max_tries
+          timeout = @machine.config.ssh.timeout
+
+          @logger.info("Attempting SSH. Retries: #{retries}. Timeout: #{timeout}")
+          connection = retryable(:tries => retries, :on => exceptions) do
+            Timeout.timeout(timeout) do
+              begin
+                # This logger will get the Net-SSH log data for us.
+                ssh_logger_io = StringIO.new
+                ssh_logger    = Logger.new(ssh_logger_io)
+
+                # Setup logging for connections
+                connect_opts = opts.merge({
+                  :logger  => ssh_logger,
+                  :verbose => :debug
+                })
+
+                @logger.info("Attempting to connect to SSH: #{ssh_info[:host]}:#{ssh_info[:port]}")
+                Net::SSH.start(ssh_info[:host], ssh_info[:username], connect_opts)
+              ensure
+                # Make sure we output the connection log
+                @logger.debug("== Net-SSH connection debug-level log START ==")
+                @logger.debug(ssh_logger_io.string)
+                @logger.debug("== Net-SSH connection debug-level log END ==")
+              end
+            end
           end
+        rescue Errno::ETIMEDOUT, Timeout::Error
+          # This happens if we continued to timeout when attempting to connect.
+          raise Vagrant::Errors::SSHConnectionTimeout
         rescue Net::SSH::AuthenticationFailed
           # This happens if authentication failed. We wrap the error in our
           # own exception.
-          raise Errors::SSHAuthenticationFailed
+          raise Vagrant::Errors::SSHAuthenticationFailed
+        rescue Net::SSH::Disconnect
+          # This happens if the remote server unexpectedly closes the
+          # connection. This is usually raised when SSH is running on the
+          # other side but can't properly setup a connection. This is
+          # usually a server-side issue.
+          raise Vagrant::Errors::SSHDisconnected
         rescue Errno::ECONNREFUSED
           # This is raised if we failed to connect the max amount of times
-          raise Errors::SSHConnectionRefused
+          raise Vagrant::Errors::SSHConnectionRefused
+        rescue Errno::ECONNRESET
+          # This is raised if we failed to connect the max number of times
+          # due to an ECONNRESET.
+          raise Vagrant::Errors::SSHConnectionReset
+        rescue Errno::EHOSTDOWN
+          # This is raised if we get an ICMP DestinationUnknown error.
+          raise Vagrant::Errors::SSHHostDown
         rescue NotImplementedError
           # This is raised if a private key type that Net-SSH doesn't support
           # is used. Show a nicer error.
-          raise Errors::SSHKeyTypeNotSupported
+          raise Vagrant::Errors::SSHKeyTypeNotSupported
         end
 
         @connection = connection
@@ -178,7 +250,7 @@ module Vagrant
 
         # Determine the shell to execute. If we are using `sudo` then we
         # need to wrap the shell in a `sudo` call.
-        shell = "#{@vm.config.ssh.shell} -l"
+        shell = @machine.config.ssh.shell
         shell = "sudo -H #{shell}" if sudo
 
         # Open the channel so we can execute or command
@@ -186,21 +258,17 @@ module Vagrant
           ch.exec(shell) do |ch2, _|
             # Setup the channel callbacks so we can get data and exit status
             ch2.on_data do |ch3, data|
-              if block_given?
-                # Filter out the clear screen command
-                data = remove_ansi_escape_codes(data)
-                @logger.debug("stdout: #{data}")
-                yield :stdout, data
-              end
+              # Filter out the clear screen command
+              data = remove_ansi_escape_codes(data)
+              @logger.debug("stdout: #{data}")
+              yield :stdout, data if block_given?
             end
 
             ch2.on_extended_data do |ch3, type, data|
-              if block_given?
-                # Filter out the clear screen command
-                data = remove_ansi_escape_codes(data)
-                @logger.debug("stderr: #{data}")
-                yield :stderr, data
-              end
+              # Filter out the clear screen command
+              data = remove_ansi_escape_codes(data)
+              @logger.debug("stderr: #{data}")
+              yield :stderr, data if block_given?
             end
 
             ch2.on_request("exit-status") do |ch3, data|
@@ -216,6 +284,9 @@ module Vagrant
 
             # Remember to exit or this channel will hang open
             ch2.send_data "exit\n"
+
+            # Send eof to let server know we're done
+            ch2.eof!
           end
         end
 
@@ -225,6 +296,22 @@ module Vagrant
         # Return the final exit status
         return exit_status
       end
+
+      # Opens an SCP connection and yields it so that you can download
+      # and upload files.
+      def scp_connect
+        # Connect to SCP and yield the SCP object
+        connect do |connection|
+          scp = Net::SCP.new(connection)
+          return yield scp
+        end
+      rescue Net::SCP::Error => e
+        # If we get the exit code of 127, then this means SCP is unavailable.
+        raise Vagrant::Errors::SCPUnavailable if e.message =~ /\(127\)/
+
+        # Otherwise, just raise the error up
+        raise
+      end
     end
   end
 end