vagrant 1.0.7 → 1.5.0

data/lib/vagrant/communication/ssh.rb

@@ -1,230 +0,0 @@
-require 'timeout'
-
-require 'log4r'
-require 'net/ssh'
-require 'net/scp'
-
-require 'vagrant/util/ansi_escape_code_remover'
-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::ANSIEscapeCodeRemover
-      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)
-        @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)
-        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.debug("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
-        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::ECONNREFUSED,
-            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)
-          end
-        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
-        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
-        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?
-      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 = "#{@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|
-              if block_given?
-                # Filter out the clear screen command
-                data = remove_ansi_escape_codes(data)
-                @logger.debug("stdout: #{data}")
-                yield :stdout, data
-              end
-            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
-            end
-
-            ch2.on_request("exit-status") do |ch3, data|
-              exit_status = data.read_long
-              @logger.debug("Exit status: #{exit_status}")
-            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

data/lib/vagrant/config.rb

@@ -1,49 +0,0 @@
-module Vagrant
-  module Config
-    autoload :Base,          'vagrant/config/base'
-    autoload :Container,     'vagrant/config/container'
-    autoload :ErrorRecorder, 'vagrant/config/error_recorder'
-    autoload :Loader,        'vagrant/config/loader'
-    autoload :Top,           'vagrant/config/top'
-
-    autoload :NFSConfig,     'vagrant/config/nfs'
-    autoload :PackageConfig, 'vagrant/config/package'
-    autoload :SSHConfig,     'vagrant/config/ssh'
-    autoload :VagrantConfig, 'vagrant/config/vagrant'
-    autoload :VMConfig,      'vagrant/config/vm'
-
-    CONFIGURE_MUTEX = Mutex.new
-
-    # This is the method which is called by all Vagrantfiles to configure Vagrant.
-    # This method expects a block which accepts a single argument representing
-    # an instance of the {Config::Top} class.
-    #
-    # Note that the block is not run immediately. Instead, it's proc is stored
-    # away for execution later.
-    def self.run(&block)
-      # Store it for later
-      @last_procs ||= []
-      @last_procs << block
-    end
-
-    # This is a method which will yield to a block and will capture all
-    # ``Vagrant.configure`` calls, returning an array of `Proc`s.
-    #
-    # Wrapping this around anytime you call code which loads configurations
-    # will force a mutex so that procs never get mixed up. This keeps
-    # the configuration loading part of Vagrant thread-safe.
-    def self.capture_configures
-      CONFIGURE_MUTEX.synchronize do
-        # Reset the last procs so that we start fresh
-        @last_procs = []
-
-        # Yield to allow the caller to do whatever loading needed
-        yield
-
-        # Return the last procs we've seen while still in the mutex,
-        # knowing we're safe.
-        return @last_procs
-      end
-    end
-  end
-end

data/lib/vagrant/config/base.rb

@@ -1,82 +0,0 @@
-module Vagrant
-  module Config
-    # The base class for all configuration classes. This implements
-    # basic things such as the environment instance variable which all
-    # config classes need as well as a basic `to_json` implementation.
-    class Base
-      # Loads configuration values from JSON back into the proper
-      # configuration classes. By default, this is done by simply
-      # iterating over all values in the JSON hash and assigning them
-      # to instance variables on the class.
-      def self.json_create(data)
-        data.inject(new) do |result, data|
-          key, value = data
-          result.instance_variable_set("@#{key}".to_sym, value) if key != "json_class"
-          result
-        end
-      end
-
-      # Allows setting options from a hash. By default this simply calls
-      # the `#{key}=` method on the config class with the value, which is
-      # the expected behavior most of the time.
-      def set_options(options)
-        options.each do |key, value|
-          send("#{key}=", value)
-        end
-      end
-
-      # Merge another configuration object into this one.
-      #
-      # @param [Object] other The other configuration object to merge from,
-      #   this must be the same type of object as this one.
-      # @return [Object] The merged object.
-      def merge(other)
-        result = self.class.new
-        instance_variables_hash.merge(other.instance_variables_hash).each do |key, value|
-          # Ignore keys that start with a double underscore. This allows
-          # configuration classes to still hold around internal state
-          # that isn't propagated.
-          if !key.start_with?("__")
-            result.instance_variable_set("@#{key}".to_sym, value)
-          end
-        end
-
-        result
-      end
-
-      # Called by {Top} after the configuration is loaded to validate
-      # the configuaration objects. Subclasses should implement this
-      # method and add any errors to the `errors` object given.
-      #
-      # @param [ErrorRecorder] errors
-      def validate(env, errors); end
-
-      # Converts the configuration to a raw hash by calling `#to_hash`
-      # on all instance variables (if it can) and putting them into
-      # a hash.
-      def to_hash
-        instance_variables_hash.inject({}) do |acc, data|
-          k,v = data
-          v = v.to_hash if v.respond_to?(:to_hash)
-          acc[k] = v
-          acc
-        end
-      end
-
-      # Converts to JSON, with the `json_class` field set so that when
-      # the JSON is parsed back, it can be loaded back into the proper class.
-      # See {json_create}.
-      def to_json(*a)
-        instance_variables_hash.to_json(*a)
-      end
-
-      # Returns the instance variables as a hash of key-value pairs.
-      def instance_variables_hash
-        instance_variables.inject({}) do |acc, iv|
-          acc[iv.to_s[1..-1]] = instance_variable_get(iv)
-          acc
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/config/container.rb

@@ -1,37 +0,0 @@
-module Vagrant
-  module Config
-    # Contains loaded configuration values and provides access to those
-    # values.
-    #
-    # This is the class returned when loading configuration and stores
-    # the completely loaded configuration values. This class is meant to
-    # be immutable.
-    class Container
-      attr_reader :global
-      attr_reader :vms
-
-      # Initializes the configuration container.
-      #
-      # @param [Top] global Top-level configuration for the global
-      #   applicatoin.
-      # @param [Array] vms Array of VM configurations.
-      def initialize(global, vms)
-        @global = global
-        @vms    = []
-        @vm_configs = {}
-
-        vms.each do |vm_config|
-          @vms << vm_config.vm.name
-          @vm_configs[vm_config.vm.name] = vm_config
-        end
-      end
-
-      # This returns the configuration for a specific virtual machine.
-      # The values for this configuration are usually pertinent to a
-      # single virtual machine and do not affect the system globally.
-      def for_vm(name)
-        @vm_configs[name]
-      end
-    end
-  end
-end

data/lib/vagrant/config/error_recorder.rb

@@ -1,19 +0,0 @@
-module Vagrant
-  module Config
-    # A class which is passed into the various {Base#validate} methods and
-    # can be used as a helper to add error messages about a single config
-    # class.
-    class ErrorRecorder
-      attr_reader :errors
-
-      def initialize
-        @errors = []
-      end
-
-      # Adds an error to the list of errors.
-      def add(message)
-        @errors << message
-      end
-    end
-  end
-end

data/lib/vagrant/config/loader.rb

@@ -1,127 +0,0 @@
-require "pathname"
-
-require "log4r"
-
-module Vagrant
-  module Config
-    # This class is responsible for loading Vagrant configuration,
-    # usually in the form of Vagrantfiles.
-    #
-    # Loading works by specifying the sources for the configuration
-    # as well as the order the sources should be loaded. Configuration
-    # set later always overrides those set earlier; this is how
-    # configuration "scoping" is implemented.
-    class Loader
-      # This is an array of symbols specifying the order in which
-      # configuration is loaded. For examples, see the class documentation.
-      attr_accessor :load_order
-
-      def initialize
-        @logger  = Log4r::Logger.new("vagrant::config::loader")
-        @sources = {}
-        @proc_cache = {}
-        @config_cache = {}
-      end
-
-      # Set the configuration data for the given name.
-      #
-      # The `name` should be a symbol and must uniquely identify the data
-      # being given.
-      #
-      # `data` can either be a path to a Ruby Vagrantfile or a `Proc` directly.
-      # `data` can also be an array of such values.
-      #
-      # At this point, no configuration is actually loaded. Note that calling
-      # `set` multiple times with the same name will override any previously
-      # set values. In this way, the last set data for a given name wins.
-      def set(name, sources)
-        @logger.debug("Set #{name.inspect} = #{sources.inspect}")
-
-        # Sources should be an array
-        sources = [sources] if !sources.kind_of?(Array)
-
-        # Gather the procs for every source, since that is what we care about.
-        procs = []
-        sources.each do |source|
-          if !@proc_cache.has_key?(source)
-            # Load the procs for this source and cache them. This caching
-            # avoids the issue where a file may have side effects when loading
-            # and loading it multiple times causes unexpected behavior.
-            @logger.debug("Populating proc cache for #{source.inspect}")
-            @proc_cache[source] = procs_for_source(source)
-          end
-
-          # Add on to the array of procs we're going to use
-          procs.concat(@proc_cache[source])
-        end
-
-        # Set this source by name.
-        @sources[name] = procs
-      end
-
-      # This loads the configured sources in the configured order and returns
-      # an actual configuration object that is ready to be used.
-      def load
-        @logger.debug("Loading configuration in order: #{@load_order.inspect}")
-
-        unknown_sources = @sources.keys - @load_order
-        if !unknown_sources.empty?
-          # TODO: Raise exception here perhaps.
-          @logger.error("Unknown config sources: #{unknown_sources.inspect}")
-        end
-
-        # Create the top-level configuration which will hold all the config.
-        result = Top.new
-
-        @load_order.each do |key|
-          next if !@sources.has_key?(key)
-
-          @sources[key].each do |proc|
-            if !@config_cache.has_key?(proc)
-              @logger.debug("Loading from: #{key} (evaluating)")
-              current = Top.new
-              proc.call(current)
-              @config_cache[proc] = current
-            else
-              @logger.debug("Loading from: #{key} (cache)")
-            end
-
-            # Merge in the results of this proc's configuration
-            result = result.merge(@config_cache[proc])
-          end
-        end
-
-        @logger.debug("Configuration loaded successfully")
-        result
-      end
-
-      protected
-
-      # This returns an array of `Proc` objects for the given source.
-      # The `Proc` objects returned will expect a single argument for
-      # the configuration object and are expected to mutate this
-      # configuration object.
-      def procs_for_source(source)
-        return [source] if source.is_a?(Proc)
-
-        # Assume all string sources are actually pathnames
-        source = Pathname.new(source) if source.is_a?(String)
-
-        if source.is_a?(Pathname)
-          @logger.debug("Load procs for pathname: #{source.inspect}")
-
-          begin
-            return Config.capture_configures do
-              Kernel.load source
-            end
-          rescue SyntaxError => e
-            # Report syntax errors in a nice way.
-            raise Errors::VagrantfileSyntaxError, :file => e.message
-          end
-        end
-
-        raise Exception, "Unknown configuration source: #{source.inspect}"
-      end
-    end
-  end
-end