vagrant-fixed-ssh 1.0.7

data/lib/vagrant/provisioners/puppet_server.rb

@@ -0,0 +1,78 @@
+module Vagrant
+  module Provisioners
+    class PuppetServerError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet_server")
+    end
+
+    class PuppetServer < Base
+      class Config < Vagrant::Config::Base
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+        attr_accessor :options
+        attr_accessor :facter
+
+        def facter; @facter ||= {}; end
+        def puppet_server; @puppet_server || "puppet"; end
+        def options; @options ||= []; end
+      end
+
+      def self.config_class
+        Config
+      end
+
+      def provision!
+        verify_binary("puppet")
+        run_puppet_agent
+      end
+
+      def verify_binary(binary)
+        env[:vm].channel.sudo("which #{binary}",
+                              :error_class => PuppetServerError,
+                              :error_key => :not_detected,
+                              :binary => binary)
+      end
+
+      def run_puppet_agent
+        options = config.options
+        options = [options] if !options.is_a?(Array)
+
+        # Intelligently set the puppet node cert name based on certain
+        # external parameters.
+        cn = nil
+        if config.puppet_node
+          # If a node name is given, we use that directly for the certname
+          cn = config.puppet_node
+        elsif env[:vm].config.vm.host_name
+          # If a host name is given, we explicitly set the certname to
+          # nil so that the hostname becomes the cert name.
+          cn = nil
+        else
+          # Otherwise, we default to the name of the box.
+          cn = env[:vm].config.vm.box
+        end
+
+        # Add the certname option if there is one
+        options += ["--certname", cn] if cn
+        options = options.join(" ")
+
+        # Build up the custom facts if we have any
+        facter = ""
+        if !config.facter.empty?
+          facts = []
+          config.facter.each do |key, value|
+            facts << "FACTER_#{key}='#{value}'"
+          end
+
+          facter = "#{facts.join(" ")} "
+        end
+
+        command = "#{facter}puppet agent #{options} --server #{config.puppet_server} --detailed-exitcodes || [ $? -eq 2 ]"
+
+        env[:ui].info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+        env[:vm].channel.sudo(command) do |type, data|
+          env[:ui].info(data.chomp, :prefix => false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/shell.rb

@@ -0,0 +1,103 @@
+require 'tempfile'
+
+module Vagrant
+  module Provisioners
+    class Shell < Base
+      class Config < Vagrant::Config::Base
+        attr_accessor :inline
+        attr_accessor :path
+        attr_accessor :upload_path
+        attr_accessor :args
+
+        def initialize
+          @upload_path = "/tmp/vagrant-shell"
+        end
+
+        def validate(env, errors)
+          # Validate that the parameters are properly set
+          if path && inline
+            errors.add(I18n.t("vagrant.provisioners.shell.path_and_inline_set"))
+          elsif !path && !inline
+            errors.add(I18n.t("vagrant.provisioners.shell.no_path_or_inline"))
+          end
+
+          # Validate the existence of a script to upload
+          if path
+            expanded_path = Pathname.new(path).expand_path(env.root_path)
+            if !expanded_path.file?
+              errors.add(I18n.t("vagrant.provisioners.shell.path_invalid",
+                                :path => expanded_path))
+            end
+          end
+
+          # There needs to be a path to upload the script to
+          if !upload_path
+            errors.add(I18n.t("vagrant.provisioners.shell.upload_path_not_set"))
+          end
+
+          # If there are args and its not a string, that is a problem
+          if args && !args.is_a?(String)
+            errors.add(I18n.t("vagrant.provisioners.shell.args_not_string"))
+          end
+        end
+      end
+
+      def self.config_class
+        Config
+      end
+
+      # This method yields the path to a script to upload and execute
+      # on the remote server. This method will properly clean up the
+      # script file if needed.
+      def with_script_file
+        if config.path
+          # Just yield the path to that file...
+          yield Pathname.new(config.path).expand_path(env[:root_path])
+          return
+        end
+
+        # Otherwise we have an inline script, we need to Tempfile it,
+        # and handle it specially...
+        file = Tempfile.new('vagrant-shell')
+
+        # Unless you set binmode, on a Windows host the shell script will
+        # have CRLF line endings instead of LF line endings, causing havoc
+        # when the guest executes it
+        file.binmode
+
+        begin
+          file.write(config.inline)
+          file.fsync
+          file.close
+          yield file.path
+        ensure
+          file.close
+          file.unlink
+        end
+      end
+
+      def provision!
+        args = ""
+        args = " #{config.args}" if config.args
+        command = "chmod +x #{config.upload_path} && #{config.upload_path}#{args}"
+
+        with_script_file do |path|
+          # Upload the script to the VM
+          env[:vm].channel.upload(path.to_s, config.upload_path)
+
+          # Execute it with sudo
+          env[:vm].channel.sudo(command) do |type, data|
+            if [:stderr, :stdout].include?(type)
+              # Output the data with the proper color based on the stream.
+              color = type == :stdout ? :green : :red
+
+              # Note: Be sure to chomp the data to avoid the newlines that the
+              # Chef outputs.
+              env[:ui].info(data.chomp, :color => color, :prefix => false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/registry.rb

@@ -0,0 +1,52 @@
+module Vagrant
+  # Register components in a single location that can be queried.
+  #
+  # This allows certain components (such as guest systems, configuration
+  # pieces, etc.) to be registered and queried.
+  class Registry
+    def initialize
+      @actions = {}
+      @results_cache = {}
+    end
+
+    # Register a callable by key.
+    #
+    # The callable should be given in a block which will be lazily evaluated
+    # when the action is needed.
+    #
+    # If an action by the given name already exists then it will be
+    # overwritten.
+    def register(key, value=nil, &block)
+      block = lambda { value } if value
+      @actions[key] = block
+    end
+
+    # Get an action by the given key.
+    #
+    # This will evaluate the block given to `register` and return the resulting
+    # action stack.
+    def get(key)
+      return nil if !@actions.has_key?(key)
+      return @results_cache[key] if @results_cache.has_key?(key)
+      @results_cache[key] = @actions[key].call
+    end
+    alias :[] :get
+
+    # Iterate over the keyspace.
+    def each(&block)
+      @actions.each do |key, _|
+        yield key, get(key)
+      end
+    end
+
+    # Converts this registry to a hash
+    def to_hash
+      result = {}
+      self.each do |key, value|
+        result[key] = value
+      end
+
+      result
+    end
+  end
+end

data/lib/vagrant/ssh.rb

@@ -0,0 +1,126 @@
+require 'log4r'
+
+require 'vagrant/util/file_mode'
+require 'vagrant/util/platform'
+require 'vagrant/util/safe_exec'
+
+module Vagrant
+  # Manages SSH connection information as well as allows opening an
+  # SSH connection.
+  class SSH
+    include Util::SafeExec
+
+    def initialize(vm)
+      @vm     = vm
+      @logger = Log4r::Logger.new("vagrant::ssh")
+    end
+
+    # Returns a hash of information necessary for accessing this
+    # virtual machine via SSH.
+    #
+    # @return [Hash]
+    def info
+      results = {
+        :host          => @vm.config.ssh.host,
+        :port          => @vm.config.ssh.port || @vm.driver.ssh_port(@vm.config.ssh.guest_port),
+        :username      => @vm.config.ssh.username,
+        :forward_agent => @vm.config.ssh.forward_agent,
+        :forward_x11   => @vm.config.ssh.forward_x11
+      }
+
+      # This can happen if no port is set and for some reason Vagrant
+      # can't detect an SSH port.
+      raise Errors::SSHPortNotDetected if !results[:port]
+
+      # Determine the private key path, which is either set by the
+      # configuration or uses just the built-in insecure key.
+      pk_path = @vm.config.ssh.private_key_path || @vm.env.default_private_key_path
+      results[:private_key_path] = File.expand_path(pk_path, @vm.env.root_path)
+
+      # We need to check and fix the private key permissions
+      # to make sure that SSH gets a key with 0600 perms.
+      check_key_permissions(results[:private_key_path])
+
+      # Return the results
+      return results
+    end
+
+    # Connects to the environment's virtual machine, replacing the ruby
+    # process with an SSH process.
+    #
+    # @param [Hash] opts Options hash
+    # @options opts [Boolean] :plain_mode If True, doesn't authenticate with
+    #   the machine, only connects, allowing the user to connect.
+    def exec(opts={})
+      # Get the SSH information and cache it here
+      ssh_info = info
+
+      if Util::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 if !Kernel.system("which ssh > /dev/null 2>&1")
+
+      # 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", "UserKnownHostsFile=/dev/null",
+                         "-o", "StrictHostKeyChecking=no", "-o", "LogLevel=ERROR"]
+
+      # Solaris/OpenSolaris/Illumos uses SunSSH which doesn't support the IdentitiesOnly option
+      command_options += ["-o", "IdentitiesOnly=yes"] unless Util::Platform.solaris?
+
+      command_options += ["-i", options[:private_key_path]] if !plain_mode
+      command_options += ["-o", "ForwardAgent=yes"] if ssh_info[:forward_agent]
+
+      # If there are extra options, then we append those
+      command_options.concat(opts[:extra_args]) if opts[:extra_args]
+
+      if ssh_info[:forward_x11]
+        # Both are required so that no warnings are shown regarding X11
+        command_options += ["-o", "ForwardX11=yes"]
+        command_options += ["-o", "ForwardX11Trusted=yes"]
+      end
+
+      host_string = options[:host]
+      host_string = "#{options[:username]}@#{host_string}" if !plain_mode
+      command_options << host_string
+      @logger.info("Invoking SSH: #{command_options.inspect}")
+      safe_exec("ssh", *command_options)
+    end
+
+    # Checks the file permissions for a private key, resetting them
+    # if needed.
+    def check_key_permissions(key_path)
+      # Windows systems don't have this issue
+      return if Util::Platform.windows?
+
+      @logger.debug("Checking key permissions: #{key_path}")
+      stat = File.stat(key_path)
+
+      if stat.owned? && Util::FileMode.from_octal(stat.mode) != "600"
+        @logger.info("Attempting to correct key permissions to 0600")
+        File.chmod(0600, key_path)
+
+        if Util::FileMode.from_octal(stat.mode) != "600"
+          raise Errors::SSHKeyBadPermissions, :key_path => key_path
+        end
+      end
+    rescue Errno::EPERM
+      # This shouldn't happen since we verified we own the file, but
+      # it is possible in theory, so we raise an error.
+      raise Errors::SSHKeyBadPermissions, :key_path => key_path
+    end
+  end
+end

data/lib/vagrant/test_helpers.rb

@@ -0,0 +1,154 @@
+module Vagrant
+  # Test helpers provided by Vagrant to allow for plugin developers
+  # to write automated tests for their code. This module simply provides
+  # methods which can be included into any test framework (`test/unit`,
+  # RSpec, Shoulda, etc.)
+  module TestHelpers
+    #------------------------------------------------------------
+    # Environment creation helpers
+    #------------------------------------------------------------
+    # Creates a "vagrant_app" directory in the test tmp folder
+    # which can be used for creating test Vagrant environments.
+    # Returns the root directory of the app. This typically doesn't need
+    # to be called directly unless you're setting up a custom application.
+    # See the examples for common use cases.
+    def vagrant_app(*path)
+      root = tmp_path.join("vagrant_app")
+      FileUtils.rm_rf(root)
+      FileUtils.mkdir_p(root)
+      root.join(*path)
+    end
+
+    # Creates a Vagrantfile with the given contents in the given
+    # app directory. If no app directory is specified, then a default
+    # Vagrant app is used.
+    def vagrantfile(*args)
+      path = args.shift.join("Vagrantfile") if Pathname === args.first
+      path ||= vagrant_app("Vagrantfile")
+
+      # Create this box so that it exists
+      vagrant_box("base")
+
+      str  = args.shift || ""
+      File.open(path.to_s, "w") do |f|
+        f.puts "ENV['VAGRANT_HOME'] = '#{home_path}'"
+        f.puts "Vagrant::Config.run do |config|"
+        f.puts "config.vm.base_mac = 'foo' if !config.vm.base_mac"
+        f.puts "config.vm.box = 'base'"
+        f.puts str
+        f.puts "end"
+      end
+
+      path.parent
+    end
+
+    # Creates and _loads_ a Vagrant environment at the given path.
+    # If no path is given, then a default {#vagrantfile} is used.
+    def vagrant_env(*args)
+      path = args.shift if Pathname === args.first
+      path ||= vagrantfile
+      Vagrant::Environment.new(:cwd => path).load!
+    end
+
+    # Creates the folder to contain a vagrant box. This allows for
+    # "fake" boxes to be made with the specified name.
+    #
+    # @param [String] name
+    # @return [Pathname]
+    def vagrant_box(name)
+      result = boxes_path.join(name)
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Returns an instantiated downloader with a mocked tempfile
+    # which can be passed into it.
+    #
+    # @param [Class] klass The downloader class
+    # @return [Array] Returns an array of `downloader` `tempfile`
+    def vagrant_mock_downloader(klass)
+      tempfile = mock("tempfile")
+      tempfile.stubs(:write)
+
+      _, env = action_env
+      [klass.new(env), tempfile]
+    end
+
+    # Returns a blank app (callable) and action environment with the
+    # given vagrant environment. This allows for testing of middlewares.
+    def action_env(v_env = nil)
+      v_env ||= vagrant_env
+      # duplicate the Vagrant::Environment ui and get the default vm object
+      # for the new action environment from the first pair in the vms list
+      opts = {:ui => v_env.ui.dup, :vm => v_env.vms.first.last}
+      app = lambda { |env| }
+      env = Vagrant::Action::Environment.new(opts)
+      env["vagrant.test"] = true
+      [app, env]
+    end
+
+    # Utility method for capturing output streams.
+    # @example Evaluate the output
+    #   output = capture(:stdout){ env.cli("foo") }
+    #   assert_equal "bar", output
+    # @example Silence the output
+    #   silence(:stdout){ env.cli("init") }
+    # @param [:stdout, :stderr] stream The stream to capture
+    # @yieldreturn String
+    # @see https://github.com/wycats/thor/blob/master/spec/spec_helper.rb
+    def capture(stream)
+      begin
+        stream = stream.to_s
+        eval "$#{stream} = StringIO.new"
+        yield
+        result = eval("$#{stream}").string
+      ensure
+        eval("$#{stream} = #{stream.upcase}")
+      end
+
+      result
+    end
+    alias :silence :capture
+
+    #------------------------------------------------------------
+    # Path helpers
+    #------------------------------------------------------------
+    # Path to the tmp directory for the tests.
+    #
+    # @return [Pathname]
+    def tmp_path
+      result = Vagrant.source_root.join("test", "tmp")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the "home" directory for the tests
+    #
+    # @return [Pathname]
+    def home_path
+      result = tmp_path.join("home")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Path to the boxes directory in the home directory
+    #
+    # @return [Pathname]
+    def boxes_path
+      result = home_path.join("boxes")
+      FileUtils.mkdir_p(result)
+      result
+    end
+
+    # Cleans all the test temp paths, which includes the boxes path,
+    # home path, etc. This allows for cleaning between tests.
+    def clean_paths
+      FileUtils.rm_rf(tmp_path)
+
+      # Call these methods only to rebuild the directories
+      tmp_path
+      home_path
+      boxes_path
+    end
+  end
+end