Added --export command

cmd/nerdctl/container/container.go

@@ -55,6 +55,7 @@ func Command() *cobra.Command {
 		StatsCommand(),
 		AttachCommand(),
 		HealthCheckCommand(),
+		ExportCommand(),
 	)
 	AddCpCommand(cmd)
 	return cmd

cmd/nerdctl/container/container_export.go

@@ -0,0 +1,78 @@
+package container
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/mattn/go-isatty"
+	"github.com/spf13/cobra"
+
+	"github.com/containerd/nerdctl/v2/cmd/nerdctl/completion"
+	"github.com/containerd/nerdctl/v2/cmd/nerdctl/helpers"
+	"github.com/containerd/nerdctl/v2/pkg/api/types"
+	"github.com/containerd/nerdctl/v2/pkg/clientutil"
+	"github.com/containerd/nerdctl/v2/pkg/cmd/container"
+)
+
+func ExportCommand() *cobra.Command {
+	var exportCommand = &cobra.Command{
+		Use:               "export [OPTIONS] CONTAINER",
+		Args:              cobra.ExactArgs(1),
+		Short:             "Export a containers filesystem as a tar archive",
+		Long:              "Export a containers filesystem as a tar archive",
+		RunE:              exportAction,
+		ValidArgsFunction: exportShellComplete,
+		SilenceUsage:      true,
+		SilenceErrors:     true,
+	}
+	exportCommand.Flags().StringP("output", "o", "", "Write to a file, instead of STDOUT")
+
+	return exportCommand
+}
+
+func exportAction(cmd *cobra.Command, args []string) error {
+	globalOptions, err := helpers.ProcessRootCmdFlags(cmd)
+	if err != nil {
+		return err
+	}
+	if len(args) == 0 {
+		return fmt.Errorf("requires at least 1 argument")
+	}
+
+	output, err := cmd.Flags().GetString("output")
+	if err != nil {
+		return err
+	}
+
+	client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address)
+	if err != nil {
+		return err
+	}
+	defer cancel()
+
+	writer := cmd.OutOrStdout()
+	if output != "" {
+		f, err := os.OpenFile(output, os.O_CREATE|os.O_WRONLY, 0644)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		writer = f
+	} else {
+		if isatty.IsTerminal(os.Stdout.Fd()) {
+			return fmt.Errorf("cowardly refusing to save to a terminal. Use the -o flag or redirect")
+		}
+	}
+
+	options := types.ContainerExportOptions{
+		Stdout:   writer,
+		GOptions: globalOptions,
+	}
+
+	return container.Export(ctx, client, args[0], options)
+}
+
+func exportShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	// show container names
+	return completion.ContainerNames(cmd, nil)
+}

cmd/nerdctl/container/container_export_test.go

@@ -0,0 +1,157 @@
+/*
+   Copyright The containerd Authors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package container
+
+import (
+	"archive/tar"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"gotest.tools/v3/assert"
+
+	"github.com/containerd/nerdctl/mod/tigron/test"
+	"github.com/containerd/nerdctl/mod/tigron/tig"
+
+	"github.com/containerd/nerdctl/v2/pkg/testutil"
+	"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
+)
+
+// validateExportedTar checks that the tar file exists and contains /bin/busybox
+func validateExportedTar(outFile string) test.Comparator {
+	return func(stdout string, t tig.T) {
+		// Check if the tar file was created
+		_, err := os.Stat(outFile)
+		assert.Assert(t, !os.IsNotExist(err), "exported tar file %s was not created", outFile)
+
+		// Open and read the tar file to check for /bin/busybox
+		file, err := os.Open(outFile)
+		assert.NilError(t, err, "failed to open tar file %s", outFile)
+		defer file.Close()
+
+		tarReader := tar.NewReader(file)
+		busyboxFound := false
+
+		for {
+			header, err := tarReader.Next()
+			if err == io.EOF {
+				break
+			}
+			assert.NilError(t, err, "failed to read tar entry")
+
+			if header.Name == "bin/busybox" || header.Name == "./bin/busybox" {
+				busyboxFound = true
+				break
+			}
+		}
+
+		assert.Assert(t, busyboxFound, "exported tar file %s does not contain /bin/busybox", outFile)
+		t.Log("Export validation passed: tar file exists and contains /bin/busybox")
+	}
+}
+
+func TestExportStoppedContainer(t *testing.T) {
+	testCase := nerdtest.Setup()
+	testCase.Setup = func(data test.Data, helpers test.Helpers) {
+		identifier := data.Identifier("container")
+		helpers.Ensure("create", "--name", identifier, testutil.CommonImage)
+		data.Labels().Set("cID", identifier)
+		data.Labels().Set("outFile", filepath.Join(os.TempDir(), identifier+".tar"))
+	}
+	testCase.Cleanup = func(data test.Data, helpers test.Helpers) {
+		helpers.Anyhow("container", "rm", "-f", data.Labels().Get("cID"))
+		helpers.Anyhow("rm", "-f", data.Labels().Get("cID"))
+		os.Remove(data.Labels().Get("outFile"))
+	}
+
+	testCase.SubTests = []*test.Case{
+		{
+			Description: "export command succeeds",
+			NoParallel:  true,
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("export", "-o", data.Labels().Get("outFile"), data.Labels().Get("cID"))
+			},
+			Expected: test.Expects(0, nil, nil),
+		},
+		{
+			Description: "tar file exists and has content",
+			NoParallel:  true,
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				// Use a simple command that always succeeds to trigger the validation
+				return helpers.Custom("echo", "validating tar file")
+			},
+			Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
+				return &test.Expected{
+					ExitCode: 0,
+					Output:   validateExportedTar(data.Labels().Get("outFile")),
+				}
+			},
+		},
+	}
+
+	testCase.Run(t)
+}
+
+func TestExportRunningContainer(t *testing.T) {
+	testCase := nerdtest.Setup()
+	testCase.Setup = func(data test.Data, helpers test.Helpers) {
+		identifier := data.Identifier("container")
+		helpers.Ensure("run", "-d", "--name", identifier, testutil.CommonImage, "sleep", nerdtest.Infinity)
+		data.Labels().Set("cID", identifier)
+		data.Labels().Set("outFile", filepath.Join(os.TempDir(), identifier+".tar"))
+	}
+	testCase.Cleanup = func(data test.Data, helpers test.Helpers) {
+		helpers.Anyhow("rm", "-f", data.Labels().Get("cID"))
+		os.Remove(data.Labels().Get("outFile"))
+	}
+
+	testCase.SubTests = []*test.Case{
+		{
+			Description: "export command succeeds",
+			NoParallel:  true,
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("export", "-o", data.Labels().Get("outFile"), data.Labels().Get("cID"))
+			},
+			Expected: test.Expects(0, nil, nil),
+		},
+		{
+			Description: "tar file exists and has content",
+			NoParallel:  true,
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				// Use a simple command that always succeeds to trigger the validation
+				return helpers.Custom("echo", "validating tar file")
+			},
+			Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
+				return &test.Expected{
+					ExitCode: 0,
+					Output:   validateExportedTar(data.Labels().Get("outFile")),
+				}
+			},
+		},
+	}
+
+	testCase.Run(t)
+}
+
+func TestExportNonexistentContainer(t *testing.T) {
+	testCase := nerdtest.Setup()
+	testCase.Command = test.Command("export", "nonexistent-container")
+	testCase.Expected = test.Expects(1, nil, nil)
+
+	testCase.Run(t)
+}

cmd/nerdctl/main.go

@@ -287,6 +287,7 @@ Config file ($NERDCTL_TOML): %s
 		container.PauseCommand(),
 		container.UnpauseCommand(),
 		container.CommitCommand(),
+		container.ExportCommand(),
 		container.WaitCommand(),
 		container.RenameCommand(),
 		container.AttachCommand(),

pkg/api/types/container_types.go

@@ -44,6 +44,13 @@ type ContainerKillOptions struct {
 	KillSignal string
 }
 
+// ContainerExportOptions specifies options for `nerdctl (container) export`.
+type ContainerExportOptions struct {
+	Stdout io.Writer
+	// GOptions is the global options
+	GOptions GlobalCommandOptions
+}
+
 // ContainerCreateOptions specifies options for `nerdctl (container) create` and `nerdctl (container) run`.
 type ContainerCreateOptions struct {
 	Stdout io.Writer