fixed-vagrant 0.7.4.dev

data/lib/vagrant/provisioners/puppet.rb

@@ -0,0 +1,137 @@
+module Vagrant
+  module Provisioners
+    class PuppetError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet")
+    end
+
+    class Puppet < Base
+      register :puppet
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :manifest_file
+        attr_accessor :manifests_path
+        attr_accessor :module_path
+        attr_accessor :pp_path
+        attr_accessor :options
+
+        def initialize
+          @manifest_file = nil
+          @manifests_path = "manifests"
+          @module_path = nil
+          @pp_path = "/tmp/vagrant-puppet"
+          @options = []
+        end
+
+        # Returns the manifests path expanded relative to the root path of the
+        # environment.
+        def expanded_manifests_path
+          Pathname.new(manifests_path).expand_path(env.root_path)
+        end
+
+        # Returns the manifest file if set otherwise returns the box name pp file
+        # which may or may not exist.
+        def computed_manifest_file
+          manifest_file || "#{top.vm.box}.pp"
+        end
+
+        # Returns the module paths as an array of paths expanded relative to the
+        # root path.
+        def expanded_module_paths
+          return [] if !module_path
+
+          # Get all the paths and expand them relative to the root path, returning
+          # the array of expanded paths
+          paths = module_path
+          paths = [paths] if !paths.is_a?(Array)
+          paths.map do |path|
+            Pathname.new(path).expand_path(env.root_path)
+          end
+        end
+
+        def validate(errors)
+          super
+
+          # Manifests path/file validation
+          if !expanded_manifests_path.directory?
+            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing", :path => expanded_manifests_path))
+          else
+            if !expanded_manifests_path.join(computed_manifest_file).file?
+              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing", :manifest => computed_manifest_file))
+            end
+          end
+
+          # Module paths validation
+          expanded_module_paths.each do |path|
+            if !path.directory?
+              errors.add(I18n.t("vagrant.provisioners.puppet.module_path_missing", :path => path))
+            end
+          end
+        end
+      end
+
+      def prepare
+        set_module_paths
+        share_manifests
+        share_module_paths
+      end
+
+      def provision!
+        verify_binary("puppet")
+        run_puppet_client
+      end
+
+      def share_manifests
+        env.config.vm.share_folder("manifests", manifests_guest_path, config.expanded_manifests_path)
+      end
+
+      def share_module_paths
+        count = 0
+        @module_paths.each do |from, to|
+          # Sorry for the cryptic key here, but VirtualBox has a strange limit on
+          # maximum size for it and its something small (around 10)
+          env.config.vm.share_folder("v-pp-m#{count}", to, from)
+          count += 1
+        end
+      end
+
+      def set_module_paths
+        @module_paths = {}
+        config.expanded_module_paths.each_with_index do |path, i|
+          @module_paths[path] = File.join(config.pp_path, "modules-#{i}")
+        end
+      end
+
+      def manifests_guest_path
+        File.join(config.pp_path, "manifests")
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("which #{binary}", :error_class => PuppetError, :_key => :puppet_not_detected, :binary => binary)
+        end
+      end
+
+      def run_puppet_client
+        options = [config.options].flatten
+        options << "--modulepath '#{@module_paths.values.join(':')}'" if !@module_paths.empty?
+        options << config.computed_manifest_file
+        options = options.join(" ")
+
+        commands = ["cd #{manifests_guest_path}",
+                    "puppet #{options}"]
+
+        env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet", :manifest => config.computed_manifest_file)
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo! commands do |ch, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info(data)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/puppet_server.rb

@@ -0,0 +1,55 @@
+module Vagrant
+  module Provisioners
+    class PuppetServerError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet_server")
+    end
+
+    class PuppetServer < Base
+      register :puppet_server
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+        attr_accessor :options
+
+        def initialize
+          @puppet_server = "puppet"
+          @puppet_node = "puppet_node"
+          @options = []
+        end
+      end
+
+      def provision!
+        verify_binary("puppetd")
+        run_puppetd_client
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("which #{binary}", :error_class => PuppetServerError, :_key => :puppetd_not_detected, :binary => binary)
+        end
+      end
+
+      def run_puppetd_client
+        options = config.options
+        options = options.join(" ") if options.is_a?(Array)
+        if config.puppet_node
+          cn = config.puppet_node
+        else
+          cn = env.config.vm.box
+        end
+
+        commands = "puppetd #{options} --server #{config.puppet_server} --certname #{cn}"
+
+        env.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(commands) do |channel, type, data|
+            ssh.check_exit_status(data, commands) if type == :exit_status
+            env.ui.info(data) if type != :exit_status
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/provisioners/shell.rb

@@ -0,0 +1,52 @@
+module Vagrant
+  module Provisioners
+    class Shell < Base
+      register :shell
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :path
+        attr_accessor :upload_path
+
+        def initialize
+          @upload_path = "/tmp/vagrant-shell"
+        end
+
+        def expanded_path
+          Pathname.new(path).expand_path(env.root_path) if path
+        end
+
+        def validate(errors)
+          super
+
+          if !path
+            errors.add(I18n.t("vagrant.provisioners.shell.path_not_set"))
+          elsif !expanded_path.file?
+            errors.add(I18n.t("vagrant.provisioners.shell.path_invalid", :path => expanded_path))
+          end
+
+          if !upload_path
+            errors.add(I18n.t("vagrant.provisioners.shell.upload_path_not_set"))
+          end
+        end
+      end
+
+      def provision!
+        commands = ["chmod +x #{config.upload_path}", config.upload_path]
+
+        # Upload the script to the VM
+        vm.ssh.upload!(config.expanded_path.to_s, config.upload_path)
+
+        # Execute it with sudo
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(commands) do |ch, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info(data)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/ssh.rb

@@ -0,0 +1,173 @@
+require 'timeout'
+require 'net/ssh'
+require 'net/scp'
+require 'mario'
+
+require 'vagrant/ssh/session'
+
+module Vagrant
+  # Manages SSH access to a specific environment. Allows an environment to
+  # replace the process with SSH itself, run a specific set of commands,
+  # upload files, or even check if a host is up.
+  class SSH
+    include Util::Retryable
+
+    # Reference back up to the environment which this SSH object belongs
+    # to
+    attr_accessor :env
+
+    def initialize(environment)
+      @env = environment
+    end
+
+    # Connects to the environment's virtual machine, replacing the ruby
+    # process with an SSH process. This method optionally takes a hash
+    # of options which override the configuration values.
+    def connect(opts={})
+      if Mario::Platform.windows?
+        raise Errors::SSHUnavailableWindows, :key_path => env.config.ssh.private_key_path,
+                                             :ssh_port => port(opts)
+      end
+
+      raise Errors::SSHUnavailable if !Kernel.system("which ssh > /dev/null 2>&1")
+
+      options = {}
+      options[:port] = port(opts)
+      [:host, :username, :private_key_path].each do |param|
+        options[param] = opts[param] || env.config.ssh.send(param)
+      end
+
+      check_key_permissions(options[:private_key_path])
+
+      # Command line options
+      command_options = ["-p #{options[:port]}", "-o UserKnownHostsFile=/dev/null",
+                         "-o StrictHostKeyChecking=no", "-o IdentitiesOnly=yes",
+                         "-i #{options[:private_key_path]}"]
+      command_options << "-o ForwardAgent=yes" if env.config.ssh.forward_agent
+
+      if env.config.ssh.forward_x11
+        # Both are required so that no warnings are shown regarding X11
+        command_options << "-o ForwardX11=yes"
+        command_options << "-o ForwardX11Trusted=yes"
+      end
+
+      # Some hackery going on here. On Mac OS X Leopard (10.5), exec fails
+      # (GH-51). As a workaround, we fork and wait. On all other platforms,
+      # we simply exec.
+      pid = nil
+      pid = fork if Util::Platform.leopard? || Util::Platform.tiger?
+      Kernel.exec "ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]}".strip if pid.nil?
+      Process.wait(pid) if pid
+    end
+
+    # Opens an SSH connection to this environment's virtual machine and yields
+    # a Net::SSH object which can be used to execute remote commands.
+    def execute(opts={})
+      # Check the key permissions to avoid SSH hangs
+      check_key_permissions(env.config.ssh.private_key_path)
+
+      # Merge in any additional options
+      opts = opts.dup
+      opts[:forward_agent] = true if env.config.ssh.forward_agent
+      opts[:port] ||= port
+
+      retryable(:tries => 5, :on => Errno::ECONNREFUSED) do
+        Net::SSH.start(env.config.ssh.host,
+                       env.config.ssh.username,
+                       opts.merge( :keys => [env.config.ssh.private_key_path],
+                                   :keys_only => true,
+                                   :user_known_hosts_file => [],
+                                   :paranoid => false,
+                                   :config => false)) do |ssh|
+          yield SSH::Session.new(ssh, env)
+        end
+      end
+    rescue Errno::ECONNREFUSED
+      raise Errors::SSHConnectionRefused
+    end
+
+    # Uploads a file from `from` to `to`. `from` is expected to be a filename
+    # or StringIO, and `to` is expected to be a path. This method simply forwards
+    # the arguments to `Net::SCP#upload!` so view that for more information.
+    def upload!(from, to)
+      retryable(:tries => 5, :on => IOError) do
+        execute do |ssh|
+          scp = Net::SCP.new(ssh.session)
+          scp.upload!(from, to)
+        end
+      end
+    end
+
+    # Checks if this environment's machine is up (i.e. responding to SSH).
+    #
+    # @return [Boolean]
+    def up?
+      # We have to determine the port outside of the block since it uses
+      # API calls which can only be used from the main thread in JRuby on
+      # Windows
+      ssh_port = port
+
+      Timeout.timeout(env.config.ssh.timeout) do
+        execute(:timeout => env.config.ssh.timeout,
+                :port => ssh_port) { |ssh| }
+      end
+
+      true
+    rescue Net::SSH::AuthenticationFailed
+      raise Errors::SSHAuthenticationFailed
+    rescue Timeout::Error, Errno::ECONNREFUSED, Net::SSH::Disconnect,
+           Errors::SSHConnectionRefused, Net::SSH::AuthenticationFailed
+      return false
+    end
+
+    # Checks the file permissions for the private key, resetting them
+    # if needed, or on failure erroring.
+    def check_key_permissions(key_path)
+      # Windows systems don't have this issue
+      return if Mario::Platform.windows?
+
+      stat = File.stat(key_path)
+
+      if stat.owned? && file_perms(key_path) != "600"
+        File.chmod(0600, key_path)
+
+        raise Errors::SSHKeyBadPermissions, :key_path => key_path if file_perms(key_path) != "600"
+      end
+    rescue Errno::EPERM
+      # This shouldn't happen since we verify we own the file, but just
+      # in case.
+      raise Errors::SSHKeyBadPermissions, :key_path => key_path
+    end
+
+    # Returns the file permissions of a given file. This is fairly unix specific
+    # and probably doesn't belong in this class. Will be refactored out later.
+    def file_perms(path)
+      perms = sprintf("%o", File.stat(path).mode)
+      perms.reverse[0..2].reverse
+    end
+
+    # Returns the port which is either given in the options hash or taken from
+    # the config by finding it in the forwarded ports hash based on the
+    # `config.ssh.forwarded_port_key`.
+    def port(opts={})
+      # Check if port was specified in options hash
+      pnum = opts[:port]
+      return pnum if pnum
+
+      # Check if we have an SSH forwarded port
+      pnum = nil
+      env.vm.vm.network_adapters.each do |na|
+        pnum = na.nat_driver.forwarded_ports.detect do |fp|
+          fp.name == env.config.ssh.forwarded_port_key
+        end
+
+        break if pnum
+      end
+
+      return pnum.hostport if pnum
+
+      # This should NEVER happen.
+      raise Errors::SSHPortNotDetected
+    end
+  end
+end

data/lib/vagrant/ssh/session.rb

@@ -0,0 +1,125 @@
+module Vagrant
+  class SSH
+    # A helper class which wraps around `Net::SSH::Connection::Session`
+    # in order to provide basic command error checking while still
+    # providing access to the actual session object.
+    class Session
+      include Util::Retryable
+
+      attr_reader :session
+      attr_reader :env
+
+      def initialize(session, env)
+        @session = session
+        @env = env
+      end
+
+      # Executes a given command and simply returns true/false if the
+      # command succeeded or not.
+      def test?(command)
+        exec!(command) do |ch, type, data|
+          return true if type == :exit_status && data == 0
+        end
+
+        false
+      end
+
+      # Executes a given command on the SSH session using `sudo` and
+      # blocks until the command completes. This takes the same parameters
+      # as {#exec!}. The only difference is that the command can be an
+      # array of commands, which will be placed into the same script.
+      #
+      # This is different than just calling {#exec!} with `sudo`, since
+      # this command is tailor-made to be compliant with older versions
+      # of `sudo`.
+      def sudo!(commands, options=nil, &block)
+        channel = session.open_channel do |ch|
+          ch.exec("sudo #{env.config.ssh.sudo_shell} -l") do |ch2, success|
+            # Set the terminal
+            ch2.send_data "export TERM=vt100\n"
+
+            # Output each command as if they were entered on the command line
+            [commands].flatten.each do |command|
+              ch2.send_data "#{command}\n"
+            end
+
+            # Remember to exit or we'll hang!
+            ch2.send_data "exit\n"
+
+            # Setup the callbacks with our options so we get all the
+            # stdout/stderr and error checking goodies
+            setup_channel_callbacks(ch2, commands, options, block)
+          end
+        end
+
+        channel.wait
+        channel[:result]
+      end
+
+      # Executes a given command on the SSH session and blocks until
+      # the command completes. This is an almost line for line copy of
+      # the actual `exec!` implementation, except that this
+      # implementation also reports `:exit_status` to the block if given.
+      def exec!(command, options=nil, &block)
+        retryable(:tries => 5, :on => [IOError, Net::SSH::Disconnect], :sleep => 1.0) do
+          metach = session.open_channel do |channel|
+            channel.exec(command) do |ch, success|
+              raise "could not execute command: #{command.inspect}" unless success
+              setup_channel_callbacks(ch, command, options, block)
+            end
+          end
+
+          metach.wait
+          metach[:result]
+        end
+      end
+
+      # Sets up the channel callbacks to properly check exit statuses and
+      # callback on stdout/stderr.
+      def setup_channel_callbacks(channel, command, options, block)
+        options = { :error_check => true }.merge(options || {})
+
+        block ||= Proc.new do |ch, type, data|
+          check_exit_status(data, command, options, ch[:result]) if type == :exit_status && options[:error_check]
+
+          ch[:result] ||= ""
+          ch[:result] << data if [:stdout, :stderr].include?(type)
+        end
+
+        # Output stdout data to the block
+        channel.on_data do |ch2, data|
+          # This clears the screen, we want to filter it out.
+          data.gsub!("\e[H", "")
+
+          block.call(ch2, :stdout, data)
+        end
+
+        # Output stderr data to the block
+        channel.on_extended_data do |ch2, type, data|
+          block.call(ch2, :stderr, data)
+        end
+
+        # Output exit status information to the block
+        channel.on_request("exit-status") do |ch2, data|
+          block.call(ch2, :exit_status, data.read_long)
+        end
+      end
+
+      # Checks for an erroroneous exit status and raises an exception
+      # if so.
+      def check_exit_status(exit_status, commands, options=nil, output=nil)
+        if exit_status != 0
+          output ||= '[no output]'
+          options = {
+            :_error_class => Errors::VagrantError,
+            :_key => :ssh_bad_exit_status,
+            :command => [commands].flatten.join("\n"),
+            :output => output
+          }.merge(options || {})
+
+          raise options[:_error_class], options
+        end
+      end
+    end
+  end
+end