tnargav 1.3.5 → 1.3.6

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,44 @@
+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
+
+        max_name_length = 25
+        with_target_vms(argv) do |machine|
+          max_name_length = machine.name.length if machine.name.length > max_name_length
+        end
+
+        state = nil
+        results = []
+        with_target_vms(argv) do |machine|
+          state = machine.state if !state
+          results << "#{machine.name.to_s.ljust(max_name_length)} #{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,67 @@
+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 = {}
+        options[:destroy_on_error] = true
+        options[:parallel] = true
+        options[:provision_ignore_sentinel] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant up [vm-name] [options] [-h]"
+          o.separator ""
+
+          build_start_options(o, options)
+
+          o.on("--[no-]destroy-on-error",
+               "Destroy machine if any fatal error happens (default to true).") do |destroy|
+            options[:destroy_on_error] = destroy
+          end
+
+          o.on("--[no-]parallel",
+               "Enable or disable parallelism if provider supports it.") do |parallel|
+            options[:parallel] = parallel
+          end
+
+          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
+
+        # Validate the provisioners
+        validate_provisioner_flags!(options)
+
+        # Go over each VM and bring it up
+        @logger.debug("'Up' each target VM...")
+
+        # Build up the batch job of what we'll do
+        @env.batch(options[:parallel]) do |batch|
+          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))
+
+            batch.action(machine, :up, options)
+          end
+        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/plugins/commands/up/start_mixins.rb

@@ -0,0 +1,37 @@
+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.
+      #
+      # @param [OptionParser] parser
+      # @param [Hash] options
+      def build_start_options(parser, options)
+        # Setup the defaults
+        options[:provision_types] = nil
+
+        # Add the options
+        parser.on("--[no-]provision", "Enable or disable provisioning") do |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.map { |type| type.to_sym }
+        end
+      end
+
+      # This validates the provisioner flags and raises an exception
+      # if there are invalid ones.
+      def validate_provisioner_flags!(options)
+        (options[:provision_types] || []).each do |type|
+            klass = Vagrant.plugin("2").manager.provisioners[type]
+            if !klass
+              raise Vagrant::Errors::ProvisionerFlagInvalid,
+                name: type.to_s
+            end
+        end
+      end
+    end
+  end
+end

data/plugins/communicators/ssh/communicator.rb

@@ -0,0 +1,400 @@
+require 'logger'
+require 'pathname'
+require 'stringio'
+require 'timeout'
+
+require 'log4r'
+require 'net/ssh'
+require 'net/ssh/proxy/command'
+require 'net/scp'
+
+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 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 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...")
+
+        # 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 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
+
+      def execute(command, opts=nil, &block)
+        opts = {
+          :error_check => true,
+          :error_class => Vagrant::Errors::VagrantError,
+          :error_key   => :ssh_bad_exit_status,
+          :command     => command,
+          :sudo        => false
+        }.merge(opts || {})
+
+        # Connect via SSH and execute the command in the shell.
+        stdout = ""
+        stderr = ""
+        exit_status = connect do |connection|
+          shell_execute(connection, command, opts[:sudo]) do |type, data|
+            if type == :stdout
+              stdout += data
+            elsif type == :stderr
+              stderr += data
+            end
+
+            block.call(type, data) if block
+          end
+        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],
+            :stdout => stdout,
+            :stderr => stderr
+          )
+          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 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}")
+
+        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 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
+
+      # 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 Exception => e
+            @logger.info("Connection errored, not re-using. Will reconnect.")
+            @logger.debug(e.inspect)
+            @connection = nil
+          end
+
+          # If the @connection is still around, then it is valid,
+          # and we use it.
+          if @connection
+            @logger.debug("Re-using SSH connection.")
+            return yield @connection if block_given?
+            return
+          end
+        end
+
+        # 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 = {
+          :auth_methods          => ["none", "publickey", "hostbased", "password"],
+          :config                => false,
+          :forward_agent         => ssh_info[:forward_agent],
+          :keys                  => [ssh_info[:private_key_path]],
+          :keys_only             => true,
+          :paranoid              => false,
+          :port                  => ssh_info[:port],
+          :user_known_hosts_file => []
+        }
+
+        # Check that the private key permissions are valid
+        Vagrant::Util::SSH.check_key_permissions(Pathname.new(ssh_info[:private_key_path]))
+
+        # Connect to SSH, giving it a few tries
+        connection = nil
+        begin
+          # These are the exceptions that we retry because they represent
+          # errors that are generally fixed from a retry and don't
+          # necessarily represent immediate failure cases.
+          exceptions = [
+            Errno::EACCES,
+            Errno::EADDRINUSE,
+            Errno::ECONNREFUSED,
+            Errno::ECONNRESET,
+            Errno::ENETUNREACH,
+            Errno::EHOSTUNREACH,
+            Net::SSH::Disconnect,
+            Timeout::Error
+          ]
+
+          retries = 5
+          timeout = 60
+
+          @logger.info("Attempting SSH connnection...")
+          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,
+                  :timeout => 15,
+                  :verbose => :debug
+                })
+
+                if ssh_info[:proxy_command]
+                  connect_opts[:proxy] = Net::SSH::Proxy::Command.new(ssh_info[:proxy_command])
+                end
+
+                @logger.info("Attempting to connect to SSH...")
+                @logger.info("  - Host: #{ssh_info[:host]}")
+                @logger.info("  - Port: #{ssh_info[:port]}")
+                @logger.info("  - Username: #{ssh_info[:username]}")
+                @logger.info("  - Key Path: #{ssh_info[:private_key_path]}")
+
+                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::EACCES
+          # This happens on connect() for unknown reasons yet...
+          raise Vagrant::Errors::SSHConnectEACCES
+        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 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 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 Errno::EHOSTUNREACH
+          # This is raised if we can't work out how to route traffic.
+          raise Vagrant::Errors::SSHNoRoute
+        rescue NotImplementedError
+          # This is raised if a private key type that Net-SSH doesn't support
+          # is used. Show a nicer error.
+          raise Vagrant::Errors::SSHKeyTypeNotSupported
+        end
+
+        @connection = connection
+
+        # Yield the connection that is ready to be used and
+        # return the value of the block
+        return yield connection if block_given?
+      end
+
+      # Executes the command on an SSH connection within a login shell.
+      def shell_execute(connection, command, sudo=false)
+        @logger.info("Execute: #{command} (sudo=#{sudo.inspect})")
+        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 = @machine.config.ssh.shell
+        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|
+              # 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|
+              # 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|
+              exit_status = data.read_long
+              @logger.debug("Exit status: #{exit_status}")
+
+              # Close the channel, since after the exit status we're
+              # probably done. This fixes up issues with hanging.
+              channel.close
+            end
+
+            # Set the terminal
+            ch2.send_data "export TERM=vt100\n"
+
+            # Set SSH_AUTH_SOCK if we are in sudo and forwarding agent.
+            # This is to work around often misconfigured boxes where
+            # the SSH_AUTH_SOCK env var is not preserved.
+            if @machine.ssh_info[:forward_agent] && sudo
+              auth_socket = ""
+              execute("echo; printf $SSH_AUTH_SOCK") do |type, data|
+                if type == :stdout
+                  auth_socket += data
+                end
+              end
+
+              if auth_socket != ""
+                # Make sure we only read the last line which should be
+                # the $SSH_AUTH_SOCK env var we printed.
+                auth_socket = auth_socket.split("\n").last.chomp
+              end
+
+              if auth_socket == ""
+                @logger.warn("No SSH_AUTH_SOCK found despite forward_agent being set.")
+              else
+                @logger.info("Setting SSH_AUTH_SOCK remotely: #{auth_socket}")
+                ch2.send_data "export SSH_AUTH_SOCK=#{auth_socket}\n"
+              end
+            end
+
+            # Output the command
+            ch2.send_data "#{command}\n"
+
+            # 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
+
+        begin
+          keep_alive = nil
+
+          if @machine.config.ssh.keep_alive
+            # Begin sending keep-alive packets while we wait for the script
+            # to complete. This avoids connections closing on long-running
+            # scripts.
+            keep_alive = Thread.new do
+              loop do
+                sleep 5
+                @logger.debug("Sending SSH keep-alive...")
+                connection.send_global_request("keep-alive@openssh.com")
+              end
+            end
+          end
+
+          # Wait for the channel to complete
+          begin
+            channel.wait
+          rescue IOError
+            @logger.info("SSH connection unexpected closed. Assuming reboot or something.")
+            exit_status = 0
+          end
+        ensure
+          # Kill the keep-alive thread
+          keep_alive.kill if keep_alive
+        end
+
+        # 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