vagrant 0.8.10 → 0.9.0

data/lib/vagrant/command/resume.rb

@@ -1,14 +1,27 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class ResumeCommand < NamedBase
-      register "resume", "Resume a suspended Vagrant environment."
-
+    class Resume < Base
       def execute
-        target_vms.each do |vm|
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.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[0]) do |vm|
           if vm.created?
+            @logger.info("Resume: #{vm.name}")
             vm.resume
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("Not created: #{vm.name}. Not resuming.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end

data/lib/vagrant/command/ssh.rb

@@ -1,49 +1,87 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class SSHCommand < NamedBase
-      class_option :command, :type => :string, :default => false, :aliases => "-c"
-      register "ssh", "SSH into the currently running Vagrant environment."
-
+    class SSH < Base
       def execute
-        if options[:command]
-          ssh_execute
-        else
-          ssh_connect
-        end
-      end
+        options = {}
 
-      protected
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant ssh [vm-name] [-c command] [-- extra ssh args]"
+
+          opts.separator ""
 
-      def ssh_execute
-        ssh_vm.ssh.execute do |ssh|
-          ssh.exec!(options[:command]) do |channel, type, data|
-            if type != :exit_status
-              # 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
-              ssh_vm.env.ui.info(data.to_s, :prefix => false, :new_line => false)
-            end
+          opts.on("-c", "--command COMMAND", "Execute an SSH command directly.") do |c|
+            options[:command] = c
+          end
+          opts.on("-p", "--plain", "Plain mode, leaves authentication up to user.") do |p|
+            options[:plain_mode] = p
           end
         end
-      end
 
-      def ssh_connect
-        ssh_vm.ssh.connect
-      end
+        # Parse the options and return if we don't have any target.
+        argv = parse_options(opts)
+        return if !argv
 
-      def ssh_vm
-        @ssh_vm ||= begin
-          vm = self.name.nil? && env.multivm? ? env.primary_vm : nil
-          raise Errors::MultiVMTargetRequired, :command => "ssh" if !vm && target_vms.length > 1
-          vm = target_vms.first if !vm
+        # Parse out the extra args to send to SSH, which is everything
+        # after the "--"
+        ssh_args = ARGV.drop_while { |i| i != "--" }
+        ssh_args = ssh_args[1..-1]
+        options[:ssh_args] = ssh_args
 
+        # If the remaining arguments ARE the SSH arguments, then just
+        # clear it out. This happens because optparse returns what is
+        # after the "--" as remaining ARGV, and Vagrant can think it is
+        # a multi-vm name (wrong!)
+        argv = [] if argv == ssh_args
+
+        # Execute the actual SSH
+        with_target_vms(argv[0], true) do |vm|
           # Basic checks that are required for proper SSH
           raise Errors::VMNotCreatedError if !vm.created?
-          raise Errors::VMInaccessible if !vm.vm.accessible?
-          raise Errors::VMNotRunningError if !vm.vm.running?
+          raise Errors::VMInaccessible if !vm.state == :inaccessible
+          raise Errors::VMNotRunningError if vm.state != :running
+
+          if options[:command]
+            ssh_execute(vm, options[:command])
+          else
+            opts = {
+              :plain_mode => options[:plain_mode],
+              :extra_args => options[:ssh_args]
+            }
 
-          vm
+            ssh_connect(vm, opts)
+          end
         end
       end
+
+      protected
+
+      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)
+        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
 end

data/lib/vagrant/command/ssh_config.rb

@@ -1,28 +1,43 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class SSHConfigCommand < NamedBase
-      class_option :host, :type => :string, :default => nil, :aliases => "-h"
-      register "ssh_config", "outputs .ssh/config valid syntax for connecting to this environment via ssh"
-
+    class SSHConfig < Base
       def execute
-        raise Errors::MultiVMTargetRequired, :command => "ssh_config" if target_vms.length > 1
-        vm = target_vms.first
-        raise Errors::VMNotCreatedError if !vm.created?
-        raise Errors::VMInaccessible if !vm.vm.accessible?
-
-        # We need to fix the file permissions of the key if they aren't set
-        # properly, otherwise if the user attempts to SSH in, it won't work!
-        vm.ssh.check_key_permissions(vm.env.config.ssh.private_key_path)
-
-        $stdout.puts(Util::TemplateRenderer.render("ssh_config", {
-          :host_key => options[:host] || vm.name || "vagrant",
-          :ssh_host => vm.env.config.ssh.host,
-          :ssh_user => vm.env.config.ssh.username,
-          :ssh_port => vm.ssh.port,
-          :private_key_path => vm.env.config.ssh.private_key_path,
-          :forward_agent => vm.env.config.ssh.forward_agent,
-          :forward_x11   => vm.env.config.ssh.forward_x11
-        }))
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant ssh-config [vm-name] [-h name]"
+
+          opts.separator ""
+
+          opts.on("-h", "--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[0], true) do |vm|
+          raise Errors::VMNotCreatedError if !vm.created?
+          raise Errors::VMInaccessible if !vm.state == :inaccessible
+
+          ssh_info  = vm.ssh.info
+          variables = {
+            :host_key => options[:host] || vm.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"
+          $stdout.puts(Util::TemplateRenderer.render(template, variables))
+        end
       end
     end
   end

data/lib/vagrant/command/status.rb

@@ -1,30 +1,32 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class StatusCommand < NamedBase
-      register "status", "Shows the status of the current Vagrant environment."
-
+    class Status < Base
       def execute
-        state = nil
-        results = target_vms.collect do |vm|
-          if vm.created?
-            if vm.vm.accessible?
-              state = vm.vm.state.to_s
-            else
-              state = "inaccessible"
-            end
-          else
-            state = "not_created"
-          end
+        options = {}
 
-          "#{vm.name.to_s.ljust(25)}#{state.gsub("_", " ")}"
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant status [vm-name]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        state = nil
+        results = []
+        with_target_vms(argv[0]) do |vm|
+          state = vm.state.to_s if !state
+          results << "#{vm.name.to_s.ljust(25)}#{vm.state.to_s.gsub("_", " ")}"
         end
 
-        state = target_vms.length == 1 ? state : "listing"
+        state = results.length == 1 ? state : "listing"
 
-        env.ui.info(I18n.t("vagrant.commands.status.output",
-                    :states => results.join("\n"),
-                    :message => I18n.t("vagrant.commands.status.#{state}")),
-                    :prefix => false)
+        @env.ui.info(I18n.t("vagrant.commands.status.output",
+                            :states => results.join("\n"),
+                            :message => I18n.t("vagrant.commands.status.#{state}")),
+                     :prefix => false)
       end
     end
   end

data/lib/vagrant/command/suspend.rb

@@ -1,14 +1,27 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class SuspendCommand < NamedBase
-      register "suspend", "Suspend a running Vagrant environment."
-
+    class Suspend < Base
       def execute
-        target_vms.each do |vm|
+        options = {}
+
+        opts = OptionParser.new do |opts|
+          opts.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[0]) do |vm|
           if vm.created?
+            @logger.info("Suspending: #{vm.name}")
             vm.suspend
           else
-            vm.env.ui.info I18n.t("vagrant.commands.common.vm_not_created")
+            @logger.info("Not created: #{vm.name}. Not suspending.")
+            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
           end
         end
       end

data/lib/vagrant/command/up.rb

@@ -1,16 +1,49 @@
+require 'optparse'
+
 module Vagrant
   module Command
-    class UpCommand < NamedBase
-      class_option :provision, :type => :boolean, :default => true
-      register "up", "Creates the Vagrant environment"
-
+    class Up < Base
       def execute
-        target_vms.each do |vm|
+        options = {
+          :provision => true,
+          :provisioners => nil
+        }
+
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: vagrant up [vm-name] [--[no-]provision] [-h]"
+
+          opts.separator ""
+
+          opts.on("--[no-]provision", "Enable or disable provisioning") do |p|
+            options[:provision] = p
+          end
+
+          opts.on("--provision-with x,y,z", Array,
+                  "Enable only certain provisioners, by type.") do |list|
+            options[:provisioners] = list
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        # Parameters to send to actions
+        action_params = {
+          "provision.enabled" => options[:provision],
+          "provision.types"   => options[:provisioners]
+        }
+
+        # Go over each VM and bring it up
+        @logger.debug("'Up' each target VM...")
+        with_target_vms(argv[0]) do |vm|
           if vm.created?
-            vm.env.ui.info I18n.t("vagrant.commands.up.vm_created")
-            vm.start("provision.enabled" => options[:provision])
+            @logger.info("Booting: #{vm.name}")
+            vm.ui.info I18n.t("vagrant.commands.up.vm_created")
+            vm.start(action_params)
           else
-            vm.up("provision.enabled" => options[:provision])
+            @logger.info("Creating: #{vm.name}")
+            vm.up(action_params)
           end
         end
       end

data/lib/vagrant/communication.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  module Communication
+    autoload :Base, 'vagrant/communication/base'
+
+    autoload :SSH,  'vagrant/communication/ssh'
+  end
+end

data/lib/vagrant/communication/base.rb

@@ -0,0 +1,56 @@
+module Vagrant
+  module Communication
+    # The base class for any classes that provide an API for communicating
+    # with the virtual machine.
+    #
+    # There are various stages that require Vagrant to copy files or
+    # run commands on the target system, and communication classes provide
+    # the abstraction necessary to perform these tasks, via SSH or some
+    # other mechanism.
+    #
+    # Any subclasses of this class **must** implement all of the methods
+    # below.
+    class Base
+      # Checks if the target machine is ready for communication.
+      #
+      # @return [Boolean]
+      def ready?
+      end
+
+      # Upload a file to the virtual machine.
+      #
+      # @param [String] from Path to a file to upload.
+      # @param [String] to Path to where to save this file.
+      def upload(from, to)
+      end
+
+      # Execute a command on the remote machine.
+      #
+      # @param [String] command Command to execute.
+      # @yield [type, data] Realtime output of the command being executed.
+      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
+      # @yieldparam [String] data Data for the given output.
+      # @return [Integer] Exit code of the command.
+      def execute(command, opts=nil)
+      end
+
+      # Execute a comand with super user privileges.
+      #
+      # See #execute for parameter information.
+      def sudo(command, opts=nil)
+      end
+
+      # Executes a command and returns a boolean statement if it was successful
+      # or not.
+      #
+      # This is implemented by default as expecting `execute` to return 0.
+      def test(command, opts=nil)
+        # Disable error checking no matter what
+        opts = (opts || {}).merge(:error_check => false)
+
+        # Successful if the exit status is 0
+        execute(command, opts) == 0
+      end
+    end
+  end
+end

data/lib/vagrant/communication/ssh.rb

@@ -0,0 +1,200 @@
+require 'timeout'
+
+require 'log4r'
+require 'net/ssh'
+require 'net/scp'
+
+require 'vagrant/util/file_mode'
+require 'vagrant/util/platform'
+require 'vagrant/util/retryable'
+
+module Vagrant
+  module Communication
+    # Provides communication with the VM via SSH.
+    class SSH < Base
+      include Util::Retryable
+
+      def initialize(vm)
+        @vm     = vm
+        @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
+
+        # 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.
+        @logger.info("SSH not up: #{e.inspect}")
+        return false
+      end
+
+      def execute(command, opts=nil, &block)
+        opts = {
+          :error_check => true,
+          :error_class => Errors::VagrantError,
+          :error_key   => :ssh_bad_exit_status,
+          :command     => command,
+          :sudo        => false
+        }.merge(opts || {})
+
+        # Connect via SSH and execute the command in the shell.
+        exit_status = connect do |connection|
+          shell_execute(connection, command, opts[:sudo], &block)
+        end
+
+        # Check for any errors
+        if opts[:error_check] && exit_status != 0
+          # The error classes expect the translation key to be _key,
+          # but that makes for an ugly configuration parameter, so we
+          # set it here from `error_key`
+          error_opts = opts.merge(:_key => opts[:error_key])
+          raise opts[:error_class], error_opts
+        end
+
+        # Return the exit status
+        exit_status
+      end
+
+      def sudo(command, opts=nil, &block)
+        # Run `execute` but with the `sudo` option.
+        opts = { :sudo => true }.merge(opts || {})
+        execute(command, opts, &block)
+      end
+
+      def upload(from, to)
+        # Do an SCP-based upload...
+        connect do |connection|
+          scp = Net::SCP.new(connection)
+          scp.upload!(from, to)
+        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
+      end
+
+      protected
+
+      # Opens an SSH connection and yields it to a block.
+      def connect
+        if @connection && !@connection.closed?
+          # There is a chance that the socket is closed despite us checking
+          # 'closed?' above. To test this we need to send data through the
+          # socket.
+          begin
+            @connection.exec!("")
+          rescue IOError
+            @logger.info("Connection has been closed. Not re-using.")
+            @connection = nil
+          end
+
+          # If the @connection is still around, then it is valid,
+          # and we use it.
+          if @connection
+            @logger.info("Re-using SSH connection.")
+            return yield @connection if block_given?
+            return
+          end
+        end
+
+        ssh_info = @vm.ssh.info
+
+        # Build the options we'll use to initiate the connection via Net::SSH
+        opts = {
+          :port                  => ssh_info[:port],
+          :keys                  => [ssh_info[:private_key_path]],
+          :keys_only             => true,
+          :user_known_hosts_file => [],
+          :paranoid              => false,
+          :config                => false,
+          :forward_agent         => ssh_info[:forward_agent]
+        }
+
+        # Check that the private key permissions are valid
+        @vm.ssh.check_key_permissions(ssh_info[:private_key_path])
+
+        # Connect to SSH, giving it a few tries
+        @logger.info("Connecting to SSH: #{ssh_info[:host]}:#{ssh_info[:port]}")
+        exceptions = [Errno::ECONNREFUSED, Net::SSH::Disconnect]
+        connection = retryable(:tries => @vm.config.ssh.max_tries, :on => exceptions) do
+          Net::SSH.start(ssh_info[:host], ssh_info[:username], opts)
+        end
+
+        @connection = connection
+
+        # This is hacky but actually helps with some issues where
+        # Net::SSH is simply not robust enough to handle... see
+        # issue #391, #455, etc.
+        sleep 4
+
+        # Yield the connection that is ready to be used and
+        # return the value of the block
+        return yield connection if block_given?
+      rescue Net::SSH::AuthenticationFailed
+        # This happens if authentication failed. We wrap the error in our
+        # own exception.
+        raise Errors::SSHAuthenticationFailed
+      rescue Errno::ECONNREFUSED
+        # This is raised if we failed to connect the max amount of times
+        raise Errors::SSHConnectionRefused
+      ensure
+        # Be sure the connection is always closed
+        # connection.close if connection && !connection.closed?
+      end
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(connection, command, sudo=false)
+        exit_status = nil
+
+        # 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 = "sudo -H #{shell}" if sudo
+
+        # Open the channel so we can execute or command
+        channel = connection.open_channel do |ch|
+          ch.exec(shell) do |ch2, _|
+            # Setup the channel callbacks so we can get data and exit status
+            ch2.on_data do |ch3, data|
+              yield :stdout, data if block_given?
+            end
+
+            ch2.on_extended_data do |ch3, type, data|
+              yield :stderr, data if block_given?
+            end
+
+            ch2.on_request("exit-status") do |ch3, data|
+              exit_status = data.read_long
+            end
+
+            # Set the terminal
+            ch2.send_data "export TERM=vt100\n"
+
+            # Output the command
+            ch2.send_data "#{command}\n"
+
+            # Remember to exit or this channel will hang open
+            ch2.send_data "exit\n"
+          end
+        end
+
+        # Wait for the channel to complete
+        channel.wait
+
+        # Return the final exit status
+        return exit_status
+      end
+    end
+  end
+end