Refactor volume import to support the remote client

As with `volume export`, this was coded up exclusively in cmd/
instead of in libpod. Move it into Libpod, add a REST endpoint,
add bindings, and now everything talks using the ContainerEngine
wiring.

Also similar to `volume export` this also makes things work much
better with volumes that require mounting - we can now guarantee
they're actually mounted, instead of just hoping.

Includes some refactoring of `volume export` as well, to simplify
its implementation and ensure both Import and Export work with
readers/writers, as opposed to just files.

Fixes #26409

Signed-off-by: Matt Heon <[email protected]>

Author: mheon

cmd/podman/volumes/export.go

@@ -3,6 +3,8 @@ package volumes
 import (
 	"context"
 	"errors"
+	"fmt"
+	"os"
 
 	"github.com/containers/common/pkg/completion"
 	"github.com/containers/podman/v5/cmd/podman/common"
@@ -27,7 +29,7 @@ Allow content of volume to be exported into external tar.`
 )
 
 var (
-	cliExportOpts entities.VolumeExportOptions
+	targetPath string
 )
 
 func init() {
@@ -38,20 +40,30 @@ func init() {
 	flags := exportCommand.Flags()
 
 	outputFlagName := "output"
-	flags.StringVarP(&cliExportOpts.OutputPath, outputFlagName, "o", "/dev/stdout", "Write to a specified file (default: stdout, which must be redirected)")
+	flags.StringVarP(&targetPath, outputFlagName, "o", "", "Write to a specified file (default: stdout, which must be redirected)")
 	_ = exportCommand.RegisterFlagCompletionFunc(outputFlagName, completion.AutocompleteDefault)
 }
 
 func export(cmd *cobra.Command, args []string) error {
 	containerEngine := registry.ContainerEngine()
 	ctx := context.Background()
 
-	if cliExportOpts.OutputPath == "" {
-		return errors.New("expects output path, use --output=[path]")
+	if targetPath == "" && cmd.Flag("output").Changed {
+		return errors.New("must provide valid path for file to write to")
 	}
 
-	if err := containerEngine.VolumeExport(ctx, args[0], cliExportOpts); err != nil {
-		return err
+	exportOpts := entities.VolumeExportOptions{}
+
+	if targetPath != "" {
+		targetFile, err := os.Create(targetPath)
+		if err != nil {
+			return fmt.Errorf("unable to create target file path %q: %w", targetPath, err)
+		}
+		defer targetFile.Close()
+		exportOpts.Output = targetFile
+	} else {
+		exportOpts.Output = os.Stdout
 	}
-	return nil
+
+	return containerEngine.VolumeExport(ctx, args[0], exportOpts)
 }

cmd/podman/volumes/import.go

@@ -1,23 +1,20 @@
 package volumes
 
 import (
-	"errors"
+	"context"
 	"fmt"
 	"os"
 
 	"github.com/containers/podman/v5/cmd/podman/common"
 	"github.com/containers/podman/v5/cmd/podman/parse"
 	"github.com/containers/podman/v5/cmd/podman/registry"
 	"github.com/containers/podman/v5/pkg/domain/entities"
-	"github.com/containers/podman/v5/pkg/errorhandling"
-	"github.com/containers/podman/v5/utils"
 	"github.com/spf13/cobra"
 )
 
 var (
 	importDescription = `Imports contents into a podman volume from specified tarball (.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz).`
 	importCommand     = &cobra.Command{
-		Annotations:       map[string]string{registry.EngineMode: registry.ABIMode},
 		Use:               "import VOLUME [SOURCE]",
 		Short:             "Import a tarball contents into a podman volume",
 		Long:              importDescription,
@@ -37,65 +34,26 @@ func init() {
 }
 
 func importVol(cmd *cobra.Command, args []string) error {
-	var inspectOpts entities.InspectOptions
-	var tarFile *os.File
-	containerEngine := registry.ContainerEngine()
-	ctx := registry.Context()
-	// create a slice of volumes since inspect expects slice as arg
-	volumes := []string{args[0]}
-	tarPath := args[1]
+	opts := entities.VolumeImportOptions{}
 
-	if tarPath != "-" {
-		err := parse.ValidateFileName(tarPath)
-		if err != nil {
+	filepath := args[1]
+	if filepath == "-" {
+		opts.Input = os.Stdin
+	} else {
+		if err := parse.ValidateFileName(filepath); err != nil {
 			return err
 		}
 
-		// open tar file
-		tarFile, err = os.Open(tarPath)
+		targetFile, err := os.Open(filepath)
 		if err != nil {
-			return err
+			return fmt.Errorf("unable open input file: %w", err)
 		}
-	} else {
-		tarFile = os.Stdin
+		defer targetFile.Close()
+		opts.Input = targetFile
 	}
 
-	inspectOpts.Type = common.VolumeType
-	inspectOpts.Type = common.VolumeType
-	volumeData, errs, err := containerEngine.VolumeInspect(ctx, volumes, inspectOpts)
-	if err != nil {
-		return err
-	}
-	if len(errs) > 0 {
-		return errorhandling.JoinErrors(errs)
-	}
-	if len(volumeData) < 1 {
-		return errors.New("no volume data found")
-	}
-	mountPoint := volumeData[0].VolumeConfigResponse.Mountpoint
-	driver := volumeData[0].VolumeConfigResponse.Driver
-	volumeOptions := volumeData[0].VolumeConfigResponse.Options
-	volumeMountStatus, err := containerEngine.VolumeMounted(ctx, args[0])
-	if err != nil {
-		return err
-	}
-	if mountPoint == "" {
-		return errors.New("volume is not mounted anywhere on host")
-	}
-	// Check if volume is using external plugin and export only if volume is mounted
-	if driver != "" && driver != "local" {
-		if !volumeMountStatus.Value {
-			return fmt.Errorf("volume is using a driver %s and volume is not mounted on %s", driver, mountPoint)
-		}
-	}
-	// Check if volume is using `local` driver and has mount options type other than tmpfs
-	if driver == "local" {
-		if mountOptionType, ok := volumeOptions["type"]; ok {
-			if mountOptionType != "tmpfs" && !volumeMountStatus.Value {
-				return fmt.Errorf("volume is using a driver %s and volume is not mounted on %s", driver, mountPoint)
-			}
-		}
-	}
-	// dont care if volume is mounted or not we are gonna import everything to mountPoint
-	return utils.UntarToFileSystem(mountPoint, tarFile, nil)
+	containerEngine := registry.ContainerEngine()
+	ctx := context.Background()
+
+	return containerEngine.VolumeImport(ctx, args[0], opts)
 }

docs/source/markdown/podman-volume-export.1.md

@@ -12,8 +12,6 @@ podman\-volume\-export - Export volume to external tar
 on the local machine. **podman volume export** writes to STDOUT by default and can be
 redirected to a file using the `--output` flag.
 
-Note: Following command is not supported by podman-remote.
-
 **podman volume export [OPTIONS] VOLUME**
 
 ## OPTIONS

docs/source/markdown/podman-volume-import.1.md

@@ -14,8 +14,6 @@ The contents of the volume is merged with the content of the tarball with the la
 
 The given volume must already exist and is not created by podman volume import.
 
-Note: Following command is not supported by podman-remote.
-
 #### **--help**
 
 Print usage statement

libpod/volume.go

@@ -11,6 +11,7 @@ import (
 	"github.com/containers/podman/v5/libpod/lock"
 	"github.com/containers/podman/v5/libpod/plugin"
 	"github.com/containers/podman/v5/utils"
+	"github.com/containers/storage/pkg/archive"
 	"github.com/containers/storage/pkg/directory"
 	"github.com/sirupsen/logrus"
 )
@@ -299,10 +300,12 @@ func (v *Volume) NeedsMount() bool {
 	return v.needsMount()
 }
 
+// Export volume to tar.
 // Returns a ReadCloser which points to a tar of all the volume's contents.
-func (v *Volume) ExportVolume() (io.ReadCloser, error) {
+func (v *Volume) Export() (io.ReadCloser, error) {
 	v.lock.Lock()
 	err := v.mount()
+	mountPoint := v.mountPoint()
 	v.lock.Unlock()
 	if err != nil {
 		return nil, err
@@ -316,10 +319,35 @@ func (v *Volume) ExportVolume() (io.ReadCloser, error) {
 		}
 	}()
 
-	volContents, err := utils.TarWithChroot(v.mountPoint())
+	volContents, err := utils.TarWithChroot(mountPoint)
 	if err != nil {
 		return nil, fmt.Errorf("creating tar of volume %s contents: %w", v.Name(), err)
 	}
 
 	return volContents, nil
 }
+
+// Import a volume from a tar file, provided as an io.Reader.
+func (v *Volume) Import(r io.Reader) error {
+	v.lock.Lock()
+	err := v.mount()
+	mountPoint := v.mountPoint()
+	v.lock.Unlock()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		v.lock.Lock()
+		defer v.lock.Unlock()
+
+		if err := v.unmount(false); err != nil {
+			logrus.Errorf("Error unmounting volume %s: %v", v.Name(), err)
+		}
+	}()
+
+	if err := archive.Untar(r, mountPoint, nil); err != nil {
+		return fmt.Errorf("extracting into volume %s: %w", v.Name(), err)
+	}
+
+	return nil
+}

pkg/api/handlers/libpod/volumes.go

@@ -4,12 +4,11 @@ package libpod
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
 
-	"errors"
-
 	"github.com/containers/podman/v5/libpod"
 	"github.com/containers/podman/v5/libpod/define"
 	"github.com/containers/podman/v5/pkg/api/handlers/utils"
@@ -223,14 +222,39 @@ func ExportVolume(w http.ResponseWriter, r *http.Request) {
 
 	vol, err := runtime.GetVolume(name)
 	if err != nil {
-		utils.Error(w, http.StatusNotFound, err)
+		utils.VolumeNotFound(w, name, err)
 		return
 	}
 
-	contents, err := vol.ExportVolume()
+	contents, err := vol.Export()
 	if err != nil {
 		utils.Error(w, http.StatusInternalServerError, err)
 		return
 	}
 	utils.WriteResponse(w, http.StatusOK, contents)
 }
+
+// ImportVolume imports a volume
+func ImportVolume(w http.ResponseWriter, r *http.Request) {
+	runtime := r.Context().Value(api.RuntimeKey).(*libpod.Runtime)
+	name := utils.GetName(r)
+
+	vol, err := runtime.GetVolume(name)
+	if err != nil {
+		utils.VolumeNotFound(w, name, err)
+		return
+	}
+
+	if r.Body == nil {
+		utils.Error(w, http.StatusInternalServerError, errors.New("must provide tar file to import in request body"))
+		return
+	}
+	defer r.Body.Close()
+
+	if err := vol.Import(r.Body); err != nil {
+		utils.Error(w, http.StatusInternalServerError, err)
+		return
+	}
+
+	utils.WriteResponse(w, http.StatusNoContent, "")
+}

pkg/api/server/register_volumes.go

@@ -161,18 +161,47 @@ func (s *APIServer) registerVolumeHandlers(r *mux.Router) error {
 	//    description: the name or ID of the volume
 	// produces:
 	// - application/x-tar
-        // responses:
-        //   200:
+	// responses:
+	//   200:
 	//     description: no error
 	//     schema:
 	//      type: string
-        //      format: binary
+	//      format: binary
 	//   404:
 	//     $ref: "#/responses/volumeNotFound"
 	//   500:
 	//     $ref: "#/responses/internalError"
 	r.Handle(VersionedPath("/libpod/volumes/{name}/export"), s.APIHandler(libpod.ExportVolume)).Methods(http.MethodGet)
 
+	// swagger:operation POST /libpod/volumes/{name}/import libpod VolumeImportLibpod
+	// ---
+	// tags:
+	//  - volumes
+	// summary: Populate a volume by importing provided tar
+	// parameters:
+	//  - in: path
+	//    name: name
+	//    type: string
+	//    required: true
+	//    description: the name or ID of the volume
+	//  - in: body
+	//    name: inputStream
+	//    description: |
+	//      An uncompressed tar archive
+	//    schema:
+	//      type: string
+	//      format: binary
+	// produces:
+	// - application/json
+	// responses:
+	//   204:
+	//     description: Successful import
+	//   404:
+	//     $ref: "#/responses/volumeNotFound"
+	//   500:
+	//     $ref: "#/responses/internalError"
+	r.Handle(VersionedPath("/libpod/volumes/{name}/import"), s.APIHandler(libpod.ImportVolume)).Methods(http.MethodPost)
+
 	/*
 	 * Docker compatibility endpoints
 	 */