podman 1.0.3

data/lib/vagrant/podman/action/host_machine_build_dir.rb

@@ -0,0 +1,49 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "digest/md5"
+
+require "log4r"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class HostMachineBuildDir
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::podman::hostmachinebuilddir")
+        end
+
+        def call(env)
+          machine   = env[:machine]
+          build_dir = machine.provider_config.build_dir
+
+          # If we're not building a Podmanfile, ignore
+          return @app.call(env) if !build_dir
+
+          # If we're building a podman file, expand the directory
+          build_dir = File.expand_path(build_dir, env[:machine].env.root_path)
+          env[:build_dir] = build_dir
+
+          # If we're not on a host VM, we're done
+          return @app.call(env) if !machine.provider.host_vm?
+
+          # We're on a host VM, so we need to move our build dir to
+          # that machine. We do this by putting the synced folder on
+          # ourself and letting HostMachineSyncFolders handle it.
+          new_build_dir = "/var/lib/podman/podman_build_#{Digest::MD5.hexdigest(build_dir)}"
+          options       = {
+            podman__ignore: true,
+            podman__exact: true,
+          }.merge(machine.provider_config.host_vm_build_dir_options || {})
+          machine.config.vm.synced_folder(build_dir, new_build_dir, options)
+
+          # Set the build dir to be the correct one
+          env[:build_dir] = new_build_dir
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/host_machine_port_checker.rb

@@ -0,0 +1,34 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      # This sets up the middleware env var to check for ports in use.
+      class HostMachinePortChecker
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::podman::hostmachineportchecker")
+        end
+
+        def call(env)
+          return @app.call(env) if !env[:machine].provider.host_vm?
+
+          @machine = env[:machine]
+          env[:port_collision_port_check] = method(:port_check)
+
+          @app.call(env)
+        end
+
+        protected
+
+        def port_check(port)
+          host_machine = @machine.provider.host_vm
+          host_machine.guest.capability(:port_open_check, port)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/host_machine_port_warning.rb

@@ -0,0 +1,40 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class HostMachinePortWarning
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env[:machine].provider.host_vm?
+            return @app.call(env)
+          end
+
+          # If we have forwarded ports, then notify the user that they
+          # won't be immediately available unless a private network
+          # is created.
+          if has_forwarded_ports?(env[:machine])
+            env[:machine].ui.warn(I18n.t(
+              "podman_provider.host_machine_forwarded_ports"))
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        def has_forwarded_ports?(machine)
+          machine.config.vm.networks.each do |type, _|
+            return true if type == :forwarded_port
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/host_machine_required.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      # This middleware is used with Call to test if we're using a host VM.
+      class HostMachineRequired
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].provider.host_vm?
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/host_machine_sync_folders.rb

@@ -0,0 +1,176 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "digest/md5"
+require "securerandom"
+
+require "log4r"
+
+require "vagrant/action/builtin/mixin_synced_folders"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      # This action is responsible for creating the host machine if
+      # we need to. The host machine is where Podman containers will
+      # live.
+      class HostMachineSyncFolders
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::podman::hostmachine")
+        end
+
+        def call(env)
+          return @app.call(env) if !env[:machine].provider.host_vm?
+
+          if !env.key?(:host_machine_sync_folders)
+            env[:host_machine_sync_folders] = true
+          end
+
+          host_machine = env[:machine].provider.host_vm
+
+          # Lock while we make changes
+          begin
+            env[:machine].provider.host_vm_lock do
+              setup_synced_folders(host_machine, env)
+            end
+          rescue Vagrant::Errors::EnvironmentLockedError
+            sleep 1
+            retry
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        def setup_synced_folders(host_machine, env)
+          # Write the host machine SFID if we have one
+          id_path = env[:machine].data_dir.join("host_machine_sfid")
+          if !id_path.file?
+            host_sfid = SecureRandom.uuid
+            id_path.open("w") do |f|
+              f.binmode
+              f.write("#{host_sfid}\n")
+            end
+          else
+            host_sfid = id_path.read.chomp
+          end
+
+          # Create a UI for this machine that stays at the detail level
+          proxy_ui = host_machine.ui.dup
+          proxy_ui.opts[:bold] = false
+          proxy_ui.opts[:prefix_spaces] = true
+          proxy_ui.opts[:target] = env[:machine].name.to_s
+
+          # Read the existing folders that are setup
+          existing_folders = synced_folders(host_machine, cached: true)
+          existing_ids = {}
+          if existing_folders
+            existing_folders.each do |impl, fs|
+              fs.each do |_name, data|
+                if data[:podman_sfid] && data[:podman_host_sfid] == host_sfid
+                  existing_ids[data[:podman_sfid]] = data
+                end
+              end
+            end
+          end
+
+          # Sync some folders so that our volumes work later.
+          new_config  = VagrantPlugins::Kernel_V2::VMConfig.new
+          our_folders = synced_folders(env[:machine])
+          our_folders.each do |type, folders|
+            folders.each do |id, data|
+              data = data.dup
+
+              if type == :podman
+                # We don't use the Podman type explicitly on the host VM
+                data.delete(:type)
+              end
+
+              # Expand the hostpath relative to _our_ root path. Otherwise,
+              # it expands it relative to the proxy VM, which is not what
+              # we want.
+              data[:hostpath] = File.expand_path(
+                data[:hostpath], env[:machine].env.root_path)
+
+              # Generate an ID that is deterministic based on our machine
+              # and Vagrantfile path...
+              id = Digest::MD5.hexdigest(
+                "#{env[:machine].env.root_path}" +
+                "#{data[:hostpath]}" +
+                "#{data[:guestpath]}" +
+                "#{env[:machine].name}")
+
+              # Generate a new guestpath
+              data[:podman_guestpath] = data[:guestpath]
+              data[:podman_sfid] = id
+              data[:podman_host_sfid] = host_sfid
+              data[:id] = id[0...6] + rand(10000).to_s
+
+              # If we specify exact then we know what we're doing
+              if !data[:podman__exact]
+                data[:guestpath] = "/var/lib/podman/podman_#{id}"
+              end
+
+              # Add this synced folder onto the new config if we haven't
+              # already shared it before.
+              if !existing_ids.key?(id)
+                # A bit of a hack for VirtualBox to mount our
+                # folder as transient. This can be removed once
+                # the VirtualBox synced folder mechanism is smarter.
+                data[:virtualbox__transient] = true
+
+                new_config.synced_folder(
+                  data[:hostpath],
+                  data[:guestpath],
+                  data)
+              else
+                # We already have the folder, so just load its data
+                data = existing_ids[id]
+              end
+
+              # Remove from our machine
+              env[:machine].config.vm.synced_folders.delete(id)
+
+              # Add the "fixed" folder to our machine
+              data = data.merge({
+                hostpath_exact: true,
+                type: :podman,
+              })
+              env[:machine].config.vm.synced_folder(
+                data[:guestpath],
+                data[:podman_guestpath],
+                data)
+            end
+          end
+
+          if !env[:host_machine_sync_folders]
+            @logger.info("Not syncing folders because container created.")
+          end
+
+          if !new_config.synced_folders.empty?
+            # Sync the folders!
+            env[:machine].ui.output(I18n.t(
+              "podman_provider.host_machine_syncing_folders"))
+            host_machine.with_ui(proxy_ui) do
+              action_env = { synced_folders_config: new_config }
+              begin
+                host_machine.action(:sync_folders, action_env)
+              rescue Vagrant::Errors::MachineActionLockedError
+                sleep 1
+                retry
+              rescue Vagrant::Errors::UnimplementedProviderAction
+                callable = Vagrant::Action::Builder.new
+                callable.use Vagrant::Action::Builtin::SyncedFolders
+                host_machine.action_raw(:sync_folders, callable, action_env)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/host_machine_sync_folders_disable.rb

@@ -0,0 +1,91 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require "vagrant/action/builtin/mixin_synced_folders"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      # This action disables the synced folders we created.
+      class HostMachineSyncFoldersDisable
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::podman::hostmachine")
+        end
+
+        def call(env)
+          return @app.call(env) if !env[:machine].provider.host_vm?
+
+          # Read our random ID for this instance
+          id_path   = env[:machine].data_dir.join("host_machine_sfid")
+          return @app.call(env) if !id_path.file?
+          host_sfid = id_path.read.chomp
+
+          host_machine = env[:machine].provider.host_vm
+
+          @app.call(env)
+
+          begin
+            env[:machine].provider.host_vm_lock do
+              setup_synced_folders(host_machine, host_sfid, env)
+            end
+          rescue Vagrant::Errors::EnvironmentLockedError
+            sleep 1
+            retry
+          end
+        end
+
+        protected
+
+        def setup_synced_folders(host_machine, host_sfid, env)
+          to_disable = []
+
+          # Read the existing folders that are setup
+          existing_folders = synced_folders(host_machine, cached: true)
+          if existing_folders
+            existing_folders.each do |impl, fs|
+              fs.each do |id, data|
+                if data[:podman_host_sfid] == host_sfid
+                  to_disable << id
+                end
+              end
+            end
+          end
+
+          # Nothing to do if we have no bad folders
+          return if to_disable.empty?
+
+          # Create a UI for this machine that stays at the detail level
+          proxy_ui = host_machine.ui.dup
+          proxy_ui.opts[:bold] = false
+          proxy_ui.opts[:prefix_spaces] = true
+          proxy_ui.opts[:target] = env[:machine].name.to_s
+
+          env[:machine].ui.output(I18n.t(
+            "podman_provider.host_machine_disabling_folders"))
+          host_machine.with_ui(proxy_ui) do
+            action_env = {
+              synced_folders_cached: true,
+              synced_folders_disable: to_disable,
+            }
+
+            begin
+              host_machine.action(:sync_folders, action_env)
+            rescue Vagrant::Errors::MachineActionLockedError
+              sleep 1
+              retry
+            rescue Vagrant::Errors::UnimplementedProviderAction
+              callable = Vagrant::Action::Builder.new
+              callable.use Vagrant::Action::Builtin::SyncedFolders
+              host_machine.action_raw(:sync_folders, callable, action_env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/init_state.rb

@@ -0,0 +1,23 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class InitState
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          # We set the ID of the machine to "preparing" so that we can use
+          # the data dir without it being deleted with the not_created state.
+          env[:machine].id = nil
+          env[:machine].id = "preparing"
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/is_build.rb

@@ -0,0 +1,19 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class IsBuild
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          env[:result] = (!!env[:machine].provider_config.build_dir || !!env[:machine].provider_config.git_repo)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/is_host_machine_created.rb

@@ -0,0 +1,32 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class IsHostMachineCreated
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if !env[:machine].provider.host_vm?
+            env[:result] = true
+            return @app.call(env)
+          end
+
+          host_machine = env[:machine].provider.host_vm
+          env[:result] =
+            host_machine.state.id != Vagrant::MachineState::NOT_CREATED_ID
+
+          # If the host machine isn't created, neither are we. It is
+          # important we set this to nil here so that global-status
+          # sees the right thing.
+          env[:machine].id = nil if !env[:result]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/login.rb

@@ -0,0 +1,51 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class Login
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::podman::login")
+        end
+
+        def login(env, config, driver)
+          # Login!
+          env[:ui].output(I18n.t("podman_provider.logging_in"))
+          driver.login(
+            config.email, config.username,
+            config.password, config.auth_server)
+
+          # Continue, so that the auth is protected
+          # from meddling.
+          @app.call(env)
+
+          # Log out
+          driver.logout(config.auth_server)
+        end
+
+        def call(env)
+          config = env[:machine].provider_config
+          driver = env[:machine].provider.driver
+
+          # If we don't have a password set, don't auth
+          return @app.call(env) if config.password == ""
+
+          if !env[:machine].provider.host_vm?
+            # no host vm in use, using podman directly
+            login(env, config, driver)
+          else
+            # Grab a host VM lock to do the login so that we only login
+            # once per container for the rest of this process.
+            env[:machine].provider.host_vm_lock do
+              login(env, config, driver)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/podman/action/prepare_forwarded_port_collision_params.rb

@@ -0,0 +1,64 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class PrepareForwardedPortCollisionParams
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          # Get the forwarded ports used by other containers and
+          # consider those in use as well.
+          other_used_ports = machine.provider.driver.read_used_ports
+          env[:port_collision_extra_in_use] = other_used_ports
+
+          # Build the remap for any existing collision detections
+          #
+          # Note: This remap might not be required yet (as it is with the virtualbox provider)
+          # so for now we leave the remap hash empty.
+          remap = {}
+          env[:port_collision_remap] = remap
+
+          # This port checker method calls the custom port_check method
+          # defined below. If its false, it will go ahead and use the built-in
+          # port_check method to see if there are any live containers with bound
+          # ports
+          podman_port_check = proc { |host_ip, host_port|
+                                      result = port_check(env, host_port)
+                                      if !result
+                                        result = Vagrant::Action::Builtin::HandleForwardedPortCollisions.port_check(machine, host_ip, host_port)
+                                      end
+                                      result}
+          env[:port_collision_port_check] = podman_port_check
+
+          @app.call(env)
+        end
+
+        protected
+
+        # This check is required the podman provider. Containers
+        # can bind ports but be halted. We don't want new containers to
+        # grab these bound ports, so this check is here for that since
+        # the checks above won't detect it
+        #
+        # @param [Vagrant::Environment] env
+        # @param [String] host_port
+        # @returns [Bool]
+        def port_check(env, host_port)
+          extra_in_use = env[:port_collision_extra_in_use]
+
+          if extra_in_use
+            return extra_in_use.include?(host_port.to_s)
+          else
+            return false
+          end
+        end
+      end
+    end
+  end
+end