vagrant-unbundled 2.2.7.0 → 2.2.16.0

data/plugins/provisioners/docker/installer.rb

@@ -1,10 +1,8 @@
+require_relative "../container/installer"
+
 module VagrantPlugins
   module DockerProvisioner
-    class Installer
-      def initialize(machine)
-        @machine = machine
-      end
-
+    class Installer < VagrantPlugins::ContainerProvisioner::Installer
       # This handles verifying the Docker installation, installing it if it was
       # requested, and so on. This method will raise exceptions if things are
       # wrong.

data/plugins/provisioners/docker/plugin.rb

@@ -29,14 +29,14 @@ module VagrantPlugins
         Cap::Fedora::DockerInstall
       end
 
-      guest_capability("redhat", "docker_install") do
-        require_relative "cap/redhat/docker_install"
-        Cap::Redhat::DockerInstall
+      guest_capability("centos", "docker_install") do
+        require_relative "cap/centos/docker_install"
+        Cap::Centos::DockerInstall
       end
 
-      guest_capability("redhat", "docker_start_service") do
-        require_relative "cap/redhat/docker_start_service"
-        Cap::Redhat::DockerStartService
+      guest_capability("centos", "docker_start_service") do
+        require_relative "cap/centos/docker_start_service"
+        Cap::Centos::DockerStartService
       end
 
       guest_capability("linux", "docker_installed") do

data/plugins/provisioners/docker/provisioner.rb

@@ -1,3 +1,5 @@
+require_relative "../container/provisioner"
+
 require_relative "client"
 require_relative "installer"
 
@@ -7,17 +9,16 @@ module VagrantPlugins
       error_namespace("vagrant.provisioners.docker")
     end
 
-    class Provisioner < Vagrant.plugin("2", :provisioner)
+    class Provisioner < VagrantPlugins::ContainerProvisioner::Provisioner
       def initialize(machine, config, installer = nil, client = nil)
         super(machine, config)
 
         @installer = installer || Installer.new(@machine)
         @client    = client    || Client.new(@machine)
+        @logger = Log4r::Logger.new("vagrant::provisioners::docker")
       end
 
       def provision
-        @logger = Log4r::Logger.new("vagrant::provisioners::docker")
-
         @logger.info("Checking for Docker installation...")
         if @installer.ensure_installed
           if !config.post_install_provisioner.nil?
@@ -50,13 +51,6 @@ module VagrantPlugins
         end
       end
 
-      def run_provisioner(env)
-        klass  = Vagrant.plugin("2").manager.provisioners[env[:provisioner].type]
-        result = klass.new(env[:machine], env[:provisioner].config)
-        result.config.finalize!
-
-        result.provision
-      end
     end
   end
 end

data/plugins/provisioners/podman/cap/centos/podman_install.rb

@@ -0,0 +1,35 @@
+module VagrantPlugins
+  module PodmanProvisioner
+    module Cap
+      module Centos
+        module PodmanInstall
+          def self.podman_install(machine, kubic)
+            if kubic
+              # Official install instructions for podman
+              # https://podman.io/getting-started/installation.html
+              case machine.guest.capability("flavor")
+              when :centos_7
+                machine.communicate.tap do |comm|
+                  comm.sudo("curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/CentOS_7/devel:kubic:libcontainers:stable.repo")
+                  comm.sudo("yum -q -y install podman")
+                end
+              when :centos_8
+                machine.communicate.tap do |comm|
+                  comm.sudo("dnf -y module disable container-tools &> /dev/null || echo 'container-tools module does not exist'")
+                  comm.sudo("dnf -y install 'dnf-command(copr)'")
+                  comm.sudo("dnf -y copr enable rhcontainerbot/container-selinux")
+                  comm.sudo("curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/CentOS_8/devel:kubic:libcontainers:stable.repo")
+                  comm.sudo("dnf -y install podman")
+                end
+              end
+            else
+              machine.communicate.tap do |comm|
+                comm.sudo("yum -q -y install podman")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/podman/cap/linux/podman_installed.rb

@@ -0,0 +1,13 @@
+module VagrantPlugins
+  module PodmanProvisioner
+    module Cap
+      module Linux
+        module PodmanInstalled
+          def self.podman_installed(machine)
+            machine.communicate.test("command -v podman")
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/podman/cap/redhat/podman_install.rb

@@ -0,0 +1,26 @@
+module VagrantPlugins
+  module PodmanProvisioner
+    module Cap
+      module Redhat
+        module PodmanInstall
+          def self.podman_install(machine, kubic)
+            # Official install instructions for podman
+            # https://podman.io/getting-started/installation.html
+            case machine.guest.capability("flavor")
+            when :rhel_7
+              machine.communicate.tap do |comm|
+                comm.sudo("subscription-manager repos --enable=rhel-7-server-extras-rpms")
+                comm.sudo("yum -q -y install podman")
+              end
+            when :rhel_8
+              machine.communicate.tap do |comm|
+                comm.sudo("yum module enable -y container-tools")
+                comm.sudo("yum module install -y container-tools")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/podman/client.rb

@@ -0,0 +1,12 @@
+require_relative "../container/client"
+
+module VagrantPlugins
+  module PodmanProvisioner
+    class Client < VagrantPlugins::ContainerProvisioner::Client
+      def initialize(machine)
+        super(machine, "podman")
+        @container_command = "podman"
+      end
+    end
+  end
+end

data/plugins/provisioners/podman/config.rb

@@ -0,0 +1,28 @@
+require_relative "../container/config"
+
+module VagrantPlugins
+  module PodmanProvisioner
+    class Config < VagrantPlugins::ContainerProvisioner::Config
+      attr_accessor :kubic
+
+      def initialize
+        super()
+        @kubic = UNSET_VALUE
+      end
+
+      def finalize!
+        super()
+        @kubic = false if @kubic == UNSET_VALUE
+      end
+
+      def post_install_provision(name, **options, &block)
+        # Abort
+        raise PodmanError, :wrong_provisioner if options[:type] == "podman"
+
+        proxy = VagrantPlugins::Kernel_V2::VMConfig.new
+        proxy.provision(name, **options, &block)
+        @post_install_provisioner = proxy.provisioners.first
+      end
+    end
+  end
+end

data/plugins/provisioners/podman/installer.rb

@@ -0,0 +1,33 @@
+require_relative "../container/installer"
+
+module VagrantPlugins
+  module PodmanProvisioner
+    class Installer < VagrantPlugins::ContainerProvisioner::Installer
+      # This handles verifying the Podman installation, installing it if it was
+      # requested, and so on. This method will raise exceptions if things are
+      # wrong.
+      # @params [Boolean] - if true install should use kubic project (this will)
+      #                     add a yum repo.
+      #                     if false install comes from default yum
+      # @return [Boolean] - false if podman cannot be detected on machine, else
+      #                     true if podman installs correctly or is installed
+      def ensure_installed(kubic)
+        if !@machine.guest.capability?(:podman_installed)
+          @machine.ui.warn("Podman can not be installed")
+          return false
+        end
+
+        if !@machine.guest.capability(:podman_installed)
+          @machine.ui.detail("Podman installing")
+          @machine.guest.capability(:podman_install, kubic)
+        end
+
+        if !@machine.guest.capability(:podman_installed)
+          raise PodmanError, :install_failed
+        end
+
+        true
+      end
+    end
+  end
+end

data/plugins/provisioners/podman/plugin.rb

@@ -0,0 +1,38 @@
+require "vagrant"
+
+module VagrantPlugins
+  module PodmanProvisioner
+    class Plugin < Vagrant.plugin("2")
+      name "podman"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      OCI images and containers using Podman.
+      DESC
+
+      config(:podman, :provisioner) do
+        require_relative "config"
+        Config
+      end
+
+      guest_capability("redhat", "podman_install") do
+        require_relative "cap/redhat/podman_install"
+        Cap::Redhat::PodmanInstall
+      end
+
+      guest_capability("centos", "podman_install") do
+        require_relative "cap/centos/podman_install"
+        Cap::Centos::PodmanInstall
+      end
+
+      guest_capability("linux", "podman_installed") do
+        require_relative "cap/linux/podman_installed"
+        Cap::Linux::PodmanInstalled
+      end
+
+      provisioner(:podman) do
+        require_relative "provisioner"
+        Provisioner
+      end
+    end
+  end
+end

data/plugins/provisioners/podman/provisioner.rb

@@ -0,0 +1,52 @@
+require_relative "../container/provisioner"
+
+require_relative "installer"
+require_relative "client"
+
+module VagrantPlugins
+  module PodmanProvisioner
+    class PodmanError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.podman")
+    end
+
+    class Provisioner < VagrantPlugins::ContainerProvisioner::Provisioner
+      def initialize(machine, config, installer = nil, client = nil)
+        super(machine, config, installer, client)
+
+        @installer = installer || Installer.new(@machine)
+        @client    = client    || Client.new(@machine)
+        @logger = Log4r::Logger.new("vagrant::provisioners::podman")
+      end
+
+      def provision
+        @logger.info("Checking for Podman installation...")
+
+        if @installer.ensure_installed(config.kubic)
+          if !config.post_install_provisioner.nil?
+            @logger.info("Running post setup provision script...")
+            env = {
+                  callable: method(:run_provisioner),
+                  provisioner: config.post_install_provisioner,
+                  machine: machine}
+            machine.env.hook(:run_provisioner, env)
+          end
+        end
+
+        if config.images.any?
+          @machine.ui.info(I18n.t("vagrant.docker_pulling_images"))
+          @client.pull_images(*config.images)
+        end
+
+        if config.build_images.any?
+          @machine.ui.info(I18n.t("vagrant.docker_building_images"))
+          @client.build_images(config.build_images)
+        end
+
+        if config.containers.any?
+          @machine.ui.info(I18n.t("vagrant.docker_starting_containers"))
+          @client.run(config.containers)
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/salt/bootstrap-salt.sh

@@ -4,13 +4,16 @@ cd `mktemp -d`
 
 # We just download the bootstrap script by default and execute that.
 if [ -x /usr/bin/fetch ]; then
-    /usr/bin/fetch -o bootstrap-salt.sh https://raw.githubusercontent.com/saltstack/salt-bootstrap/stable/bootstrap-salt.sh
+    /usr/bin/fetch -o bootstrap-salt.sh https://bootstrap.saltproject.io
 elif [ -x /usr/bin/curl ]; then
-    /usr/bin/curl --silent --show-error -L -O https://raw.githubusercontent.com/saltstack/salt-bootstrap/stable/bootstrap-salt.sh
+    /usr/bin/curl --silent --show-error -L --output bootstrap-salt.sh https://bootstrap.saltproject.io
 elif [ -x /usr/bin/wget ]; then
-    /usr/bin/wget -O bootstrap-salt.sh https://raw.githubusercontent.com/saltstack/salt-bootstrap/stable/bootstrap-salt.sh
+    /usr/bin/wget -O bootstrap-salt.sh https://bootstrap.saltproject.io
+elif [ "2" = `python -c 'import sys; sys.stdout.write(str(sys.version_info.major))'` ]; then
+    # TODO: remove after there is no supported distros with Python 2
+    python -c 'import urllib; urllib.urlretrieve("https://bootstrap.saltproject.io", "bootstrap-salt.sh")'
 else
-    python -c 'import urllib; urllib.urlretrieve("https://raw.githubusercontent.com/saltstack/salt-bootstrap/stable/bootstrap-salt.sh", "bootstrap-salt.sh")'
+    python -c 'import urllib.request; urllib.request.urlretrieve("https://bootstrap.saltproject.io", "bootstrap-salt.sh")'
 fi
 
 if [ -e bootstrap-salt.sh ]; then

data/plugins/provisioners/salt/provisioner.rb

@@ -158,6 +158,10 @@ module VagrantPlugins
           options = "%s -N" % options
         end
 
+        if @config.python_version && @machine.config.vm.communicator != :winrm
+          options = "%s -x python%s" % [options, @config.python_version]
+        end
+
         if @config.install_type && @machine.config.vm.communicator != :winrm
           options = "%s %s" % [options, @config.install_type]
         end

data/plugins/provisioners/shell/config.rb

@@ -55,7 +55,7 @@ module VagrantPlugins
         @sha384               = nil if @sha384 == UNSET_VALUE
         @sha512               = nil if @sha512 == UNSET_VALUE
         @env                  = {}  if @env == UNSET_VALUE
-        @upload_path          = "/tmp/vagrant-shell" if @upload_path == UNSET_VALUE
+        @upload_path          = nil if @upload_path == UNSET_VALUE
         @privileged           = true if @privileged == UNSET_VALUE
         @binary               = false if @binary == UNSET_VALUE
         @keep_color           = false if @keep_color == UNSET_VALUE
@@ -109,11 +109,6 @@ module VagrantPlugins
           errors << I18n.t("vagrant.provisioners.shell.env_must_be_a_hash")
         end
 
-        # There needs to be a path to upload the script to
-        if !upload_path
-          errors << I18n.t("vagrant.provisioners.shell.upload_path_not_set")
-        end
-
         if !args_valid?
           errors << I18n.t("vagrant.provisioners.shell.args_bad_type")
         end

data/plugins/provisioners/shell/provisioner.rb

@@ -9,6 +9,10 @@ module VagrantPlugins
     class Provisioner < Vagrant.plugin("2", :provisioner)
       include Vagrant::Util::Retryable
 
+      DEFAULT_WINDOWS_SHELL_EXT = ".ps1".freeze
+
+      CMD_WINDOWS_SHELL_EXT = ".bat".freeze
+
       def provision
         args = ""
         if config.args.is_a?(String)
@@ -38,6 +42,27 @@ module VagrantPlugins
         end
       end
 
+      def upload_path
+        if !defined?(@_upload_path)
+          case @machine.config.vm.guest
+          when :windows
+            @_upload_path = Vagrant::Util::Platform.unix_windows_path(config.upload_path.to_s)
+          else
+            @_upload_path = config.upload_path.to_s
+          end
+
+          if @_upload_path.empty?
+            case @machine.config.vm.guest
+            when :windows
+              @_upload_path = "C:/tmp/vagrant-shell"
+            else
+              @_upload_path = "/tmp/vagrant-shell"
+            end
+          end
+        end
+        @_upload_path
+      end
+
       protected
 
       # This handles outputting the communication data back to the UI
@@ -63,10 +88,10 @@ module VagrantPlugins
         env = config.env.map { |k,v| "#{k}=#{quote_and_escape(v.to_s)}" }
         env = env.join(" ")
 
-        command =  "chmod +x '#{config.upload_path}'"
+        command =  "chmod +x '#{upload_path}'"
         command << " &&"
         command << " #{env}" if !env.empty?
-        command << " #{config.upload_path}#{args}"
+        command << " #{upload_path}#{args}"
 
         with_script_file do |path|
           # Upload the script to the machine
@@ -79,10 +104,10 @@ module VagrantPlugins
             end
 
             user = info[:username]
-            comm.sudo("chown -R #{user} #{config.upload_path}",
+            comm.sudo("chown -R #{user} #{upload_path}",
                       error_check: false)
 
-            comm.upload(path.to_s, config.upload_path)
+            comm.upload(path.to_s, upload_path)
 
             if config.name
               @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
@@ -113,22 +138,21 @@ module VagrantPlugins
         with_script_file do |path|
           # Upload the script to the machine
           @machine.communicate.tap do |comm|
-            env = config.env.map{|k,v| comm.generate_environment_export(k, v)}.join
-            upload_path = config.upload_path.to_s
-            if File.extname(upload_path).empty?
-              remote_ext = @machine.config.winssh.shell == "powershell" ? "ps1" : "bat"
-              upload_path << ".#{remote_ext}"
-            end
-            if remote_ext == "ps1"
+            env = config.env.map{|k,v| comm.generate_environment_export(k, v)}.join(';')
+
+            remote_ext = get_windows_ext(path)
+            remote_path = add_extension(upload_path, remote_ext)
+
+            if remote_ext == ".bat"
+              command = "#{env}\n cmd.exe /c \"#{remote_path}\" #{args}"
+            else
               # Copy powershell_args from configuration
               shell_args = config.powershell_args
               # For PowerShell scripts bypass the execution policy unless already specified
               shell_args += " -ExecutionPolicy Bypass" if config.powershell_args !~ /[-\/]ExecutionPolicy/i
               # CLIXML output is kinda useless, especially on non-windows hosts
               shell_args += " -OutputFormat Text" if config.powershell_args !~ /[-\/]OutputFormat/i
-              command = "#{env}\npowershell #{shell_args} #{upload_path}#{args}"
-            else
-              command = "#{env}\n#{upload_path}#{args}"
+              command = "#{env}\npowershell #{shell_args} -file \"#{remote_path}\"#{args}"
             end
 
             # Reset upload path permissions for the current ssh user
@@ -137,8 +161,8 @@ module VagrantPlugins
               info = @machine.ssh_info
               raise Vagrant::Errors::SSHNotReady if info.nil?
             end
-
-            comm.upload(path.to_s, upload_path)
+            
+            comm.upload(path.to_s, remote_path)
 
             if config.name
               @machine.ui.detail(I18n.t("vagrant.provisioners.shell.running",
@@ -154,7 +178,7 @@ module VagrantPlugins
             # Execute it with sudo
             comm.execute(
               command,
-              sudo: config.privileged,
+              shell: :powershell,
               error_key: :ssh_bad_exit_status_muted
             ) do |type, data|
               handle_comm(type, data)
@@ -174,20 +198,17 @@ module VagrantPlugins
           @machine.communicate.tap do |comm|
             # Make sure that the upload path has an extension, since
             # having an extension is critical for Windows execution
-            upload_path = config.upload_path.to_s
-            if File.extname(upload_path) == ""
-              upload_path += File.extname(path.to_s)
-            end
+            winrm_upload_path = add_extension(upload_path,  get_windows_ext(path))
 
             # Upload it
-            comm.upload(path.to_s, upload_path)
+            comm.upload(path.to_s, winrm_upload_path)
 
             # Build the environment
             env = config.env.map { |k,v| "$env:#{k} = #{quote_and_escape(v.to_s)}" }
             env = env.join("; ")
 
             # Calculate the path that we'll be executing
-            exec_path = upload_path
+            exec_path = winrm_upload_path
             exec_path.gsub!('/', '\\')
             exec_path = "c:#{exec_path}" if exec_path.start_with?("\\")
 
@@ -236,6 +257,22 @@ module VagrantPlugins
         "#{quote}#{text.gsub(/#{quote}/) { |m| "#{m}\\#{m}#{m}" }}#{quote}"
       end
 
+      def add_extension(path, ext)
+        return path if !File.extname(path.to_s).empty?
+        path + ext
+      end
+
+      def get_windows_ext(path)
+        remote_ext = File.extname(upload_path.to_s)
+        if remote_ext.empty?
+          remote_ext = File.extname(path.to_s)
+          if remote_ext.empty?
+            remote_ext = @machine.config.winssh.shell == "cmd" ? CMD_WINDOWS_SHELL_EXT : DEFAULT_WINDOWS_SHELL_EXT
+          end
+        end
+        remote_ext
+      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.
@@ -269,14 +306,12 @@ module VagrantPlugins
           ext    = File.extname(config.path)
           script = Pathname.new(config.path).expand_path(root_path).read
         else
-          # The script is just the inline code...
-          ext    = ".ps1"
           script = config.inline
         end
 
         # Replace Windows line endings with Unix ones unless binary file
         # or we're running on Windows.
-        if !config.binary && @machine.config.vm.communicator != :winrm
+        if !config.binary && @machine.config.vm.guest != :windows
           begin
             script = script.gsub(/\r\n?$/, "\n")
           rescue ArgumentError