podman 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '082faff2e76df636e5a1a4ca4c00b274b9d4df36bff0561cffe1a1616c5e36df'
+  data.tar.gz: e47d60be09054bd2baee911fd6de2613f20533dadebc34dc49d2a68293254879
+SHA512:
+  metadata.gz: 893940e9818bb79dfe6c3ca870d4ff63b18ef9b4b43d7fb45d55cb171316f84378992ba513dc5bdd259d1eea24dcd1ed6495b15339008f66602117c1788bc07f
+  data.tar.gz: 68da4fd089db40130897028e96b003e0347ab61dffa9ce7ae3b6bc0bf92de98da5c2d9573b7c74d9c931cf2220eddb03789a03d983d96077becb8c80bf8bfff0

data/lib/podman.rb

@@ -0,0 +1 @@
+require "podman/plugin"

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

@@ -0,0 +1,99 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+require "vagrant/util/ansi_escape_code_remover"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class Build
+        include Vagrant::Util::ANSIEscapeCodeRemover
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::podman::build")
+        end
+
+        def call(env)
+          machine   = env[:machine]
+          build_dir = env[:build_dir]
+          build_dir ||= machine.provider_config.build_dir
+          git_repo  = env[:git_repo]
+          git_repo  ||= machine.provider_config.git_repo
+
+          # If we're not building a container, then just skip this step
+          return @app.call(env) if (!build_dir && !git_repo)
+
+          # Try to read the image ID from the cache file if we've
+          # already built it.
+          image_file = machine.data_dir.join("podman_build_image")
+          image      = nil
+          if image_file.file?
+            image = image_file.read.chomp
+          end
+
+          # Verify the image exists if we have one
+          if image && !machine.provider.driver.image?(image)
+            machine.ui.output(I18n.t("podman_provider.build_image_invalid"))
+            image = nil
+          end
+
+          # If we have no image or we're rebuilding, we rebuild
+          if !image || env[:build_rebuild]
+            # Build it
+            args = machine.provider_config.build_args.clone
+            if machine.provider_config.podmanfile
+              podmanfile      = machine.provider_config.podmanfile
+              podmanfile_path = build_dir ? File.join(build_dir, podmanfile) : podmanfile
+
+              args.push("--file").push(podmanfile_path)
+              if build_dir
+                machine.ui.output(
+                  I18n.t("podman_provider.building_named_podmanfile",
+                  file: machine.provider_config.podmanfile))
+              else
+                machine.ui.output(
+                  I18n.t("podman_provider.building_git_repo_named_podmanfile",
+                  file: machine.provider_config.podmanfile,
+                  repo: git_repo))
+              end
+            else
+              if build_dir
+                machine.ui.output(I18n.t("podman_provider.building"))
+              else
+                machine.ui.output(
+                  I18n.t("podman_provider.building_git_repo",
+                  repo: git_repo))
+              end
+            end
+
+            image = machine.provider.driver.build(
+              build_dir || git_repo,
+              extra_args: args) do |type, data|
+              data = remove_ansi_escape_codes(data.chomp).chomp
+              env[:ui].detail(data) if data != ""
+            end
+
+            # Output the final image
+            machine.ui.detail("\nImage: #{image}")
+
+            # Store the image ID
+            image_file.open("w") do |f|
+              f.binmode
+              f.write("#{image}\n")
+            end
+          else
+            machine.ui.output(I18n.t("podman_provider.already_built"))
+          end
+
+          # Set the image for creation
+          env[:create_image] = image
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant/action/builtin/mixin_synced_folders"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class CompareSyncedFolders
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          machine = env[:machine]
+
+          # Get the synced folders that are cached, and those that aren't
+          cached = synced_folders(machine, cached: true)
+          fresh  = synced_folders(machine)
+
+          # Build up a mapping of existing setup synced folders
+          existing = {}
+          cached.each do |_, fs|
+            fs.each do |_, data|
+              existing[data[:guestpath]] = data[:hostpath]
+            end
+          end
+
+          # Remove the matching folders, and build up non-matching or
+          # new synced folders.
+          invalids = {}
+          fresh.each do |_, fs|
+            fs.each do |_, data|
+              invalid = false
+              old     = existing.delete(data[:guestpath])
+              if !old
+                invalid = true
+              else
+                old = File.expand_path(old)
+              end
+
+              if !invalid && old
+                invalid = true if old != File.expand_path(data[:hostpath])
+              end
+
+              if invalid
+                invalids[File.expand_path(data[:guestpath])] = File.expand_path(data[:hostpath])
+              end
+            end
+          end
+
+          # If we have invalid entries, these are changed or new entries.
+          # If we have existing entries, then we removed some entries.
+          if !invalids.empty? || !existing.empty?
+            machine.ui.warn(I18n.t("podman_provider.synced_folders_changed"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'ipaddr'
+require 'log4r'
+
+require 'vagrant/util/scoped_hash_override'
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class ConnectNetworks
+
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant::plugins::podman::connectnetworks')
+        end
+
+        # Generate CLI arguments for creating the podman network.
+        #
+        # @param [Hash] options Options from the network config
+        # @returns[Array<String> Network create arguments
+        def generate_connect_cli_arguments(options)
+          options.map do |key, value|
+            # If value is false, option is not set
+            next if value.to_s == "false"
+            # If value is true, consider feature flag with no value
+            opt = value.to_s == "true" ? [] : [value]
+            opt.unshift("--#{key.to_s.tr("_", "-")}")
+          end.flatten.compact
+        end
+
+        # Execute the action
+        def call(env)
+          # If we are using a host VM, then don't worry about it
+          machine = env[:machine]
+          if machine.provider.host_vm?
+            @logger.debug("Not setting up networks because podman host_vm is in use")
+            return @app.call(env)
+          end
+
+          env[:ui].info(I18n.t("podman_provider.network_connect"))
+
+          connections = env[:podman_connects] || {}
+
+          machine.config.vm.networks.each_with_index do |args, idx|
+            type, options = args
+            next if type != :private_network && type != :public_network
+
+            network_options = scoped_hash_override(options, :podman_connect)
+            network_options.delete_if{|k,_| options.key?(k)}
+            network_name = connections[idx]
+
+            if !network_name
+              raise Errors::NetworkNameMissing,
+                index: idx,
+                container: machine.name
+            end
+
+            @logger.debug("Connecting network #{network_name} to container guest #{machine.name}")
+            if options[:ip] && options[:type] != "dhcp"
+              if IPAddr.new(options[:ip]).ipv4?
+                network_options[:ip] = options[:ip]
+              else
+                network_options[:ip6] = options[:ip]
+              end
+            end
+            network_options[:alias] = options[:alias] if options[:alias]
+            connect_opts = generate_connect_cli_arguments(network_options)
+            machine.provider.driver.connect_network(network_name, machine.id, connect_opts)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class Create
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          @env             = env
+          @machine         = env[:machine]
+          @provider_config = @machine.provider_config
+          @machine_config  = @machine.config
+          @driver          = @machine.provider.driver
+
+          params = create_params
+
+          # If we're running a single command, we modify the params a bit
+          if env[:machine_action] == :run_command
+            # Use the command that is given to us
+            params[:cmd] = env[:run_command]
+
+            # Don't detach, we want to watch the command run
+            params[:detach] = false
+
+            # No ports should be shared to the host
+            params[:ports] = []
+
+            # Allocate a pty if it was requested
+            params[:pty] = true if env[:run_pty]
+
+            # Remove container after execution
+            params[:rm] = true if env[:run_rm]
+
+            # Name should be unique
+            params[:name] = "#{params[:name]}_#{Time.now.to_i}"
+
+            # We link to our original container
+            # TODO
+          end
+
+          env[:ui].output(I18n.t("podman_provider.creating"))
+          env[:ui].detail("  Name: #{params[:name]}")
+
+          env[:ui].detail(" Image: #{params[:image]}")
+          if params[:cmd] && !params[:cmd].empty?
+            env[:ui].detail("   Cmd: #{params[:cmd].join(" ")}")
+          end
+          params[:volumes].each do |volume|
+            env[:ui].detail("Volume: #{volume}")
+          end
+          params[:ports].each do |pair|
+            env[:ui].detail("  Port: #{pair}")
+          end
+          params[:links].each do |name, other|
+            env[:ui].detail("  Link: #{name}:#{other}")
+          end
+
+          if env[:machine_action] != :run_command
+            # For regular "ups" create it and get the CID
+            cid = @driver.create(params)
+            env[:ui].detail(" \n"+I18n.t(
+              "podman_provider.created", id: cid[0...16]))
+            @machine.id = cid
+          elsif params[:detach]
+            env[:ui].detail(" \n"+I18n.t("podman_provider.running_detached"))
+          else
+            ui_opts = {}
+
+            # If we're running with a pty, we want the output to look as
+            # authentic as possible. We don't prefix things and we don't
+            # output a newline.
+            if env[:run_pty]
+              ui_opts[:prefix] = false
+              ui_opts[:new_line] = false
+            end
+
+            # For run commands, we run it and stream back the output
+            env[:ui].detail(" \n"+I18n.t("podman_provider.running")+"\n ")
+            @driver.create(params, stdin: env[:run_pty]) do |type, data|
+              env[:ui].detail(data.chomp, **ui_opts)
+            end
+          end
+
+          @app.call(env)
+        end
+
+        def create_params
+          container_name = @provider_config.name
+          if !container_name
+            container_name = "#{@env[:root_path].basename.to_s}_#{@machine.name}"
+            container_name.gsub!(/[^-a-z0-9_]/i, "")
+            container_name << "_#{Time.now.to_i}"
+          end
+
+          image = @env[:create_image]
+          image ||= @provider_config.image
+
+          links = []
+          @provider_config._links.each do |link|
+            parts = link.split(":", 2)
+            links << parts
+          end
+
+          {
+            cmd:        @provider_config.cmd,
+            detach:     true,
+            env:        @provider_config.env,
+            expose:     @provider_config.expose,
+            extra_args: @provider_config.create_args,
+            hostname:   @machine_config.vm.hostname,
+            image:      image,
+            links:      links,
+            name:       container_name,
+            ports:      forwarded_ports(@provider_config.has_ssh),
+            privileged: @provider_config.privileged,
+            network: @provider_config.network,
+            user:  @provider_config.user,
+            userns:  @provider_config.userns,
+            pty:        false,
+            volumes:    @provider_config.volumes,
+          }
+        end
+
+        def forwarded_ports(include_ssh=false)
+          mappings = {}
+          random = []
+
+          @machine.config.vm.networks.each do |type, options|
+            next if type != :forwarded_port
+
+            # Don't include SSH if we've explicitly asked not to
+            next if options[:id] == "ssh" && !include_ssh
+
+            # Skip port if it is disabled
+            next if options[:disabled]
+
+            # If the guest port is 0, put it in the random group
+            if options[:guest] == 0
+              random << options[:host]
+              next
+            end
+
+            mappings["#{options[:host]}/#{options[:protocol]}"] = options
+          end
+
+          # Build the results
+          result = random.map(&:to_s)
+          result += mappings.values.map do |fp|
+            protocol = ""
+            protocol = "/udp" if fp[:protocol].to_s == "udp"
+            host_ip = ""
+            host_ip = "#{fp[:host_ip]}:" if fp[:host_ip]
+            "#{host_ip}#{fp[:host]}:#{fp[:guest]}#{protocol}"
+          end.compact
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class Destroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info I18n.t("podman_provider.messages.destroying")
+
+          machine = env[:machine]
+          driver  = machine.provider.driver
+
+          # If we have a build image, store that
+          image_file = machine.data_dir.join("podman_build_image")
+          image      = nil
+          if image_file.file?
+            image = image_file.read.chomp
+          end
+          env[:build_image] = image
+
+          driver.rm(machine.id)
+          machine.id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class DestroyBuildImage
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::podman::destroybuildimage")
+        end
+
+        def call(env)
+          machine = env[:machine]
+          image   = env[:build_image]
+          image_file = nil
+
+          if !image
+            # Try to read the image ID from the cache file if we've
+            # already built it.
+            image_file = machine.data_dir.join("podman_build_image")
+            image      = nil
+            if image_file.file?
+              image = image_file.read.chomp
+            end
+          end
+
+          if image
+            machine.ui.output(I18n.t("podman_provider.build_image_destroy"))
+            if !machine.provider.driver.rmi(image)
+              machine.ui.detail(I18n.t(
+                "podman_provider.build_image_destroy_in_use"))
+            end
+          end
+
+          if image_file && image_file.file?
+            begin
+              image_file.delete
+            rescue Errno::ENOENT
+              # Its okay
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'log4r'
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class DestroyNetwork
+
+        @@lock = Mutex.new
+
+        def initialize(app, env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant::plugins::podman::network')
+        end
+
+        def call(env)
+          # If we are using a host VM, then don't worry about it
+          machine = env[:machine]
+          if machine.provider.host_vm?
+            @logger.debug("Not setting up networks because podman host_vm is in use")
+            return @app.call(env)
+          end
+
+          @@lock.synchronize do
+            machine.env.lock("podman-network-destroy", retry: true) do
+              machine.config.vm.networks.each do |type, options|
+                next if type != :private_network && type != :public_network
+
+                vagrant_networks = machine.provider.driver.list_network_names.find_all do |n|
+                  n.start_with?("vagrant_network")
+                end
+
+                vagrant_networks.each do |network_name|
+                  if machine.provider.driver.existing_named_network?(network_name) &&
+                      !machine.provider.driver.network_used?(network_name)
+                    env[:ui].info(I18n.t("podman_provider.network_destroy", network_name: network_name))
+                    machine.provider.driver.rm_network(network_name)
+                  else
+                    @logger.debug("Network #{network_name} not found or in use")
+                  end
+                end
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    module Action
+      class ForwardedPorts
+        def initialize(app, env)
+          @app = app
+        end
+
+        # Converts the `ports` podman provider param into proper network configs
+        # of type :forwarded_port
+        def call(env)
+          env[:machine].provider_config.ports.each do |p|
+            host_ip = nil
+            protocol = "tcp"
+            host, guest = p.split(":", 2)
+            if guest.include?(":")
+              host_ip = host
+              host, guest = guest.split(":", 2)
+            end
+
+            guest, protocol = guest.split("/", 2) if guest.include?("/")
+            env[:machine].config.vm.network "forwarded_port",
+              host: host.to_i, guest: guest.to_i,
+              host_ip: host_ip,
+              protocol: protocol
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# 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 this machine supports
+      # SSH.
+      class HasSSH
+        def initialize(app, env)
+          @app    = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].provider_config.has_ssh
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "log4r"
+
+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 HostMachine
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant::podman::hostmachine")
+        end
+
+        def call(env)
+          if !env[:machine].provider.host_vm?
+            @logger.info("No host machine needed.")
+            return @app.call(env)
+          end
+
+          env[:machine].ui.output(I18n.t(
+            "podman_provider.host_machine_needed"))
+
+          host_machine = env[:machine].provider.host_vm
+
+          begin
+            env[:machine].provider.host_vm_lock do
+              setup_host_machine(host_machine, env)
+            end
+          rescue Vagrant::Errors::EnvironmentLockedError
+            sleep 1
+            retry
+          end
+
+          @app.call(env)
+        end
+
+        protected
+
+        def setup_host_machine(host_machine, env)
+          # 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
+
+          # Reload the machine so that if it was created while we didn't
+          # hold the lock, we'll see the updated state.
+          host_machine.reload
+
+          # See if the machine is ready already. If not, start it.
+          if host_machine.communicate.ready?
+            env[:machine].ui.detail(I18n.t("podman_provider.host_machine_ready"))
+          else
+            env[:machine].ui.detail(
+              I18n.t("podman_provider.host_machine_starting"))
+            env[:machine].ui.detail(" ")
+            host_machine.with_ui(proxy_ui) do
+              host_machine.action(:up)
+            end
+
+            # Verify communication is ready. If not, we have a problem.
+            if !host_machine.communicate.ready?
+              raise Errors::HostVMCommunicatorNotReady,
+                id: host_machine.id
+            end
+          end
+        end
+      end
+    end
+  end
+end