vagrant 1.5.0 → 2.4.4

data/plugins/provisioners/puppet/config/puppet_server.rb

@@ -0,0 +1,84 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Puppet
+    module Config
+      class PuppetServer < Vagrant.plugin("2", :config)
+        # The path to Puppet's bin/ directory.
+        # @return [String]
+        attr_accessor :binary_path
+
+        attr_accessor :client_cert_path
+        attr_accessor :client_private_key_path
+        attr_accessor :facter
+        attr_accessor :options
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+
+        def initialize
+          super
+
+          @binary_path             = UNSET_VALUE
+          @client_cert_path        = UNSET_VALUE
+          @client_private_key_path = UNSET_VALUE
+          @facter                  = {}
+          @options                 = []
+          @puppet_node             = UNSET_VALUE
+          @puppet_server           = UNSET_VALUE
+        end
+
+        def merge(other)
+          super.tap do |result|
+            result.facter  = @facter.merge(other.facter)
+          end
+        end
+
+        def finalize!
+          super
+
+          @binary_path      = nil if @binary_path == UNSET_VALUE
+          @client_cert_path = nil if @client_cert_path == UNSET_VALUE
+          @client_private_key_path = nil if @client_private_key_path == UNSET_VALUE
+          @puppet_node   = nil if @puppet_node == UNSET_VALUE
+          @puppet_server = "puppet" if @puppet_server == UNSET_VALUE
+        end
+
+        def validate(machine)
+          errors = _detected_errors
+
+          if (client_cert_path && !client_private_key_path) ||
+            (client_private_key_path && !client_cert_path)
+            errors << I18n.t(
+              "vagrant.provisioners.puppet_server.client_cert_and_private_key")
+          end
+
+          if client_cert_path
+            path = Pathname.new(client_cert_path).
+              expand_path(machine.env.root_path)
+            if !path.file?
+              errors << I18n.t(
+                "vagrant.provisioners.puppet_server.client_cert_not_found")
+            end
+          end
+
+          if client_private_key_path
+            path = Pathname.new(client_private_key_path).
+              expand_path(machine.env.root_path)
+            if !path.file?
+              errors << I18n.t(
+                "vagrant.provisioners.puppet_server.client_private_key_not_found")
+            end
+          end
+
+          if !puppet_node && (client_cert_path || client_private_key_path)
+            errors << I18n.t(
+              "vagrant.provisioners.puppet_server.cert_requires_node")
+          end
+
+          { "puppet server provisioner" => errors }
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/plugin.rb

@@ -0,0 +1,36 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module Puppet
+    class Plugin < Vagrant.plugin("2")
+      name "puppet"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      Puppet either using `puppet apply` or a Puppet server.
+      DESC
+
+      config(:puppet, :provisioner) do
+        require_relative "config/puppet"
+        Config::Puppet
+      end
+
+      config(:puppet_server, :provisioner) do
+        require_relative "config/puppet_server"
+        Config::PuppetServer
+      end
+
+      provisioner(:puppet) do
+        require_relative "provisioner/puppet"
+        Provisioner::Puppet
+      end
+
+      provisioner(:puppet_server) do
+        require_relative "provisioner/puppet_server"
+        Provisioner::PuppetServer
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/provisioner/puppet.rb

@@ -0,0 +1,336 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "digest/md5"
+require "log4r"
+
+module VagrantPlugins
+  module Puppet
+    module Provisioner
+      class PuppetError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant.provisioners.puppet")
+      end
+
+      class Puppet < Vagrant.plugin("2", :provisioner)
+        def initialize(machine, config)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provisioners::puppet")
+        end
+
+        def configure(root_config)
+          # Calculate the paths we're going to use based on the environment
+          root_path = @machine.env.root_path
+          @expanded_module_paths   = @config.expanded_module_paths(root_path)
+
+          # Setup the module paths
+          @module_paths = []
+          @expanded_module_paths.each_with_index do |path, _|
+            key = Digest::MD5.hexdigest(path.to_s)
+            @module_paths << [path, File.join(config.temp_dir, "modules-#{key}")]
+          end
+
+          folder_opts = {}
+          folder_opts[:type] = @config.synced_folder_type if @config.synced_folder_type
+          folder_opts[:owner] = "root" if !@config.synced_folder_type
+          folder_opts[:args] = @config.synced_folder_args if @config.synced_folder_args
+          folder_opts[:nfs__quiet] = true
+
+          if @config.environment_path.is_a?(Array)
+            # Share the environments directory with the guest
+            if @config.environment_path[0].to_sym == :host
+              root_config.vm.synced_folder(
+                File.expand_path(@config.environment_path[1], root_path),
+                environments_guest_path, folder_opts)
+            end
+          end
+          if @config.manifest_file
+            @manifest_file  = File.join(manifests_guest_path, @config.manifest_file)
+            # Share the manifests directory with the guest
+            if @config.manifests_path[0].to_sym == :host
+              root_config.vm.synced_folder(
+                File.expand_path(@config.manifests_path[1], root_path),
+                manifests_guest_path, folder_opts)
+            end
+          end
+
+          # Share the module paths
+          @module_paths.each do |from, to|
+            root_config.vm.synced_folder(from, to, folder_opts)
+          end
+        end
+
+        def parse_environment_metadata
+          # Parse out the environment manifest path since puppet apply doesnt do that for us.
+          environment_conf = File.join(environments_guest_path, @config.environment, "environment.conf")
+          if @machine.communicate.test("test -e #{environment_conf}", sudo: true)
+            @machine.communicate.sudo("cat #{environment_conf}") do | type, data|
+              if type == :stdout
+                data.each_line do |line|
+                  if line =~ /^\s*manifest\s+=\s+([^\s]+)/
+                    @manifest_file = $1
+                    @manifest_file.gsub! "$codedir", File.dirname(environments_guest_path)
+                    @manifest_file.gsub! "$environment", @config.environment
+                    if !@manifest_file.start_with? "/"
+                      @manifest_file = File.join(environments_guest_path, @config.environment, @manifest_file)
+                    end
+                    @logger.debug("Using manifest from environment.conf: #{@manifest_file}")
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def provision
+          # If the machine has a wait for reboot functionality, then
+          # do that (primarily Windows)
+          if @machine.guest.capability?(:wait_for_reboot)
+            @machine.guest.capability(:wait_for_reboot)
+          end
+
+          # In environment mode we still need to specify a manifest file, if its not, use the one from env config if specified.
+          if !@manifest_file
+            @manifest_file = "#{environments_guest_path}/#{@config.environment}/manifests"
+            parse_environment_metadata
+          end
+          # Check that the shared folders are properly shared
+          check = []
+          if @config.manifests_path.is_a?(Array) && @config.manifests_path[0] == :host
+            check << manifests_guest_path
+          end
+          if @config.environment_path.is_a?(Array) && @config.environment_path[0] == :host
+            check << environments_guest_path
+          end
+          @module_paths.each do |host_path, guest_path|
+            check << guest_path
+          end
+
+          # Make sure the temporary directory is properly set up
+          if windows?
+            tmp_command = "mkdir -p #{config.temp_dir}"
+            comm_opts = { shell: :powershell}
+          else
+            tmp_command = "mkdir -p #{config.temp_dir}; chmod 0777 #{config.temp_dir}"
+            comm_opts = {}
+          end
+
+          @machine.communicate.tap do |comm|
+            comm.sudo(tmp_command, comm_opts)
+          end
+
+          verify_shared_folders(check)
+
+          # Verify Puppet is installed and run it
+          puppet_bin = "puppet"
+          verify_binary(puppet_bin)
+
+          # Upload Hiera configuration if we have it
+          @hiera_config_path = nil
+          if config.hiera_config_path
+            local_hiera_path   = File.expand_path(config.hiera_config_path,
+              @machine.env.root_path)
+            @hiera_config_path = File.join(config.temp_dir, "hiera.yaml")
+            @machine.communicate.upload(local_hiera_path, @hiera_config_path)
+          end
+
+          # Build up the structured custom facts if we have any
+          # With structured facts on, we assume the config.facter is yaml.
+          if config.structured_facts && !config.facter.empty?
+            @facter_config_path = "/etc/puppetlabs/facter/facts.d/vagrant_facts.yaml"
+            if windows?
+              @facter_config_path = "/ProgramData/PuppetLabs/facter/facts.d/vagrant_facts.yaml"
+            end
+            t = Tempfile.new("vagrant_facts.yaml")
+            t.write(config.facter.to_yaml)
+            t.close()
+            @machine.communicate.tap do |comm|
+              comm.upload(t.path, File.join(@config.temp_dir, "vagrant_facts.yaml"))
+              comm.sudo("cp #{config.temp_dir}/vagrant_facts.yaml #{@facter_config_path}")
+            end
+           end
+
+          run_puppet_apply
+        end
+
+        def manifests_guest_path
+          if config.manifests_path[0] == :host
+            # The path is on the host, so point to where it is shared
+            key = Digest::MD5.hexdigest(config.manifests_path[1])
+            File.join(config.temp_dir, "manifests-#{key}")
+          else
+            # The path is on the VM, so just point directly to it
+            config.manifests_path[1]
+          end
+        end
+
+        def environments_guest_path
+          if config.environment_path[0] == :host
+            # The path is on the host, so point to where it is shared
+            File.join(config.temp_dir, "environments")
+          else
+            # The path is on the VM, so just point directly to it
+            config.environment_path[1]
+          end
+        end
+
+        def verify_binary(binary)
+          # Determine the command to use to test whether Puppet is available.
+          # This is very platform dependent.
+          test_cmd = "sh -c 'command -v #{binary}'"
+          if windows?
+            test_cmd = "where.exe #{binary}"
+            if @config.binary_path
+              test_cmd = "where.exe \"#{@config.binary_path}:#{binary}\""
+            end
+          end
+
+          if !machine.communicate.test(test_cmd)
+            @config.binary_path = "/opt/puppetlabs/bin/"
+            @machine.communicate.sudo(
+              "test -x /opt/puppetlabs/bin/#{binary}",
+              error_class: PuppetError,
+              error_key: :not_detected,
+              binary: binary)
+          end
+        end
+
+        def run_puppet_apply
+          default_module_path = "/etc/puppet/modules"
+          if windows?
+            default_module_path = "/ProgramData/PuppetLabs/puppet/etc/modules"
+          end
+
+          options = [config.options].flatten
+          module_paths = @module_paths.map { |_, to| to }
+          if !@module_paths.empty?
+            # Append the default module path
+            module_paths << default_module_path
+
+            # Add the command line switch to add the module path
+            module_path_sep = windows? ? ";" : ":"
+            options << "--modulepath '#{module_paths.join(module_path_sep)}'"
+          end
+
+          if @hiera_config_path
+            options << "--hiera_config=#{@hiera_config_path}"
+          end
+
+          if !@machine.env.ui.color?
+            options << "--color=false"
+          end
+
+          options << "--detailed-exitcodes"
+          if config.environment_path
+            options << "--environmentpath #{environments_guest_path}/"
+            options << "--environment #{@config.environment}"
+          end
+
+          options << @manifest_file
+          options = options.join(" ")
+
+          # Build up the custom facts if we have any
+          facter = nil
+          # Build up the (non-structured) custom facts if we have any
+          if !config.structured_facts && !config.facter.empty?
+            facts = []
+            config.facter.each do |key, value|
+              facts << "FACTER_#{key}='#{value}'"
+            end
+
+            # If we're on Windows, we need to use the PowerShell style
+            if windows?
+              facts.map! { |v| "$env:#{v};" }
+            end
+
+            facter = facts.join(" ")
+          end
+
+          puppet_bin = "puppet"
+          if @config.binary_path
+            puppet_bin = File.join(@config.binary_path, puppet_bin)
+          end
+
+          env_vars = nil
+          if !config.environment_variables.nil? && !config.environment_variables.empty?
+            env_vars = config.environment_variables.map do |env_key, env_value|
+              "#{env_key}=\"#{env_value}\""
+            end
+
+            if windows?
+              env_vars.map! do |env_var_string|
+                "$env:#{env_var_string}"
+              end
+              env_vars = env_vars.join("; ")
+              env_vars << ";"
+            else
+              env_vars = env_vars.join(" ")
+            end
+          end
+
+          command = [
+            env_vars,
+            facter,
+            puppet_bin,
+            "apply",
+            options
+          ].compact.map(&:to_s).join(" ")
+          if config.working_directory
+            if windows?
+              command = "cd #{config.working_directory}; if ($?) \{ #{command} \}"
+            else
+              command = "cd #{config.working_directory} && #{command}"
+            end
+          end
+
+          if config.environment_path
+            @machine.ui.info(I18n.t(
+              "vagrant.provisioners.puppet.running_puppet_env",
+              environment: config.environment))
+          else
+            @machine.ui.info(I18n.t(
+              "vagrant.provisioners.puppet.running_puppet",
+              manifest: config.manifest_file))
+          end
+
+          opts = {
+            elevated: true,
+            error_class: Vagrant::Errors::VagrantError,
+            error_key: :ssh_bad_exit_status_muted,
+            good_exit: [0,2],
+          }
+
+          if windows?
+            opts[:shell] = :powershell
+          end
+          @machine.communicate.sudo(command, opts) do |type, data|
+            if !data.chomp.empty?
+              @machine.ui.info(data.chomp)
+            end
+          end
+        end
+
+        def verify_shared_folders(folders)
+          folders.each do |folder|
+            @logger.debug("Checking for shared folder: #{folder}")
+            if windows?
+              testcommand = "Test-Path #{folder}"
+              comm_opts = { shell: :powershell}
+            else
+              testcommand = "test -d #{folder}"
+              comm_opts = { sudo: true}
+            end
+
+            if !@machine.communicate.test(testcommand, comm_opts)
+              raise PuppetError, :missing_shared_folders
+            end
+          end
+        end
+
+        def windows?
+          @machine.config.vm.communicator == :winrm || @machine.config.vm.communicator == :winssh
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/provisioner/puppet_server.rb

@@ -0,0 +1,114 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module Puppet
+    module Provisioner
+      class PuppetServerError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant.provisioners.puppet_server")
+      end
+
+      class PuppetServer < Vagrant.plugin("2", :provisioner)
+        def provision
+          if @machine.config.vm.communicator == :winrm
+            raise Vagrant::Errors::ProvisionerWinRMUnsupported,
+              name: "puppet_server"
+          end
+
+          verify_binary("puppet")
+          run_puppet_agent
+        end
+
+        def verify_binary(binary)
+          if @config.binary_path
+            test_cmd = "test -x #{@config.binary_path}/#{binary}"
+          else
+            test_cmd = "which #{binary}"
+          end
+
+          @machine.communicate.sudo(
+            test_cmd,
+            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 @machine.config.vm.hostname
+            # 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 = @machine.config.vm.box
+          end
+
+          # Add the certname option if there is one
+          options += ["--certname", cn] if cn
+
+          # A shortcut to make things easier
+          comm = @machine.communicate
+
+          # If we have client certs specified, then upload them
+          if config.client_cert_path && config.client_private_key_path
+            @machine.ui.info(
+              I18n.t("vagrant.provisioners.puppet_server.uploading_client_cert"))
+            dirname = "/tmp/puppet-#{Time.now.to_i}-#{rand(1000)}"
+            comm.sudo("mkdir -p #{dirname}")
+            comm.sudo("mkdir -p #{dirname}/certs")
+            comm.sudo("mkdir -p #{dirname}/private_keys")
+            comm.sudo("chmod -R 0777 #{dirname}")
+            comm.upload(config.client_cert_path, "#{dirname}/certs/#{cn}.pem")
+            comm.upload(config.client_private_key_path,
+              "#{dirname}/private_keys/#{cn}.pem")
+
+            # Setup the options so that they point to our directories
+            options << "--certdir=#{dirname}/certs"
+            options << "--privatekeydir=#{dirname}/private_keys"
+          end
+
+          # Disable colors if we must
+          if !@machine.env.ui.color?
+            options << "--color=false"
+          end
+
+          # 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
+
+
+          puppet_bin = "puppet"
+          if @config.binary_path
+            puppet_bin = File.join(@config.binary_path, puppet_bin)
+          end
+          options = options.join(" ")
+          command = "#{facter} #{puppet_bin} agent --onetime --no-daemonize #{options} " +
+            "--server #{config.puppet_server} --detailed-exitcodes || [ $? -eq 2 ]"
+
+          @machine.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+          @machine.communicate.sudo(command) do |type, data|
+            if !data.chomp.empty?
+              @machine.ui.info(data.chomp)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/salt/bootstrap_downloader.rb

@@ -0,0 +1,62 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'open-uri'
+require 'digest'
+
+require_relative "./errors"
+
+module VagrantPlugins
+  module Salt
+    class BootstrapDownloader
+      WINDOWS_URL = "https://github.com/saltstack/salt-bootstrap/releases/latest/download/bootstrap-salt.ps1"
+      URL = "https://github.com/saltstack/salt-bootstrap/releases/latest/download/bootstrap-salt.sh"
+      SHA256_SUFFIX = ".sha256"
+
+      def initialize(guest)
+        @guest = guest
+        @logger  = Log4r::Logger.new("vagrant::salt::bootstrap_downloader")
+      end
+
+      def source_url 
+        @guest == :windows ? WINDOWS_URL : URL
+      end
+
+      def get_bootstrap_script
+        @logger.debug "Downloading bootstrap script from #{source_url}"
+        script_file = download(source_url)
+
+        verify_sha256(script_file)
+
+        @logger.info "Downloaded and verified salt-bootstrap script"
+        script_file
+      end
+
+      def verify_sha256(script)
+        @logger.debug "Downloading sha256 file from #{source_url}#{SHA256_SUFFIX}"
+        sha256_file = download("#{source_url}#{SHA256_SUFFIX}")
+        sha256 = extract_sha256(sha256_file.read)
+        sha256_file.close
+
+        @logger.debug "Computing sha256 value from script file"
+        computed_sha256 = Digest::SHA256.hexdigest(script.read)
+        script.rewind
+
+        @logger.debug "Comparing sha256 values"
+        if computed_sha256 != sha256
+          @logger.debug "Mismatched sha256, expected #{sha256} but computed #{computed_sha256}"
+          raise Salt::Errors::InvalidShasumError, source: source_url, expected_sha: sha256, computed_sha: computed_sha256
+        end
+        @logger.debug "Sha256 values match"
+      end
+
+      def extract_sha256(text)
+        text.scan(/\b([a-f0-9]{64})\b/).last.first
+      end
+
+      def download(url)
+        URI(url).open
+      end
+    end
+  end
+end