tnargav 1.2.2

data/lib/vagrant/util/ssh.rb

@@ -0,0 +1,150 @@
+require "log4r"
+
+require "vagrant/util/file_mode"
+require "vagrant/util/platform"
+require "vagrant/util/safe_exec"
+require "vagrant/util/subprocess"
+require "vagrant/util/which"
+
+module Vagrant
+  module Util
+    # This is a class that has helpers on it for dealing with SSH. These
+    # helpers don't depend on any part of Vagrant except what is given
+    # via the parameters.
+    class SSH
+      LOGGER = Log4r::Logger.new("vagrant::util::ssh")
+
+      # Checks that the permissions for a private key are valid, and fixes
+      # them if possible. SSH requires that permissions on the private key
+      # are 0600 on POSIX based systems. This will make a best effort to
+      # fix these permissions if they are not properly set.
+      #
+      # @param [Pathname] key_path The path to the private key.
+      def self.check_key_permissions(key_path)
+        # Don't do anything if we're on Windows, since Windows doesn't worry
+        # about key permissions.
+        return if Platform.windows?
+
+        LOGGER.debug("Checking key permissions: #{key_path}")
+        stat = key_path.stat
+
+        if !stat.owned?
+          # The SSH key must be owned by ourselves
+          raise Errors::SSHKeyBadOwner, :key_path => key_path
+        end
+
+        if FileMode.from_octal(stat.mode) != "600"
+          LOGGER.info("Attempting to correct key permissions to 0600")
+          key_path.chmod(0600)
+
+          # Re-stat the file to get the new mode, and verify it worked
+          stat = key_path.stat
+          if FileMode.from_octal(stat.mode) != "600"
+            raise Errors::SSHKeyBadPermissions, :key_path => key_path
+          end
+        end
+      rescue Errno::EPERM
+        # This shouldn't happen since we verify we own the file, but
+        # it is possible in theory, so we raise an error.
+        raise Errors::SSHKeyBadPermissions, :key_path => key_path
+      end
+
+      # Halts the running of this process and replaces it with a full-fledged
+      # SSH shell into a remote machine.
+      #
+      # Note: This method NEVER returns. The process ends after this.
+      #
+      # @param [Hash] ssh_info This is the SSH information. For the keys
+      #   required please see the documentation of {Machine#ssh_info}.
+      # @param [Hash] opts These are additional options that are supported
+      #   by exec.
+      def self.exec(ssh_info, opts={})
+        # Ensure the platform supports ssh. On Windows there are several programs which
+        # include ssh, notably git, mingw and cygwin, but make sure ssh is in the path!
+        ssh_path = Which.which("ssh")
+        if !ssh_path
+          if Platform.windows?
+            raise Errors::SSHUnavailableWindows,
+              :host => ssh_info[:host],
+              :port => ssh_info[:port],
+              :username => ssh_info[:username],
+              :key_path => ssh_info[:private_key_path]
+          end
+
+          raise Errors::SSHUnavailable
+        end
+
+        # On Windows, we need to detect whether SSH is actually "plink"
+        # underneath the covers. In this case, we tell the user.
+        if Platform.windows?
+          r = Subprocess.execute(ssh_path)
+          if r.stdout.include?("PuTTY Link")
+            raise Errors::SSHIsPuttyLink,
+              :host => ssh_info[:host],
+              :port => ssh_info[:port],
+              :username => ssh_info[:username],
+              :key_path => ssh_info[:private_key_path]
+          end
+        end
+
+        # If plain mode is enabled then we don't do any authentication (we don't
+        # set a user or an identity file)
+        plain_mode = opts[:plain_mode]
+
+        options = {}
+        options[:host] = ssh_info[:host]
+        options[:port] = ssh_info[:port]
+        options[:username] = ssh_info[:username]
+        options[:private_key_path] = ssh_info[:private_key_path]
+
+        # Command line options
+        command_options = [
+          "-p", options[:port].to_s,
+          "-o", "LogLevel=FATAL",
+          "-o", "StrictHostKeyChecking=no",
+          "-o", "UserKnownHostsFile=/dev/null"]
+
+        # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the
+        # IdentitiesOnly option. Also, we don't enable it in plain mode so
+        # that SSH properly searches our identities and tries to do it itself.
+        if !Platform.solaris? && !plain_mode
+          command_options += ["-o", "IdentitiesOnly=yes"]
+        end
+
+        # If we're not in plain mode, attach the private key path.
+        command_options += ["-i", options[:private_key_path].to_s] if !plain_mode
+
+        if ssh_info[:forward_x11]
+          # Both are required so that no warnings are shown regarding X11
+          command_options += [
+            "-o", "ForwardX11=yes",
+            "-o", "ForwardX11Trusted=yes"]
+        end
+
+        # Configurables -- extra_args should always be last due to the way the
+        # ssh args parser works. e.g. if the user wants to use the -t option,
+        # any shell command(s) she'd like to run on the remote server would
+        # have to be the last part of the 'ssh' command:
+        #
+        #   $ ssh localhost -t -p 2222 "cd mydirectory; bash"
+        #
+        # Without having extra_args be last, the user loses this ability
+        command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
+        command_options.concat(opts[:extra_args]) if opts[:extra_args]
+
+        # Build up the host string for connecting
+        host_string = options[:host]
+        host_string = "#{options[:username]}@#{host_string}" if !plain_mode
+        command_options.unshift(host_string)
+
+        # On Cygwin we want to get rid of any DOS file warnings because
+        # we really don't care since both work.
+        ENV["nodosfilewarning"] = "1" if Platform.cygwin?
+
+        # Invoke SSH with all our options
+        LOGGER.info("Invoking SSH: #{command_options.inspect}")
+        SafeExec.exec("ssh", *command_options)
+      end
+    end
+  end
+end

data/lib/vagrant/util/stacked_proc_runner.rb

@@ -0,0 +1,35 @@
+module Vagrant
+  module Util
+    # Represents the "stacked proc runner" behavior which is used a
+    # couple places within Vagrant. This allows procs to "stack" on
+    # each other, then all execute in a single action. An example of
+    # its uses can be seen in the {Config} class.
+    module StackedProcRunner
+      # Returns the proc stack. This should always be called as the
+      # accessor of the stack. The instance variable itself should _never_
+      # be used.
+      #
+      # @return [Array<Proc>]
+      def proc_stack
+        @_proc_stack ||= []
+      end
+
+      # Adds (pushes) a proc to the stack. The actual proc added here is
+      # not executed, but merely stored.
+      #
+      # @param [Proc] block
+      def push_proc(&block)
+        proc_stack << block
+      end
+
+      # Executes all the procs on the stack, passing in the given arguments.
+      # The stack is not cleared afterwords. It is up to the user of this
+      # mixin to clear the stack by calling `proc_stack.clear`.
+      def run_procs!(*args)
+        proc_stack.each do |proc|
+          proc.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/string_block_editor.rb

@@ -0,0 +1,77 @@
+module Vagrant
+  module Util
+    # This class modifies strings by creating and managing Vagrant-owned
+    # "blocks" via wrapping them in specially formed comments.
+    #
+    # This is useful when modifying a file that someone else owns and adding
+    # automatic entries into it. Example: /etc/exports or some other
+    # configuration file.
+    #
+    # Vagrant marks ownership of a block in the string by wrapping it in
+    # VAGRANT-BEGIN and VAGRANT-END comments with a unique ID. Example:
+    #
+    #     foo
+    #     # VAGRANT-BEGIN: id
+    #     some contents
+    #     created by vagrant
+    #     # VAGRANT-END: id
+    #
+    # The goal of this class is to be able to insert and remove these
+    # blocks without modifying anything else in the string.
+    #
+    # The strings usually come from files but it is up to the caller to
+    # manage the file resource.
+    class StringBlockEditor
+      # The current string value. This is the value that is modified by
+      # the methods below.
+      #
+      # @return [String]
+      attr_reader :value
+
+      def initialize(string)
+        @value = string
+      end
+
+      # This returns the keys (or ids) that are in the string.
+      #
+      # @return [<Array<String>]
+      def keys
+        regexp = /^#\s*VAGRANT-BEGIN:\s*(.+?)$\r?\n?(.*)$\r?\n?^#\s*VAGRANT-END:\s(\1)$/m
+        @value.scan(regexp).map do |match|
+          match[0]
+        end
+      end
+
+      # This deletes the block with the given key if it exists.
+      def delete(key)
+        key    = Regexp.quote(key)
+        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$.*^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
+        @value.gsub!(regexp, "")
+      end
+
+      # This gets the value of the block with the given key.
+      def get(key)
+        key    = Regexp.quote(key)
+        regexp = /^#\s*VAGRANT-BEGIN:\s*#{key}$\r?\n?(.*?)\r?\n?^#\s*VAGRANT-END:\s*#{key}$\r?\n?/m
+        match  = regexp.match(@value)
+        return nil if !match
+        match[1]
+      end
+
+      # This inserts a block with the given key and value.
+      #
+      # @param [String] key
+      # @param [String] value
+      def insert(key, value)
+        # Insert the new block into the value
+        new_block = <<BLOCK
+# VAGRANT-BEGIN: #{key}
+#{value.strip}
+# VAGRANT-END: #{key}
+BLOCK
+
+        @value << new_block
+      end
+    end
+  end
+end

data/lib/vagrant/util/subprocess.rb

@@ -0,0 +1,273 @@
+require 'thread'
+
+require 'childprocess'
+require 'log4r'
+
+require 'vagrant/util/platform'
+require 'vagrant/util/safe_chdir'
+
+module Vagrant
+  module Util
+    # Execute a command in a subprocess, gathering the results and
+    # exit status.
+    #
+    # This class also allows you to read the data as it is outputted
+    # from the subprocess in real time, by simply passing a block to
+    # the execute method.
+    class Subprocess
+      # The chunk size for reading from subprocess IO.
+      READ_CHUNK_SIZE = 4096
+
+      # Convenience method for executing a method.
+      def self.execute(*command, &block)
+        new(*command).execute(&block)
+      end
+
+      def initialize(*command)
+        @options = command.last.is_a?(Hash) ? command.pop : {}
+        @command = command
+        @logger  = Log4r::Logger.new("vagrant::util::subprocess")
+      end
+
+      def execute
+        # Get the timeout, if we have one
+        timeout = @options[:timeout]
+
+        # Get the working directory
+        workdir = @options[:workdir] || Dir.pwd
+
+        # Get what we're interested in being notified about
+        notify  = @options[:notify] || []
+        notify  = [notify] if !notify.is_a?(Array)
+        if notify.empty? && block_given?
+          # If a block is given, subscribers must be given, otherwise the
+          # block is never called. This is usually NOT what you want, so this
+          # is an error.
+          message = "A list of notify subscriptions must be given if a block is given"
+          raise ArgumentError, message
+        end
+
+        # Let's get some more useful booleans that we access a lot so
+        # we're not constantly calling an `include` check
+        notify_table = {}
+        notify_table[:stderr] = notify.include?(:stderr)
+        notify_table[:stdout] = notify.include?(:stdout)
+        notify_stdin  = notify.include?(:stdin)
+
+        # Build the ChildProcess
+        @logger.info("Starting process: #{@command.inspect}")
+        process = ChildProcess.build(*@command)
+
+        # Create the pipes so we can read the output in real time as
+        # we execute the command.
+        stdout, stdout_writer = IO.pipe
+        stderr, stderr_writer = IO.pipe
+        process.io.stdout = stdout_writer
+        process.io.stderr = stderr_writer
+        process.duplex = true
+
+        # Set the environment on the process if we must
+        if @options[:env]
+          @options[:env].each do |k, v|
+            process.environment[k] = v
+          end
+        end
+
+        # Start the process
+        begin
+          SafeChdir.safe_chdir(workdir) do
+            process.start
+          end
+        rescue ChildProcess::LaunchError => ex
+          # Raise our own version of the error so that users of the class
+          # don't need to be aware of ChildProcess
+          raise LaunchError.new(ex.message)
+        end
+
+        # Make sure the stdin does not buffer
+        process.io.stdin.sync = true
+
+        if RUBY_PLATFORM != "java"
+          # On Java, we have to close after. See down the method...
+          # Otherwise, we close the writers right here, since we're
+          # not on the writing side.
+          stdout_writer.close
+          stderr_writer.close
+        end
+
+        # Create a dictionary to store all the output we see.
+        io_data = { :stdout => "", :stderr => "" }
+
+        # Record the start time for timeout purposes
+        start_time = Time.now.to_i
+
+        @logger.debug("Selecting on IO")
+        while true
+          writers = notify_stdin ? [process.io.stdin] : []
+          results = IO.select([stdout, stderr], writers, nil, timeout || 0.1)
+          results ||= []
+          readers = results[0]
+          writers = results[1]
+
+          # Check if we have exceeded our timeout
+          raise TimeoutExceeded, process.pid if timeout && (Time.now.to_i - start_time) > timeout
+
+          # Check the readers to see if they're ready
+          if readers && !readers.empty?
+            readers.each do |r|
+              # Read from the IO object
+              data = read_io(r)
+
+              # We don't need to do anything if the data is empty
+              next if data.empty?
+
+              io_name = r == stdout ? :stdout : :stderr
+              @logger.debug("#{io_name}: #{data.chomp}")
+
+              io_data[io_name] += data
+              yield io_name, data if block_given? && notify_table[io_name]
+            end
+          end
+
+          # Break out if the process exited. We have to do this before
+          # attempting to write to stdin otherwise we'll get a broken pipe
+          # error.
+          break if process.exited?
+
+          # Check the writers to see if they're ready, and notify any listeners
+          if writers && !writers.empty?
+            yield :stdin, process.io.stdin if block_given?
+          end
+        end
+
+        # Wait for the process to end.
+        begin
+          remaining = (timeout || 32000) - (Time.now.to_i - start_time)
+          remaining = 0 if remaining < 0
+          @logger.debug("Waiting for process to exit. Remaining to timeout: #{remaining}")
+
+          process.poll_for_exit(remaining)
+        rescue ChildProcess::TimeoutError
+          raise TimeoutExceeded, process.pid
+        end
+
+        @logger.debug("Exit status: #{process.exit_code}")
+
+        # Read the final output data, since it is possible we missed a small
+        # amount of text between the time we last read data and when the
+        # process exited.
+        [stdout, stderr].each do |io|
+          # Read the extra data, ignoring if there isn't any
+          extra_data = read_io(io)
+          next if extra_data == ""
+
+          # Log it out and accumulate
+          io_name = io == stdout ? :stdout : :stderr
+          io_data[io_name] += extra_data
+          @logger.debug("#{io_name}: #{extra_data.chomp}")
+
+          # Yield to any listeners any remaining data
+          yield io_name, extra_data if block_given?
+        end
+
+        if RUBY_PLATFORM == "java"
+          # On JRuby, we need to close the writers after the process,
+          # for some reason. See GH-711.
+          stdout_writer.close
+          stderr_writer.close
+        end
+
+        # Return an exit status container
+        return Result.new(process.exit_code, io_data[:stdout], io_data[:stderr])
+      end
+
+      protected
+
+      # Reads data from an IO object while it can, returning the data it reads.
+      # When it encounters a case when it can't read anymore, it returns the
+      # data.
+      #
+      # @return [String]
+      def read_io(io)
+        data = ""
+
+        while true
+          begin
+            if Platform.windows?
+              # Windows doesn't support non-blocking reads on
+              # file descriptors or pipes so we have to get
+              # a bit more creative.
+
+              # Check if data is actually ready on this IO device.
+              # We have to do this since `readpartial` will actually block
+              # until data is available, which can cause blocking forever
+              # in some cases.
+              results = IO.select([io], nil, nil, 0.1)
+              break if !results || results[0].empty?
+
+              # Read!
+              data << io.readpartial(READ_CHUNK_SIZE)
+            else
+              # Do a simple non-blocking read on the IO object
+              data << io.read_nonblock(READ_CHUNK_SIZE)
+            end
+          rescue Exception => e
+            # The catch-all rescue here is to support multiple Ruby versions,
+            # since we use some Ruby 1.9 specific exceptions.
+
+            breakable = false
+            if e.is_a?(EOFError)
+              # An `EOFError` means this IO object is done!
+              breakable = true
+            elsif defined?(IO::WaitReadable) && e.is_a?(IO::WaitReadable)
+              # IO::WaitReadable is only available on Ruby 1.9+
+
+              # An IO::WaitReadable means there may be more IO but this
+              # IO object is not ready to be read from yet. No problem,
+              # we read as much as we can, so we break.
+              breakable = true
+            elsif e.is_a?(Errno::EAGAIN)
+              # Otherwise, we just look for the EAGAIN error which should be
+              # all that IO::WaitReadable does in Ruby 1.9.
+              breakable = true
+            end
+
+            # Break out if we're supposed to. Otherwise re-raise the error
+            # because it is a real problem.
+            break if breakable
+            raise
+          end
+        end
+
+        data
+      end
+
+      # An error which raises when a process fails to start
+      class LaunchError < StandardError; end
+
+      # An error which occurs when the process doesn't end within
+      # the given timeout.
+      class TimeoutExceeded < StandardError
+        attr_reader :pid
+
+        def initialize(pid)
+          super()
+          @pid = pid
+        end
+      end
+
+      # Container class to store the results of executing a subprocess.
+      class Result
+        attr_reader :exit_code
+        attr_reader :stdout
+        attr_reader :stderr
+
+        def initialize(exit_code, stdout, stderr)
+          @exit_code = exit_code
+          @stdout    = stdout
+          @stderr    = stderr
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/util/template_renderer.rb

@@ -0,0 +1,83 @@
+require 'ostruct'
+require 'erubis'
+
+module Vagrant
+  module Util
+    # This class is used to render the ERB templates in the
+    # `GEM_ROOT/templates` directory.
+    class TemplateRenderer < OpenStruct
+      class << self
+        # Render a given template and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @return [String] Rendered template
+        def render(*args)
+          render_with(:render, *args)
+        end
+
+        # Render a given string and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @param [String] template The template data string.
+        # @return [String] Rendered template
+        def render_string(*args)
+          render_with(:render_string, *args)
+        end
+
+        # Method used internally to DRY out the other renderers. This method
+        # creates and sets up the renderer before calling a specified method on it.
+        def render_with(method, template, data={})
+          renderer = new(template, data)
+          yield renderer if block_given?
+          renderer.send(method.to_sym)
+        end
+      end
+
+      def initialize(template, data = {})
+        super()
+
+        data[:template] = template
+        data.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      # Renders the template using the class intance as the binding. Because the
+      # renderer inherits from `OpenStruct`, additional view variables can be
+      # added like normal accessors.
+      #
+      # @return [String]
+      def render
+        # TODO: Seems like a pretty dirty way to do this. Perhaps refactor this
+        old_template = template
+        result = nil
+        File.open(full_template_path, 'r') do |f|
+          self.template = f.read
+          result = render_string
+        end
+
+        result
+      ensure
+        self.template = old_template
+      end
+
+      # Renders a template, handling the template as a string, but otherwise
+      # acting the same way as {#render}.
+      #
+      # @return [String]
+      def render_string
+        Erubis::Eruby.new(template, :trim => true).result(binding)
+      end
+
+      # Returns the full path to the template, taking into accoun the gem directory
+      # and adding the `.erb` extension to the end.
+      #
+      # @return [String]
+      def full_template_path
+        Vagrant.source_root.join('templates', "#{template}.erb").to_s.squeeze("/")
+      end
+    end
+  end
+end

data/lib/vagrant/util/which.rb

@@ -0,0 +1,43 @@
+require "vagrant/util/platform"
+
+module Vagrant
+  module Util
+    class Which
+      # Cross-platform way of finding an executable in the PATH.
+      #
+      #   which('ruby') #=> /usr/bin/ruby
+      #
+      # This code is adapted from the following post by mislav:
+      #   http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      #
+      # @param [String] cmd The command to search for in the PATH.
+      # @return [String] The full path to the executable or `nil` if not found.
+      def self.which(cmd)
+        exts = nil
+
+        if !Platform.windows? || ENV['PATHEXT'].nil?
+          # If the PATHEXT variable is empty, we're on *nix and need to find
+          # the exact filename
+          exts = ['']
+        elsif File.extname(cmd).length != 0
+          # On Windows: if filename contains an extension, we must match that
+          # exact filename
+          exts = ['']
+        else
+          # On Windows: otherwise try to match all possible executable file
+          # extensions (.EXE .COM .BAT etc.)
+          exts = ENV['PATHEXT'].split(';')
+        end
+
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = "#{path}#{File::SEPARATOR}#{cmd}#{ext}"
+            return exe if File.executable? exe
+          end
+        end
+
+        return nil
+      end
+    end
+  end
+end

data/lib/vagrant/util.rb

@@ -0,0 +1,12 @@
+module Vagrant
+  module Util
+    autoload :Busy,                      'vagrant/util/busy'
+    autoload :Counter,                   'vagrant/util/counter'
+    autoload :HashWithIndifferentAccess, 'vagrant/util/hash_with_indifferent_access'
+    autoload :Platform,                  'vagrant/util/platform'
+    autoload :Retryable,                 'vagrant/util/retryable'
+    autoload :SafeExec,                  'vagrant/util/safe_exec'
+    autoload :StackedProcRunner,         'vagrant/util/stacked_proc_runner'
+    autoload :TemplateRenderer,          'vagrant/util/template_renderer'
+  end
+end

data/lib/vagrant/version.rb

@@ -0,0 +1,6 @@
+module Vagrant
+  # This will always be up to date with the current version of Vagrant,
+  # since it is used to generate the gemspec and is also the source of
+  # the version for `vagrant -v`
+  VERSION = "1.2.2"
+end