bmhatfield-vagrant 1.0.7

data/lib/vagrant/provisioners/puppet.rb

@@ -0,0 +1,176 @@
+require "log4r"
+
+module Vagrant
+  module Provisioners
+    class PuppetError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet")
+    end
+
+    class Puppet < Base
+      class Config < Vagrant::Config::Base
+        attr_accessor :manifest_file
+        attr_accessor :manifests_path
+        attr_accessor :module_path
+        attr_accessor :pp_path
+        attr_accessor :options
+        attr_accessor :facter
+
+        def manifest_file; @manifest_file || "default.pp"; end
+        def manifests_path; @manifests_path || "manifests"; end
+        def pp_path; @pp_path || "/tmp/vagrant-puppet"; end
+        def options; @options ||= []; end
+        def facter; @facter ||= {}; end
+
+        # Returns the manifests path expanded relative to the root path of the
+        # environment.
+        def expanded_manifests_path(root_path)
+          Pathname.new(manifests_path).expand_path(root_path)
+        end
+
+        # Returns the module paths as an array of paths expanded relative to the
+        # root path.
+        def expanded_module_paths(root_path)
+          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(root_path)
+          end
+        end
+
+        def validate(env, errors)
+          # Calculate the manifests and module paths based on env
+          this_expanded_manifests_path = expanded_manifests_path(env.root_path)
+          this_expanded_module_paths = expanded_module_paths(env.root_path)
+
+          # Manifests path/file validation
+          if !this_expanded_manifests_path.directory?
+            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing",
+                              :path => this_expanded_manifests_path))
+          else
+            expanded_manifest_file = this_expanded_manifests_path.join(manifest_file)
+            if !expanded_manifest_file.file?
+              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing",
+                                :manifest => expanded_manifest_file.to_s))
+            end
+          end
+
+          # Module paths validation
+          this_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 self.config_class
+        Config
+      end
+
+      def initialize(env, config)
+        super
+
+        @logger = Log4r::Logger.new("vagrant::provisioners::puppet")
+      end
+
+      def prepare
+        # Calculate the paths we're going to use based on the environment
+        @expanded_manifests_path = config.expanded_manifests_path(env[:root_path])
+        @expanded_module_paths   = config.expanded_module_paths(env[:root_path])
+        @manifest_file           = File.join(manifests_guest_path, config.manifest_file)
+
+        set_module_paths
+        share_manifests
+        share_module_paths
+      end
+
+      def provision!
+        # Check that the shared folders are properly shared
+        check = [manifests_guest_path]
+        @module_paths.each do |host_path, guest_path|
+          check << guest_path
+        end
+
+        verify_shared_folders(check)
+
+        # Verify Puppet is installed and run it
+        verify_binary("puppet")
+        run_puppet_client
+      end
+
+      def share_manifests
+        env[:vm].config.vm.share_folder("manifests", manifests_guest_path, @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[:vm].config.vm.share_folder("v-pp-m#{count}", to, from)
+          count += 1
+        end
+      end
+
+      def set_module_paths
+        @module_paths = []
+        @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)
+        env[:vm].channel.sudo("which #{binary}",
+                              :error_class => PuppetError,
+                              :error_key => :not_detected,
+                              :binary => binary)
+      end
+
+      def run_puppet_client
+        options = [config.options].flatten
+        module_paths = @module_paths.map { |_, to| to }
+        options << "--modulepath '#{module_paths.join(':')}'" if !@module_paths.empty?
+        options << @manifest_file
+        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 = "cd #{manifests_guest_path} && #{facter}puppet apply #{options} --detailed-exitcodes || [ $? -eq 2 ]"
+
+        env[:ui].info I18n.t("vagrant.provisioners.puppet.running_puppet",
+                             :manifest => @manifest_file)
+
+        env[:vm].channel.sudo(command) do |type, data|
+          env[:ui].info(data.chomp, :prefix => false)
+        end
+      end
+
+      def verify_shared_folders(folders)
+        folders.each do |folder|
+          @logger.debug("Checking for shared folder: #{folder}")
+          if !env[:vm].channel.test("test -d #{folder}")
+            raise PuppetError, :missing_shared_folders
+          end
+        end
+      end
+    end
+  end
+end
+

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