podman 1.0.3

data/lib/vagrant/podman/plugin.rb

@@ -0,0 +1,89 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    autoload :Action, File.expand_path("../action", __FILE__)
+    autoload :Driver, File.expand_path("../driver", __FILE__)
+    autoload :Errors, File.expand_path("../errors", __FILE__)
+
+    module Executor
+      autoload :Local, File.expand_path("../executor/local", __FILE__)
+      autoload :Vagrant, File.expand_path("../executor/vagrant", __FILE__)
+    end
+
+    class Plugin < Vagrant.plugin("2")
+      name "podman-provider"
+      description <<-EOF
+      The Podman provider allows Vagrant to manage and control
+      Podman containers.
+      EOF
+
+      provider(:podman, box_optional: true, parallel: true, defaultable: false) do
+        require_relative 'provider'
+        init!
+        Provider
+      end
+
+      command("podman-exec", primary: false) do
+        require_relative "command/exec"
+        init!
+        Command::Exec
+      end
+
+      command("podman-logs", primary: false) do
+        require_relative "command/logs"
+        init!
+        Command::Logs
+      end
+
+      command("podman-run", primary: false) do
+        require_relative "command/run"
+        init!
+        Command::Run
+      end
+
+      communicator(:podman_hostvm) do
+        require_relative "communicator"
+        init!
+        Communicator
+      end
+
+      config(:podman, :provider) do
+        require_relative 'config'
+        init!
+        Config
+      end
+
+      synced_folder(:podman) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
+
+      provider_capability("podman", "public_address") do
+        require_relative "cap/public_address"
+        Cap::PublicAddress
+      end
+
+      provider_capability("podman", "proxy_machine") do
+        require_relative "cap/proxy_machine"
+        Cap::ProxyMachine
+      end
+
+      provider_capability("podman", "has_communicator") do
+        require_relative "cap/has_communicator"
+        Cap::HasCommunicator
+      end
+
+      protected
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path(
+          "templates/locales/providers_podman.yml", Vagrant.source_root)
+        I18n.reload!
+        @_init = true
+      end
+    end
+  end
+end

data/lib/vagrant/podman/provider.rb

@@ -0,0 +1,216 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "digest/md5"
+require "fileutils"
+require "thread"
+
+require "log4r"
+
+require "vagrant/util/silence_warnings"
+
+module VagrantPlugins
+  module PodmanProvider
+    class Provider < Vagrant.plugin("2", :provider)
+      @@host_vm_mutex = Mutex.new
+
+      def self.usable?(raise_error=false)
+        Driver.new.execute("podman", "version")
+        true
+      rescue Vagrant::Errors::CommandUnavailable, Errors::ExecuteError
+        raise if raise_error
+        return false
+      end
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant::provider::podman")
+        @machine = machine
+
+        if host_vm?
+          # We need to use a special communicator that proxies our
+          # SSH requests over our host VM to the container itself.
+          @machine.config.vm.communicator = :podman_hostvm
+        end
+      end
+
+      # @see Vagrant::Plugin::V2::Provider#action
+      def action(name)
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      # Returns the driver instance for this provider.
+      def driver
+        if !@driver
+          if @machine.provider_config.compose
+            @driver = Driver::Compose.new(@machine)
+          else
+            @driver = Driver.new
+          end
+        end
+        if host_vm?
+          @driver.executor = Executor::Vagrant.new(host_vm)
+        end
+
+        @driver
+      end
+
+      # This returns the {Vagrant::Machine} that is our host machine.
+      # It does not perform any action on the machine or verify it is
+      # running.
+      #
+      # @return [Vagrant::Machine]
+      def host_vm
+        return @host_vm if @host_vm
+
+        vf_path           = @machine.provider_config.vagrant_vagrantfile
+        host_machine_name = @machine.provider_config.vagrant_machine || :default
+        if !vf_path
+          # We don't have a Vagrantfile path set, so we're going to use
+          # the default but we need to copy it into the data dir so that
+          # we don't write into our installation dir (we can't).
+          default_path = File.expand_path("../hostmachine/Vagrantfile", __FILE__)
+          vf_path      = @machine.env.data_dir.join("podman-host", "Vagrantfile")
+          begin
+            @machine.env.lock("podman-provider-hostvm") do
+              vf_path.dirname.mkpath
+              FileUtils.cp(default_path, vf_path)
+            end
+          rescue Vagrant::Errors::EnvironmentLockedError
+            # Lock contention, just retry
+            retry
+          end
+
+          # Set the machine name since we hardcode that for the default
+          host_machine_name = :default
+        end
+
+        # Expand it so that the home directories and so on get processed
+        # properly.
+        vf_path = File.expand_path(vf_path, @machine.env.root_path)
+
+        vf_file = File.basename(vf_path)
+        vf_path = File.dirname(vf_path)
+
+        # Create the env to manage this machine
+        @host_vm = Vagrant::Util::SilenceWarnings.silence! do
+          host_env = Vagrant::Environment.new(
+            cwd: vf_path,
+            home_path: @machine.env.home_path,
+            ui_class: @machine.env.ui_class,
+            vagrantfile_name: vf_file,
+          )
+
+          # If there is no root path, then the Vagrantfile wasn't found
+          # and it is an error...
+          raise Errors::VagrantfileNotFound if !host_env.root_path
+
+          host_env.machine(
+            host_machine_name,
+            host_env.default_provider(
+              exclude: [:podman],
+              force_default: false,
+            ))
+        end
+
+        @host_vm
+      end
+
+      # This acquires a lock on the host VM.
+      def host_vm_lock
+        hash = Digest::MD5.hexdigest(host_vm.data_dir.to_s)
+
+        # We do a process-level mutex on the outside, since we can
+        # wait for that a short amount of time. Then, we do a process lock
+        # on the inside, which will raise an exception if locked.
+        host_vm_mutex.synchronize do
+          @machine.env.lock(hash) do
+            return yield
+          end
+        end
+      end
+
+      # This is a process-local mutex that can be used by parallel
+      # providers to lock the host VM access.
+      def host_vm_mutex
+        @@host_vm_mutex
+      end
+
+      # This says whether or not Podman will be running within a VM
+      # rather than directly on our system. Podman needs to run in a VM
+      # when we're not on Linux, or not on a Linux that supports Podman.
+      def host_vm?
+        @machine.provider_config.force_host_vm
+      end
+
+      # Returns the SSH info for accessing the Container.
+      def ssh_info
+        # If the container isn't running, we can't SSH into it
+        return nil if state.id != :running
+
+        port_name = "#{@machine.config.ssh.guest_port}/tcp"
+        network   = driver.inspect_container(@machine.id)['NetworkSettings']
+
+        if network["Ports"][port_name].respond_to?(:first)
+          port_info = network["Ports"][port_name].first
+        else
+          ip = network["IPAddress"]
+          port = @machine.config.ssh.guest_port
+          if !ip.to_s.empty?
+            port_info = {
+              "HostIp" => ip,
+              "HostPort" => port
+            }
+          end
+        end
+
+        # If we were not able to identify the container's IP, we return nil
+        # here and we let Vagrant core deal with it ;)
+        return nil if port_info.nil? || port_info.empty?
+
+        {
+          host: port_info['HostIp'],
+          port: port_info['HostPort']
+        }
+      end
+
+      def state
+        state_id = nil
+        state_id = :not_created if !@machine.id
+
+        begin
+          state_id = :host_state_unknown if !state_id && \
+            host_vm? && !host_vm.communicate.ready?
+        rescue Errors::VagrantfileNotFound
+          state_id = :host_state_unknown
+        end
+
+        state_id = :not_created if !state_id && \
+          (!@machine.id || !driver.created?(@machine.id))
+        state_id = driver.state(@machine.id) if @machine.id && !state_id
+        state_id = :unknown if !state_id
+
+        # This is a special pseudo-state so that we don't set the
+        # NOT_CREATED_ID while we're setting up the machine. This avoids
+        # clearing the data dir.
+        state_id = :preparing if @machine.id == "preparing"
+
+        short = state_id.to_s.gsub("_", " ")
+        long  = I18n.t("podman_provider.status.#{state_id}")
+
+        # If we're not created, then specify the special ID flag
+        if state_id == :not_created
+          state_id = Vagrant::MachineState::NOT_CREATED_ID
+        end
+
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id ? @machine.id : "new container"
+        "Podman (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant/podman/synced_folder.rb

@@ -0,0 +1,35 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+module VagrantPlugins
+  module PodmanProvider
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine, raise_error=false)
+        # These synced folders only work if the provider is Podman
+        if machine.provider_name != :podman
+          if raise_error
+            raise Errors::SyncedFolderNonPodman,
+              provider: machine.provider_name.to_s
+          end
+
+          return false
+        end
+
+        true
+      end
+
+      def prepare(machine, folders, _opts)
+        folders.each do |id, data|
+          next if data[:ignore]
+
+          host_path  = data[:hostpath]
+          guest_path = data[:guestpath]
+          # Append consistency option if it exists, otherwise let it nil out
+          consistency = data[:podman_consistency]
+          consistency &&= ":" + consistency
+          machine.provider_config.volumes << "#{host_path}:#{guest_path}#{consistency}"
+        end
+      end
+    end
+  end
+end

data/templates/locales/providers_podman.yml

@@ -0,0 +1,321 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+en:
+  podman_provider:
+    already_built: |-
+      Image is already built from the Podmanfile. `vagrant reload` to rebuild.
+    build_image_destroy: |-
+      Removing built image...
+    build_image_destroy_in_use: |-
+      Build image couldn't be destroyed because the image is in use. The
+      image must be destroyed manually in the future if you want to remove
+      it.
+    build_image_invalid: |-
+      Build image no longer exists. Rebuilding...
+    building: |-
+      Building the container from a Podmanfile...
+    building_git_repo: |-
+      Building the container from the git repository: %{repo}...
+    building_named_podmanfile: |-
+      Building the container from the named Podmanfile: %{file}...
+    building_git_repo_named_podmanfile: |-
+      Building the container from the named Podmanfile: %{file} in the git repository: %{repo}...
+    creating: |-
+      Creating the container...
+    created: |-
+      Container created: %{id}
+    host_machine_disabling_folders: |-
+      Removing synced folders...
+    host_machine_forwarded_ports: |-
+      Warning: When using a remote Podman host, forwarded ports will NOT be
+      immediately available on your machine. They will still be forwarded on
+      the remote machine, however, so if you have a way to access the remote
+      machine, then you should be able to access those ports there. This is
+      not an error, it is only an informational message.
+    host_machine_needed: |-
+      Podman host is required. One will be created if necessary...
+    host_machine_ready: |-
+      Podman host VM is already ready.
+    host_machine_starting: |-
+      Vagrant will now create or start a local VM to act as the Podman
+      host. You'll see the output of the `vagrant up` for this VM below.
+    host_machine_syncing_folders: |-
+      Syncing folders to the host VM...
+    logging_in: |-
+      Logging in to Podman server...
+    logs_host_state_unknown: |-
+      This container requires a host VM, and the state of that VM
+      is unknown. Run `vagrant up` to verify that the container and
+      its host VM is running, then try again.
+    network_bridge_gateway_invalid: |-
+      The provided gateway IP address is invalid (%{gateway}). Please
+      provide a valid IP address.
+    network_bridge_gateway_outofbounds: |-
+      The provided gateway IP (%{gateway}) is not within the defined
+      subnet (%{subnet}). Please provide an IP address within the
+      defined subnet.
+    network_bridge_gateway_request: |-
+      Gateway IP address for %{interface} interface [%{default_gateway}]:
+    network_bridge_iprange_info: |-
+      When an explicit address is not provided to a container attached
+      to this bridged network, podman will supply an address to the
+      container. This is independent of the local DHCP service that
+      may be available on the network.
+    network_bridge_iprange_invalid: |-
+      The provided IP address range is invalid (%{range}). Please
+      provide a valid range.
+    network_bridge_iprange_outofbounds: |-
+      The provided IP address range (%{range}) is not within the
+      defined subnet (%{subnet}). Please provide an address range
+      within the defined subnet.
+    network_bridge_iprange_request: |-
+      Available address range for assignment on %{interface} interface [%{default_range}]:
+    network_create: |-
+      Creating and configuring podman networks...
+    network_connect: |-
+      Enabling network interfaces...
+    network_destroy: |-
+      Removing network %{network_name} ...
+    not_created_skip: |-
+      Container not created. Skipping.
+    not_podman_provider: |-
+      Not backed by Podman provider. Skipping.
+    pull: |-
+      Pulling image '%{image}'...
+    run_command_required: |-
+      `vagrant podman-run` requires a command to execute. This command
+      must be specified after a `--` in the command line. This is used
+      to separate possible machine names and options from the actual
+      command to execute. An example is shown below:
+
+        vagrant podman-run web -- rails new .
+
+    running: |-
+      Container is starting. Output will stream in below...
+    running_detached: |-
+      Container is started detached.
+    ssh_through_host_vm: |-
+      SSH will be proxied through the Podman virtual machine since we're
+      not running Podman natively. This is just a notice, and not an error.
+    subnet_exists: |-
+      A network called '%{network_name}' using subnet '%{subnet}' is already in use.
+      Using '%{network_name}' instead of creating a new network...
+    synced_folders_changed: |-
+      Vagrant has noticed that the synced folder definitions have changed.
+      With Podman, these synced folder changes won't take effect until you
+      destroy the container and recreate it.
+    waiting_for_running: |-
+      Waiting for container to enter "running" state...
+    volume_path_not_expanded: |-
+      Host path `%{host}` exists as a `volumes` key and is a folder on disk. Vagrant
+      will not expand this key like it used to and instead leave it as is defined.
+      If this folder is intended to be used, make sure its full path is defined
+      in your `volumes` config. More information can be found on volumes in the
+      podman compose documentation.
+
+    messages:
+      destroying: |-
+        Deleting the container...
+      not_created: |-
+        The container hasn't been created yet.
+      not_created_original: |-
+        The original container hasn't been created yet. Run `vagrant up`
+        for this machine first.
+      not_running: |-
+        The container is not currently running.
+      preparing: |-
+        Preparing to start the container...
+      provision_no_ssh: |-
+        Provisioners will not be run since container doesn't support SSH.
+      will_not_destroy: |-
+        The container will not be destroyed, since the confirmation was declined.
+      starting: |-
+        Starting container...
+      stopping: |-
+        Stopping container...
+      container_ready: |-
+        Container started and ready for use!
+      not_provisioning: |-
+        The following provisioners require a communicator, though none is available (this container does not support SSH).
+        Not running the following provisioners:
+        - %{provisioners}
+
+    status:
+      host_state_unknown: |-
+        The host VM for the Podman containers appears to not be running
+        or is currently inaccessible. Because of this, we can't determine
+        the state of the containers on that host. Run `vagrant up` to
+        bring up the host VM again.
+      not_created: |-
+        The environment has not yet been created. Run `vagrant up` to
+        create the environment. If a machine is not created, only the
+        default provider will be shown. So if a provider is not listed,
+        then the machine is not created for that environment.
+      preparing: |-
+        Vagrant is preparing to start this Podman container. Run `vagrant up`
+        to continue.
+      running: |-
+        The container is created and running. You can stop it using
+        `vagrant halt`, see logs with `vagrant podman-logs`, and
+        kill/destroy it with `vagrant destroy`.
+      stopped: |-
+        The container is created but not running. You can run it again
+        with `vagrant up`. If the container always goes to "stopped"
+        right away after being started, it is because the command being
+        run exits and doesn't keep running.
+
+    errors:
+      build_error: |-
+        Vagrant received unknown output from `podman build` while building a container: %{result}
+      compose_lock_timeout: |-
+        Vagrant encountered a timeout waiting for the podman compose driver
+        to become available. Please try to run your command again. If you
+        continue to experience this error it may be resolved by disabling
+        parallel execution.
+      podman_compose_not_installed: |-
+        Vagrant has been instructed to use to use the Compose driver for the
+        Podman plugin but was unable to locate the `podman-compose` executable.
+        Ensure that `podman-compose` is installed and available on the PATH.
+      not_created: |-
+        The container hasn't been created yet.
+      not_running: |-
+        The container is not currently running.
+      communicator_non_podman: |-
+        The "podman_hostvm" communicator was specified on a machine that
+        is not provided by the Podman provider. This is a bug with your
+        Vagrantfile. Please contact the creator of your Vagrant environment
+        and notify them to not use this communicator for anything except the
+        "podman" provider.
+      config:
+        both_build_and_image_and_git: |-
+          Only one of "build_dir", "git_repo" or "image" can be set
+        build_dir_invalid: |-
+          "build_dir" must exist and contain a Podmanfile
+        git_repo_invalid: |-
+          "git_repo" must be a valid repository URL
+        build_dir_or_image: |-
+          One of "build_dir", "git_repo" or "image" must be set
+        compose_configuration_hash: |-
+          "compose_configuration" must be a hash
+        compose_force_vm: |-
+          Podman compose is not currently supported from within proxy VM.
+        git_repo_invalid: |-
+          "git_repo" must be a valid git URL
+        create_args_array: |-
+          "create_args" must be an array
+        invalid_link: |-
+          Invalid link (should be 'name:alias'): "%{link}"
+        invalid_vagrantfile: |-
+          "vagrant_vagrantfile" must point to a Vagrantfile that exists.
+      podman_provider_nfs_without_privileged: |-
+        You've configured a NFS synced folder but didn't enable privileged
+        mode for the container. Please set the `privileged` option to true
+        on the provider block from your Vagrantfile, recreate the container
+        and try again.
+      podman_provider_image_not_configured: |-
+        The base Podman image has not been set for the '%{name}' VM!
+      execute_error: |-
+        A Podman command executed by Vagrant didn't complete successfully!
+        The command run along with the output from the command is shown
+        below.
+
+        Command: %{command}
+
+        Stderr: %{stderr}
+
+        Stdout: %{stdout}
+      exec_command_required: |-
+        The "podman-exec" command requires a command to execute. This command
+        must be specified after a "--" in the command line. This is used to
+        separate machine name and options from the actual command to execute.
+        An example is show below:
+
+          $ vagrant podman-exec -t nginx -- bash
+
+      host_vm_communicator_not_ready: |-
+        The Podman provider was able to bring up the host VM successfully
+        but the host VM is still reporting that SSH is unavailable. This
+        sometimes happens with certain providers due to bugs in the
+        underlying hypervisor, and can be fixed with a `vagrant reload`.
+        The ID for the host VM is shown below for convenience.
+
+        If this does not fix it, please verify that the host VM provider
+        is functional and properly configured.
+
+        Host VM ID: %{id}
+      network_address_invalid: |-
+        The configured network address is not valid within the configured
+        subnet of the defined network. Please update the network settings
+        and try again.
+
+          Configured address: %{address}
+          Network name:       %{network_name}
+      network_address_required: |-
+        An IP address is required if not using `type: "dhcp"` or not specifying a `subnet`.
+      network_invalid_option: |-
+        Invalid option given for podman network for guest "%{container}". Must specify either
+        a `subnet` or use `type: "dhcp"`.
+      network_name_missing: |-
+        The Podman provider is unable to connect the container to the
+        defined network due to a missing network name. Please validate
+        your configuration and try again.
+
+          Container: %{container}
+          Network Number: %{index}
+      network_name_undefined: |-
+        The Podman provider was unable to configure networking using the
+        provided network name `%{network_name}`. Please ensure the network
+        name is correct and exists, then try again.
+      network_no_interfaces: |-
+        The Podman provider was unable to list any available interfaces to bridge
+        the public network with.
+      network_subnet_invalid: |-
+        The configured network subnet is not valid for the defined network.
+        Please update the network settings and try again.
+
+          Configured subnet: %{subnet}
+          Network name:      %{network_name}
+      package_not_supported: |-
+        The "package" command is not supported with the Podman provider.
+        If you'd like to commit or push your Podman container, please SSH
+        into the host VM (if there is one), and run `podman commit` and
+        so on manually.
+      state_not_running: |-
+        The container never entered the "running" state, or entered it
+        briefly but reverted back to another state. Please verify that
+        the configuration of the container is correct.
+
+        If you meant for this container to not remain running, please
+        set the Podman provider configuration "remains_running" to "false":
+
+          config.vm.provider "podman" do |d|
+            d.remains_running = false
+          end
+
+      state_stopped: |-
+        The container started either never left the "stopped" state or
+        very quickly reverted to the "stopped" state. This is usually
+        because the container didn't execute a command that kept it running,
+        and usually indicates a misconfiguration.
+
+        If you meant for this container to not remain running, please
+        set the Podman provider configuration "remains_running" to "false":
+
+          config.vm.provider "podman" do |d|
+            d.remains_running = false
+          end
+
+      suspend_not_supported: |-
+        The "suspend" command is not supported with the Podman provider.
+        Podman containers don't natively support suspend. If you're using
+        a host machine, you can suspend the host machine by finding it
+        in `vagrant global-status` and using `vagrant suspend <id>`.
+      synced_folder_non_podman: |-
+        The "podman" synced folder type can't be used because the  provider
+        in use is not Podman. This synced folder type only works with the
+        Podman provider. The provider this machine is using is: %{provider}
+      vagrantfile_not_found: |-
+        The configured host VM Vagrantfile could not be found. Please fix
+        the Vagrantfile for this Podman environment to point to a valid
+        host VM.