Merge pull request containerd#3551 from austinvazquez/support-load-container-quiet-mode

Add image load and container run quiet mode

Author: AkihiroSuda

cmd/nerdctl/container/container_create.go

@@ -409,12 +409,17 @@ func processContainerCreateOptions(cmd *cobra.Command) (types.ContainerCreateOpt
 	if err != nil {
 		return opt, err
 	}
+	quiet, err := cmd.Flags().GetBool("quiet")
+	if err != nil {
+		return opt, err
+	}
 	opt.ImagePullOpt = types.ImagePullOptions{
 		GOptions:      opt.GOptions,
 		VerifyOptions: imageVerifyOpt,
 		IPFSAddress:   opt.IPFSAddress,
 		Stdout:        opt.Stdout,
 		Stderr:        opt.Stderr,
+		Quiet:         quiet,
 	}
 	// #endregion
 

cmd/nerdctl/container/container_run.go

@@ -92,6 +92,7 @@ func setCreateFlags(cmd *cobra.Command) {
 	})
 	cmd.Flags().Bool("rm", false, "Automatically remove the container when it exits")
 	cmd.Flags().String("pull", "missing", `Pull image before running ("always"|"missing"|"never")`)
+	cmd.Flags().BoolP("quiet", "q", false, "Suppress the pull output")
 	cmd.RegisterFlagCompletionFunc("pull", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
 		return []string{"always", "missing", "never"}, cobra.ShellCompDirectiveNoFileComp
 	})

cmd/nerdctl/container/container_run_test.go

@@ -631,3 +631,30 @@ func TestRunAttachFlag(t *testing.T) {
 		})
 	}
 }
+
+func TestRunQuiet(t *testing.T) {
+	base := testutil.NewBase(t)
+
+	teardown := func() {
+		base.Cmd("rmi", "-f", testutil.CommonImage).Run()
+	}
+	defer teardown()
+	teardown()
+
+	sentinel := "test run quiet"
+	result := base.Cmd("run", "--rm", "--quiet", testutil.CommonImage, fmt.Sprintf(`echo "%s"`, sentinel)).Run()
+	assert.Assert(t, strings.Contains(result.Combined(), sentinel))
+
+	wasQuiet := func(output, sentinel string) bool {
+		return !strings.Contains(output, sentinel)
+	}
+
+	// Docker and nerdctl image pulls are not 1:1.
+	if testutil.GetTarget() == testutil.Docker {
+		sentinel = "Pull complete"
+	} else {
+		sentinel = "resolved"
+	}
+
+	assert.Assert(t, wasQuiet(result.Combined(), sentinel), "Found %s in container run output", sentinel)
+}

cmd/nerdctl/image/image_load.go

@@ -38,6 +38,7 @@ func NewLoadCommand() *cobra.Command {
 	}
 
 	loadCommand.Flags().StringP("input", "i", "", "Read from tar archive file, instead of STDIN")
+	loadCommand.Flags().BoolP("quiet", "q", false, "Suppress the load output")
 
 	// #region platform flags
 	// platform is defined as StringSlice, not StringArray, to allow specifying "--platform=amd64,arm64"
@@ -66,13 +67,18 @@ func processLoadCommandFlags(cmd *cobra.Command) (types.ImageLoadOptions, error)
 	if err != nil {
 		return types.ImageLoadOptions{}, err
 	}
+	quiet, err := cmd.Flags().GetBool("quiet")
+	if err != nil {
+		return types.ImageLoadOptions{}, err
+	}
 	return types.ImageLoadOptions{
 		GOptions:     globalOptions,
 		Input:        input,
 		Platform:     platform,
 		AllPlatforms: allPlatforms,
 		Stdout:       cmd.OutOrStdout(),
 		Stdin:        cmd.InOrStdin(),
+		Quiet:        quiet,
 	}, nil
 }
 

cmd/nerdctl/image/image_load_test.go

@@ -79,3 +79,33 @@ func TestLoadStdinEmpty(t *testing.T) {
 
 	testCase.Run(t)
 }
+
+func TestLoadQuiet(t *testing.T) {
+	nerdtest.Setup()
+
+	testCase := &test.Case{
+		Description: "TestLoadQuiet",
+		Setup: func(data test.Data, helpers test.Helpers) {
+			helpers.Ensure("pull", testutil.CommonImage)
+			helpers.Ensure("tag", testutil.CommonImage, data.Identifier())
+			helpers.Ensure("save", data.Identifier(), "-o", filepath.Join(data.TempDir(), "common.tar"))
+			helpers.Ensure("rmi", "-f", data.Identifier())
+		},
+		Cleanup: func(data test.Data, helpers test.Helpers) {
+			helpers.Anyhow("rmi", "-f", data.Identifier())
+		},
+		Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+			return helpers.Command("load", "--quiet", "--input", filepath.Join(data.TempDir(), "common.tar"))
+		},
+		Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
+			return &test.Expected{
+				Output: test.All(
+					test.Contains(fmt.Sprintf("Loaded image: %s:latest", data.Identifier())),
+					test.DoesNotContain("Loading layer"),
+				),
+			}
+		},
+	}
+
+	testCase.Run(t)
+}

docs/command-reference.md

@@ -151,6 +151,7 @@ Basic flags:
 - :whale: `--rm`: Automatically remove the container when it exits
 - :whale: `--pull=(always|missing|never)`: Pull image before running
   - Default: "missing"
+- :whale: `-q, --quiet`: Suppress the pull output
 - :whale: `--pid=(host|container:<container>)`: PID namespace to use
 - :whale: `--uts=(host)` : UTS namespace to use
 - :whale: `--stop-signal`: Signal to stop a container (default "SIGTERM")
@@ -815,11 +816,10 @@ Usage: `nerdctl load [OPTIONS]`
 Flags:
 
 - :whale: `-i, --input`: Read from tar archive file, instead of STDIN
+- :whale: `-q, --quiet`: Suppress the load output
 - :nerd_face: `--platform=(amd64|arm64|...)`: Import content for a specific platform
 - :nerd_face: `--all-platforms`: Import content for all platforms
 
-Unimplemented `docker load` flags: `--quiet`
-
 ### :whale: nerdctl save
 
 Save one or more images to a tar archive (streamed to STDOUT by default)

pkg/api/types/load_types.go

@@ -29,4 +29,6 @@ type ImageLoadOptions struct {
 	Platform []string
 	// AllPlatforms import content for all platforms
 	AllPlatforms bool
+	// Quiet suppresses the load output.
+	Quiet bool
 }

pkg/cmd/container/create.go

@@ -138,7 +138,6 @@ func Create(ctx context.Context, client *containerd.Client, args []string, netMa
 		options.ImagePullOpt.Mode = options.Pull
 		options.ImagePullOpt.OCISpecPlatform = ocispecPlatforms
 		options.ImagePullOpt.Unpack = nil
-		options.ImagePullOpt.Quiet = false
 
 		ensuredImage, err = image.EnsureImage(ctx, client, rawRef, options.ImagePullOpt)
 		if err != nil {

pkg/cmd/image/load.go

@@ -73,10 +73,10 @@ func Load(ctx context.Context, client *containerd.Client, options types.ImageLoa
 	if err != nil {
 		return err
 	}
-	return loadImage(ctx, client, decompressor, platMC, false, options)
+	return loadImage(ctx, client, decompressor, platMC, options)
 }
 
-func loadImage(ctx context.Context, client *containerd.Client, in io.Reader, platMC platforms.MatchComparer, quiet bool, options types.ImageLoadOptions) error {
+func loadImage(ctx context.Context, client *containerd.Client, in io.Reader, platMC platforms.MatchComparer, options types.ImageLoadOptions) error {
 	// In addition to passing WithImagePlatform() to client.Import(), we also need to pass WithDefaultPlatform() to NewClient().
 	// Otherwise unpacking may fail.
 	r := &readCounter{Reader: in}
@@ -95,19 +95,17 @@ func loadImage(ctx context.Context, client *containerd.Client, in io.Reader, pla
 		image := containerd.NewImageWithPlatform(client, img, platMC)
 
 		// TODO: Show unpack status
-		if !quiet {
+		if !options.Quiet {
 			fmt.Fprintf(options.Stdout, "unpacking %s (%s)...\n", img.Name, img.Target.Digest)
 		}
 		err = image.Unpack(ctx, options.GOptions.Snapshotter)
 		if err != nil {
 			return err
 		}
-		if quiet {
-			fmt.Fprintln(options.Stdout, img.Target.Digest)
-		} else {
-			repo, tag := imgutil.ParseRepoTag(img.Name)
-			fmt.Fprintf(options.Stdout, "Loaded image: %s:%s\n", repo, tag)
-		}
+
+		// Loaded message is shown even when quiet.
+		repo, tag := imgutil.ParseRepoTag(img.Name)
+		fmt.Fprintf(options.Stdout, "Loaded image: %s:%s\n", repo, tag)
 	}
 
 	return nil