From 1316fd2748f420a3a8dead5a86951a165b7d324e Mon Sep 17 00:00:00 2001 From: "Zheao.Li" Date: Sat, 21 Jan 2023 23:45:59 +0800 Subject: [PATCH] [Refactor] Reorder the method argument ordering in pkg/cmd Signed-off-by: Zheao.Li --- cmd/nerdctl/apparmor_inspect_linux.go | 6 +- cmd/nerdctl/apparmor_ls_linux.go | 13 ++-- cmd/nerdctl/build.go | 54 +++++++++-------- cmd/nerdctl/container_inspect.go | 5 +- cmd/nerdctl/image_convert.go | 60 +++++++++---------- cmd/nerdctl/image_cryptutil.go | 27 +++++---- cmd/nerdctl/image_inspect.go | 17 +++--- cmd/nerdctl/image_tag.go | 2 +- cmd/nerdctl/images.go | 20 +++---- cmd/nerdctl/info.go | 17 +++--- cmd/nerdctl/inspect.go | 5 +- cmd/nerdctl/kill.go | 7 ++- cmd/nerdctl/load.go | 16 ++--- cmd/nerdctl/namespace_create.go | 8 +-- cmd/nerdctl/namespace_inspect.go | 13 ++-- cmd/nerdctl/namespace_rm.go | 13 ++-- cmd/nerdctl/namespace_update.go | 8 +-- cmd/nerdctl/network_create.go | 2 +- cmd/nerdctl/network_inspect.go | 5 +- cmd/nerdctl/network_ls.go | 6 +- cmd/nerdctl/network_prune.go | 9 +-- cmd/nerdctl/network_rm.go | 5 +- cmd/nerdctl/pull.go | 24 ++++---- cmd/nerdctl/push.go | 27 +++++---- cmd/nerdctl/rm.go | 7 ++- cmd/nerdctl/run.go | 15 ++--- cmd/nerdctl/system_prune.go | 11 ++-- cmd/nerdctl/volume_create.go | 13 ++-- cmd/nerdctl/volume_inspect.go | 15 ++--- cmd/nerdctl/volume_ls.go | 19 +++--- cmd/nerdctl/volume_prune.go | 17 +++--- cmd/nerdctl/volume_rm.go | 13 ++-- pkg/api/types/apparmor_types.go | 12 +++- .../{build_types.go => builder_types.go} | 9 ++- pkg/api/types/container_types.go | 18 ++++-- pkg/api/types/image_types.go | 30 ++++++---- pkg/api/types/info_types.go | 8 ++- pkg/api/types/load_types.go | 8 ++- pkg/api/types/namespace_types.go | 20 ++++--- pkg/api/types/network_types.go | 30 ++++++---- pkg/api/types/pull_types.go | 8 ++- pkg/api/types/volume_types.go | 28 +++++---- pkg/cmd/apparmor/inspect_linux.go | 6 +- pkg/cmd/apparmor/list_linux.go | 7 +-- pkg/cmd/builder/build.go | 14 ++--- pkg/cmd/container/inspect.go | 5 +- pkg/cmd/container/kill.go | 15 +++-- pkg/cmd/container/remove.go | 11 ++-- pkg/cmd/image/convert.go | 16 ++--- pkg/cmd/image/crypt.go | 7 +-- pkg/cmd/image/inspect.go | 5 +- pkg/cmd/image/list.go | 4 +- pkg/cmd/image/load.go | 16 ++--- pkg/cmd/image/pull.go | 11 ++-- pkg/cmd/image/push.go | 6 +- pkg/cmd/image/tag.go | 2 +- pkg/cmd/info/info.go | 8 +-- pkg/cmd/namespace/create.go | 2 +- pkg/cmd/namespace/inspect.go | 5 +- pkg/cmd/namespace/remove.go | 5 +- pkg/cmd/namespace/update.go | 2 +- pkg/cmd/network/create.go | 2 +- pkg/cmd/network/inspect.go | 5 +- pkg/cmd/network/list.go | 7 +-- pkg/cmd/network/prune.go | 9 ++- pkg/cmd/network/remove.go | 5 +- pkg/cmd/volume/create.go | 5 +- pkg/cmd/volume/inspect.go | 6 +- pkg/cmd/volume/list.go | 11 ++-- pkg/cmd/volume/prune.go | 13 ++-- pkg/cmd/volume/rm.go | 5 +- 71 files changed, 469 insertions(+), 396 deletions(-) rename pkg/api/types/{build_types.go => builder_types.go} (92%) diff --git a/cmd/nerdctl/apparmor_inspect_linux.go b/cmd/nerdctl/apparmor_inspect_linux.go index 7eeff7dbee6..0071a22a824 100644 --- a/cmd/nerdctl/apparmor_inspect_linux.go +++ b/cmd/nerdctl/apparmor_inspect_linux.go @@ -19,6 +19,8 @@ package main import ( "fmt" + "github.com/containerd/nerdctl/pkg/api/types" + "github.com/containerd/nerdctl/pkg/cmd/apparmor" "github.com/containerd/nerdctl/pkg/defaults" "github.com/spf13/cobra" @@ -37,5 +39,7 @@ func newApparmorInspectCommand() *cobra.Command { } func apparmorInspectAction(cmd *cobra.Command, args []string) error { - return apparmor.Inspect(cmd.OutOrStdout()) + return apparmor.Inspect(types.ApparmorInspectOptions{ + Stdout: cmd.OutOrStdout(), + }) } diff --git a/cmd/nerdctl/apparmor_ls_linux.go b/cmd/nerdctl/apparmor_ls_linux.go index a7a34b6e714..aa0073b048e 100644 --- a/cmd/nerdctl/apparmor_ls_linux.go +++ b/cmd/nerdctl/apparmor_ls_linux.go @@ -41,25 +41,26 @@ func newApparmorLsCommand() *cobra.Command { return cmd } -func processApparmorListCommandOptions(cmd *cobra.Command) (types.ApparmorListCommandOptions, error) { +func processApparmorListOptions(cmd *cobra.Command) (types.ApparmorListOptions, error) { quiet, err := cmd.Flags().GetBool("quiet") if err != nil { - return types.ApparmorListCommandOptions{}, err + return types.ApparmorListOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.ApparmorListCommandOptions{}, err + return types.ApparmorListOptions{}, err } - return types.ApparmorListCommandOptions{ + return types.ApparmorListOptions{ Quiet: quiet, Format: format, + Stdout: cmd.OutOrStdout(), }, nil } func apparmorLsAction(cmd *cobra.Command, args []string) error { - options, err := processApparmorListCommandOptions(cmd) + options, err := processApparmorListOptions(cmd) if err != nil { return err } - return apparmor.List(options, cmd.OutOrStdout()) + return apparmor.List(options) } diff --git a/cmd/nerdctl/build.go b/cmd/nerdctl/build.go index e5fc55fa627..020424eff1f 100644 --- a/cmd/nerdctl/build.go +++ b/cmd/nerdctl/build.go @@ -68,91 +68,91 @@ If Dockerfile is not present and -f is not specified, it will look for Container return buildCommand } -func processBuildCommandFlag(cmd *cobra.Command, args []string) (*types.BuildCommandOptions, error) { +func processBuildCommandFlag(cmd *cobra.Command, args []string) (types.BuilderBuildOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } buildKitHost, err := getBuildkitHost(cmd, globalOptions.Namespace) if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } platform, err := cmd.Flags().GetStringSlice("platform") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } platform = strutil.DedupeStrSlice(platform) if len(args) < 1 { - return nil, errors.New("context needs to be specified") + return types.BuilderBuildOptions{}, errors.New("context needs to be specified") } buildContext := args[0] if buildContext == "-" || strings.Contains(buildContext, "://") { - return nil, fmt.Errorf("unsupported build context: %q", buildContext) + return types.BuilderBuildOptions{}, fmt.Errorf("unsupported build context: %q", buildContext) } if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } output, err := cmd.Flags().GetString("output") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } tagValue, err := cmd.Flags().GetStringArray("tag") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } progress, err := cmd.Flags().GetString("progress") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } filename, err := cmd.Flags().GetString("file") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } target, err := cmd.Flags().GetString("target") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } buildArgs, err := cmd.Flags().GetStringArray("build-arg") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } label, err := cmd.Flags().GetStringArray("label") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } noCache, err := cmd.Flags().GetBool("no-cache") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } secret, err := cmd.Flags().GetStringArray("secret") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } ssh, err := cmd.Flags().GetStringArray("ssh") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } cacheFrom, err := cmd.Flags().GetStringArray("cache-from") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } cacheTo, err := cmd.Flags().GetStringArray("cache-to") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } rm, err := cmd.Flags().GetBool("rm") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } iidfile, err := cmd.Flags().GetString("iidfile") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } quiet, err := cmd.Flags().GetBool("quiet") if err != nil { - return nil, err + return types.BuilderBuildOptions{}, err } - result := &types.BuildCommandOptions{ + return types.BuilderBuildOptions{ GOptions: globalOptions, BuildKitHost: buildKitHost, BuildContext: buildContext, @@ -172,8 +172,10 @@ func processBuildCommandFlag(cmd *cobra.Command, args []string) (*types.BuildCom IidFile: iidfile, Quiet: quiet, Platform: platform, - } - return result, nil + Stdout: cmd.OutOrStdout(), + Stderr: cmd.OutOrStderr(), + Stdin: cmd.InOrStdin(), + }, nil } func getBuildkitHost(cmd *cobra.Command, namespace string) (string, error) { @@ -196,7 +198,7 @@ func buildAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - if err := builder.Build(cmd.Context(), options, cmd.InOrStdin(), cmd.OutOrStdout(), cmd.ErrOrStderr()); err != nil { + if err := builder.Build(cmd.Context(), options); err != nil { return err } return nil diff --git a/cmd/nerdctl/container_inspect.go b/cmd/nerdctl/container_inspect.go index 66d23aa7198..e33544a1401 100644 --- a/cmd/nerdctl/container_inspect.go +++ b/cmd/nerdctl/container_inspect.go @@ -68,12 +68,13 @@ func containerInspectAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - return container.Inspect(cmd.Context(), types.ContainerInspectCommandOptions{ + return container.Inspect(cmd.Context(), types.ContainerInspectOptions{ GOptions: globalOptions, Format: format, Mode: mode, Containers: args, - }, cmd.OutOrStdout()) + Stdout: cmd.OutOrStdout(), + }) } func containerInspectShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/image_convert.go b/cmd/nerdctl/image_convert.go index 5b5e06ca1c4..4650bcb6bb6 100644 --- a/cmd/nerdctl/image_convert.go +++ b/cmd/nerdctl/image_convert.go @@ -95,127 +95,126 @@ func newImageConvertCommand() *cobra.Command { return imageConvertCommand } -func processImageConvertCommandOptions(cmd *cobra.Command) (types.ImageConvertCommandOptions, error) { +func processImageConvertOptions(cmd *cobra.Command) (types.ImageConvertOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } // #region estargz flags estargz, err := cmd.Flags().GetBool("estargz") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } estargzRecordIn, err := cmd.Flags().GetString("estargz-record-in") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } estargzCompressionLevel, err := cmd.Flags().GetInt("estargz-compression-level") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } estargzChunkSize, err := cmd.Flags().GetInt("estargz-chunk-size") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } estargzMinChunkSize, err := cmd.Flags().GetInt("estargz-min-chunk-size") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } estargzExternalTOC, err := cmd.Flags().GetBool("estargz-external-toc") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } estargzKeepDiffID, err := cmd.Flags().GetBool("estargz-keep-diff-id") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } // #endregion // #region zstd:chunked flags zstdchunked, err := cmd.Flags().GetBool("zstdchunked") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } zstdChunkedCompressionLevel, err := cmd.Flags().GetInt("zstdchunked-compression-level") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } zstdChunkedChunkSize, err := cmd.Flags().GetInt("zstdchunked-chunk-size") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } zstdChunkedRecordIn, err := cmd.Flags().GetString("zstdchunked-record-in") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } // #endregion // #region nydus flags nydus, err := cmd.Flags().GetBool("nydus") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } nydusBuilderPath, err := cmd.Flags().GetString("nydus-builder-path") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } nydusWorkDir, err := cmd.Flags().GetString("nydus-work-dir") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } nydusPrefetchPatterns, err := cmd.Flags().GetString("nydus-prefetch-patterns") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } nydusCompressor, err := cmd.Flags().GetString("nydus-compressor") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } // #endregion // #region overlaybd flags overlaybd, err := cmd.Flags().GetBool("overlaybd") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } overlaybdFsType, err := cmd.Flags().GetString("overlaybd-fs-type") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } overlaybdDbstr, err := cmd.Flags().GetString("overlaybd-dbstr") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } // #endregion // #region generic flags uncompress, err := cmd.Flags().GetBool("uncompress") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } oci, err := cmd.Flags().GetBool("oci") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } // #endregion // #region platform flags platforms, err := cmd.Flags().GetStringSlice("platform") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } allPlatforms, err := cmd.Flags().GetBool("all-platforms") if err != nil { - return types.ImageConvertCommandOptions{}, err + return types.ImageConvertOptions{}, err } // #endregion - - return types.ImageConvertCommandOptions{ + return types.ImageConvertOptions{ GOptions: globalOptions, Format: format, // #region estargz flags @@ -253,17 +252,18 @@ func processImageConvertCommandOptions(cmd *cobra.Command) (types.ImageConvertCo Platforms: platforms, AllPlatforms: allPlatforms, // #endregion + Stdout: cmd.OutOrStdout(), }, nil } func imageConvertAction(cmd *cobra.Command, args []string) error { - options, err := processImageConvertCommandOptions(cmd) + options, err := processImageConvertOptions(cmd) if err != nil { return err } srcRawRef := args[0] destRawRef := args[1] - return image.Convert(cmd.Context(), srcRawRef, destRawRef, options, cmd.OutOrStdout()) + return image.Convert(cmd.Context(), srcRawRef, destRawRef, options) } func imageConvertShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/image_cryptutil.go b/cmd/nerdctl/image_cryptutil.go index cb059dfbde4..5f6364eea3e 100644 --- a/cmd/nerdctl/image_cryptutil.go +++ b/cmd/nerdctl/image_cryptutil.go @@ -51,43 +51,43 @@ func registerImgcryptFlags(cmd *cobra.Command, encrypt bool) { } } -func processImgCryptCommandOptions(cmd *cobra.Command, args []string, encrypt bool) (types.ImageCryptCommandOptions, error) { +func processImgCryptOptions(cmd *cobra.Command, args []string, encrypt bool) (types.ImageCryptOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } platforms, err := cmd.Flags().GetStringSlice("platform") if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } allPlatforms, err := cmd.Flags().GetBool("all-platforms") if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } gpgHomeDir, err := cmd.Flags().GetString("gpg-homedir") if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } gpgVersion, err := cmd.Flags().GetString("gpg-version") if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } keys, err := cmd.Flags().GetStringSlice("key") if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } decRecipients, err := cmd.Flags().GetStringSlice("dec-recipient") if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } var recipients []string if encrypt { recipients, err = cmd.Flags().GetStringSlice("recipient") if err != nil { - return types.ImageCryptCommandOptions{}, err + return types.ImageCryptOptions{}, err } } - return types.ImageCryptCommandOptions{ + return types.ImageCryptOptions{ GOptions: globalOptions, Platforms: platforms, AllPlatforms: allPlatforms, @@ -96,18 +96,19 @@ func processImgCryptCommandOptions(cmd *cobra.Command, args []string, encrypt bo Keys: keys, DecRecipients: decRecipients, Recipients: recipients, - }, err + Stdout: cmd.OutOrStdout(), + }, nil } func getImgcryptAction(encrypt bool) func(cmd *cobra.Command, args []string) error { return func(cmd *cobra.Command, args []string) error { - options, err := processImgCryptCommandOptions(cmd, args, encrypt) + options, err := processImgCryptOptions(cmd, args, encrypt) if err != nil { return err } srcRawRef := args[0] targetRawRef := args[1] - return image.Crypt(cmd.Context(), options, cmd.OutOrStdout(), srcRawRef, targetRawRef, encrypt) + return image.Crypt(cmd.Context(), srcRawRef, targetRawRef, encrypt, options) } } diff --git a/cmd/nerdctl/image_inspect.go b/cmd/nerdctl/image_inspect.go index 14c8a0cd003..666da90eabc 100644 --- a/cmd/nerdctl/image_inspect.go +++ b/cmd/nerdctl/image_inspect.go @@ -50,40 +50,41 @@ func newImageInspectCommand() *cobra.Command { return imageInspectCommand } -func processImageInspectCommandOptions(cmd *cobra.Command, platform *string) (types.ImageInspectCommandOptions, error) { +func processImageInspectOptions(cmd *cobra.Command, platform *string) (types.ImageInspectOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.ImageInspectCommandOptions{}, err + return types.ImageInspectOptions{}, err } mode, err := cmd.Flags().GetString("mode") if err != nil { - return types.ImageInspectCommandOptions{}, err + return types.ImageInspectOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.ImageInspectCommandOptions{}, err + return types.ImageInspectOptions{}, err } if platform == nil { tempPlatform, err := cmd.Flags().GetString("platform") if err != nil { - return types.ImageInspectCommandOptions{}, err + return types.ImageInspectOptions{}, err } platform = &tempPlatform } - return types.ImageInspectCommandOptions{ + return types.ImageInspectOptions{ GOptions: globalOptions, Mode: mode, Format: format, Platform: *platform, + Stdout: cmd.OutOrStdout(), }, nil } func imageInspectAction(cmd *cobra.Command, args []string) error { - options, err := processImageInspectCommandOptions(cmd, nil) + options, err := processImageInspectOptions(cmd, nil) if err != nil { return err } - return image.Inspect(cmd.Context(), options, cmd.OutOrStdout(), args) + return image.Inspect(cmd.Context(), args, options) } func imageInspectShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/image_tag.go b/cmd/nerdctl/image_tag.go index f8000d887cb..af06d24ddc6 100644 --- a/cmd/nerdctl/image_tag.go +++ b/cmd/nerdctl/image_tag.go @@ -41,7 +41,7 @@ func tagAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - return image.Tag(cmd.Context(), types.ImageTagCommandOptions{ + return image.Tag(cmd.Context(), types.ImageTagOptions{ GOptions: globalOptions, Source: args[0], Target: args[1], diff --git a/cmd/nerdctl/images.go b/cmd/nerdctl/images.go index c6af23e2140..649b28f9b0b 100644 --- a/cmd/nerdctl/images.go +++ b/cmd/nerdctl/images.go @@ -66,49 +66,49 @@ Properties: return imagesCommand } -func processImagesFlag(cmd *cobra.Command, args []string) (types.ImageListCommandOptions, error) { +func processImagesFlag(cmd *cobra.Command, args []string) (types.ImageListOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } var filters []string if len(args) > 0 { canonicalRef, err := referenceutil.ParseAny(args[0]) if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } filters = append(filters, fmt.Sprintf("name==%s", canonicalRef.String())) filters = append(filters, fmt.Sprintf("name==%s", args[0])) } quiet, err := cmd.Flags().GetBool("quiet") if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } noTrunc, err := cmd.Flags().GetBool("no-trunc") if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } var inputFilters []string if cmd.Flags().Changed("filter") { inputFilters, err = cmd.Flags().GetStringSlice("filter") if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } } digests, err := cmd.Flags().GetBool("digests") if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } names, err := cmd.Flags().GetBool("names") if err != nil { - return types.ImageListCommandOptions{}, err + return types.ImageListOptions{}, err } - return types.ImageListCommandOptions{ + return types.ImageListOptions{ GOptions: globalOptions, Quiet: quiet, NoTrunc: noTrunc, diff --git a/cmd/nerdctl/info.go b/cmd/nerdctl/info.go index 4080061825a..a1b28019230 100644 --- a/cmd/nerdctl/info.go +++ b/cmd/nerdctl/info.go @@ -42,32 +42,33 @@ func newInfoCommand() *cobra.Command { return infoCommand } -func processInfoCommandOptions(cmd *cobra.Command) (types.InfoCommandOptions, error) { +func processInfoOptions(cmd *cobra.Command) (types.SystemInfoOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.InfoCommandOptions{}, err + return types.SystemInfoOptions{}, err } mode, err := cmd.Flags().GetString("mode") if err != nil { - return types.InfoCommandOptions{}, err + return types.SystemInfoOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.InfoCommandOptions{}, err + return types.SystemInfoOptions{}, err } - - return types.InfoCommandOptions{ + return types.SystemInfoOptions{ GOptions: globalOptions, Mode: mode, Format: format, + Stdout: cmd.OutOrStdout(), + Stderr: cmd.OutOrStderr(), }, nil } func infoAction(cmd *cobra.Command, args []string) error { - options, err := processInfoCommandOptions(cmd) + options, err := processInfoOptions(cmd) if err != nil { return err } - return info.Info(cmd.Context(), cmd.OutOrStdout(), cmd.ErrOrStderr(), options) + return info.Info(cmd.Context(), options) } diff --git a/cmd/nerdctl/inspect.go b/cmd/nerdctl/inspect.go index e2c649b7aa4..7d5a513c75a 100644 --- a/cmd/nerdctl/inspect.go +++ b/cmd/nerdctl/inspect.go @@ -129,11 +129,12 @@ func inspectAction(cmd *cobra.Command, args []string) error { } if ni != 0 { platform := "" - imageInspectOptions, err := processImageInspectCommandOptions(cmd, &platform) + imageInspectOptions, err := processImageInspectOptions(cmd, &platform) + imageInspectOptions.Stdout = cmd.OutOrStdout() if err != nil { return err } - if err := image.Inspect(cmd.Context(), imageInspectOptions, cmd.OutOrStdout(), []string{req}); err != nil { + if err := image.Inspect(cmd.Context(), []string{req}, imageInspectOptions); err != nil { errs = append(errs, err) } continue diff --git a/cmd/nerdctl/kill.go b/cmd/nerdctl/kill.go index 0e916dda0b5..99fd46b2824 100644 --- a/cmd/nerdctl/kill.go +++ b/cmd/nerdctl/kill.go @@ -46,11 +46,12 @@ func killAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - options := types.KillCommandOptions{ + return container.Kill(cmd.Context(), args, types.KillOptions{ GOptions: globalOptions, KillSignal: killSignal, - } - return container.Kill(cmd.Context(), args, options, cmd.OutOrStdout(), cmd.ErrOrStderr()) + Stdout: cmd.OutOrStdout(), + Stderr: cmd.ErrOrStderr(), + }) } func killShellComplete(cmd *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/load.go b/cmd/nerdctl/load.go index 5761b9005e2..1019ca71b93 100644 --- a/cmd/nerdctl/load.go +++ b/cmd/nerdctl/load.go @@ -45,28 +45,30 @@ func newLoadCommand() *cobra.Command { return loadCommand } -func processLoadCommandFlags(cmd *cobra.Command) (types.LoadCommandOptions, error) { +func processLoadCommandFlags(cmd *cobra.Command) (types.ImageLoadOptions, error) { input, err := cmd.Flags().GetString("input") if err != nil { - return types.LoadCommandOptions{}, err + return types.ImageLoadOptions{}, err } globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.LoadCommandOptions{}, err + return types.ImageLoadOptions{}, err } allPlatforms, err := cmd.Flags().GetBool("all-platforms") if err != nil { - return types.LoadCommandOptions{}, err + return types.ImageLoadOptions{}, err } platform, err := cmd.Flags().GetStringSlice("platform") if err != nil { - return types.LoadCommandOptions{}, err + return types.ImageLoadOptions{}, err } - return types.LoadCommandOptions{ + return types.ImageLoadOptions{ GOptions: globalOptions, Input: input, Platform: platform, AllPlatforms: allPlatforms, + Stdout: cmd.OutOrStdout(), + Stdin: cmd.InOrStdin(), }, nil } @@ -75,5 +77,5 @@ func loadAction(cmd *cobra.Command, _ []string) error { if err != nil { return err } - return image.Load(cmd.Context(), cmd.InOrStdin(), cmd.OutOrStdout(), options) + return image.Load(cmd.Context(), options) } diff --git a/cmd/nerdctl/namespace_create.go b/cmd/nerdctl/namespace_create.go index 913f3c282c1..01e69e14e53 100644 --- a/cmd/nerdctl/namespace_create.go +++ b/cmd/nerdctl/namespace_create.go @@ -36,16 +36,16 @@ func newNamespaceCreateCommand() *cobra.Command { return namespaceCreateCommand } -func processNamespaceCreateCommandOption(cmd *cobra.Command) (types.NamespaceCreateCommandOptions, error) { +func processNamespaceCreateCommandOption(cmd *cobra.Command) (types.NamespaceCreateOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.NamespaceCreateCommandOptions{}, err + return types.NamespaceCreateOptions{}, err } labels, err := cmd.Flags().GetStringArray("label") if err != nil { - return types.NamespaceCreateCommandOptions{}, err + return types.NamespaceCreateOptions{}, err } - return types.NamespaceCreateCommandOptions{ + return types.NamespaceCreateOptions{ GOptions: globalOptions, Labels: labels, }, nil diff --git a/cmd/nerdctl/namespace_inspect.go b/cmd/nerdctl/namespace_inspect.go index f85bd3ecfb0..5ead922e83e 100644 --- a/cmd/nerdctl/namespace_inspect.go +++ b/cmd/nerdctl/namespace_inspect.go @@ -38,25 +38,26 @@ func newNamespaceInspectCommand() *cobra.Command { return namespaceInspectCommand } -func processNamespaceInspectCommandOptions(cmd *cobra.Command) (types.NamespaceInspectCommandOptions, error) { +func processNamespaceInspectOptions(cmd *cobra.Command) (types.NamespaceInspectOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.NamespaceInspectCommandOptions{}, err + return types.NamespaceInspectOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.NamespaceInspectCommandOptions{}, err + return types.NamespaceInspectOptions{}, err } - return types.NamespaceInspectCommandOptions{ + return types.NamespaceInspectOptions{ GOptions: globalOptions, Format: format, + Stdout: cmd.OutOrStdout(), }, nil } func labelInspectAction(cmd *cobra.Command, args []string) error { - options, err := processNamespaceInspectCommandOptions(cmd) + options, err := processNamespaceInspectOptions(cmd) if err != nil { return err } - return namespace.Inspect(cmd.Context(), args, options, cmd.OutOrStdout()) + return namespace.Inspect(cmd.Context(), args, options) } diff --git a/cmd/nerdctl/namespace_rm.go b/cmd/nerdctl/namespace_rm.go index f4aede66022..4a6bf42a691 100644 --- a/cmd/nerdctl/namespace_rm.go +++ b/cmd/nerdctl/namespace_rm.go @@ -36,25 +36,26 @@ func newNamespaceRmCommand() *cobra.Command { return namespaceRmCommand } -func processNamespaceRemoveCommandOptions(cmd *cobra.Command) (types.NamespaceRemoveCommandOptions, error) { +func processNamespaceRemoveOptions(cmd *cobra.Command) (types.NamespaceRemoveOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.NamespaceRemoveCommandOptions{}, err + return types.NamespaceRemoveOptions{}, err } cgroup, err := cmd.Flags().GetBool("cgroup") if err != nil { - return types.NamespaceRemoveCommandOptions{}, err + return types.NamespaceRemoveOptions{}, err } - return types.NamespaceRemoveCommandOptions{ + return types.NamespaceRemoveOptions{ GOptions: globalOptions, CGroup: cgroup, + Stdout: cmd.OutOrStdout(), }, nil } func namespaceRmAction(cmd *cobra.Command, args []string) error { - options, err := processNamespaceRemoveCommandOptions(cmd) + options, err := processNamespaceRemoveOptions(cmd) if err != nil { return err } - return namespace.Remove(cmd.Context(), args, options, cmd.OutOrStdout()) + return namespace.Remove(cmd.Context(), args, options) } diff --git a/cmd/nerdctl/namespace_update.go b/cmd/nerdctl/namespace_update.go index 83cda8c0b15..7c5886c7914 100644 --- a/cmd/nerdctl/namespace_update.go +++ b/cmd/nerdctl/namespace_update.go @@ -35,16 +35,16 @@ func newNamespacelabelUpdateCommand() *cobra.Command { return namespaceLableCommand } -func processNamespaceUpdateCommandOption(cmd *cobra.Command) (types.NamespaceUpdateCommandOptions, error) { +func processNamespaceUpdateCommandOption(cmd *cobra.Command) (types.NamespaceUpdateOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.NamespaceUpdateCommandOptions{}, err + return types.NamespaceUpdateOptions{}, err } labels, err := cmd.Flags().GetStringArray("label") if err != nil { - return types.NamespaceUpdateCommandOptions{}, err + return types.NamespaceUpdateOptions{}, err } - return types.NamespaceUpdateCommandOptions{ + return types.NamespaceUpdateOptions{ GOptions: globalOptions, Labels: labels, }, nil diff --git a/cmd/nerdctl/network_create.go b/cmd/nerdctl/network_create.go index fb25117e829..c7452277bdf 100644 --- a/cmd/nerdctl/network_create.go +++ b/cmd/nerdctl/network_create.go @@ -97,7 +97,7 @@ func networkCreateAction(cmd *cobra.Command, args []string) error { } labels = strutil.DedupeStrSlice(labels) - return network.Create(types.NetworkCreateCommandOptions{ + return network.Create(types.NetworkCreateOptions{ GOptions: globalOptions, CreateOptions: netutil.CreateOptions{ Name: name, diff --git a/cmd/nerdctl/network_inspect.go b/cmd/nerdctl/network_inspect.go index d321eb4e097..af9adb0ffb0 100644 --- a/cmd/nerdctl/network_inspect.go +++ b/cmd/nerdctl/network_inspect.go @@ -56,12 +56,13 @@ func networkInspectAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - return network.Inspect(types.NetworkInspectCommandOptions{ + return network.Inspect(types.NetworkInspectOptions{ GOptions: globalOptions, Mode: mode, Format: format, Networks: args, - }, cmd.OutOrStdout()) + Stdout: cmd.OutOrStdout(), + }) } func networkInspectShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/network_ls.go b/cmd/nerdctl/network_ls.go index a93370f67b0..c45b1e6f7b1 100644 --- a/cmd/nerdctl/network_ls.go +++ b/cmd/nerdctl/network_ls.go @@ -54,10 +54,10 @@ func networkLsAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - options := types.NetworkListCommandOptions{ + return network.List(cmd.Context(), types.NetworkListOptions{ GOptions: globalOptions, Quiet: quiet, Format: format, - } - return network.List(cmd.Context(), options, cmd.OutOrStdout()) + Stdout: cmd.OutOrStdout(), + }) } diff --git a/cmd/nerdctl/network_prune.go b/cmd/nerdctl/network_prune.go index 0257eabc74f..138e48801b6 100644 --- a/cmd/nerdctl/network_prune.go +++ b/cmd/nerdctl/network_prune.go @@ -62,9 +62,10 @@ func networkPruneAction(cmd *cobra.Command, _ []string) error { return nil } } - - return network.Prune(cmd.Context(), types.NetworkPruneCommandOptions{ + options := types.NetworkPruneOptions{ GOptions: globalOptions, - NetworkDriversToKeep: networkDriversToKeep}, - cmd.InOrStdin(), cmd.OutOrStdout()) + NetworkDriversToKeep: networkDriversToKeep, + Stdout: cmd.OutOrStdout(), + } + return network.Prune(cmd.Context(), options) } diff --git a/cmd/nerdctl/network_rm.go b/cmd/nerdctl/network_rm.go index 0374d51c6dc..2b5b3529212 100644 --- a/cmd/nerdctl/network_rm.go +++ b/cmd/nerdctl/network_rm.go @@ -44,10 +44,11 @@ func networkRmAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - return network.Remove(cmd.Context(), types.NetworkRemoveCommandOptions{ + return network.Remove(cmd.Context(), types.NetworkRemoveOptions{ GOptions: globalOptions, Networks: args, - }, cmd.OutOrStdout()) + Stdout: cmd.OutOrStdout(), + }) } func networkRmShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/pull.go b/cmd/nerdctl/pull.go index e0582ebd2bc..c005ba0ec2b 100644 --- a/cmd/nerdctl/pull.go +++ b/cmd/nerdctl/pull.go @@ -58,41 +58,41 @@ func newPullCommand() *cobra.Command { return pullCommand } -func processPullCommandFlags(cmd *cobra.Command) (types.PullCommandOptions, error) { +func processPullCommandFlags(cmd *cobra.Command) (types.ImagePullOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } allPlatforms, err := cmd.Flags().GetBool("all-platforms") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } platform, err := cmd.Flags().GetStringSlice("platform") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } unpackStr, err := cmd.Flags().GetString("unpack") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } quiet, err := cmd.Flags().GetBool("quiet") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } verifier, err := cmd.Flags().GetString("verify") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } cosignKey, err := cmd.Flags().GetString("cosign-key") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } ipfsAddressStr, err := cmd.Flags().GetString("ipfs-address") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } - return types.PullCommandOptions{ + return types.ImagePullOptions{ GOptions: globalOptions, AllPlatforms: allPlatforms, Platform: platform, @@ -101,6 +101,8 @@ func processPullCommandFlags(cmd *cobra.Command) (types.PullCommandOptions, erro Verify: verifier, CosignKey: cosignKey, IPFSAddress: ipfsAddressStr, + Stdout: cmd.OutOrStdout(), + Stderr: cmd.OutOrStderr(), }, nil } @@ -110,5 +112,5 @@ func pullAction(cmd *cobra.Command, args []string) error { return err } - return image.Pull(cmd.Context(), args[0], cmd.OutOrStdout(), cmd.ErrOrStderr(), pullOptions) + return image.Pull(cmd.Context(), args[0], pullOptions) } diff --git a/cmd/nerdctl/push.go b/cmd/nerdctl/push.go index b9a8fcef423..32ac6e01f6f 100644 --- a/cmd/nerdctl/push.go +++ b/cmd/nerdctl/push.go @@ -60,44 +60,44 @@ func newPushCommand() *cobra.Command { return pushCommand } -func processImagePushCommandOptions(cmd *cobra.Command) (types.ImagePushCommandOptions, error) { +func processImagePushOptions(cmd *cobra.Command) (types.ImagePushOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } platform, err := cmd.Flags().GetStringSlice("platform") if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } allPlatforms, err := cmd.Flags().GetBool("all-platforms") if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } estargz, err := cmd.Flags().GetBool("estargz") if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } ipfsEnsureImage, err := cmd.Flags().GetBool("ipfs-ensure-image") if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } ipfsAddress, err := cmd.Flags().GetString("ipfs-address") if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } sign, err := cmd.Flags().GetString("sign") if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } cosignKey, err := cmd.Flags().GetString("cosign-key") if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } allowNonDist, err := cmd.Flags().GetBool(allowNonDistFlag) if err != nil { - return types.ImagePushCommandOptions{}, err + return types.ImagePushOptions{}, err } - return types.ImagePushCommandOptions{ + return types.ImagePushOptions{ GOptions: globalOptions, Platforms: platform, AllPlatforms: allPlatforms, @@ -107,16 +107,17 @@ func processImagePushCommandOptions(cmd *cobra.Command) (types.ImagePushCommandO Sign: sign, CosignKey: cosignKey, AllowNondistributableArtifacts: allowNonDist, + Stdout: cmd.OutOrStdout(), }, nil } func pushAction(cmd *cobra.Command, args []string) error { - options, err := processImagePushCommandOptions(cmd) + options, err := processImagePushOptions(cmd) if err != nil { return err } rawRef := args[0] - return image.Push(cmd.Context(), rawRef, options, cmd.OutOrStdout()) + return image.Push(cmd.Context(), rawRef, options) } func pushShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/rm.go b/cmd/nerdctl/rm.go index aa0cf09a7a3..cfcb4a3e36a 100644 --- a/cmd/nerdctl/rm.go +++ b/cmd/nerdctl/rm.go @@ -50,11 +50,12 @@ func rmAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - - return container.Remove(cmd.Context(), args, types.ContainerRemoveCommandOptions{ + return container.Remove(cmd.Context(), args, types.ContainerRemoveOptions{ GOptions: globalOptions, Force: force, - Volumes: removeAnonVolumes}, cmd.OutOrStdout()) + Volumes: removeAnonVolumes, + Stdout: cmd.OutOrStdout(), + }) } func rmShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/run.go b/cmd/nerdctl/run.go index cc376328250..1b6e64c9b8b 100644 --- a/cmd/nerdctl/run.go +++ b/cmd/nerdctl/run.go @@ -741,23 +741,25 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd // When refactor `nerdctl run`, this func should be removed and replaced by // creating a `PullCommandOptions` directly from `RunCommandOptions`. -func processPullCommandFlagsInRun(cmd *cobra.Command) (types.PullCommandOptions, error) { +func processPullCommandFlagsInRun(cmd *cobra.Command) (types.ImagePullOptions, error) { verifier, err := cmd.Flags().GetString("verify") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } cosignKey, err := cmd.Flags().GetString("cosign-key") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } ipfsAddressStr, err := cmd.Flags().GetString("ipfs-address") if err != nil { - return types.PullCommandOptions{}, err + return types.ImagePullOptions{}, err } - return types.PullCommandOptions{ + return types.ImagePullOptions{ Verify: verifier, CosignKey: cosignKey, IPFSAddress: ipfsAddressStr, + Stdout: cmd.OutOrStdout(), + Stderr: cmd.ErrOrStderr(), }, nil } @@ -791,8 +793,7 @@ func generateRootfsOpts(ctx context.Context, client *containerd.Client, platform } options.GOptions = globalOptions - - ensured, err = image.EnsureImage(ctx, client, rawRef, cmd.OutOrStdout(), cmd.ErrOrStderr(), options, ocispecPlatforms, pull, nil, false) + ensured, err = image.EnsureImage(ctx, client, rawRef, ocispecPlatforms, pull, nil, false, options) if err != nil { return nil, nil, nil, err } diff --git a/cmd/nerdctl/system_prune.go b/cmd/nerdctl/system_prune.go index c1e7001ce63..3aef35afe18 100644 --- a/cmd/nerdctl/system_prune.go +++ b/cmd/nerdctl/system_prune.go @@ -104,17 +104,20 @@ func systemPruneAction(cmd *cobra.Command, args []string) error { if err := containerPrune(ctx, cmd, client, globalOptions); err != nil { return err } - if err := network.Prune(ctx, types.NetworkPruneCommandOptions{ + if err := network.Prune(ctx, types.NetworkPruneOptions{ GOptions: globalOptions, NetworkDriversToKeep: networkDriversToKeep, - }, cmd.InOrStdin(), cmd.OutOrStdout()); err != nil { + Stdout: cmd.OutOrStdout(), + }); err != nil { return err } if vFlag { - if err := volume.Prune(ctx, types.VolumePruneCommandOptions{ + if err := volume.Prune(ctx, types.VolumePruneOptions{ GOptions: globalOptions, Force: true, - }, cmd.InOrStdin(), cmd.OutOrStdout()); err != nil { + Stdout: cmd.OutOrStdout(), + Stdin: cmd.InOrStdin(), + }); err != nil { return err } } diff --git a/cmd/nerdctl/volume_create.go b/cmd/nerdctl/volume_create.go index 9c234f6d0bd..5122e60d465 100644 --- a/cmd/nerdctl/volume_create.go +++ b/cmd/nerdctl/volume_create.go @@ -36,25 +36,26 @@ func newVolumeCreateCommand() *cobra.Command { return volumeCreateCommand } -func processVolumeCreateCommandOptions(cmd *cobra.Command) (types.VolumeCreateCommandOptions, error) { +func processVolumeCreateOptions(cmd *cobra.Command) (types.VolumeCreateOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.VolumeCreateCommandOptions{}, err + return types.VolumeCreateOptions{}, err } labels, err := cmd.Flags().GetStringArray("label") if err != nil { - return types.VolumeCreateCommandOptions{}, err + return types.VolumeCreateOptions{}, err } - return types.VolumeCreateCommandOptions{ + return types.VolumeCreateOptions{ GOptions: globalOptions, Labels: labels, + Stdout: cmd.OutOrStdout(), }, nil } func volumeCreateAction(cmd *cobra.Command, args []string) error { - options, err := processVolumeCreateCommandOptions(cmd) + options, err := processVolumeCreateOptions(cmd) if err != nil { return nil } - return volume.Create(args[0], options, cmd.OutOrStdout()) + return volume.Create(args[0], options) } diff --git a/cmd/nerdctl/volume_inspect.go b/cmd/nerdctl/volume_inspect.go index 1db1b436563..64ef29a35d2 100644 --- a/cmd/nerdctl/volume_inspect.go +++ b/cmd/nerdctl/volume_inspect.go @@ -40,32 +40,33 @@ func newVolumeInspectCommand() *cobra.Command { return volumeInspectCommand } -func processVolumeInspectCommandOptions(cmd *cobra.Command) (types.VolumeInspectCommandOptions, error) { +func processVolumeInspectOptions(cmd *cobra.Command) (types.VolumeInspectOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.VolumeInspectCommandOptions{}, err + return types.VolumeInspectOptions{}, err } volumeSize, err := cmd.Flags().GetBool("size") if err != nil { - return types.VolumeInspectCommandOptions{}, err + return types.VolumeInspectOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.VolumeInspectCommandOptions{}, err + return types.VolumeInspectOptions{}, err } - return types.VolumeInspectCommandOptions{ + return types.VolumeInspectOptions{ GOptions: globalOptions, Format: format, Size: volumeSize, + Stdout: cmd.OutOrStdout(), }, nil } func volumeInspectAction(cmd *cobra.Command, args []string) error { - options, err := processVolumeInspectCommandOptions(cmd) + options, err := processVolumeInspectOptions(cmd) if err != nil { return err } - return volume.Inspect(args, options, cmd.OutOrStdout()) + return volume.Inspect(args, options) } func volumeInspectShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/cmd/nerdctl/volume_ls.go b/cmd/nerdctl/volume_ls.go index 0e0a90df791..847eba092e0 100644 --- a/cmd/nerdctl/volume_ls.go +++ b/cmd/nerdctl/volume_ls.go @@ -45,42 +45,43 @@ func newVolumeLsCommand() *cobra.Command { return volumeLsCommand } -func processVolumeLsCommandOptions(cmd *cobra.Command) (types.VolumeListCommandOptions, error) { +func processVolumeLsOptions(cmd *cobra.Command) (types.VolumeListOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.VolumeListCommandOptions{}, err + return types.VolumeListOptions{}, err } quiet, err := cmd.Flags().GetBool("quiet") if err != nil { - return types.VolumeListCommandOptions{}, err + return types.VolumeListOptions{}, err } format, err := cmd.Flags().GetString("format") if err != nil { - return types.VolumeListCommandOptions{}, err + return types.VolumeListOptions{}, err } size, err := cmd.Flags().GetBool("size") if err != nil { - return types.VolumeListCommandOptions{}, err + return types.VolumeListOptions{}, err } filters, err := cmd.Flags().GetStringSlice("filter") if err != nil { - return types.VolumeListCommandOptions{}, err + return types.VolumeListOptions{}, err } - return types.VolumeListCommandOptions{ + return types.VolumeListOptions{ GOptions: globalOptions, Quiet: quiet, Format: format, Size: size, Filters: filters, + Stdout: cmd.OutOrStdout(), }, nil } func volumeLsAction(cmd *cobra.Command, args []string) error { - options, err := processVolumeLsCommandOptions(cmd) + options, err := processVolumeLsOptions(cmd) if err != nil { return err } - return volume.List(options, cmd.OutOrStdout()) + return volume.List(options) } func getVolumes(cmd *cobra.Command, globalOptions types.GlobalCommandOptions) (map[string]native.Volume, error) { diff --git a/cmd/nerdctl/volume_prune.go b/cmd/nerdctl/volume_prune.go index 1f1aff5a793..83151a3da58 100644 --- a/cmd/nerdctl/volume_prune.go +++ b/cmd/nerdctl/volume_prune.go @@ -35,25 +35,28 @@ func newVolumePruneCommand() *cobra.Command { return volumePruneCommand } -func processVolumePruneCommandOptions(cmd *cobra.Command) (types.VolumePruneCommandOptions, error) { +func processVolumePruneOptions(cmd *cobra.Command) (types.VolumePruneOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.VolumePruneCommandOptions{}, err + return types.VolumePruneOptions{}, err } force, err := cmd.Flags().GetBool("force") if err != nil { - return types.VolumePruneCommandOptions{}, err + return types.VolumePruneOptions{}, err } - return types.VolumePruneCommandOptions{ + options := types.VolumePruneOptions{ GOptions: globalOptions, Force: force, - }, nil + Stdout: cmd.OutOrStdout(), + Stdin: cmd.InOrStdin(), + } + return options, nil } func volumePruneAction(cmd *cobra.Command, _ []string) error { - options, err := processVolumePruneCommandOptions(cmd) + options, err := processVolumePruneOptions(cmd) if err != nil { return err } - return volume.Prune(cmd.Context(), options, cmd.InOrStdin(), cmd.OutOrStdout()) + return volume.Prune(cmd.Context(), options) } diff --git a/cmd/nerdctl/volume_rm.go b/cmd/nerdctl/volume_rm.go index c082d0a5eda..9319d2d01f6 100644 --- a/cmd/nerdctl/volume_rm.go +++ b/cmd/nerdctl/volume_rm.go @@ -38,27 +38,28 @@ func newVolumeRmCommand() *cobra.Command { return volumeRmCommand } -func processVolumeRmCommandOptions(cmd *cobra.Command) (types.VolumeRemoveCommandOptions, error) { +func processVolumeRmOptions(cmd *cobra.Command) (types.VolumeRemoveOptions, error) { globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return types.VolumeRemoveCommandOptions{}, err + return types.VolumeRemoveOptions{}, err } force, err := cmd.Flags().GetBool("force") if err != nil { - return types.VolumeRemoveCommandOptions{}, err + return types.VolumeRemoveOptions{}, err } - return types.VolumeRemoveCommandOptions{ + return types.VolumeRemoveOptions{ GOptions: globalOptions, Force: force, + Stdout: cmd.OutOrStdout(), }, nil } func volumeRmAction(cmd *cobra.Command, args []string) error { - options, err := processVolumeRmCommandOptions(cmd) + options, err := processVolumeRmOptions(cmd) if err != nil { return err } - return volume.Remove(cmd.Context(), args, options, cmd.OutOrStdout()) + return volume.Remove(cmd.Context(), args, options) } func volumeRmShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { diff --git a/pkg/api/types/apparmor_types.go b/pkg/api/types/apparmor_types.go index b896e74b028..d4578c1fa56 100644 --- a/pkg/api/types/apparmor_types.go +++ b/pkg/api/types/apparmor_types.go @@ -16,10 +16,18 @@ package types -// ApparmorListCommandOptions specifies options for `nerdctl apparmor ls`. -type ApparmorListCommandOptions struct { +import "io" + +// ApparmorListOptions specifies options for `nerdctl apparmor ls`. +type ApparmorListOptions struct { + Stdout io.Writer // Only display profile names Quiet bool // Format the output using the given go template Format string } + +// ApparmorInspectOptions specifies options for `nerdctl apparmor inspect` +type ApparmorInspectOptions struct { + Stdout io.Writer +} diff --git a/pkg/api/types/build_types.go b/pkg/api/types/builder_types.go similarity index 92% rename from pkg/api/types/build_types.go rename to pkg/api/types/builder_types.go index 2eb6876955b..6b15532dbfb 100644 --- a/pkg/api/types/build_types.go +++ b/pkg/api/types/builder_types.go @@ -16,8 +16,13 @@ package types -// BuildCommandOptions specifies options for `nerdctl (image/builder) build`. -type BuildCommandOptions struct { +import "io" + +// BuilderBuildOptions specifies options for `nerdctl (image/builder) build`. +type BuilderBuildOptions struct { + Stdin io.Reader + Stdout io.Writer + Stderr io.Writer // GOptions is the global options GOptions GlobalCommandOptions // BuildKitHost is the buildkit host diff --git a/pkg/api/types/container_types.go b/pkg/api/types/container_types.go index 27d8316e852..729f3be4a4d 100644 --- a/pkg/api/types/container_types.go +++ b/pkg/api/types/container_types.go @@ -16,16 +16,21 @@ package types -// KillCommandOptions specifies options for `nerdctl (container) kill`. -type KillCommandOptions struct { +import "io" + +// KillOptions specifies options for `nerdctl (container) kill`. +type KillOptions struct { + Stdout io.Writer + Stderr io.Writer // GOptions is the global options GOptions GlobalCommandOptions // KillSignal is the signal to send to the container KillSignal string } -// ContainerRemoveCommandOptions specifies options for `nerdctl (container) rm`. -type ContainerRemoveCommandOptions struct { +// ContainerRemoveOptions specifies options for `nerdctl (container) rm`. +type ContainerRemoveOptions struct { + Stdout io.Writer // GOptions is the global options GOptions GlobalCommandOptions // Force enables to remove a running|paused|unknown container (uses SIGKILL) @@ -34,8 +39,9 @@ type ContainerRemoveCommandOptions struct { Volumes bool } -// ContainerInspectCommandOptions specifies options for `nerdctl container inspect` -type ContainerInspectCommandOptions struct { +// ContainerInspectOptions specifies options for `nerdctl container inspect` +type ContainerInspectOptions struct { + Stdout io.Writer // GOptions is the global options GOptions GlobalCommandOptions // Format of the output diff --git a/pkg/api/types/image_types.go b/pkg/api/types/image_types.go index 7bfe3768225..7f9028c34f1 100644 --- a/pkg/api/types/image_types.go +++ b/pkg/api/types/image_types.go @@ -16,8 +16,10 @@ package types -// ImageListCommandOptions specifies options for `nerdctl image ls`. -type ImageListCommandOptions struct { +import "io" + +// ImageListOptions specifies options for `nerdctl image ls`. +type ImageListOptions struct { // GOptions is the global options GOptions GlobalCommandOptions // Quiet only show numeric IDs @@ -38,8 +40,9 @@ type ImageListCommandOptions struct { All bool } -// ImageConvertCommandOptions specifies options for `nerdctl image convert`. -type ImageConvertCommandOptions struct { +// ImageConvertOptions specifies options for `nerdctl image convert`. +type ImageConvertOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // #region generic flags @@ -111,8 +114,9 @@ type ImageConvertCommandOptions struct { } -// ImageCryptCommandOptions specifies options for `nerdctl image encrypt` and `nerdctl image decrypt`. -type ImageCryptCommandOptions struct { +// ImageCryptOptions specifies options for `nerdctl image encrypt` and `nerdctl image decrypt`. +type ImageCryptOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Platforms convert content for a specific platform Platforms []string @@ -130,8 +134,9 @@ type ImageCryptCommandOptions struct { Recipients []string } -// ImageInspectCommandOptions specifies options for `nerdctl image inspect`. -type ImageInspectCommandOptions struct { +// ImageInspectOptions specifies options for `nerdctl image inspect`. +type ImageInspectOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Mode Inspect mode, "dockercompat" for Docker-compatible output, "native" for containerd-native output Mode string @@ -141,8 +146,9 @@ type ImageInspectCommandOptions struct { Platform string } -// ImagePushCommandOptions specifies options for `nerdctl (image) push`. -type ImagePushCommandOptions struct { +// ImagePushOptions specifies options for `nerdctl (image) push`. +type ImagePushOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Platforms convert content for a specific platform Platforms []string @@ -163,8 +169,8 @@ type ImagePushCommandOptions struct { AllowNondistributableArtifacts bool } -// ImageTagCommandOptions specifies options for `nerdctl (image) tag`. -type ImageTagCommandOptions struct { +// ImageTagOptions specifies options for `nerdctl (image) tag`. +type ImageTagOptions struct { // GOptions is the global options GOptions GlobalCommandOptions // Source is the image to be referenced. diff --git a/pkg/api/types/info_types.go b/pkg/api/types/info_types.go index 8470cccd2e4..ed6278f60bb 100644 --- a/pkg/api/types/info_types.go +++ b/pkg/api/types/info_types.go @@ -16,8 +16,12 @@ package types -// InfoCommandOptions specifies options for `nerdctl (system) info`. -type InfoCommandOptions struct { +import "io" + +// SystemInfoOptions specifies options for `nerdctl (system) info`. +type SystemInfoOptions struct { + Stdout io.Writer + Stderr io.Writer // GOptions is the global options GOptions GlobalCommandOptions // Information mode, "dockercompat" for Docker-compatible output, "native" for containerd-native output diff --git a/pkg/api/types/load_types.go b/pkg/api/types/load_types.go index 83a5c651d97..df115234cdd 100644 --- a/pkg/api/types/load_types.go +++ b/pkg/api/types/load_types.go @@ -16,8 +16,12 @@ package types -// LoadCommandOptions specifies options for `nerdctl (image) load`. -type LoadCommandOptions struct { +import "io" + +// ImageLoadOptions specifies options for `nerdctl (image) load`. +type ImageLoadOptions struct { + Stdout io.Writer + Stdin io.Reader GOptions GlobalCommandOptions // Input read from tar archive file, instead of STDIN Input string diff --git a/pkg/api/types/namespace_types.go b/pkg/api/types/namespace_types.go index 20814c90193..c3e8d2c4b08 100644 --- a/pkg/api/types/namespace_types.go +++ b/pkg/api/types/namespace_types.go @@ -16,25 +16,29 @@ package types -// NamespaceCreateCommandOptions specifies options for `nerdctl namespace create`. -type NamespaceCreateCommandOptions struct { +import "io" + +// NamespaceCreateOptions specifies options for `nerdctl namespace create`. +type NamespaceCreateOptions struct { GOptions GlobalCommandOptions // Labels are the namespace labels Labels []string } -// NamespaceUpdateCommandOptions specifies options for `nerdctl namespace update`. -type NamespaceUpdateCommandOptions NamespaceCreateCommandOptions +// NamespaceUpdateOptions specifies options for `nerdctl namespace update`. +type NamespaceUpdateOptions NamespaceCreateOptions -// NamespaceRemoveCommandOptions specifies options for `nerdctl namespace rm`. -type NamespaceRemoveCommandOptions struct { +// NamespaceRemoveOptions specifies options for `nerdctl namespace rm`. +type NamespaceRemoveOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // CGroup delete the namespace's cgroup CGroup bool } -// NamespaceInspectCommandOptions specifies options for `nerdctl namespace inspect`. -type NamespaceInspectCommandOptions struct { +// NamespaceInspectOptions specifies options for `nerdctl namespace inspect`. +type NamespaceInspectOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Format the output using the given Go template, e.g, '{{json .}}' Format string diff --git a/pkg/api/types/network_types.go b/pkg/api/types/network_types.go index bc5e33f34cd..4a65ff2122d 100644 --- a/pkg/api/types/network_types.go +++ b/pkg/api/types/network_types.go @@ -16,18 +16,23 @@ package types -import "github.com/containerd/nerdctl/pkg/netutil" +import ( + "io" -// NetworkCreateCommandOptions specifies options for `nerdctl network create`. -type NetworkCreateCommandOptions struct { + "github.com/containerd/nerdctl/pkg/netutil" +) + +// NetworkCreateOptions specifies options for `nerdctl network create`. +type NetworkCreateOptions struct { // GOptions is the global options GOptions GlobalCommandOptions // CreateOptions is the option for creating network CreateOptions netutil.CreateOptions } -// NetworkInspectCommandOptions specifies options for `nerdctl network inspect`. -type NetworkInspectCommandOptions struct { +// NetworkInspectOptions specifies options for `nerdctl network inspect`. +type NetworkInspectOptions struct { + Stdout io.Writer // GOptions is the global options GOptions GlobalCommandOptions // Inspect mode, "dockercompat" for Docker-compatible output, "native" for containerd-native output @@ -38,8 +43,9 @@ type NetworkInspectCommandOptions struct { Networks []string } -// NetworkListCommandOptions specifies options for `nerdctl network ls`. -type NetworkListCommandOptions struct { +// NetworkListOptions specifies options for `nerdctl network ls`. +type NetworkListOptions struct { + Stdout io.Writer // GOptions is the global options GOptions GlobalCommandOptions // Quiet only show numeric IDs @@ -48,16 +54,18 @@ type NetworkListCommandOptions struct { Format string } -// NetworkPruneCommandOptions specifies options for `nerdctl network prune`. -type NetworkPruneCommandOptions struct { +// NetworkPruneOptions specifies options for `nerdctl network prune`. +type NetworkPruneOptions struct { + Stdout io.Writer // GOptions is the global options GOptions GlobalCommandOptions // Network drivers to keep while pruning NetworkDriversToKeep []string } -// NetworkRemoveCommandOptions specifies options for `nerdctl network rm`. -type NetworkRemoveCommandOptions struct { +// NetworkRemoveOptions specifies options for `nerdctl network rm`. +type NetworkRemoveOptions struct { + Stdout io.Writer // GOptions is the global options GOptions GlobalCommandOptions // Networks are the networks to be removed diff --git a/pkg/api/types/pull_types.go b/pkg/api/types/pull_types.go index 300c63e237c..3353183e750 100644 --- a/pkg/api/types/pull_types.go +++ b/pkg/api/types/pull_types.go @@ -16,8 +16,12 @@ package types -// PullCommandOptions specifies options for `nerdctl (image) pull`. -type PullCommandOptions struct { +import "io" + +// ImagePullOptions specifies options for `nerdctl (image) pull`. +type ImagePullOptions struct { + Stdout io.Writer + Stderr io.Writer GOptions GlobalCommandOptions // Unpack the image for the current single platform (auto/true/false) Unpack string diff --git a/pkg/api/types/volume_types.go b/pkg/api/types/volume_types.go index 6e7d4e89ac1..fdda1b62ee0 100644 --- a/pkg/api/types/volume_types.go +++ b/pkg/api/types/volume_types.go @@ -16,15 +16,19 @@ package types -// VolumeCreateCommandOptions specifies options for `nerdctl volume create`. -type VolumeCreateCommandOptions struct { +import "io" + +// VolumeCreateOptions specifies options for `nerdctl volume create`. +type VolumeCreateOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Labels are the volume labels Labels []string } -// VolumeInspectCommandOptions specifies options for `nerdctl volume inspect`. -type VolumeInspectCommandOptions struct { +// VolumeInspectOptions specifies options for `nerdctl volume inspect`. +type VolumeInspectOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Format the output using the given go template Format string @@ -32,8 +36,9 @@ type VolumeInspectCommandOptions struct { Size bool } -// VolumeListCommandOptions specifies options for `nerdctl volume ls`. -type VolumeListCommandOptions struct { +// VolumeListOptions specifies options for `nerdctl volume ls`. +type VolumeListOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Only display volume names Quiet bool @@ -45,15 +50,18 @@ type VolumeListCommandOptions struct { Filters []string } -// VolumePruneCommandOptions specifies options for `nerdctl volume prune`. -type VolumePruneCommandOptions struct { +// VolumePruneOptions specifies options for `nerdctl volume prune`. +type VolumePruneOptions struct { + Stdout io.Writer + Stdin io.Reader GOptions GlobalCommandOptions // Do not prompt for confirmation Force bool } -// VolumeRemoveCommandOptions specifies options for `nerdctl volume rm`. -type VolumeRemoveCommandOptions struct { +// VolumeRemoveOptions specifies options for `nerdctl volume rm`. +type VolumeRemoveOptions struct { + Stdout io.Writer GOptions GlobalCommandOptions // Force the removal of one or more volumes Force bool diff --git a/pkg/cmd/apparmor/inspect_linux.go b/pkg/cmd/apparmor/inspect_linux.go index fb0dda7782d..5fa2a17286d 100644 --- a/pkg/cmd/apparmor/inspect_linux.go +++ b/pkg/cmd/apparmor/inspect_linux.go @@ -18,17 +18,17 @@ package apparmor import ( "fmt" - "io" "github.com/containerd/containerd/contrib/apparmor" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/defaults" ) -func Inspect(stdout io.Writer) error { +func Inspect(options types.ApparmorInspectOptions) error { b, err := apparmor.DumpDefaultProfile(defaults.AppArmorProfileName) if err != nil { return err } - _, err = fmt.Fprint(stdout, b) + _, err = fmt.Fprint(options.Stdout, b) return err } diff --git a/pkg/cmd/apparmor/list_linux.go b/pkg/cmd/apparmor/list_linux.go index d33bb42e087..c7a03b3798b 100644 --- a/pkg/cmd/apparmor/list_linux.go +++ b/pkg/cmd/apparmor/list_linux.go @@ -20,7 +20,6 @@ import ( "bytes" "errors" "fmt" - "io" "text/tabwriter" "text/template" @@ -29,14 +28,14 @@ import ( "github.com/containerd/nerdctl/pkg/formatter" ) -func List(options types.ApparmorListCommandOptions, stdout io.Writer) error { +func List(options types.ApparmorListOptions) error { quiet := options.Quiet - w := stdout + w := options.Stdout var tmpl *template.Template format := options.Format switch format { case "", "table", "wide": - w = tabwriter.NewWriter(stdout, 4, 8, 4, ' ', 0) + w = tabwriter.NewWriter(w, 4, 8, 4, ' ', 0) if !quiet { fmt.Fprintln(w, "NAME\tMODE") } diff --git a/pkg/cmd/builder/build.go b/pkg/cmd/builder/build.go index 24045e31607..bbf2e8c51a3 100644 --- a/pkg/cmd/builder/build.go +++ b/pkg/cmd/builder/build.go @@ -42,8 +42,8 @@ import ( "github.com/sirupsen/logrus" ) -func Build(ctx context.Context, options *types.BuildCommandOptions, stdin io.Reader, stdout, stderr io.Writer) error { - buildctlBinary, buildctlArgs, needsLoading, metaFile, tags, cleanup, err := generateBuildctlArgs(ctx, stdin, options) +func Build(ctx context.Context, options types.BuilderBuildOptions) error { + buildctlBinary, buildctlArgs, needsLoading, metaFile, tags, cleanup, err := generateBuildctlArgs(ctx, options) if err != nil { return err } @@ -62,10 +62,10 @@ func Build(ctx context.Context, options *types.BuildCommandOptions, stdin io.Rea return err } } else { - buildctlCmd.Stdout = stdout + buildctlCmd.Stdout = options.Stdout } if !options.Quiet { - buildctlCmd.Stderr = stderr + buildctlCmd.Stderr = options.Stderr } if err := buildctlCmd.Start(); err != nil { @@ -77,7 +77,7 @@ func Build(ctx context.Context, options *types.BuildCommandOptions, stdin io.Rea if err != nil { return err } - if err = loadImage(ctx, buildctlStdout, options.GOptions.Namespace, options.GOptions.Address, options.GOptions.Snapshotter, stdout, platMC, options.Quiet); err != nil { + if err = loadImage(ctx, buildctlStdout, options.GOptions.Namespace, options.GOptions.Address, options.GOptions.Snapshotter, options.Stdout, platMC, options.Quiet); err != nil { return err } } @@ -171,7 +171,7 @@ func loadImage(ctx context.Context, in io.Reader, namespace, address, snapshotte return nil } -func generateBuildctlArgs(ctx context.Context, stdin io.Reader, options *types.BuildCommandOptions) (buildCtlBinary string, +func generateBuildctlArgs(ctx context.Context, options types.BuilderBuildOptions) (buildCtlBinary string, buildctlArgs []string, needsLoading bool, metaFile string, tags []string, cleanup func(), err error) { buildctlBinary, err := buildkitutil.BuildctlBinary() @@ -251,7 +251,7 @@ func generateBuildctlArgs(ctx context.Context, stdin io.Reader, options *types.B if options.File == "-" { // Super Warning: this is a special trick to update the dir variable, Don't move this line!!!!!! var err error - dir, err = buildkitutil.WriteTempDockerfile(stdin) + dir, err = buildkitutil.WriteTempDockerfile(options.Stdin) if err != nil { return "", nil, false, "", nil, nil, err } diff --git a/pkg/cmd/container/inspect.go b/pkg/cmd/container/inspect.go index 6c800bfbb7e..1102ca3d0ee 100644 --- a/pkg/cmd/container/inspect.go +++ b/pkg/cmd/container/inspect.go @@ -19,7 +19,6 @@ package container import ( "context" "fmt" - "io" "time" "github.com/containerd/nerdctl/pkg/api/types" @@ -30,7 +29,7 @@ import ( "github.com/containerd/nerdctl/pkg/inspecttypes/dockercompat" ) -func Inspect(ctx context.Context, options types.ContainerInspectCommandOptions, stdout io.Writer) error { +func Inspect(ctx context.Context, options types.ContainerInspectOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -59,7 +58,7 @@ func Inspect(ctx context.Context, options types.ContainerInspectCommandOptions, return fmt.Errorf("%d errors: %v", len(errs), errs) } - return formatter.FormatSlice(options.Format, stdout, f.entries) + return formatter.FormatSlice(options.Format, options.Stdout, f.entries) } type containerInspector struct { diff --git a/pkg/cmd/container/kill.go b/pkg/cmd/container/kill.go index f43d8593b38..29d1d1823ec 100644 --- a/pkg/cmd/container/kill.go +++ b/pkg/cmd/container/kill.go @@ -19,7 +19,6 @@ package container import ( "context" "fmt" - "io" "os" "strings" "syscall" @@ -34,16 +33,16 @@ import ( "github.com/sirupsen/logrus" ) -func Kill(ctx context.Context, reqs []string, opt types.KillCommandOptions, stdout, stderr io.Writer) error { - if !strings.HasPrefix(opt.KillSignal, "SIG") { - opt.KillSignal = "SIG" + opt.KillSignal +func Kill(ctx context.Context, reqs []string, options types.KillOptions) error { + if !strings.HasPrefix(options.KillSignal, "SIG") { + options.KillSignal = "SIG" + options.KillSignal } - parsedSignal, err := signal.ParseSignal(opt.KillSignal) + parsedSignal, err := signal.ParseSignal(options.KillSignal) if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(ctx, opt.GOptions.Namespace, opt.GOptions.Address) + client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err } @@ -57,12 +56,12 @@ func Kill(ctx context.Context, reqs []string, opt types.KillCommandOptions, stdo } if err := killContainer(ctx, found.Container, parsedSignal); err != nil { if errdefs.IsNotFound(err) { - fmt.Fprintf(stderr, "No such container: %s\n", found.Req) + fmt.Fprintf(options.Stderr, "No such container: %s\n", found.Req) os.Exit(1) } return err } - _, err := fmt.Fprintf(stdout, "%s\n", found.Container.ID()) + _, err := fmt.Fprintf(options.Stdout, "%s\n", found.Container.ID()) return err }, } diff --git a/pkg/cmd/container/remove.go b/pkg/cmd/container/remove.go index dc56ee8dffa..dc387e8ebf1 100644 --- a/pkg/cmd/container/remove.go +++ b/pkg/cmd/container/remove.go @@ -21,7 +21,6 @@ import ( "encoding/json" "errors" "fmt" - "io" "os" "syscall" @@ -61,8 +60,8 @@ func NewStatusError(id string, status containerd.ProcessStatus) error { } // Remove removes a list of `containers`. -func Remove(ctx context.Context, containers []string, opt types.ContainerRemoveCommandOptions, out io.Writer) error { - client, ctx, cancel, err := clientutil.NewClient(ctx, opt.GOptions.Namespace, opt.GOptions.Address) +func Remove(ctx context.Context, containers []string, options types.ContainerRemoveOptions) error { + client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err } @@ -74,13 +73,13 @@ func Remove(ctx context.Context, containers []string, opt types.ContainerRemoveC if found.MatchCount > 1 { return fmt.Errorf("multiple IDs found with provided prefix: %s", found.Req) } - if err := RemoveContainer(ctx, found.Container, opt.GOptions, opt.Force, opt.Volumes); err != nil { + if err := RemoveContainer(ctx, found.Container, options.GOptions, options.Force, options.Volumes); err != nil { if errors.As(err, &ErrContainerStatus{}) { err = fmt.Errorf("%s. unpause/stop container first or force removal", err) } return err } - _, err = fmt.Fprintf(out, "%s\n", found.Req) + _, err = fmt.Fprintf(options.Stdout, "%s\n", found.Req) return err }, } @@ -90,7 +89,7 @@ func Remove(ctx context.Context, containers []string, opt types.ContainerRemoveC err = fmt.Errorf("no such container %s", req) } if err != nil { - if opt.Force { + if options.Force { logrus.Error(err) } else { return err diff --git a/pkg/cmd/image/convert.go b/pkg/cmd/image/convert.go index 1d1ed81a598..e5e69e94b2f 100644 --- a/pkg/cmd/image/convert.go +++ b/pkg/cmd/image/convert.go @@ -46,7 +46,7 @@ import ( "github.com/sirupsen/logrus" ) -func Convert(ctx context.Context, srcRawRef, targetRawRef string, options types.ImageConvertCommandOptions, stdout io.Writer) error { +func Convert(ctx context.Context, srcRawRef, targetRawRef string, options types.ImageConvertOptions) error { var ( convertOpts = []converter.Opt{} ) @@ -200,10 +200,10 @@ func Convert(ctx context.Context, srcRawRef, targetRawRef string, options types. } res.ExtraImages = append(res.ExtraImages, finimg.Name+"@"+finimg.Target.Digest.String()) } - return printConvertedImage(stdout, options, res) + return printConvertedImage(options.Stdout, options, res) } -func getESGZConverter(options types.ImageConvertCommandOptions) (convertFunc converter.ConvertFunc, finalize func(ctx context.Context, cs content.Store, ref string, desc *ocispec.Descriptor) (*images.Image, error), _ error) { +func getESGZConverter(options types.ImageConvertOptions) (convertFunc converter.ConvertFunc, finalize func(ctx context.Context, cs content.Store, ref string, desc *ocispec.Descriptor) (*images.Image, error), _ error) { if options.EstargzExternalToc && !options.GOptions.Experimental { return nil, nil, fmt.Errorf("estargz-external-toc requires experimental mode to be enabled") } @@ -234,7 +234,7 @@ func getESGZConverter(options types.ImageConvertCommandOptions) (convertFunc con return convertFunc, finalize, nil } -func getESGZConvertOpts(options types.ImageConvertCommandOptions) ([]estargz.Option, error) { +func getESGZConvertOpts(options types.ImageConvertOptions) ([]estargz.Option, error) { esgzOpts := []estargz.Option{ estargz.WithCompressionLevel(options.EstargzCompressionLevel), @@ -259,7 +259,7 @@ func getESGZConvertOpts(options types.ImageConvertCommandOptions) ([]estargz.Opt return esgzOpts, nil } -func getZstdchunkedConverter(options types.ImageConvertCommandOptions) (converter.ConvertFunc, error) { +func getZstdchunkedConverter(options types.ImageConvertOptions) (converter.ConvertFunc, error) { esgzOpts := []estargz.Option{ estargz.WithChunkSize(options.ZstdChunkedChunkSize), @@ -282,7 +282,7 @@ func getZstdchunkedConverter(options types.ImageConvertCommandOptions) (converte return zstdchunkedconvert.LayerConvertFuncWithCompressionLevel(zstd.EncoderLevelFromZstd(options.ZstdChunkedCompressionLevel), esgzOpts...), nil } -func getNydusConvertOpts(options types.ImageConvertCommandOptions) (*nydusconvert.PackOption, error) { +func getNydusConvertOpts(options types.ImageConvertOptions) (*nydusconvert.PackOption, error) { workDir := options.NydusWorkDir if workDir == "" { var err error @@ -303,7 +303,7 @@ func getNydusConvertOpts(options types.ImageConvertCommandOptions) (*nydusconver }, nil } -func getOBDConvertOpts(options types.ImageConvertCommandOptions) ([]overlaybdconvert.Option, error) { +func getOBDConvertOpts(options types.ImageConvertOptions) ([]overlaybdconvert.Option, error) { obdOpts := []overlaybdconvert.Option{ overlaybdconvert.WithFsType(options.OverlayFsType), overlaybdconvert.WithDbstr(options.OverlaydbDBStr), @@ -333,7 +333,7 @@ func readPathsFromRecordFile(filename string) ([]string, error) { return paths, nil } -func printConvertedImage(stdout io.Writer, options types.ImageConvertCommandOptions, img converterutil.ConvertedImageInfo) error { +func printConvertedImage(stdout io.Writer, options types.ImageConvertOptions, img converterutil.ConvertedImageInfo) error { switch options.Format { case "json": b, err := json.MarshalIndent(img, "", " ") diff --git a/pkg/cmd/image/crypt.go b/pkg/cmd/image/crypt.go index fc6e1076e6a..0b91a959cc2 100644 --- a/pkg/cmd/image/crypt.go +++ b/pkg/cmd/image/crypt.go @@ -20,7 +20,6 @@ import ( "context" "errors" "fmt" - "io" "github.com/containerd/containerd/content" "github.com/containerd/containerd/images/converter" @@ -33,7 +32,7 @@ import ( ocispec "github.com/opencontainers/image-spec/specs-go/v1" ) -func Crypt(ctx context.Context, options types.ImageCryptCommandOptions, stdout io.Writer, srcRawRef, targetRawRef string, encrypt bool) error { +func Crypt(ctx context.Context, srcRawRef, targetRawRef string, encrypt bool, options types.ImageCryptOptions) error { var convertOpts = []converter.Opt{} if srcRawRef == "" || targetRawRef == "" { return errors.New("src and target image need to be specified") @@ -101,12 +100,12 @@ func Crypt(ctx context.Context, options types.ImageCryptCommandOptions, stdout i if err != nil { return err } - fmt.Fprintln(stdout, newImg.Target.Digest.String()) + fmt.Fprintln(options.Stdout, newImg.Target.Digest.String()) return nil } // parseImgcryptFlags corresponds to https://github.com/containerd/imgcrypt/blob/v1.1.2/cmd/ctr/commands/images/crypt_utils.go#L244-L252 -func parseImgcryptFlags(options types.ImageCryptCommandOptions, encrypt bool) (parsehelpers.EncArgs, error) { +func parseImgcryptFlags(options types.ImageCryptOptions, encrypt bool) (parsehelpers.EncArgs, error) { var a parsehelpers.EncArgs a.GPGHomedir = options.GpgHomeDir diff --git a/pkg/cmd/image/inspect.go b/pkg/cmd/image/inspect.go index 90192f71e8a..8d01886bc94 100644 --- a/pkg/cmd/image/inspect.go +++ b/pkg/cmd/image/inspect.go @@ -19,7 +19,6 @@ package image import ( "context" "fmt" - "io" "time" "github.com/containerd/containerd" @@ -32,7 +31,7 @@ import ( "github.com/containerd/nerdctl/pkg/inspecttypes/dockercompat" ) -func Inspect(ctx context.Context, options types.ImageInspectCommandOptions, stdout io.Writer, imageFilter []string) error { +func Inspect(ctx context.Context, imageFilter []string, options types.ImageInspectOptions) error { var clientOpts []containerd.ClientOpt if options.Platform != "" { platformParsed, err := platforms.Parse(options.Platform) @@ -89,7 +88,7 @@ func Inspect(ctx context.Context, options types.ImageInspectCommandOptions, stdo if len(errs) > 0 { return fmt.Errorf("%d errors: %v", len(errs), errs) } - return formatter.FormatSlice(options.Format, stdout, f.entries) + return formatter.FormatSlice(options.Format, options.Stdout, f.entries) } type imageInspector struct { diff --git a/pkg/cmd/image/list.go b/pkg/cmd/image/list.go index 51c96151786..1ab37d90f2c 100644 --- a/pkg/cmd/image/list.go +++ b/pkg/cmd/image/list.go @@ -46,7 +46,7 @@ import ( "github.com/sirupsen/logrus" ) -func List(ctx context.Context, options types.ImageListCommandOptions) error { +func List(ctx context.Context, options types.ImageListOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -181,7 +181,7 @@ type imagePrintable struct { Platform string // nerdctl extension } -func printImages(ctx context.Context, options types.ImageListCommandOptions, client *containerd.Client, imageList []images.Image) error { +func printImages(ctx context.Context, options types.ImageListOptions, client *containerd.Client, imageList []images.Image) error { digestsFlag := options.Digests var w io.Writer w = os.Stdout diff --git a/pkg/cmd/image/load.go b/pkg/cmd/image/load.go index f60abc9d8d1..963c5c9a728 100644 --- a/pkg/cmd/image/load.go +++ b/pkg/cmd/image/load.go @@ -46,14 +46,14 @@ func (r *readCounter) Read(p []byte) (int, error) { return n, err } -func Load(ctx context.Context, stdin io.Reader, stdout io.Writer, options types.LoadCommandOptions) error { +func Load(ctx context.Context, options types.ImageLoadOptions) error { if options.Input != "" { f, err := os.Open(options.Input) if err != nil { return err } defer f.Close() - stdin = f + options.Stdin = f } else { // check if stdin is empty. stdinStat, err := os.Stdin.Stat() @@ -64,7 +64,7 @@ func Load(ctx context.Context, stdin io.Reader, stdout io.Writer, options types. return errors.New("stdin is empty and input flag is not specified") } } - decompressor, err := compression.DecompressStream(stdin) + decompressor, err := compression.DecompressStream(options.Stdin) if err != nil { return err } @@ -72,10 +72,10 @@ func Load(ctx context.Context, stdin io.Reader, stdout io.Writer, options types. if err != nil { return err } - return loadImage(ctx, decompressor, stdout, options, platMC, false) + return loadImage(ctx, decompressor, platMC, false, options) } -func loadImage(ctx context.Context, in io.Reader, stdout io.Writer, options types.LoadCommandOptions, platMC platforms.MatchComparer, quiet bool) error { +func loadImage(ctx context.Context, in io.Reader, platMC platforms.MatchComparer, quiet bool, options types.ImageLoadOptions) error { // In addition to passing WithImagePlatform() to client.Import(), we also need to pass WithDefaultPlatform() to NewClient(). // Otherwise unpacking may fail. @@ -102,16 +102,16 @@ func loadImage(ctx context.Context, in io.Reader, stdout io.Writer, options type // TODO: Show unpack status if !quiet { - fmt.Fprintf(stdout, "unpacking %s (%s)...\n", img.Name, img.Target.Digest) + 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(stdout, img.Target.Digest) + fmt.Fprintln(options.Stdout, img.Target.Digest) } else { - fmt.Fprintf(stdout, "Loaded image: %s\n", img.Name) + fmt.Fprintf(options.Stdout, "Loaded image: %s\n", img.Name) } } diff --git a/pkg/cmd/image/pull.go b/pkg/cmd/image/pull.go index 96d87f76edf..eb1fb39dda3 100644 --- a/pkg/cmd/image/pull.go +++ b/pkg/cmd/image/pull.go @@ -20,7 +20,6 @@ import ( "context" "errors" "fmt" - "io" "os" "path/filepath" @@ -37,7 +36,7 @@ import ( "github.com/sirupsen/logrus" ) -func Pull(ctx context.Context, rawRef string, stdout io.Writer, stderr io.Writer, options types.PullCommandOptions) error { +func Pull(ctx context.Context, rawRef string, options types.ImagePullOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -54,7 +53,7 @@ func Pull(ctx context.Context, rawRef string, stdout io.Writer, stderr io.Writer return err } - _, err = EnsureImage(ctx, client, rawRef, stdout, stderr, options, ocispecPlatforms, "always", unpack, options.Quiet) + _, err = EnsureImage(ctx, client, rawRef, ocispecPlatforms, "always", unpack, options.Quiet, options) if err != nil { return err } @@ -62,7 +61,7 @@ func Pull(ctx context.Context, rawRef string, stdout io.Writer, stderr io.Writer return nil } -func EnsureImage(ctx context.Context, client *containerd.Client, rawRef string, stdout io.Writer, stderr io.Writer, options types.PullCommandOptions, ocispecPlatforms []v1.Platform, pull string, unpack *bool, quiet bool) (*imgutil.EnsuredImage, error) { +func EnsureImage(ctx context.Context, client *containerd.Client, rawRef string, ocispecPlatforms []v1.Platform, pull string, unpack *bool, quiet bool, options types.ImagePullOptions) (*imgutil.EnsuredImage, error) { var ensured *imgutil.EnsuredImage @@ -84,7 +83,7 @@ func EnsureImage(ctx context.Context, client *containerd.Client, rawRef string, ipfsPath = &dir } - ensured, err = ipfs.EnsureImage(ctx, client, stdout, stderr, options.GOptions.Snapshotter, scheme, ref, + ensured, err = ipfs.EnsureImage(ctx, client, options.Stdout, options.Stderr, options.GOptions.Snapshotter, scheme, ref, pull, ocispecPlatforms, unpack, quiet, ipfsPath) if err != nil { return nil, err @@ -112,7 +111,7 @@ func EnsureImage(ctx context.Context, client *containerd.Client, rawRef string, return nil, fmt.Errorf("no verifier found: %s", options.Verify) } - ensured, err = imgutil.EnsureImage(ctx, client, stdout, stderr, options.GOptions.Snapshotter, ref, + ensured, err = imgutil.EnsureImage(ctx, client, options.Stdout, options.Stderr, options.GOptions.Snapshotter, ref, pull, options.GOptions.InsecureRegistry, options.GOptions.HostsDir, ocispecPlatforms, unpack, quiet) if err != nil { return nil, err diff --git a/pkg/cmd/image/push.go b/pkg/cmd/image/push.go index 515165e7893..cc00e9138ff 100644 --- a/pkg/cmd/image/push.go +++ b/pkg/cmd/image/push.go @@ -45,7 +45,7 @@ import ( "github.com/sirupsen/logrus" ) -func Push(ctx context.Context, rawRef string, options types.ImagePushCommandOptions, stdout io.Writer) error { +func Push(ctx context.Context, rawRef string, options types.ImagePushOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -80,7 +80,7 @@ func Push(ctx context.Context, rawRef string, options types.ImagePushCommandOpti logrus.WithError(err).Warnf("ipfs push failed") return err } - fmt.Fprintln(stdout, c) + fmt.Fprintln(options.Stdout, c) return nil } @@ -122,7 +122,7 @@ func Push(ctx context.Context, rawRef string, options types.ImagePushCommandOpti } pushFunc := func(r remotes.Resolver) error { - return push.Push(ctx, client, r, stdout, pushRef, ref, platMC, options.AllowNondistributableArtifacts) + return push.Push(ctx, client, r, options.Stdout, pushRef, ref, platMC, options.AllowNondistributableArtifacts) } var dOpts []dockerconfigresolver.Opt diff --git a/pkg/cmd/image/tag.go b/pkg/cmd/image/tag.go index f68778bb730..ef1ca6bf700 100644 --- a/pkg/cmd/image/tag.go +++ b/pkg/cmd/image/tag.go @@ -27,7 +27,7 @@ import ( "github.com/containerd/nerdctl/pkg/referenceutil" ) -func Tag(ctx context.Context, options types.ImageTagCommandOptions) error { +func Tag(ctx context.Context, options types.ImageTagOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err diff --git a/pkg/cmd/info/info.go b/pkg/cmd/info/info.go index 7bf52b6d53d..ab18cf16d39 100644 --- a/pkg/cmd/info/info.go +++ b/pkg/cmd/info/info.go @@ -40,7 +40,7 @@ import ( "github.com/sirupsen/logrus" ) -func Info(ctx context.Context, stdout io.Writer, stderr io.Writer, options types.InfoCommandOptions) error { +func Info(ctx context.Context, options types.SystemInfoOptions) error { var ( tmpl *template.Template err error @@ -85,7 +85,7 @@ func Info(ctx context.Context, stdout io.Writer, stderr io.Writer, options types if infoCompat != nil { x = infoCompat } - w := stdout + w := options.Stdout if err := tmpl.Execute(w, x); err != nil { return err } @@ -95,9 +95,9 @@ func Info(ctx context.Context, stdout io.Writer, stderr io.Writer, options types switch options.Mode { case "native": - return prettyPrintInfoNative(stdout, infoNative) + return prettyPrintInfoNative(options.Stdout, infoNative) case "dockercompat": - return prettyPrintInfoDockerCompat(stdout, stderr, infoCompat, options.GOptions) + return prettyPrintInfoDockerCompat(options.Stdout, options.Stderr, infoCompat, options.GOptions) } return nil } diff --git a/pkg/cmd/namespace/create.go b/pkg/cmd/namespace/create.go index 86f6428f1fa..bad940ce381 100644 --- a/pkg/cmd/namespace/create.go +++ b/pkg/cmd/namespace/create.go @@ -23,7 +23,7 @@ import ( "github.com/containerd/nerdctl/pkg/clientutil" ) -func Create(ctx context.Context, namespace string, options types.NamespaceCreateCommandOptions) error { +func Create(ctx context.Context, namespace string, options types.NamespaceCreateOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err diff --git a/pkg/cmd/namespace/inspect.go b/pkg/cmd/namespace/inspect.go index b41aa17f118..09f8f2bc4d5 100644 --- a/pkg/cmd/namespace/inspect.go +++ b/pkg/cmd/namespace/inspect.go @@ -18,7 +18,6 @@ package namespace import ( "context" - "io" "github.com/containerd/containerd/namespaces" "github.com/containerd/nerdctl/pkg/api/types" @@ -27,7 +26,7 @@ import ( "github.com/containerd/nerdctl/pkg/inspecttypes/native" ) -func Inspect(ctx context.Context, inspectedNamespaces []string, options types.NamespaceInspectCommandOptions, stdout io.Writer) error { +func Inspect(ctx context.Context, inspectedNamespaces []string, options types.NamespaceInspectOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -47,5 +46,5 @@ func Inspect(ctx context.Context, inspectedNamespaces []string, options types.Na } result[index] = nsInspect } - return formatter.FormatSlice(options.Format, stdout, result) + return formatter.FormatSlice(options.Format, options.Stdout, result) } diff --git a/pkg/cmd/namespace/remove.go b/pkg/cmd/namespace/remove.go index 5c9ef061338..2ee47fad1d5 100644 --- a/pkg/cmd/namespace/remove.go +++ b/pkg/cmd/namespace/remove.go @@ -19,7 +19,6 @@ package namespace import ( "context" "fmt" - "io" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/log" @@ -27,7 +26,7 @@ import ( "github.com/containerd/nerdctl/pkg/clientutil" ) -func Remove(ctx context.Context, deletedNamespaces []string, options types.NamespaceRemoveCommandOptions, stdout io.Writer) error { +func Remove(ctx context.Context, deletedNamespaces []string, options types.NamespaceRemoveOptions) error { var exitErr error client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { @@ -49,7 +48,7 @@ func Remove(ctx context.Context, deletedNamespaces []string, options types.Names continue } } - _, err := fmt.Fprintf(stdout, "%s\n", target) + _, err := fmt.Fprintf(options.Stdout, "%s\n", target) return err } return exitErr diff --git a/pkg/cmd/namespace/update.go b/pkg/cmd/namespace/update.go index 07a5965fa06..336df6879b2 100644 --- a/pkg/cmd/namespace/update.go +++ b/pkg/cmd/namespace/update.go @@ -23,7 +23,7 @@ import ( "github.com/containerd/nerdctl/pkg/clientutil" ) -func Update(ctx context.Context, namespace string, options types.NamespaceUpdateCommandOptions) error { +func Update(ctx context.Context, namespace string, options types.NamespaceUpdateOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err diff --git a/pkg/cmd/network/create.go b/pkg/cmd/network/create.go index 9b106799f72..f592a5ee62b 100644 --- a/pkg/cmd/network/create.go +++ b/pkg/cmd/network/create.go @@ -25,7 +25,7 @@ import ( "github.com/containerd/nerdctl/pkg/netutil" ) -func Create(options types.NetworkCreateCommandOptions, stdout io.Writer) error { +func Create(options types.NetworkCreateOptions, stdout io.Writer) error { if options.CreateOptions.Subnet == "" { if options.CreateOptions.Gateway != "" || options.CreateOptions.IPRange != "" { return fmt.Errorf("cannot set gateway or ip-range without subnet, specify --subnet manually") diff --git a/pkg/cmd/network/inspect.go b/pkg/cmd/network/inspect.go index 9d8fe2665fa..a6c72cb1207 100644 --- a/pkg/cmd/network/inspect.go +++ b/pkg/cmd/network/inspect.go @@ -19,7 +19,6 @@ package network import ( "encoding/json" "fmt" - "io" "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/formatter" @@ -28,7 +27,7 @@ import ( "github.com/containerd/nerdctl/pkg/netutil" ) -func Inspect(options types.NetworkInspectCommandOptions, stdout io.Writer) error { +func Inspect(options types.NetworkInspectOptions) error { e, err := netutil.NewCNIEnv(options.GOptions.CNIPath, options.GOptions.CNINetConfPath) if err != nil { return err @@ -68,5 +67,5 @@ func Inspect(options types.NetworkInspectCommandOptions, stdout io.Writer) error return fmt.Errorf("unknown mode %q", options.Mode) } } - return formatter.FormatSlice(options.Format, stdout, result) + return formatter.FormatSlice(options.Format, options.Stdout, result) } diff --git a/pkg/cmd/network/list.go b/pkg/cmd/network/list.go index 6f8e8981da4..3e0cfc54030 100644 --- a/pkg/cmd/network/list.go +++ b/pkg/cmd/network/list.go @@ -21,7 +21,6 @@ import ( "context" "errors" "fmt" - "io" "text/tabwriter" "text/template" @@ -38,16 +37,16 @@ type networkPrintable struct { file string `json:"-"` } -func List(ctx context.Context, options types.NetworkListCommandOptions, out io.Writer) error { +func List(ctx context.Context, options types.NetworkListOptions) error { globalOptions := options.GOptions quiet := options.Quiet format := options.Format - w := out + w := options.Stdout var tmpl *template.Template switch format { case "", "table", "wide": - w = tabwriter.NewWriter(out, 4, 8, 4, ' ', 0) + w = tabwriter.NewWriter(w, 4, 8, 4, ' ', 0) if !quiet { fmt.Fprintln(w, "NETWORK ID\tNAME\tFILE") } diff --git a/pkg/cmd/network/prune.go b/pkg/cmd/network/prune.go index 65876c5dd89..fbaaf3c4bfd 100644 --- a/pkg/cmd/network/prune.go +++ b/pkg/cmd/network/prune.go @@ -19,7 +19,6 @@ package network import ( "context" "fmt" - "io" "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" @@ -28,7 +27,7 @@ import ( "github.com/sirupsen/logrus" ) -func Prune(ctx context.Context, options types.NetworkPruneCommandOptions, stdin io.Reader, stdout io.Writer) error { +func Prune(ctx context.Context, options types.NetworkPruneOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -69,11 +68,11 @@ func Prune(ctx context.Context, options types.NetworkPruneCommandOptions, stdin } if len(removedNetworks) > 0 { - fmt.Fprintln(stdout, "Deleted Networks:") + fmt.Fprintln(options.Stdout, "Deleted Networks:") for _, name := range removedNetworks { - fmt.Fprintln(stdout, name) + fmt.Fprintln(options.Stdout, name) } - fmt.Fprintln(stdout, "") + fmt.Fprintln(options.Stdout, "") } return nil } diff --git a/pkg/cmd/network/remove.go b/pkg/cmd/network/remove.go index ffa5a2380fb..314d64dc36f 100644 --- a/pkg/cmd/network/remove.go +++ b/pkg/cmd/network/remove.go @@ -19,7 +19,6 @@ package network import ( "context" "fmt" - "io" "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" @@ -29,7 +28,7 @@ import ( "github.com/sirupsen/logrus" ) -func Remove(ctx context.Context, options types.NetworkRemoveCommandOptions, stdout io.Writer) error { +func Remove(ctx context.Context, options types.NetworkRemoveOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -63,7 +62,7 @@ func Remove(ctx context.Context, options types.NetworkRemoveCommandOptions, stdo if err := e.RemoveNetwork(found.Network); err != nil { return err } - fmt.Fprintln(stdout, found.Req) + fmt.Fprintln(options.Stdout, found.Req) return nil }, } diff --git a/pkg/cmd/volume/create.go b/pkg/cmd/volume/create.go index b42dd095c14..791ac514b81 100644 --- a/pkg/cmd/volume/create.go +++ b/pkg/cmd/volume/create.go @@ -18,14 +18,13 @@ package volume import ( "fmt" - "io" "github.com/containerd/containerd/identifiers" "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/strutil" ) -func Create(name string, options types.VolumeCreateCommandOptions, stdout io.Writer) error { +func Create(name string, options types.VolumeCreateOptions) error { if err := identifiers.Validate(name); err != nil { return fmt.Errorf("malformed name %s: %w", name, err) } @@ -37,6 +36,6 @@ func Create(name string, options types.VolumeCreateCommandOptions, stdout io.Wri if _, err := volStore.Create(name, labels); err != nil { return err } - fmt.Fprintf(stdout, "%s\n", name) + fmt.Fprintf(options.Stdout, "%s\n", name) return nil } diff --git a/pkg/cmd/volume/inspect.go b/pkg/cmd/volume/inspect.go index 7d1d4b75162..78221c6bd56 100644 --- a/pkg/cmd/volume/inspect.go +++ b/pkg/cmd/volume/inspect.go @@ -17,13 +17,11 @@ package volume import ( - "io" - "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/formatter" ) -func Inspect(volumes []string, options types.VolumeInspectCommandOptions, stdout io.Writer) error { +func Inspect(volumes []string, options types.VolumeInspectOptions) error { volStore, err := Store(options.GOptions.Namespace, options.GOptions.DataRoot, options.GOptions.Address) if err != nil { return err @@ -37,5 +35,5 @@ func Inspect(volumes []string, options types.VolumeInspectCommandOptions, stdout } result[i] = vol } - return formatter.FormatSlice(options.Format, stdout, result) + return formatter.FormatSlice(options.Format, options.Stdout, result) } diff --git a/pkg/cmd/volume/list.go b/pkg/cmd/volume/list.go index 79ffaac1b77..a026af5642c 100644 --- a/pkg/cmd/volume/list.go +++ b/pkg/cmd/volume/list.go @@ -20,7 +20,6 @@ import ( "bytes" "errors" "fmt" - "io" "strconv" "strings" "text/tabwriter" @@ -43,7 +42,7 @@ type volumePrintable struct { // TODO: "Links" } -func List(options types.VolumeListCommandOptions, stdout io.Writer) error { +func List(options types.VolumeListOptions) error { if options.Quiet && options.Size { logrus.Warn("cannot use --size and --quiet together, ignoring --size") options.Size = false @@ -68,7 +67,7 @@ func List(options types.VolumeListCommandOptions, stdout io.Writer) error { if err != nil { return err } - return lsPrintOutput(vols, options, stdout) + return lsPrintOutput(vols, options) } func hasSizeFilter(filters []string) bool { @@ -90,12 +89,12 @@ func removeSizeFilters(filters []string) []string { return res } -func lsPrintOutput(vols map[string]native.Volume, options types.VolumeListCommandOptions, stdout io.Writer) error { - w := stdout +func lsPrintOutput(vols map[string]native.Volume, options types.VolumeListOptions) error { + w := options.Stdout var tmpl *template.Template switch options.Format { case "", "table", "wide": - w = tabwriter.NewWriter(stdout, 4, 8, 4, ' ', 0) + w = tabwriter.NewWriter(w, 4, 8, 4, ' ', 0) if !options.Quiet { if options.Size { fmt.Fprintln(w, "VOLUME NAME\tDIRECTORY\tSIZE") diff --git a/pkg/cmd/volume/prune.go b/pkg/cmd/volume/prune.go index 44660abc1ed..dffc24f8d9b 100644 --- a/pkg/cmd/volume/prune.go +++ b/pkg/cmd/volume/prune.go @@ -19,20 +19,19 @@ package volume import ( "context" "fmt" - "io" "strings" "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" ) -func Prune(ctx context.Context, options types.VolumePruneCommandOptions, stdin io.Reader, stdout io.Writer) error { +func Prune(ctx context.Context, options types.VolumePruneOptions) error { if !options.Force { var confirm string msg := "This will remove all local volumes not used by at least one container." msg += "\nAre you sure you want to continue? [y/N] " - fmt.Fprintf(stdout, "WARNING! %s", msg) - fmt.Fscanf(stdin, "%s", &confirm) + fmt.Fprintf(options.Stdout, "WARNING! %s", msg) + fmt.Fscanf(options.Stdin, "%s", &confirm) if strings.ToLower(confirm) != "y" { return nil @@ -72,11 +71,11 @@ func Prune(ctx context.Context, options types.VolumePruneCommandOptions, stdin i return err } if len(removedNames) > 0 { - fmt.Fprintln(stdout, "Deleted Volumes:") + fmt.Fprintln(options.Stdout, "Deleted Volumes:") for _, name := range removedNames { - fmt.Fprintln(stdout, name) + fmt.Fprintln(options.Stdout, name) } - fmt.Fprintln(stdout, "") + fmt.Fprintln(options.Stdout, "") } return nil } diff --git a/pkg/cmd/volume/rm.go b/pkg/cmd/volume/rm.go index edcff0f33dc..f4eb02cc751 100644 --- a/pkg/cmd/volume/rm.go +++ b/pkg/cmd/volume/rm.go @@ -20,7 +20,6 @@ import ( "context" "encoding/json" "fmt" - "io" "github.com/containerd/containerd" "github.com/containerd/nerdctl/pkg/api/types" @@ -30,7 +29,7 @@ import ( "github.com/containerd/nerdctl/pkg/mountutil" ) -func Remove(ctx context.Context, volumes []string, options types.VolumeRemoveCommandOptions, stdout io.Writer) error { +func Remove(ctx context.Context, volumes []string, options types.VolumeRemoveOptions) error { client, ctx, cancel, err := clientutil.NewClient(ctx, options.GOptions.Namespace, options.GOptions.Address) if err != nil { return err @@ -66,7 +65,7 @@ func Remove(ctx context.Context, volumes []string, options types.VolumeRemoveCom return err } for _, name := range removedNames { - fmt.Fprintln(stdout, name) + fmt.Fprintln(options.Stdout, name) } return err }