diff --git a/cmd/nerdctl/build.go b/cmd/nerdctl/build.go index eb8b25723e7..7fa6e7a8822 100644 --- a/cmd/nerdctl/build.go +++ b/cmd/nerdctl/build.go @@ -30,6 +30,7 @@ import ( "github.com/containerd/containerd/errdefs" dockerreference "github.com/containerd/containerd/reference/docker" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/buildkitutil" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/defaults" @@ -77,7 +78,7 @@ If Dockerfile is not present and -f is not specified, it will look for Container return buildCommand } -func getBuildkitHost(cmd *cobra.Command) (string, error) { +func getBuildkitHost(cmd *cobra.Command, ns string) (string, error) { if cmd.Flags().Changed("buildkit-host") || os.Getenv("BUILDKIT_HOST") != "" { // If address is explicitly specified, use it. buildkitHost, err := cmd.Flags().GetString("buildkit-host") @@ -89,10 +90,6 @@ func getBuildkitHost(cmd *cobra.Command) (string, error) { } return buildkitHost, nil } - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return "", err - } return buildkitutil.GetBuildkitHost(ns) } @@ -126,18 +123,21 @@ func isImageSharable(buildkitHost string, namespace, uuid, snapshotter string, p } func buildAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } platform, err := cmd.Flags().GetStringSlice("platform") if err != nil { return err } platform = strutil.DedupeStrSlice(platform) - - buildkitHost, err := getBuildkitHost(cmd) + buildkitHost, err := getBuildkitHost(cmd, globalOptions.Namespace) if err != nil { return err } - buildctlBinary, buildctlArgs, needsLoading, metaFile, tags, cleanup, err := generateBuildctlArgs(cmd, buildkitHost, platform, args) + buildctlBinary, buildctlArgs, needsLoading, metaFile, tags, cleanup, err := generateBuildctlArgs(cmd, globalOptions, buildkitHost, platform, args) if err != nil { return err } @@ -176,7 +176,7 @@ func buildAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - if err = loadImage(buildctlStdout, cmd, platMC, quiet); err != nil { + if err = loadImage(buildctlStdout, cmd, globalOptions, platMC, quiet); err != nil { return err } } @@ -195,15 +195,7 @@ func buildAction(cmd *cobra.Command, args []string) error { return err } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if len(tags) > 1 { logrus.Debug("Found more than 1 tag") if err != nil { @@ -230,7 +222,7 @@ func buildAction(cmd *cobra.Command, args []string) error { return nil } -func generateBuildctlArgs(cmd *cobra.Command, buildkitHost string, platform, args []string) (buildCtlBinary string, +func generateBuildctlArgs(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, buildkitHost string, platform, args []string) (buildCtlBinary string, buildctlArgs []string, needsLoading bool, metaFile string, tags []string, cleanup func(), err error) { if len(args) < 1 { return "", nil, false, "", nil, nil, errors.New("context needs to be specified") @@ -249,15 +241,7 @@ func generateBuildctlArgs(cmd *cobra.Command, buildkitHost string, platform, arg if err != nil { return "", nil, false, "", nil, nil, err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return "", nil, false, "", nil, nil, err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return "", nil, false, "", nil, nil, err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if output == "" { if err != nil { return "", nil, false, "", nil, nil, err @@ -267,15 +251,7 @@ func generateBuildctlArgs(cmd *cobra.Command, buildkitHost string, platform, arg if err != nil { return "", nil, false, "", nil, nil, err } - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return "", nil, false, "", nil, nil, err - } - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return "", nil, false, "", nil, nil, err - } - sharable, err := isImageSharable(buildkitHost, ns, info.UUID, snapshotter, platform) + sharable, err := isImageSharable(buildkitHost, globalOptions.Namespace, info.UUID, globalOptions.Snapshotter, platform) if err != nil { return "", nil, false, "", nil, nil, err } diff --git a/cmd/nerdctl/builder.go b/cmd/nerdctl/builder.go index ba9d265ef8b..eea75696d4e 100644 --- a/cmd/nerdctl/builder.go +++ b/cmd/nerdctl/builder.go @@ -60,7 +60,11 @@ func newBuilderPruneCommand() *cobra.Command { } func builderPruneAction(cmd *cobra.Command, _ []string) error { - buildkitHost, err := getBuildkitHost(cmd) + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } + buildkitHost, err := getBuildkitHost(cmd, globalOptions.Namespace) if err != nil { return err } @@ -97,6 +101,10 @@ func newBuilderDebugCommand() *cobra.Command { } func builderDebugAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } if len(args) < 1 { return fmt.Errorf("context needs to be specified") } @@ -106,10 +114,9 @@ func builderDebugAction(cmd *cobra.Command, args []string) error { return err } buildgArgs := []string{"debug"} - debugLog, err := cmd.Flags().GetBool("debug") if err != nil { return err - } else if debugLog { + } else if globalOptions.Debug { buildgArgs = append([]string{"--debug"}, buildgArgs...) } diff --git a/cmd/nerdctl/commit.go b/cmd/nerdctl/commit.go index 2e84958c3f6..60f9505ed1b 100644 --- a/cmd/nerdctl/commit.go +++ b/cmd/nerdctl/commit.go @@ -48,23 +48,15 @@ func newCommitCommand() *cobra.Command { } func commitAction(cmd *cobra.Command, args []string) error { - opts, err := newCommitOpts(cmd, args) + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) - + opts, err := newCommitOpts(cmd, args) if err != nil { return err } + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/completion.go b/cmd/nerdctl/completion.go index 099d7c55476..aefc30b45da 100644 --- a/cmd/nerdctl/completion.go +++ b/cmd/nerdctl/completion.go @@ -28,15 +28,11 @@ import ( ) func shellCompleteImageNames(cmd *cobra.Command) ([]string, cobra.ShellCompDirective) { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return nil, cobra.ShellCompDirectiveError } - address, err := cmd.Flags().GetString("address") - if err != nil { - return nil, cobra.ShellCompDirectiveError - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return nil, cobra.ShellCompDirectiveError } @@ -55,15 +51,11 @@ func shellCompleteImageNames(cmd *cobra.Command) ([]string, cobra.ShellCompDirec } func shellCompleteContainerNames(cmd *cobra.Command, filterFunc func(containerd.ProcessStatus) bool) ([]string, cobra.ShellCompDirective) { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return nil, cobra.ShellCompDirectiveError } - address, err := cmd.Flags().GetString("address") - if err != nil { - return nil, cobra.ShellCompDirectiveError - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return nil, cobra.ShellCompDirectiveError } @@ -108,20 +100,16 @@ func shellCompleteContainerNames(cmd *cobra.Command, filterFunc func(containerd. // shellCompleteNetworkNames includes {"bridge","host","none"} func shellCompleteNetworkNames(cmd *cobra.Command, exclude []string) ([]string, cobra.ShellCompDirective) { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return nil, cobra.ShellCompDirectiveError + } excludeMap := make(map[string]struct{}, len(exclude)) for _, ex := range exclude { excludeMap[ex] = struct{}{} } - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return nil, cobra.ShellCompDirectiveError - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") - if err != nil { - return nil, cobra.ShellCompDirectiveError - } - e, err := netutil.NewCNIEnv(cniPath, cniNetconfpath) + e, err := netutil.NewCNIEnv(globalOptions.CNIPath, globalOptions.CNINetConfPath) if err != nil { return nil, cobra.ShellCompDirectiveError } @@ -144,7 +132,11 @@ func shellCompleteNetworkNames(cmd *cobra.Command, exclude []string) ([]string, } func shellCompleteVolumeNames(cmd *cobra.Command) ([]string, cobra.ShellCompDirective) { - vols, err := getVolumes(cmd) + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return nil, cobra.ShellCompDirectiveError + } + vols, err := getVolumes(cmd, globalOptions) if err != nil { return nil, cobra.ShellCompDirectiveError } diff --git a/cmd/nerdctl/compose.go b/cmd/nerdctl/compose.go index 1521e1d5fd4..3a5fbed9d50 100644 --- a/cmd/nerdctl/compose.go +++ b/cmd/nerdctl/compose.go @@ -24,6 +24,7 @@ import ( "github.com/containerd/containerd" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/platforms" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/composer" "github.com/containerd/nerdctl/pkg/composer/serviceparser" "github.com/containerd/nerdctl/pkg/cosignutil" @@ -80,7 +81,7 @@ func newComposeCommand() *cobra.Command { return composeCommand } -func getComposer(cmd *cobra.Command, client *containerd.Client) (*composer.Composer, error) { +func getComposer(cmd *cobra.Command, client *containerd.Client, globalOptions *types.GlobalCommandOptions) (*composer.Composer, error) { nerdctlCmd, nerdctlArgs := globalFlags(cmd) projectDirectory, err := cmd.Flags().GetString("project-directory") if err != nil { @@ -94,38 +95,17 @@ func getComposer(cmd *cobra.Command, client *containerd.Client) (*composer.Compo if err != nil { return nil, err } - debugFull, err := cmd.Flags().GetBool("debug-full") - if err != nil { - return nil, err - } + debugFull := globalOptions.DebugFull + snapshotter := globalOptions.Snapshotter files, err := cmd.Flags().GetStringArray("file") if err != nil { return nil, err } - insecure, err := cmd.Flags().GetBool("insecure-registry") - if err != nil { - return nil, err - } - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return nil, err - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") - if err != nil { - return nil, err - } - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return nil, err - } - hostsDirs, err := cmd.Flags().GetStringSlice("hosts-dir") - if err != nil { - return nil, err - } - experimental, err := cmd.Flags().GetBool("experimental") - if err != nil { - return nil, err - } + insecure := globalOptions.InsecureRegistry + cniPath := globalOptions.CNIPath + cniNetconfpath := globalOptions.CNINetConfPath + hostsDirs := globalOptions.HostsDir + experimental := globalOptions.Experimental o := composer.Options{ Project: projectName, @@ -156,7 +136,7 @@ func getComposer(cmd *cobra.Command, client *containerd.Client) (*composer.Compo return false, nil } - volStore, err := getVolumeStore(cmd) + volStore, err := getVolumeStore(globalOptions) if err != nil { return nil, err } diff --git a/cmd/nerdctl/compose_build.go b/cmd/nerdctl/compose_build.go index e02d39b2573..85184445767 100644 --- a/cmd/nerdctl/compose_build.go +++ b/cmd/nerdctl/compose_build.go @@ -38,34 +38,30 @@ func newComposeBuildCommand() *cobra.Command { } func composeBuildAction(cmd *cobra.Command, args []string) error { - buildArg, err := cmd.Flags().GetStringArray("build-arg") - if err != nil { - return err - } - noCache, err := cmd.Flags().GetBool("no-cache") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - progress, err := cmd.Flags().GetString("progress") + buildArg, err := cmd.Flags().GetStringArray("build-arg") if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") + noCache, err := cmd.Flags().GetBool("no-cache") if err != nil { return err } - address, err := cmd.Flags().GetString("address") + progress, err := cmd.Flags().GetString("progress") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_config.go b/cmd/nerdctl/compose_config.go index b98567020f8..4c4d7e17689 100644 --- a/cmd/nerdctl/compose_config.go +++ b/cmd/nerdctl/compose_config.go @@ -43,6 +43,10 @@ func newComposeConfigCommand() *cobra.Command { } func composeConfigAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } if len(args) != 0 { // TODO: support specifying service names as args return fmt.Errorf("arguments %v not supported", args) @@ -63,22 +67,14 @@ func composeConfigAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_create.go b/cmd/nerdctl/compose_create.go index c371beb26c4..d03b44e0d3a 100644 --- a/cmd/nerdctl/compose_create.go +++ b/cmd/nerdctl/compose_create.go @@ -41,6 +41,10 @@ func newComposeCreateCommand() *cobra.Command { } func composeCreateAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } build, err := cmd.Flags().GetBool("build") if err != nil { return err @@ -64,21 +68,13 @@ func composeCreateAction(cmd *cobra.Command, args []string) error { return errors.New("flag --force-recreate and --no-recreate cannot be specified together") } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_down.go b/cmd/nerdctl/compose_down.go index 8bbd0f06009..8d3f1a587a7 100644 --- a/cmd/nerdctl/compose_down.go +++ b/cmd/nerdctl/compose_down.go @@ -37,19 +37,15 @@ func newComposeDownCommand() *cobra.Command { } func composeDownAction(cmd *cobra.Command, args []string) error { - volumes, err := cmd.Flags().GetBool("volumes") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + volumes, err := cmd.Flags().GetBool("volumes") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -60,7 +56,7 @@ func composeDownAction(cmd *cobra.Command, args []string) error { } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_exec.go b/cmd/nerdctl/compose_exec.go index afe73db4739..7f92e6db919 100644 --- a/cmd/nerdctl/compose_exec.go +++ b/cmd/nerdctl/compose_exec.go @@ -50,6 +50,10 @@ func newComposeExecCommand() *cobra.Command { } func composeExecAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } interactive, err := cmd.Flags().GetBool("interactive") if err != nil { return err @@ -95,21 +99,13 @@ func composeExecAction(cmd *cobra.Command, args []string) error { return errors.New("currently flag -t and -d cannot be specified together (FIXME)") } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_images.go b/cmd/nerdctl/compose_images.go index 24fe5e99d34..136897686fd 100644 --- a/cmd/nerdctl/compose_images.go +++ b/cmd/nerdctl/compose_images.go @@ -47,25 +47,22 @@ func newComposeImagesCommand() *cobra.Command { } func composeImagesAction(cmd *cobra.Command, args []string) error { - quiet, err := cmd.Flags().GetBool("quiet") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + + quiet, err := cmd.Flags().GetBool("quiet") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } @@ -84,11 +81,7 @@ func composeImagesAction(cmd *cobra.Command, args []string) error { return printComposeImageIDs(ctx, containers) } - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return err - } - sn := client.SnapshotService(snapshotter) + sn := client.SnapshotService(globalOptions.Snapshotter) return printComposeImages(ctx, cmd, containers, sn) } diff --git a/cmd/nerdctl/compose_kill.go b/cmd/nerdctl/compose_kill.go index 27ed42a2fb7..8153aeb48e4 100644 --- a/cmd/nerdctl/compose_kill.go +++ b/cmd/nerdctl/compose_kill.go @@ -35,24 +35,20 @@ func newComposeKillCommand() *cobra.Command { } func composeKillAction(cmd *cobra.Command, args []string) error { - signal, err := cmd.Flags().GetString("signal") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + signal, err := cmd.Flags().GetString("signal") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_logs.go b/cmd/nerdctl/compose_logs.go index 26672de6b66..a5cd5a18df4 100644 --- a/cmd/nerdctl/compose_logs.go +++ b/cmd/nerdctl/compose_logs.go @@ -39,6 +39,10 @@ func newComposeLogsCommand() *cobra.Command { } func composeLogsAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } follow, err := cmd.Flags().GetBool("follow") if err != nil { return err @@ -59,22 +63,13 @@ func composeLogsAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_pause.go b/cmd/nerdctl/compose_pause.go index 3b3f4826fc8..9ad0fb6292f 100644 --- a/cmd/nerdctl/compose_pause.go +++ b/cmd/nerdctl/compose_pause.go @@ -40,21 +40,17 @@ func newComposePauseCommand() *cobra.Command { } func composePauseAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } @@ -106,21 +102,17 @@ func newComposeUnpauseCommand() *cobra.Command { } func composeUnpauseAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_port.go b/cmd/nerdctl/compose_port.go index a48d6c340ff..0efa45ed58a 100644 --- a/cmd/nerdctl/compose_port.go +++ b/cmd/nerdctl/compose_port.go @@ -41,6 +41,10 @@ func newComposePortCommand() *cobra.Command { } func composePortAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } index, err := cmd.Flags().GetInt("index") if err != nil { return err @@ -66,21 +70,13 @@ func composePortAction(cmd *cobra.Command, args []string) error { if port <= 0 { return fmt.Errorf("unexpected port: %d", port) } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_ps.go b/cmd/nerdctl/compose_ps.go index 467a31a0a4b..521aa6b6351 100644 --- a/cmd/nerdctl/compose_ps.go +++ b/cmd/nerdctl/compose_ps.go @@ -61,28 +61,24 @@ type composeContainerPrintable struct { } func composePsAction(cmd *cobra.Command, args []string) error { - format, err := cmd.Flags().GetString("format") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - if format != "json" && format != "" { - return fmt.Errorf("unsupported format %s, supported formats are: [json]", format) - } - namespace, err := cmd.Flags().GetString("namespace") + format, err := cmd.Flags().GetString("format") if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err + if format != "json" && format != "" { + return fmt.Errorf("unsupported format %s, supported formats are: [json]", format) } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_pull.go b/cmd/nerdctl/compose_pull.go index a2214357a94..479aaeb1445 100644 --- a/cmd/nerdctl/compose_pull.go +++ b/cmd/nerdctl/compose_pull.go @@ -35,21 +35,17 @@ func newComposePullCommand() *cobra.Command { } func composePullAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_push.go b/cmd/nerdctl/compose_push.go index 3337bd7013c..06def7aa175 100644 --- a/cmd/nerdctl/compose_push.go +++ b/cmd/nerdctl/compose_push.go @@ -34,21 +34,17 @@ func newComposePushCommand() *cobra.Command { } func composePushAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_restart.go b/cmd/nerdctl/compose_restart.go index a8a5e061ec0..e3f8b1012fe 100644 --- a/cmd/nerdctl/compose_restart.go +++ b/cmd/nerdctl/compose_restart.go @@ -35,6 +35,10 @@ func newComposeRestartCommand() *cobra.Command { } func composeRestartAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var opt composer.RestartOptions if cmd.Flags().Changed("timeout") { @@ -44,22 +48,13 @@ func composeRestartAction(cmd *cobra.Command, args []string) error { } opt.Timeout = &timeValue } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_rm.go b/cmd/nerdctl/compose_rm.go index dc555b2c351..6aefa0db0c1 100644 --- a/cmd/nerdctl/compose_rm.go +++ b/cmd/nerdctl/compose_rm.go @@ -40,6 +40,10 @@ func newComposeRemoveCommand() *cobra.Command { } func composeRemoveAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } force, err := cmd.Flags().GetBool("force") if err != nil { return err @@ -68,20 +72,12 @@ func composeRemoveAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_run.go b/cmd/nerdctl/compose_run.go index 0f0b64acf49..d654f3b7774 100644 --- a/cmd/nerdctl/compose_run.go +++ b/cmd/nerdctl/compose_run.go @@ -67,6 +67,10 @@ func newComposeRunCommand() *cobra.Command { } func composeRunAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } detach, err := cmd.Flags().GetBool("detach") if err != nil { return err @@ -163,21 +167,13 @@ func composeRunAction(cmd *cobra.Command, args []string) error { if tty && detach { return errors.New("currently flag -t and -d cannot be specified together (FIXME)") } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_start.go b/cmd/nerdctl/compose_start.go index 8faaecf17af..8ef82b53839 100644 --- a/cmd/nerdctl/compose_start.go +++ b/cmd/nerdctl/compose_start.go @@ -43,21 +43,17 @@ func newComposeStartCommand() *cobra.Command { } func composeStartAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_stop.go b/cmd/nerdctl/compose_stop.go index a437fa394f4..e85b8b68748 100644 --- a/cmd/nerdctl/compose_stop.go +++ b/cmd/nerdctl/compose_stop.go @@ -35,6 +35,10 @@ func newComposeStopCommand() *cobra.Command { } func composeStopAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var opt composer.StopOptions if cmd.Flags().Changed("timeout") { @@ -44,21 +48,13 @@ func composeStopAction(cmd *cobra.Command, args []string) error { } opt.Timeout = &timeValue } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_top.go b/cmd/nerdctl/compose_top.go index fcf40dec886..11a2c6b8a53 100644 --- a/cmd/nerdctl/compose_top.go +++ b/cmd/nerdctl/compose_top.go @@ -39,21 +39,18 @@ func newComposeTopCommand() *cobra.Command { } func composeTopAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/compose_up.go b/cmd/nerdctl/compose_up.go index bc415e5f24e..c44cdb6d2f5 100644 --- a/cmd/nerdctl/compose_up.go +++ b/cmd/nerdctl/compose_up.go @@ -48,6 +48,10 @@ func newComposeUpCommand() *cobra.Command { } func composeUpAction(cmd *cobra.Command, services []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } detach, err := cmd.Flags().GetBool("detach") if err != nil { return err @@ -99,22 +103,14 @@ func composeUpAction(cmd *cobra.Command, services []string) error { } scale[parts[0]] = uint64(replicas) } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - c, err := getComposer(cmd, client) + c, err := getComposer(cmd, client, globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/container_inspect.go b/cmd/nerdctl/container_inspect.go index 1798089e10f..8ba6b14f44c 100644 --- a/cmd/nerdctl/container_inspect.go +++ b/cmd/nerdctl/container_inspect.go @@ -53,15 +53,11 @@ func newContainerInspectCommand() *cobra.Command { } func containerInspectAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/container_prune.go b/cmd/nerdctl/container_prune.go index c8155fb7e8c..e8e15f431e5 100644 --- a/cmd/nerdctl/container_prune.go +++ b/cmd/nerdctl/container_prune.go @@ -23,6 +23,7 @@ import ( "strings" "github.com/containerd/containerd" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/sirupsen/logrus" "github.com/spf13/cobra" @@ -42,6 +43,10 @@ func newContainerPruneCommand() *cobra.Command { } func containerPruneAction(cmd *cobra.Command, _ []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } force, err := cmd.Flags().GetBool("force") if err != nil { return err @@ -58,25 +63,17 @@ func containerPruneAction(cmd *cobra.Command, _ []string) error { return nil } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - return containerPrune(ctx, cmd, client) + return containerPrune(ctx, cmd, globalOptions, client) } -func containerPrune(ctx context.Context, cmd *cobra.Command, client *containerd.Client) error { +func containerPrune(ctx context.Context, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, client *containerd.Client) error { containers, err := client.Containers(ctx) if err != nil { return err @@ -84,7 +81,7 @@ func containerPrune(ctx context.Context, cmd *cobra.Command, client *containerd. var deleted []string for _, container := range containers { - err = removeContainer(ctx, cmd, container, false, true) + err = removeContainer(ctx, cmd, globalOptions, container, false, true) if err == nil { deleted = append(deleted, container.ID()) continue diff --git a/cmd/nerdctl/create.go b/cmd/nerdctl/create.go index f93de4d0391..ab2e7f00307 100644 --- a/cmd/nerdctl/create.go +++ b/cmd/nerdctl/create.go @@ -51,28 +51,18 @@ func newCreateCommand() *cobra.Command { } func createAction(cmd *cobra.Command, args []string) error { - platform, err := cmd.Flags().GetString("platform") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - - experimental, err := cmd.Flags().GetBool("experimental") + platform, err := cmd.Flags().GetString("platform") if err != nil { return err } - - if (platform == "windows" || platform == "freebsd") && !experimental { + if (platform == "windows" || platform == "freebsd") && !globalOptions.Experimental { return fmt.Errorf("%s requires experimental mode to be enabled", platform) } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClientWithPlatform(cmd.Context(), namespace, address, platform) + client, ctx, cancel, err := clientutil.NewClientWithPlatform(cmd.Context(), globalOptions.Namespace, globalOptions.Address, platform) if err != nil { return err } @@ -83,7 +73,7 @@ func createAction(cmd *cobra.Command, args []string) error { return err } - container, gc, err := createContainer(ctx, cmd, client, args, platform, false, flagT, true) + container, gc, err := createContainer(ctx, cmd, globalOptions, client, args, platform, false, flagT, true) if err != nil { if gc != nil { gc() diff --git a/cmd/nerdctl/events.go b/cmd/nerdctl/events.go index e91c5584755..37eae290f9e 100644 --- a/cmd/nerdctl/events.go +++ b/cmd/nerdctl/events.go @@ -64,15 +64,11 @@ type Out struct { // eventsActions is from https://github.com/containerd/containerd/blob/v1.4.3/cmd/ctr/commands/events/events.go func eventsAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/exec.go b/cmd/nerdctl/exec.go index 7700998522c..ebc0e6fcf08 100644 --- a/cmd/nerdctl/exec.go +++ b/cmd/nerdctl/exec.go @@ -65,6 +65,10 @@ func newExecCommand() *cobra.Command { } func execAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } // simulate the behavior of double dash newArg := []string{} if len(args) >= 2 && args[1] == "--" { @@ -72,15 +76,7 @@ func execAction(cmd *cobra.Command, args []string) error { newArg = append(newArg, args[2:]...) args = newArg } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/flagutil.go b/cmd/nerdctl/flagutil.go new file mode 100644 index 00000000000..6e232cdfc8c --- /dev/null +++ b/cmd/nerdctl/flagutil.go @@ -0,0 +1,87 @@ +/* + Copyright The containerd Authors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package main + +import ( + "github.com/containerd/nerdctl/pkg/api/types" + "github.com/spf13/cobra" +) + +func processRootCmdFlags(cmd *cobra.Command) (*types.GlobalCommandOptions, error) { + debug, err := cmd.Flags().GetBool("debug") + if err != nil { + return nil, err + } + debugFull, err := cmd.Flags().GetBool("debug-full") + if err != nil { + return nil, err + } + address, err := cmd.Flags().GetString("address") + if err != nil { + return nil, err + } + namespace, err := cmd.Flags().GetString("namespace") + if err != nil { + return nil, err + } + snapshotter, err := cmd.Flags().GetString("snapshotter") + if err != nil { + return nil, err + } + cniPath, err := cmd.Flags().GetString("cni-path") + if err != nil { + return nil, err + } + cniConfigPath, err := cmd.Flags().GetString("cni-netconfpath") + if err != nil { + return nil, err + } + dataRoot, err := cmd.Flags().GetString("data-root") + if err != nil { + return nil, err + } + cgroupManager, err := cmd.Flags().GetString("cgroup-manager") + if err != nil { + return nil, err + } + insecureRegistry, err := cmd.Flags().GetBool("insecure-registry") + if err != nil { + return nil, err + } + hostsDir, err := cmd.Flags().GetStringSlice("hosts-dir") + if err != nil { + return nil, err + } + experimental, err := cmd.Flags().GetBool("experimental") + if err != nil { + return nil, err + } + return &types.GlobalCommandOptions{ + Debug: debug, + DebugFull: debugFull, + Address: address, + Namespace: namespace, + Snapshotter: snapshotter, + CNIPath: cniPath, + CNINetConfPath: cniConfigPath, + DataRoot: dataRoot, + CgroupManager: cgroupManager, + InsecureRegistry: insecureRegistry, + HostsDir: hostsDir, + Experimental: experimental, + }, nil +} diff --git a/cmd/nerdctl/history.go b/cmd/nerdctl/history.go index ffaadb3d903..70d2d178fd5 100644 --- a/cmd/nerdctl/history.go +++ b/cmd/nerdctl/history.go @@ -70,25 +70,16 @@ type historyPrintable struct { } func historyAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return err - } - walker := &imagewalker.ImageWalker{ Client: client, OnFound: func(ctx context.Context, found imagewalker.Found) error { @@ -119,7 +110,7 @@ func historyAction(cmd *cobra.Command, args []string) error { diffIDs := diffIDs[0 : layerCounter+1] chainID := identity.ChainID(diffIDs).String() - s := client.SnapshotService(snapshotter) + s := client.SnapshotService(globalOptions.Snapshotter) stat, err := s.Stat(ctx, chainID) if err != nil { return fmt.Errorf("failed to get stat: %w", err) diff --git a/cmd/nerdctl/image_convert.go b/cmd/nerdctl/image_convert.go index 6579fc43ed0..ccd45d5e911 100644 --- a/cmd/nerdctl/image_convert.go +++ b/cmd/nerdctl/image_convert.go @@ -30,6 +30,7 @@ import ( "github.com/containerd/containerd/images" "github.com/containerd/containerd/images/converter" "github.com/containerd/containerd/images/converter/uncompress" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" converterutil "github.com/containerd/nerdctl/pkg/imgutil/converter" "github.com/containerd/nerdctl/pkg/platformutil" @@ -119,6 +120,10 @@ func newImageConvertCommand() *cobra.Command { } func imageConvertAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var ( convertOpts = []converter.Opt{} ) @@ -178,15 +183,7 @@ func imageConvertAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -216,13 +213,13 @@ func imageConvertAction(cmd *cobra.Command, args []string) error { var convertType string switch { case estargz: - convertFunc, finalize, err = getESGZConverter(cmd) + convertFunc, finalize, err = getESGZConverter(cmd, globalOptions) if err != nil { return err } convertType = "estargz" case zstdchunked: - convertFunc, err = getZstdchunkedConverter(cmd) + convertFunc, err = getZstdchunkedConverter(cmd, globalOptions) if err != nil { return err } @@ -238,7 +235,7 @@ func imageConvertAction(cmd *cobra.Command, args []string) error { convertOpts = append(convertOpts, converter.WithIndexConvertFunc(convertFunc)) convertType = "overlaybd" case nydus: - nydusOpts, err := getNydusConvertOpts(cmd) + nydusOpts, err := getNydusConvertOpts(cmd, globalOptions) if err != nil { return err } @@ -314,12 +311,7 @@ func imageConvertAction(cmd *cobra.Command, args []string) error { return printConvertedImage(cmd, res) } -func getESGZConverter(cmd *cobra.Command) (convertFunc converter.ConvertFunc, finalize func(ctx context.Context, cs content.Store, ref string, desc *ocispec.Descriptor) (*images.Image, error), _ error) { - experimental, err := cmd.Flags().GetBool("experimental") - if err != nil { - return nil, nil, err - } - +func getESGZConverter(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) (convertFunc converter.ConvertFunc, finalize func(ctx context.Context, cs content.Store, ref string, desc *ocispec.Descriptor) (*images.Image, error), _ error) { externalTOC, err := cmd.Flags().GetBool("estargz-external-toc") if err != nil { return nil, nil, err @@ -328,7 +320,7 @@ func getESGZConverter(cmd *cobra.Command) (convertFunc converter.ConvertFunc, fi if err != nil { return nil, nil, err } - if externalTOC && !experimental { + if externalTOC && !globalOptions.Experimental { return nil, nil, fmt.Errorf("estargz-external-toc requires experimental mode to be enabled") } if keepDiffID && !externalTOC { @@ -340,7 +332,7 @@ func getESGZConverter(cmd *cobra.Command) (convertFunc converter.ConvertFunc, fi return nil, nil, err } if !keepDiffID { - esgzOpts, err := getESGZConvertOpts(cmd) + esgzOpts, err := getESGZConvertOpts(cmd, globalOptions) if err != nil { return nil, nil, err } @@ -361,7 +353,7 @@ func getESGZConverter(cmd *cobra.Command) (convertFunc converter.ConvertFunc, fi }) } } else { - esgzOpts, err := getESGZConvertOpts(cmd) + esgzOpts, err := getESGZConvertOpts(cmd, globalOptions) if err != nil { return nil, nil, err } @@ -370,7 +362,7 @@ func getESGZConverter(cmd *cobra.Command) (convertFunc converter.ConvertFunc, fi return convertFunc, finalize, nil } -func getESGZConvertOpts(cmd *cobra.Command) ([]estargz.Option, error) { +func getESGZConvertOpts(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) ([]estargz.Option, error) { estargzCompressionLevel, err := cmd.Flags().GetInt("estargz-compression-level") if err != nil { return nil, err @@ -394,13 +386,8 @@ func getESGZConvertOpts(cmd *cobra.Command) ([]estargz.Option, error) { estargz.WithMinChunkSize(estargzMinChunkSize), } - experimental, err := cmd.Flags().GetBool("experimental") - if err != nil { - return nil, err - } - if estargzRecordIn != "" { - if !experimental { + if !globalOptions.Experimental { return nil, fmt.Errorf("estargz-record-in requires experimental mode to be enabled") } @@ -416,7 +403,7 @@ func getESGZConvertOpts(cmd *cobra.Command) ([]estargz.Option, error) { return esgzOpts, nil } -func getZstdchunkedConverter(cmd *cobra.Command) (converter.ConvertFunc, error) { +func getZstdchunkedConverter(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) (converter.ConvertFunc, error) { zstdchunkedCompressionLevel, err := cmd.Flags().GetInt("zstdchunked-compression-level") if err != nil { return nil, err @@ -434,13 +421,8 @@ func getZstdchunkedConverter(cmd *cobra.Command) (converter.ConvertFunc, error) estargz.WithChunkSize(zstdchunkedChunkSize), } - experimental, err := cmd.Flags().GetBool("experimental") - if err != nil { - return nil, err - } - if zstdchunkedRecordIn != "" { - if !experimental { + if !globalOptions.Experimental { return nil, fmt.Errorf("zstdchunked-record-in requires experimental mode to be enabled") } @@ -456,7 +438,7 @@ func getZstdchunkedConverter(cmd *cobra.Command) (converter.ConvertFunc, error) return zstdchunkedconvert.LayerConvertFuncWithCompressionLevel(zstd.EncoderLevelFromZstd(zstdchunkedCompressionLevel), esgzOpts...), nil } -func getNydusConvertOpts(cmd *cobra.Command) (*nydusconvert.PackOption, error) { +func getNydusConvertOpts(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) (*nydusconvert.PackOption, error) { builderPath, err := cmd.Flags().GetString("nydus-builder-path") if err != nil { return nil, err @@ -465,16 +447,8 @@ func getNydusConvertOpts(cmd *cobra.Command) (*nydusconvert.PackOption, error) { if err != nil { return nil, err } - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return nil, err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return nil, err - } if workDir == "" { - workDir, err = clientutil.DataStore(dataRoot, address) + workDir, err = clientutil.DataStore(globalOptions.DataRoot, globalOptions.Address) if err != nil { return nil, err } diff --git a/cmd/nerdctl/image_cryptutil.go b/cmd/nerdctl/image_cryptutil.go index 3b406bf7eae..6f4254b1bad 100644 --- a/cmd/nerdctl/image_cryptutil.go +++ b/cmd/nerdctl/image_cryptutil.go @@ -99,6 +99,10 @@ func parseImgcryptFlags(cmd *cobra.Command, encrypt bool) (parsehelpers.EncArgs, func getImgcryptAction(encrypt bool) func(cmd *cobra.Command, args []string) error { return func(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var convertOpts = []converter.Opt{} srcRawRef := args[0] targetRawRef := args[1] @@ -136,15 +140,7 @@ func getImgcryptAction(encrypt bool) func(cmd *cobra.Command, args []string) err if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/image_inspect.go b/cmd/nerdctl/image_inspect.go index a3c9fa5c540..908d3e548a5 100644 --- a/cmd/nerdctl/image_inspect.go +++ b/cmd/nerdctl/image_inspect.go @@ -23,6 +23,7 @@ import ( "github.com/containerd/containerd" "github.com/containerd/containerd/platforms" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/formatter" "github.com/containerd/nerdctl/pkg/idutil/imagewalker" @@ -61,14 +62,19 @@ func newImageInspectCommand() *cobra.Command { } func imageInspectAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } platform, err := cmd.Flags().GetString("platform") if err != nil { return err } - return imageInspectActionWithPlatform(cmd, args, platform) + return imageInspectActionWithPlatform(cmd, args, platform, globalOptions) } -func imageInspectActionWithPlatform(cmd *cobra.Command, args []string, platform string) error { +func imageInspectActionWithPlatform(cmd *cobra.Command, args []string, platform string, globalOptions *types.GlobalCommandOptions) error { + var clientOpts []containerd.ClientOpt if platform != "" { platformParsed, err := platforms.Parse(platform) @@ -78,15 +84,7 @@ func imageInspectActionWithPlatform(cmd *cobra.Command, args []string, platform platformM := platforms.Only(platformParsed) clientOpts = append(clientOpts, containerd.WithDefaultPlatform(platformM)) } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address, clientOpts...) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address, clientOpts...) if err != nil { return err } diff --git a/cmd/nerdctl/image_prune.go b/cmd/nerdctl/image_prune.go index 2715c13b015..8b682466b0f 100644 --- a/cmd/nerdctl/image_prune.go +++ b/cmd/nerdctl/image_prune.go @@ -46,6 +46,10 @@ func newImagePruneCommand() *cobra.Command { } func imagePruneAction(cmd *cobra.Command, _ []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } all, err := cmd.Flags().GetBool("all") if err != nil { return err @@ -74,15 +78,7 @@ func imagePruneAction(cmd *cobra.Command, _ []string) error { return nil } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/images.go b/cmd/nerdctl/images.go index 39e2a96ef6a..72f634d5269 100644 --- a/cmd/nerdctl/images.go +++ b/cmd/nerdctl/images.go @@ -37,6 +37,7 @@ import ( "github.com/containerd/containerd/platforms" dockerreference "github.com/containerd/containerd/reference/docker" "github.com/containerd/containerd/snapshots" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/formatter" "github.com/containerd/nerdctl/pkg/imgutil" @@ -89,6 +90,10 @@ Properties: } func imagesAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var filters []string if len(args) > 0 { @@ -99,15 +104,7 @@ func imagesAction(cmd *cobra.Command, args []string) error { filters = append(filters, fmt.Sprintf("name==%s", canonicalRef.String())) filters = append(filters, fmt.Sprintf("name==%s", args[0])) } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -159,7 +156,7 @@ func imagesAction(cmd *cobra.Command, args []string) error { imageList = imgutil.FilterImages(imageList, beforeImages, sinceImages) } - return printImages(ctx, cmd, client, imageList) + return printImages(ctx, cmd, globalOptions, client, imageList) } func filterByReference(imageList []images.Image, filters []string) ([]images.Image, error) { @@ -245,7 +242,7 @@ type imagePrintable struct { Platform string // nerdctl extension } -func printImages(ctx context.Context, cmd *cobra.Command, client *containerd.Client, imageList []images.Image) error { +func printImages(ctx context.Context, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, client *containerd.Client, imageList []images.Image) error { quiet, err := cmd.Flags().GetBool("quiet") if err != nil { return err @@ -301,11 +298,6 @@ func printImages(ctx context.Context, cmd *cobra.Command, client *containerd.Cli } } - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return err - } - printer := &imagePrinter{ w: w, quiet: quiet, @@ -315,7 +307,7 @@ func printImages(ctx context.Context, cmd *cobra.Command, client *containerd.Cli tmpl: tmpl, client: client, contentStore: client.ContentStore(), - snapshotter: client.SnapshotService(snapshotter), + snapshotter: client.SnapshotService(globalOptions.Snapshotter), } for _, img := range imageList { diff --git a/cmd/nerdctl/info.go b/cmd/nerdctl/info.go index 99488a0fc96..8a16aacffcf 100644 --- a/cmd/nerdctl/info.go +++ b/cmd/nerdctl/info.go @@ -23,6 +23,7 @@ import ( "strings" "text/template" + "github.com/containerd/nerdctl/pkg/api/types" "golang.org/x/text/cases" "golang.org/x/text/language" @@ -60,9 +61,12 @@ func newInfoCommand() *cobra.Command { } func infoAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var ( tmpl *template.Template - err error ) format, err := cmd.Flags().GetString("format") if err != nil { @@ -74,15 +78,7 @@ func infoAction(cmd *cobra.Command, args []string) error { return err } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -103,20 +99,12 @@ func infoAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - infoNative, err = fulfillNativeInfo(cmd, di) + infoNative, err = fulfillNativeInfo(cmd, di, globalOptions) if err != nil { return err } case "dockercompat": - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return err - } - cgroupManager, err := cmd.Flags().GetString("cgroup-manager") - if err != nil { - return err - } - infoCompat, err = infoutil.Info(ctx, client, snapshotter, cgroupManager) + infoCompat, err = infoutil.Info(ctx, client, globalOptions.Snapshotter, globalOptions.CgroupManager) if err != nil { return err } @@ -141,29 +129,18 @@ func infoAction(cmd *cobra.Command, args []string) error { case "native": return prettyPrintInfoNative(cmd.OutOrStdout(), infoNative) case "dockercompat": - return prettyPrintInfoDockerCompat(cmd, infoCompat) + return prettyPrintInfoDockerCompat(cmd, infoCompat, globalOptions) } return nil } -func fulfillNativeInfo(cmd *cobra.Command, di *native.DaemonInfo) (*native.Info, error) { +func fulfillNativeInfo(cmd *cobra.Command, di *native.DaemonInfo, globalOptions *types.GlobalCommandOptions) (*native.Info, error) { info := &native.Info{ Daemon: di, } - flags := cmd.Flags() - var err error - info.Namespace, err = flags.GetString("namespace") - if err != nil { - return nil, err - } - info.Snapshotter, err = flags.GetString("snapshotter") - if err != nil { - return nil, err - } - info.CgroupManager, err = flags.GetString("cgroup-manager") - if err != nil { - return nil, err - } + info.Namespace = globalOptions.Namespace + info.Snapshotter = globalOptions.Snapshotter + info.CgroupManager = globalOptions.CgroupManager info.Rootless = rootlessutil.IsRootless() return info, nil } @@ -201,19 +178,11 @@ func prettyPrintInfoNative(w io.Writer, info *native.Info) error { return nil } -func prettyPrintInfoDockerCompat(cmd *cobra.Command, info *dockercompat.Info) error { +func prettyPrintInfoDockerCompat(cmd *cobra.Command, info *dockercompat.Info, globalOptions *types.GlobalCommandOptions) error { w := cmd.OutOrStdout() - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - debug, err := cmd.Flags().GetBool("debug") - if err != nil { - return err - } - + debug := globalOptions.Debug fmt.Fprintf(w, "Client:\n") - fmt.Fprintf(w, " Namespace:\t%s\n", namespace) + fmt.Fprintf(w, " Namespace:\t%s\n", globalOptions.Namespace) fmt.Fprintf(w, " Debug Mode:\t%v\n", debug) fmt.Fprintf(w, "\n") fmt.Fprintf(w, "Server:\n") diff --git a/cmd/nerdctl/inspect.go b/cmd/nerdctl/inspect.go index 9482362ed38..d12fb65d423 100644 --- a/cmd/nerdctl/inspect.go +++ b/cmd/nerdctl/inspect.go @@ -64,6 +64,12 @@ func addInspectFlags(cmd *cobra.Command) { } func inspectAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } + namespace := globalOptions.Namespace + address := globalOptions.Address inspectType, err := cmd.Flags().GetString("type") if err != nil { return err @@ -72,14 +78,6 @@ func inspectAction(cmd *cobra.Command, args []string) error { if len(inspectType) > 0 && !validInspectType[inspectType] { return fmt.Errorf("%q is not a valid value for --type", inspectType) } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) if err != nil { return err @@ -129,7 +127,7 @@ func inspectAction(cmd *cobra.Command, args []string) error { continue } if ni != 0 { - if err := imageInspectActionWithPlatform(cmd, []string{req}, ""); err != nil { + if err := imageInspectActionWithPlatform(cmd, []string{req}, "", globalOptions); err != nil { errs = append(errs, err) } continue diff --git a/cmd/nerdctl/internal_oci_hook.go b/cmd/nerdctl/internal_oci_hook.go index be4a45a9fe6..e75b32b66a7 100644 --- a/cmd/nerdctl/internal_oci_hook.go +++ b/cmd/nerdctl/internal_oci_hook.go @@ -38,33 +38,23 @@ func newInternalOCIHookCommandCommand() *cobra.Command { } func internalOCIHookAction(cmd *cobra.Command, args []string) error { - event := "" - if len(args) > 0 { - event = args[0] - } - dataRoot, err := cmd.Flags().GetString("data-root") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err + event := "" + if len(args) > 0 { + event = args[0] } if event == "" { return errors.New("event type needs to be passed") } - dataStore, err := clientutil.DataStore(dataRoot, address) - if err != nil { - return err - } - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return err - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") + dataStore, err := clientutil.DataStore(globalOptions.DataRoot, globalOptions.Address) if err != nil { return err } + cniPath := globalOptions.CNIPath + cniNetconfpath := globalOptions.CNINetConfPath return ocihook.Run(os.Stdin, os.Stderr, event, dataStore, cniPath, diff --git a/cmd/nerdctl/kill.go b/cmd/nerdctl/kill.go index 8cc7fbd25f4..f6593be2581 100644 --- a/cmd/nerdctl/kill.go +++ b/cmd/nerdctl/kill.go @@ -49,6 +49,10 @@ func newKillCommand() *cobra.Command { } func killAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } killSignal, err := cmd.Flags().GetString("signal") if err != nil { return err @@ -61,15 +65,7 @@ func killAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/load.go b/cmd/nerdctl/load.go index 1bd57799cb2..28c3d0de9f1 100644 --- a/cmd/nerdctl/load.go +++ b/cmd/nerdctl/load.go @@ -27,6 +27,7 @@ import ( "github.com/containerd/containerd/images" "github.com/containerd/containerd/images/archive" "github.com/containerd/containerd/platforms" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/platformutil" "github.com/spf13/cobra" @@ -61,6 +62,10 @@ func loadAction(cmd *cobra.Command, _ []string) error { if err != nil { return err } + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } if input != "" { f, err := os.Open(input) if err != nil { @@ -96,33 +101,21 @@ func loadAction(cmd *cobra.Command, _ []string) error { return err } - return loadImage(decompressor, cmd, platMC, false) + return loadImage(decompressor, cmd, globalOptions, platMC, false) } -func loadImage(in io.Reader, cmd *cobra.Command, platMC platforms.MatchComparer, quiet bool) error { +func loadImage(in io.Reader, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, platMC platforms.MatchComparer, quiet bool) error { // In addition to passing WithImagePlatform() to client.Import(), we also need to pass WithDefaultPlatform() to NewClient(). // Otherwise unpacking may fail. - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address, containerd.WithDefaultPlatform(platMC)) - if err != nil { - return err - } - defer cancel() - sn, err := cmd.Flags().GetString("snapshotter") + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address, containerd.WithDefaultPlatform(platMC)) if err != nil { return err } + defer cancel() r := &readCounter{Reader: in} - imgs, err := client.Import(ctx, r, containerd.WithDigestRef(archive.DigestTranslator(sn)), containerd.WithSkipDigestRef(func(name string) bool { return name != "" }), containerd.WithImportPlatform(platMC)) + imgs, err := client.Import(ctx, r, containerd.WithDigestRef(archive.DigestTranslator(globalOptions.Snapshotter)), containerd.WithSkipDigestRef(func(name string) bool { return name != "" }), containerd.WithImportPlatform(platMC)) if err != nil { if r.N == 0 { // Avoid confusing "unrecognized image format" @@ -140,7 +133,7 @@ func loadImage(in io.Reader, cmd *cobra.Command, platMC platforms.MatchComparer, if !quiet { fmt.Fprintf(cmd.OutOrStdout(), "unpacking %s (%s)...\n", img.Name, img.Target.Digest) } - err = image.Unpack(ctx, sn) + err = image.Unpack(ctx, globalOptions.Snapshotter) if err != nil { return err } diff --git a/cmd/nerdctl/login.go b/cmd/nerdctl/login.go index 78d954411eb..cc99ef4247a 100644 --- a/cmd/nerdctl/login.go +++ b/cmd/nerdctl/login.go @@ -30,6 +30,7 @@ import ( "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/remotes/docker" dockerconfig "github.com/containerd/containerd/remotes/docker/config" + ncTypes "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/errutil" "github.com/containerd/nerdctl/pkg/imgutil/dockerconfigresolver" dockercliconfig "github.com/docker/cli/cli/config" @@ -85,7 +86,10 @@ func loginAction(cmd *cobra.Command, args []string) error { } var serverAddress string - + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } if options.serverAddress == "" { serverAddress = dockerconfigresolver.IndexServer } else { @@ -102,7 +106,7 @@ func loginAction(cmd *cobra.Command, args []string) error { } if err == nil && authConfig.Username != "" && authConfig.Password != "" { //login With StoreCreds - responseIdentityToken, err = loginClientSide(ctx, cmd, *authConfig) + responseIdentityToken, err = loginClientSide(ctx, cmd, globalOptions, *authConfig) } if err != nil || authConfig.Username == "" || authConfig.Password == "" { @@ -111,7 +115,7 @@ func loginAction(cmd *cobra.Command, args []string) error { return err } - responseIdentityToken, err = loginClientSide(ctx, cmd, *authConfig) + responseIdentityToken, err = loginClientSide(ctx, cmd, globalOptions, *authConfig) if err != nil { return err } @@ -202,25 +206,17 @@ func GetDefaultAuthConfig(checkCredStore bool, serverAddress string, isDefaultRe return &res, nil } -func loginClientSide(ctx context.Context, cmd *cobra.Command, auth types.AuthConfig) (string, error) { +func loginClientSide(ctx context.Context, cmd *cobra.Command, globalOptions *ncTypes.GlobalCommandOptions, auth types.AuthConfig) (string, error) { host, err := convertToHostname(auth.ServerAddress) if err != nil { return "", err } var dOpts []dockerconfigresolver.Opt - insecure, err := cmd.Flags().GetBool("insecure-registry") - if err != nil { - return "", err - } - if insecure { + if globalOptions.InsecureRegistry { logrus.Warnf("skipping verifying HTTPS certs for %q", host) dOpts = append(dOpts, dockerconfigresolver.WithSkipVerifyCerts(true)) } - hostsDirs, err := cmd.Flags().GetStringSlice("hosts-dir") - if err != nil { - return "", err - } - dOpts = append(dOpts, dockerconfigresolver.WithHostsDirs(hostsDirs)) + dOpts = append(dOpts, dockerconfigresolver.WithHostsDirs(globalOptions.HostsDir)) authCreds := func(acArg string) (string, string, error) { if acArg == host { @@ -255,7 +251,7 @@ func loginClientSide(ctx context.Context, cmd *cobra.Command, auth types.AuthCon } for i, rh := range regHosts { err = tryLoginWithRegHost(ctx, rh) - if err != nil && insecure && (errutil.IsErrHTTPResponseToHTTPSClient(err) || errutil.IsErrConnectionRefused(err)) { + if err != nil && globalOptions.InsecureRegistry && (errutil.IsErrHTTPResponseToHTTPSClient(err) || errutil.IsErrConnectionRefused(err)) { rh.Scheme = "http" err = tryLoginWithRegHost(ctx, rh) } diff --git a/cmd/nerdctl/logs.go b/cmd/nerdctl/logs.go index a3345800e0c..83efe359a46 100644 --- a/cmd/nerdctl/logs.go +++ b/cmd/nerdctl/logs.go @@ -52,32 +52,20 @@ func newLogsCommand() *cobra.Command { } func logsAction(cmd *cobra.Command, args []string) error { - dataRoot, err := cmd.Flags().GetString("data-root") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - dataStore, err := clientutil.DataStore(dataRoot, address) + dataStore, err := clientutil.DataStore(globalOptions.DataRoot, globalOptions.Address) if err != nil { return err } - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - switch ns { + switch globalOptions.Namespace { case "moby", "k8s.io": logrus.Warn("Currently, `nerdctl logs` only supports containers created with `nerdctl run -d`") } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/main.go b/cmd/nerdctl/main.go index 31df5be1a31..91b7cfac355 100644 --- a/cmd/nerdctl/main.go +++ b/cmd/nerdctl/main.go @@ -174,6 +174,7 @@ func initRootCmdFlags(rootCmd *cobra.Command, tomlPath string) (*pflag.FlagSet, } func newApp() (*cobra.Command, error) { + tomlPath := ncdefaults.NerdctlTOML() if v, ok := os.LookupEnv("NERDCTL_TOML"); ok { tomlPath = v @@ -201,27 +202,22 @@ Config file ($NERDCTL_TOML): %s } rootCmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error { - debug, err := cmd.Flags().GetBool("debug-full") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } + debug := globalOptions.DebugFull if !debug { - debug, err = cmd.Flags().GetBool("debug") - if err != nil { - return err - } + debug = globalOptions.Debug } if debug { logrus.SetLevel(logrus.DebugLevel) } - address := cmd.Flags().Lookup("address").Value.String() + address := globalOptions.Address if strings.Contains(address, "://") && !strings.HasPrefix(address, "unix://") { return fmt.Errorf("invalid address %q", address) } - cgroupManager, err := cmd.Flags().GetString("cgroup-manager") - if err != nil { - return err - } + cgroupManager := globalOptions.CgroupManager if runtime.GOOS == "linux" { switch cgroupManager { case "systemd", "cgroupfs", "none": @@ -585,11 +581,11 @@ func AddPersistentStringArrayFlag(cmd *cobra.Command, name string, aliases, nonP func checkExperimental(feature string) func(cmd *cobra.Command, args []string) error { return func(cmd *cobra.Command, args []string) error { - experimental, err := cmd.Flags().GetBool("experimental") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - if !experimental { + if !globalOptions.Experimental { return fmt.Errorf("%s is experimental feature, you should enable experimental config", feature) } return nil diff --git a/cmd/nerdctl/main_unix.go b/cmd/nerdctl/main_unix.go index 6bbdcd14ccb..f0b6ca25830 100644 --- a/cmd/nerdctl/main_unix.go +++ b/cmd/nerdctl/main_unix.go @@ -27,19 +27,18 @@ import ( ) func shellCompleteNamespaceNames(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return nil, cobra.ShellCompDirectiveError + } if rootlessutil.IsRootlessParent() { _ = rootlessutil.ParentMain() return nil, cobra.ShellCompDirectiveNoFileComp } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return nil, cobra.ShellCompDirectiveNoFileComp - } - address, err := cmd.Flags().GetString("address") if err != nil { return nil, cobra.ShellCompDirectiveNoFileComp } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return nil, cobra.ShellCompDirectiveError } @@ -56,19 +55,15 @@ func shellCompleteNamespaceNames(cmd *cobra.Command, args []string, toComplete s } func shellCompleteSnapshotterNames(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { - if rootlessutil.IsRootlessParent() { - _ = rootlessutil.ParentMain() - return nil, cobra.ShellCompDirectiveNoFileComp - } - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { - return nil, cobra.ShellCompDirectiveNoFileComp + return nil, cobra.ShellCompDirectiveError } - address, err := cmd.Flags().GetString("address") - if err != nil { + if rootlessutil.IsRootlessParent() { + _ = rootlessutil.ParentMain() return nil, cobra.ShellCompDirectiveNoFileComp } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return nil, cobra.ShellCompDirectiveError } diff --git a/cmd/nerdctl/namespace.go b/cmd/nerdctl/namespace.go index d167a92fd8a..6ede2e28aa3 100644 --- a/cmd/nerdctl/namespace.go +++ b/cmd/nerdctl/namespace.go @@ -63,15 +63,11 @@ func newNamespaceLsCommand() *cobra.Command { } func namespaceLsAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -92,11 +88,7 @@ func namespaceLsAction(cmd *cobra.Command, args []string) error { } return nil } - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return err - } - dataStore, err := clientutil.DataStore(dataRoot, address) + dataStore, err := clientutil.DataStore(globalOptions.DataRoot, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/namespace_create.go b/cmd/nerdctl/namespace_create.go index 5d592ae5952..922190b3196 100644 --- a/cmd/nerdctl/namespace_create.go +++ b/cmd/nerdctl/namespace_create.go @@ -37,19 +37,15 @@ func newNamespaceCreateCommand() *cobra.Command { } func namespaceCreateAction(cmd *cobra.Command, args []string) error { - flagVSlice, err := cmd.Flags().GetStringArray("label") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + flagVSlice, err := cmd.Flags().GetStringArray("label") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/namespace_inspect.go b/cmd/nerdctl/namespace_inspect.go index 330f593b7b5..e571616bae1 100644 --- a/cmd/nerdctl/namespace_inspect.go +++ b/cmd/nerdctl/namespace_inspect.go @@ -41,15 +41,11 @@ func newNamespaceInspectCommand() *cobra.Command { } func labelInspectAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/namespace_rm.go b/cmd/nerdctl/namespace_rm.go index db81d470759..db1b315a59a 100644 --- a/cmd/nerdctl/namespace_rm.go +++ b/cmd/nerdctl/namespace_rm.go @@ -40,16 +40,12 @@ func newNamespaceRmCommand() *cobra.Command { } func namespaceRmAction(cmd *cobra.Command, args []string) error { - var exitErr error - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + var exitErr error + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/namespace_update.go b/cmd/nerdctl/namespace_update.go index c82301994b4..b879a200271 100644 --- a/cmd/nerdctl/namespace_update.go +++ b/cmd/nerdctl/namespace_update.go @@ -35,19 +35,15 @@ func newNamespacelabelUpdateCommand() *cobra.Command { } func labelUpdateAction(cmd *cobra.Command, args []string) error { - flagVSlice, err := cmd.Flags().GetStringArray("label") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + flagVSlice, err := cmd.Flags().GetStringArray("label") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/network_create.go b/cmd/nerdctl/network_create.go index 9d7328fc3f6..530f6bf640c 100644 --- a/cmd/nerdctl/network_create.go +++ b/cmd/nerdctl/network_create.go @@ -51,15 +51,14 @@ func newNetworkCreateCommand() *cobra.Command { } func networkCreateAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } name := args[0] if err := identifiers.Validate(name); err != nil { return fmt.Errorf("malformed name %s: %w", name, err) } - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return err - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") if err != nil { return err } @@ -103,7 +102,7 @@ func networkCreateAction(cmd *cobra.Command, args []string) error { } } - e, err := netutil.NewCNIEnv(cniPath, cniNetconfpath) + e, err := netutil.NewCNIEnv(globalOptions.CNIPath, globalOptions.CNINetConfPath) if err != nil { return err } diff --git a/cmd/nerdctl/network_inspect.go b/cmd/nerdctl/network_inspect.go index 95e2731a534..55a59c545dd 100644 --- a/cmd/nerdctl/network_inspect.go +++ b/cmd/nerdctl/network_inspect.go @@ -50,15 +50,11 @@ func newNetworkInspectCommand() *cobra.Command { } func networkInspectAction(cmd *cobra.Command, args []string) error { - cniPath, err := cmd.Flags().GetString("cni-path") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") - if err != nil { - return err - } - e, err := netutil.NewCNIEnv(cniPath, cniNetconfpath) + e, err := netutil.NewCNIEnv(globalOptions.CNIPath, globalOptions.CNINetConfPath) if err != nil { return err } diff --git a/cmd/nerdctl/network_ls.go b/cmd/nerdctl/network_ls.go index 1a9793f6f84..69afedf3c26 100644 --- a/cmd/nerdctl/network_ls.go +++ b/cmd/nerdctl/network_ls.go @@ -57,6 +57,10 @@ type networkPrintable struct { } func networkLsAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } quiet, err := cmd.Flags().GetBool("quiet") if err != nil { return err @@ -86,15 +90,7 @@ func networkLsAction(cmd *cobra.Command, args []string) error { } } - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return err - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") - if err != nil { - return err - } - e, err := netutil.NewCNIEnv(cniPath, cniNetconfpath) + e, err := netutil.NewCNIEnv(globalOptions.CNIPath, globalOptions.CNINetConfPath) if err != nil { return err } diff --git a/cmd/nerdctl/network_prune.go b/cmd/nerdctl/network_prune.go index 5426b7d3e21..e1190b51a3f 100644 --- a/cmd/nerdctl/network_prune.go +++ b/cmd/nerdctl/network_prune.go @@ -22,6 +22,7 @@ import ( "strings" "github.com/containerd/containerd" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/netutil" "github.com/containerd/nerdctl/pkg/strutil" @@ -45,6 +46,10 @@ func newNetworkPruneCommand() *cobra.Command { } func networkPruneAction(cmd *cobra.Command, _ []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } force, err := cmd.Flags().GetBool("force") if err != nil { return err @@ -62,33 +67,17 @@ func networkPruneAction(cmd *cobra.Command, _ []string) error { return nil } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - return networkPrune(ctx, cmd, client) + return networkPrune(ctx, cmd, client, globalOptions) } -func networkPrune(ctx context.Context, cmd *cobra.Command, client *containerd.Client) error { - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return err - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") - if err != nil { - return err - } - e, err := netutil.NewCNIEnv(cniPath, cniNetconfpath) +func networkPrune(ctx context.Context, cmd *cobra.Command, client *containerd.Client, globalOptions *types.GlobalCommandOptions) error { + e, err := netutil.NewCNIEnv(globalOptions.CNIPath, globalOptions.CNINetConfPath) if err != nil { return err } diff --git a/cmd/nerdctl/network_rm.go b/cmd/nerdctl/network_rm.go index 5e85bdf0d7d..16786b1a7dc 100644 --- a/cmd/nerdctl/network_rm.go +++ b/cmd/nerdctl/network_rm.go @@ -44,28 +44,16 @@ func newNetworkRmCommand() *cobra.Command { } func networkRmAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return err - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") - if err != nil { - return err - } - e, err := netutil.NewCNIEnv(cniPath, cniNetconfpath) + e, err := netutil.NewCNIEnv(globalOptions.CNIPath, globalOptions.CNINetConfPath) if err != nil { return err } diff --git a/cmd/nerdctl/pause.go b/cmd/nerdctl/pause.go index effc7bd9a61..5d51191bd45 100644 --- a/cmd/nerdctl/pause.go +++ b/cmd/nerdctl/pause.go @@ -42,15 +42,11 @@ func newPauseCommand() *cobra.Command { } func pauseAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/port.go b/cmd/nerdctl/port.go index b5429df587b..e2fb467f000 100644 --- a/cmd/nerdctl/port.go +++ b/cmd/nerdctl/port.go @@ -43,7 +43,10 @@ func newPortCommand() *cobra.Command { } func portAction(cmd *cobra.Command, args []string) error { - + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } argPort := -1 argProto := "" portProto := "" @@ -70,15 +73,7 @@ func portAction(cmd *cobra.Command, args []string) error { return fmt.Errorf("failed to parse %q", portProto) } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/ps.go b/cmd/nerdctl/ps.go index 8028ff086f0..b18bc23f7a8 100644 --- a/cmd/nerdctl/ps.go +++ b/cmd/nerdctl/ps.go @@ -69,15 +69,11 @@ func newPsCommand() *cobra.Command { } func psAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/pull.go b/cmd/nerdctl/pull.go index 8c52315491e..363a97e27bc 100644 --- a/cmd/nerdctl/pull.go +++ b/cmd/nerdctl/pull.go @@ -22,6 +22,7 @@ import ( "fmt" "github.com/containerd/containerd" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/cosignutil" "github.com/containerd/nerdctl/pkg/imgutil" @@ -70,16 +71,12 @@ func newPullCommand() *cobra.Command { } func pullAction(cmd *cobra.Command, args []string) error { - rawRef := args[0] - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + rawRef := args[0] + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -110,7 +107,7 @@ func pullAction(cmd *cobra.Command, args []string) error { return err } - _, err = ensureImage(ctx, cmd, client, rawRef, ocispecPlatforms, "always", unpack, quiet) + _, err = ensureImage(ctx, cmd, globalOptions, client, rawRef, ocispecPlatforms, "always", unpack, quiet) if err != nil { return err } @@ -118,22 +115,10 @@ func pullAction(cmd *cobra.Command, args []string) error { return nil } -func ensureImage(ctx context.Context, cmd *cobra.Command, client *containerd.Client, rawRef string, ocispecPlatforms []v1.Platform, - pull string, unpack *bool, quiet bool) (*imgutil.EnsuredImage, error) { +func ensureImage(ctx context.Context, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, client *containerd.Client, rawRef string, ocispecPlatforms []v1.Platform, pull string, unpack *bool, quiet bool) (*imgutil.EnsuredImage, error) { var ensured *imgutil.EnsuredImage - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return nil, err - } - insecureRegistry, err := cmd.Flags().GetBool("insecure-registry") - if err != nil { - return nil, err - } - hostsDirs, err := cmd.Flags().GetStringSlice("hosts-dir") - if err != nil { - return nil, err - } + verifier, err := cmd.Flags().GetString("verify") if err != nil { return nil, err @@ -144,7 +129,7 @@ func ensureImage(ctx context.Context, cmd *cobra.Command, client *containerd.Cli return nil, errors.New("--verify flag is not supported on IPFS as of now") } - ensured, err = ipfs.EnsureImage(ctx, client, cmd.OutOrStdout(), cmd.ErrOrStderr(), snapshotter, scheme, ref, + ensured, err = ipfs.EnsureImage(ctx, client, cmd.OutOrStdout(), cmd.ErrOrStderr(), globalOptions.Snapshotter, scheme, ref, pull, ocispecPlatforms, unpack, quiet) if err != nil { return nil, err @@ -155,10 +140,7 @@ func ensureImage(ctx context.Context, cmd *cobra.Command, client *containerd.Cli ref := rawRef switch verifier { case "cosign": - experimental, err := cmd.Flags().GetBool("experimental") - if err != nil { - return nil, err - } + experimental := globalOptions.Experimental if !experimental { return nil, fmt.Errorf("cosign only work with enable experimental feature") @@ -169,7 +151,7 @@ func ensureImage(ctx context.Context, cmd *cobra.Command, client *containerd.Cli return nil, err } - ref, err = cosignutil.VerifyCosign(ctx, rawRef, keyRef, hostsDirs) + ref, err = cosignutil.VerifyCosign(ctx, rawRef, keyRef, globalOptions.HostsDir) if err != nil { return nil, err } @@ -179,8 +161,8 @@ func ensureImage(ctx context.Context, cmd *cobra.Command, client *containerd.Cli return nil, fmt.Errorf("no verifier found: %s", verifier) } - ensured, err = imgutil.EnsureImage(ctx, client, cmd.OutOrStdout(), cmd.ErrOrStderr(), snapshotter, ref, - pull, insecureRegistry, hostsDirs, ocispecPlatforms, unpack, quiet) + ensured, err = imgutil.EnsureImage(ctx, client, cmd.OutOrStdout(), cmd.ErrOrStderr(), globalOptions.Snapshotter, ref, + pull, globalOptions.InsecureRegistry, globalOptions.HostsDir, ocispecPlatforms, unpack, quiet) if err != nil { return nil, err } diff --git a/cmd/nerdctl/push.go b/cmd/nerdctl/push.go index 79b2adf6e22..d11188bb4d4 100644 --- a/cmd/nerdctl/push.go +++ b/cmd/nerdctl/push.go @@ -84,16 +84,12 @@ func newPushCommand() *cobra.Command { } func pushAction(cmd *cobra.Command, args []string) error { - rawRef := args[0] - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + rawRef := args[0] + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -159,11 +155,6 @@ func pushAction(cmd *cobra.Command, args []string) error { ref := named.String() refDomain := refdocker.Domain(named) - insecure, err := cmd.Flags().GetBool("insecure-registry") - if err != nil { - return err - } - platMC, err := platformutil.NewMatchComparer(allPlatforms, platform) if err != nil { return err @@ -203,15 +194,11 @@ func pushAction(cmd *cobra.Command, args []string) error { } var dOpts []dockerconfigresolver.Opt - if insecure { + if globalOptions.InsecureRegistry { logrus.Warnf("skipping verifying HTTPS certs for %q", refDomain) dOpts = append(dOpts, dockerconfigresolver.WithSkipVerifyCerts(true)) } - hostsDirs, err := cmd.Flags().GetStringSlice("hosts-dir") - if err != nil { - return err - } - dOpts = append(dOpts, dockerconfigresolver.WithHostsDirs(hostsDirs)) + dOpts = append(dOpts, dockerconfigresolver.WithHostsDirs(globalOptions.HostsDir)) resolver, err := dockerconfigresolver.New(ctx, refDomain, dOpts...) if err != nil { return err @@ -221,7 +208,7 @@ func pushAction(cmd *cobra.Command, args []string) error { if !errutil.IsErrHTTPResponseToHTTPSClient(err) && !errutil.IsErrConnectionRefused(err) { return err } - if insecure { + if globalOptions.InsecureRegistry { logrus.WithError(err).Warnf("server %q does not seem to support HTTPS, falling back to plain HTTP", refDomain) dOpts = append(dOpts, dockerconfigresolver.WithPlainHTTP(true)) resolver, err = dockerconfigresolver.New(ctx, refDomain, dOpts...) @@ -242,12 +229,8 @@ func pushAction(cmd *cobra.Command, args []string) error { } switch signer { case "cosign": - experimental, err := cmd.Flags().GetBool("experimental") - if err != nil { - return err - } - if !experimental { + if !globalOptions.Experimental { return fmt.Errorf("cosign only work with enable experimental feature") } diff --git a/cmd/nerdctl/rename.go b/cmd/nerdctl/rename.go index 5a71a57041c..40716a79a00 100644 --- a/cmd/nerdctl/rename.go +++ b/cmd/nerdctl/rename.go @@ -43,32 +43,20 @@ func newRenameCommand() *cobra.Command { } func renameAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return err - } - dataStore, err := clientutil.DataStore(dataRoot, address) + dataStore, err := clientutil.DataStore(globalOptions.DataRoot, globalOptions.Address) if err != nil { return err } - namest, err := namestore.New(dataStore, ns) + namest, err := namestore.New(dataStore, globalOptions.Namespace) if err != nil { return err } @@ -82,7 +70,7 @@ func renameAction(cmd *cobra.Command, args []string) error { if found.MatchCount > 1 { return fmt.Errorf("multiple IDs found with provided prefix: %s", found.Req) } - return renameContainer(ctx, found.Container, args[1], ns, namest, hostst) + return renameContainer(ctx, found.Container, args[1], globalOptions.Namespace, namest, hostst) }, } req := args[0] diff --git a/cmd/nerdctl/restart.go b/cmd/nerdctl/restart.go index 972efb9bd2c..f6dc8fedcc7 100644 --- a/cmd/nerdctl/restart.go +++ b/cmd/nerdctl/restart.go @@ -42,6 +42,10 @@ func newRestartCommand() *cobra.Command { func restartAction(cmd *cobra.Command, args []string) error { // Time to wait after sending a SIGTERM and before sending a SIGKILL. + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var timeout *time.Duration if cmd.Flags().Changed("time") { timeValue, err := cmd.Flags().GetUint("time") @@ -51,15 +55,7 @@ func restartAction(cmd *cobra.Command, args []string) error { t := time.Duration(timeValue) * time.Second timeout = &t } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/rm.go b/cmd/nerdctl/rm.go index 6a2d61952ce..b07677642c0 100644 --- a/cmd/nerdctl/rm.go +++ b/cmd/nerdctl/rm.go @@ -27,6 +27,7 @@ import ( "github.com/containerd/containerd/cio" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/namespaces" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/dnsutil/hostsstore" "github.com/containerd/nerdctl/pkg/idutil/containerwalker" @@ -58,23 +59,19 @@ type statusError struct { } func rmAction(cmd *cobra.Command, args []string) error { - force, err := cmd.Flags().GetBool("force") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - removeAnonVolumes, err := cmd.Flags().GetBool("volumes") - if err != nil { - return err - } - namespace, err := cmd.Flags().GetString("namespace") + force, err := cmd.Flags().GetBool("force") if err != nil { return err } - address, err := cmd.Flags().GetString("address") + removeAnonVolumes, err := cmd.Flags().GetBool("volumes") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -86,7 +83,7 @@ func rmAction(cmd *cobra.Command, args []string) error { if found.MatchCount > 1 { return fmt.Errorf("multiple IDs found with provided prefix: %s", found.Req) } - if err := removeContainer(ctx, cmd, found.Container, force, removeAnonVolumes); err != nil { + if err := removeContainer(ctx, cmd, globalOptions, found.Container, force, removeAnonVolumes); err != nil { return err } _, err = fmt.Fprintf(cmd.OutOrStdout(), "%s\n", found.Req) @@ -109,12 +106,11 @@ func rmAction(cmd *cobra.Command, args []string) error { return nil } -func removeContainer(ctx context.Context, cmd *cobra.Command, container containerd.Container, force bool, removeAnonVolumes bool) (retErr error) { +func removeContainer(ctx context.Context, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, container containerd.Container, force bool, removeAnonVolumes bool) (retErr error) { ns, err := namespaces.NamespaceRequired(ctx) if err != nil { return err } - id := container.ID() l, err := container.Labels(ctx) if err != nil { @@ -122,15 +118,7 @@ func removeContainer(ctx context.Context, cmd *cobra.Command, container containe } stateDir := l[labels.StateDir] name := l[labels.Name] - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - dataStore, err := clientutil.DataStore(dataRoot, address) + dataStore, err := clientutil.DataStore(globalOptions.DataRoot, globalOptions.Address) if err != nil { return err } @@ -164,7 +152,7 @@ func removeContainer(ctx context.Context, cmd *cobra.Command, container containe if err := json.Unmarshal([]byte(anonVolumesJSON), &anonVolumes); err != nil { return err } - volStore, err := getVolumeStore(cmd) + volStore, err := getVolumeStore(globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/rmi.go b/cmd/nerdctl/rmi.go index b32604dbcf8..c1814289f7a 100644 --- a/cmd/nerdctl/rmi.go +++ b/cmd/nerdctl/rmi.go @@ -47,6 +47,10 @@ func newRmiCommand() *cobra.Command { } func rmiAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } force, err := cmd.Flags().GetBool("force") if err != nil { return err @@ -58,15 +62,7 @@ func rmiAction(cmd *cobra.Command, args []string) error { } else if !async { delOpts = append(delOpts, images.SynchronousDelete()) } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/run.go b/cmd/nerdctl/run.go index dff4f65d85f..f3f99404066 100644 --- a/cmd/nerdctl/run.go +++ b/cmd/nerdctl/run.go @@ -39,6 +39,7 @@ import ( "github.com/containerd/containerd/containers" "github.com/containerd/containerd/oci" gocni "github.com/containerd/go-cni" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/defaults" "github.com/containerd/nerdctl/pkg/idgen" @@ -278,19 +279,15 @@ func setCreateFlags(cmd *cobra.Command) { // runAction is heavily based on ctr implementation: // https://github.com/containerd/containerd/blob/v1.4.3/cmd/ctr/commands/run/run.go func runAction(cmd *cobra.Command, args []string) error { - platform, err := cmd.Flags().GetString("platform") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") + platform, err := cmd.Flags().GetString("platform") if err != nil { return err } - client, ctx, cancel, err := clientutil.NewClientWithPlatform(cmd.Context(), namespace, address, platform) + client, ctx, cancel, err := clientutil.NewClientWithPlatform(cmd.Context(), globalOptions.Namespace, globalOptions.Address, platform) if err != nil { return err } @@ -308,7 +305,7 @@ func runAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - container, gc, err := createContainer(ctx, cmd, client, args, platform, flagI, flagT, flagD) + container, gc, err := createContainer(ctx, cmd, globalOptions, client, args, platform, flagI, flagT, flagD) if err != nil { if gc != nil { defer gc() @@ -326,7 +323,7 @@ func runAction(cmd *cobra.Command, args []string) error { return errors.New("flag -d and --rm cannot be specified together") } defer func() { - if err := removeContainer(ctx, cmd, container, true, true); err != nil { + if err := removeContainer(ctx, cmd, globalOptions, container, true, true); err != nil { logrus.WithError(err).Warnf("failed to remove container %s", id) } }() @@ -396,7 +393,7 @@ func runAction(cmd *cobra.Command, args []string) error { } // FIXME: split to smaller functions -func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd.Client, args []string, platform string, flagI, flagT, flagD bool) (containerd.Container, func(), error) { +func createContainer(ctx context.Context, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, client *containerd.Client, args []string, platform string, flagI, flagT, flagD bool) (containerd.Container, func(), error) { // simulate the behavior of double dash newArg := []string{} if len(args) >= 2 && args[1] == "--" { @@ -407,11 +404,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd var internalLabels internalLabels internalLabels.platform = platform - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return nil, nil, err - } - internalLabels.namespace = ns + internalLabels.namespace = globalOptions.Namespace var ( opts []oci.SpecOpts @@ -428,20 +421,12 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd return nil, nil, err } } - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return nil, nil, err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return nil, nil, err - } - dataStore, err := clientutil.DataStore(dataRoot, address) + dataStore, err := clientutil.DataStore(globalOptions.DataRoot, globalOptions.Address) if err != nil { return nil, nil, err } - stateDir, err := getContainerStateDirPath(cmd, dataStore, id) + stateDir, err := getContainerStateDirPath(cmd, globalOptions, dataStore, id) if err != nil { return nil, nil, err } @@ -454,13 +439,13 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd oci.WithDefaultSpec(), ) - platformOpts, err := setPlatformOptions(ctx, cmd, client, id, &internalLabels) + platformOpts, err := setPlatformOptions(ctx, cmd, globalOptions, client, id, &internalLabels) if err != nil { return nil, nil, err } opts = append(opts, platformOpts...) - rootfsOpts, rootfsCOpts, ensuredImage, err := generateRootfsOpts(ctx, client, platform, cmd, args, id) + rootfsOpts, rootfsCOpts, ensuredImage, err := generateRootfsOpts(ctx, client, platform, cmd, globalOptions, args, id) if err != nil { return nil, nil, err } @@ -499,7 +484,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd opts = append(opts, oci.WithTTY) } - mountOpts, anonVolumes, mountPoints, err := generateMountOpts(ctx, cmd, client, ensuredImage) + mountOpts, anonVolumes, mountPoints, err := generateMountOpts(ctx, cmd, globalOptions, client, ensuredImage) if err != nil { return nil, nil, err } @@ -533,7 +518,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd if err != nil { return nil, nil, err } - if err := logDriverInst.Init(dataStore, ns, id); err != nil { + if err := logDriverInst.Init(dataStore, globalOptions.Namespace, id); err != nil { return nil, nil, err } logConfig := &logging.LogConfig{ @@ -544,7 +529,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd if err != nil { return nil, nil, err } - logConfigFilePath := logging.LogConfigFilePath(dataStore, ns, id) + logConfigFilePath := logging.LogConfigFilePath(dataStore, globalOptions.Namespace, id) if err = os.WriteFile(logConfigFilePath, logConfigB, 0600); err != nil { return nil, nil, err } @@ -610,7 +595,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd } } - netOpts, netSlice, ipAddress, ports, macAddress, err := generateNetOpts(cmd, dataStore, stateDir, ns, id) + netOpts, netSlice, ipAddress, ports, macAddress, err := generateNetOpts(cmd, globalOptions, dataStore, stateDir, globalOptions.Namespace, id) if err != nil { return nil, nil, err } @@ -644,7 +629,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd } opts = append(opts, umaskOpts...) - rtCOpts, err := generateRuntimeCOpts(cmd) + rtCOpts, err := generateRuntimeCOpts(cmd, globalOptions) if err != nil { return nil, nil, err } @@ -670,7 +655,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd name = referenceutil.SuggestContainerName(imageRef, id) } if name != "" { - containerNameStore, err = namestore.New(dataStore, ns) + containerNameStore, err = namestore.New(dataStore, globalOptions.Namespace) if err != nil { return nil, nil, err } @@ -722,7 +707,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd } if name != "" { var errE error - if containerNameStore, errE = namestore.New(dataStore, ns); errE != nil { + if containerNameStore, errE = namestore.New(dataStore, globalOptions.Namespace); errE != nil { isErr = true } if errE = containerNameStore.Release(name, id); errE != nil { @@ -739,7 +724,7 @@ func createContainer(ctx context.Context, cmd *cobra.Command, client *containerd return container, nil, nil } -func generateRootfsOpts(ctx context.Context, client *containerd.Client, platform string, cmd *cobra.Command, args []string, id string) ([]oci.SpecOpts, []containerd.NewContainerOpts, *imgutil.EnsuredImage, error) { +func generateRootfsOpts(ctx context.Context, client *containerd.Client, platform string, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, args []string, id string) ([]oci.SpecOpts, []containerd.NewContainerOpts, *imgutil.EnsuredImage, error) { var ( ensured *imgutil.EnsuredImage err error @@ -762,7 +747,7 @@ func generateRootfsOpts(ctx context.Context, client *containerd.Client, platform return nil, nil, nil, err } rawRef := args[0] - ensured, err = ensureImage(ctx, cmd, client, rawRef, ocispecPlatforms, pull, nil, false) + ensured, err = ensureImage(ctx, cmd, globalOptions, client, rawRef, ocispecPlatforms, pull, nil, false) if err != nil { return nil, nil, nil, err } @@ -959,18 +944,15 @@ func withNerdctlOCIHook(cmd *cobra.Command, id string) (oci.SpecOpts, error) { }, nil } -func getContainerStateDirPath(cmd *cobra.Command, dataStore, id string) (string, error) { - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return "", err - } - if ns == "" { +func getContainerStateDirPath(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, dataStore, id string) (string, error) { + + if globalOptions.Namespace == "" { return "", errors.New("namespace is required") } - if strings.Contains(ns, "/") { + if strings.Contains(globalOptions.Namespace, "/") { return "", errors.New("namespace with '/' is unsupported") } - return filepath.Join(dataStore, "containers", ns, id), nil + return filepath.Join(dataStore, "containers", globalOptions.Namespace, id), nil } func withContainerLabels(cmd *cobra.Command) ([]containerd.NewContainerOpts, error) { diff --git a/cmd/nerdctl/run_cgroup_linux.go b/cmd/nerdctl/run_cgroup_linux.go index 9bd10ef264f..492ade2550a 100644 --- a/cmd/nerdctl/run_cgroup_linux.go +++ b/cmd/nerdctl/run_cgroup_linux.go @@ -25,6 +25,7 @@ import ( "github.com/containerd/containerd/containers" "github.com/containerd/containerd/oci" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/infoutil" "github.com/containerd/nerdctl/pkg/rootlessutil" "github.com/docker/go-units" @@ -39,11 +40,7 @@ type customMemoryOptions struct { disableOOMKiller *bool } -func generateCgroupOpts(cmd *cobra.Command, id string) ([]oci.SpecOpts, error) { - cgroupManager, err := cmd.Flags().GetString("cgroup-manager") - if err != nil { - return nil, err - } +func generateCgroupOpts(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, id string) ([]oci.SpecOpts, error) { cpus, err := cmd.Flags().GetFloat64("cpus") if err != nil { return nil, err @@ -92,7 +89,7 @@ func generateCgroupOpts(cmd *cobra.Command, id string) ([]oci.SpecOpts, error) { return nil, err } - if cgroupManager == "none" { + if globalOptions.CgroupManager == "none" { if !rootlessutil.IsRootless() { return nil, errors.New(`cgroup-manager "none" is only supported for rootless`) } @@ -109,7 +106,7 @@ func generateCgroupOpts(cmd *cobra.Command, id string) ([]oci.SpecOpts, error) { } var opts []oci.SpecOpts // nolint: prealloc - path, err := generateCgroupPath(cmd, cgroupManager, parent, id) + path, err := generateCgroupPath(cmd, globalOptions.CgroupManager, parent, id) if err != nil { return nil, err } @@ -249,7 +246,7 @@ func generateCgroupOpts(cmd *cobra.Command, id string) ([]oci.SpecOpts, error) { if err != nil { return nil, err } - if blkioWeight != 0 && !infoutil.BlockIOWeight(cgroupManager) { + if blkioWeight != 0 && !infoutil.BlockIOWeight(globalOptions.CgroupManager) { logrus.Warn("kernel support for cgroup blkio weight missing, weight discarded") blkioWeight = 0 } diff --git a/cmd/nerdctl/run_freebsd.go b/cmd/nerdctl/run_freebsd.go index 56d658a8064..41471036ad9 100644 --- a/cmd/nerdctl/run_freebsd.go +++ b/cmd/nerdctl/run_freebsd.go @@ -22,6 +22,7 @@ import ( "github.com/containerd/containerd" "github.com/containerd/containerd/containers" "github.com/containerd/containerd/oci" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/spf13/cobra" ) @@ -42,6 +43,7 @@ func runShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]s func setPlatformOptions( ctx context.Context, cmd *cobra.Command, + _ *types.GlobalCommandOptions, client *containerd.Client, id string, internalLabels *internalLabels, diff --git a/cmd/nerdctl/run_linux.go b/cmd/nerdctl/run_linux.go index 58ddd7b053a..0cc2bd3b4e5 100644 --- a/cmd/nerdctl/run_linux.go +++ b/cmd/nerdctl/run_linux.go @@ -26,6 +26,7 @@ import ( "github.com/containerd/containerd/oci" "github.com/containerd/containerd/pkg/cap" "github.com/containerd/containerd/pkg/userns" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/bypass4netnsutil" "github.com/containerd/nerdctl/pkg/idutil/containerwalker" "github.com/containerd/nerdctl/pkg/rootlessutil" @@ -57,13 +58,7 @@ func runShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]s return nil, cobra.ShellCompDirectiveNoFileComp } -func setPlatformOptions( - ctx context.Context, - cmd *cobra.Command, - client *containerd.Client, - id string, - internalLabels *internalLabels, -) ([]oci.SpecOpts, error) { +func setPlatformOptions(ctx context.Context, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, client *containerd.Client, id string, internalLabels *internalLabels) ([]oci.SpecOpts, error) { var opts []oci.SpecOpts opts = append(opts, oci.WithDefaultUnixDevices, @@ -75,7 +70,7 @@ func setPlatformOptions( {Type: "cgroup", Source: "cgroup", Destination: "/sys/fs/cgroup", Options: []string{"ro", "nosuid", "noexec", "nodev"}}, })) - cgOpts, err := generateCgroupOpts(cmd, id) + cgOpts, err := generateCgroupOpts(cmd, globalOptions, id) if err != nil { return nil, err } diff --git a/cmd/nerdctl/run_mount.go b/cmd/nerdctl/run_mount.go index d9837a131ea..6c46c8937ea 100644 --- a/cmd/nerdctl/run_mount.go +++ b/cmd/nerdctl/run_mount.go @@ -30,6 +30,7 @@ import ( "github.com/containerd/containerd/mount" "github.com/containerd/containerd/oci" "github.com/containerd/continuity/fs" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/idgen" "github.com/containerd/nerdctl/pkg/imgutil" "github.com/containerd/nerdctl/pkg/mountutil" @@ -120,8 +121,8 @@ func parseMountFlags(cmd *cobra.Command, volStore volumestore.VolumeStore) ([]*m // generateMountOpts generates volume-related mount opts. // Other mounts such as procfs mount are not handled here. -func generateMountOpts(ctx context.Context, cmd *cobra.Command, client *containerd.Client, ensuredImage *imgutil.EnsuredImage) ([]oci.SpecOpts, []string, []*mountutil.Processed, error) { - volStore, err := getVolumeStore(cmd) +func generateMountOpts(ctx context.Context, cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, client *containerd.Client, ensuredImage *imgutil.EnsuredImage) ([]oci.SpecOpts, []string, []*mountutil.Processed, error) { + volStore, err := getVolumeStore(globalOptions) if err != nil { return nil, nil, nil, err } @@ -136,16 +137,10 @@ func generateMountOpts(ctx context.Context, cmd *cobra.Command, client *containe mounted := make(map[string]struct{}) var imageVolumes map[string]struct{} var tempDir string - if ensuredImage != nil { imageVolumes = ensuredImage.ImageConfig.Volumes - snapshotter, err := cmd.Flags().GetString("snapshotter") - if err != nil { - return nil, nil, nil, err - } - - if err := ensuredImage.Image.Unpack(ctx, snapshotter); err != nil { + if err := ensuredImage.Image.Unpack(ctx, globalOptions.Snapshotter); err != nil { return nil, nil, nil, fmt.Errorf("error unpacking image: %w", err) } @@ -155,7 +150,7 @@ func generateMountOpts(ctx context.Context, cmd *cobra.Command, client *containe } chainID := identity.ChainID(diffIDs).String() - s := client.SnapshotService(snapshotter) + s := client.SnapshotService(globalOptions.Snapshotter) tempDir, err = os.MkdirTemp("", "initialC") if err != nil { return nil, nil, nil, err diff --git a/cmd/nerdctl/run_network.go b/cmd/nerdctl/run_network.go index c205be5fe03..d2f6bba7bb7 100644 --- a/cmd/nerdctl/run_network.go +++ b/cmd/nerdctl/run_network.go @@ -30,6 +30,7 @@ import ( "github.com/containerd/containerd/containers" "github.com/containerd/containerd/oci" gocni "github.com/containerd/go-cni" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/dnsutil" "github.com/containerd/nerdctl/pkg/dnsutil/hostsstore" @@ -112,7 +113,7 @@ func withCustomHosts(src string) func(context.Context, oci.Client, *containers.C } } -func generateNetOpts(cmd *cobra.Command, dataStore, stateDir, ns, id string) ([]oci.SpecOpts, []string, string, []gocni.PortMapping, string, error) { +func generateNetOpts(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, dataStore, stateDir, ns, id string) ([]oci.SpecOpts, []string, string, []gocni.PortMapping, string, error) { opts := []oci.SpecOpts{} portSlice, err := cmd.Flags().GetStringSlice("publish") if err != nil { @@ -155,7 +156,7 @@ func generateNetOpts(cmd *cobra.Command, dataStore, stateDir, ns, id string) ([] case nettype.CNI: // We only verify flags and generate resolv.conf here. // The actual network is configured in the oci hook. - if err := verifyCNINetwork(cmd, netSlice, macAddress); err != nil { + if err := verifyCNINetwork(cmd, netSlice, macAddress, globalOptions); err != nil { return nil, nil, "", nil, "", err } @@ -191,15 +192,7 @@ func generateNetOpts(cmd *cobra.Command, dataStore, stateDir, ns, id string) ([] return nil, nil, "", nil, "", fmt.Errorf("invalid network: %s, should be \"container:\"", netSlice[0]) } containerName := network[1] - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return nil, nil, "", nil, "", err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return nil, nil, "", nil, "", err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return nil, nil, "", nil, "", err } @@ -213,7 +206,7 @@ func generateNetOpts(cmd *cobra.Command, dataStore, stateDir, ns, id string) ([] } containerID := found.Container.ID() - conStateDir, err := getContainerStateDirPath(cmd, dataStore, containerID) + conStateDir, err := getContainerStateDirPath(cmd, globalOptions, dataStore, containerID) if err != nil { return err } @@ -273,16 +266,8 @@ func getContainerNetNSPath(ctx context.Context, c containerd.Container) (string, return fmt.Sprintf("/proc/%d/ns/net", task.Pid()), nil } -func verifyCNINetwork(cmd *cobra.Command, netSlice []string, macAddress string) error { - cniPath, err := cmd.Flags().GetString("cni-path") - if err != nil { - return err - } - cniNetconfpath, err := cmd.Flags().GetString("cni-netconfpath") - if err != nil { - return err - } - e, err := netutil.NewCNIEnv(cniPath, cniNetconfpath, netutil.WithDefaultNetwork()) +func verifyCNINetwork(cmd *cobra.Command, netSlice []string, macAddress string, globalOptions *types.GlobalCommandOptions) error { + e, err := netutil.NewCNIEnv(globalOptions.CNIPath, globalOptions.CNINetConfPath, netutil.WithDefaultNetwork()) if err != nil { return err } diff --git a/cmd/nerdctl/run_runtime.go b/cmd/nerdctl/run_runtime.go index c10f01b5bc8..ab5ff66872c 100644 --- a/cmd/nerdctl/run_runtime.go +++ b/cmd/nerdctl/run_runtime.go @@ -25,22 +25,19 @@ import ( "github.com/containerd/containerd/oci" "github.com/containerd/containerd/plugin" runcoptions "github.com/containerd/containerd/runtime/v2/runc/options" + "github.com/containerd/nerdctl/pkg/api/types" runtimespec "github.com/opencontainers/runtime-spec/specs-go" "github.com/sirupsen/logrus" "github.com/spf13/cobra" ) -func generateRuntimeCOpts(cmd *cobra.Command) ([]containerd.NewContainerOpts, error) { +func generateRuntimeCOpts(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) ([]containerd.NewContainerOpts, error) { runtime := plugin.RuntimeRuncV2 var ( runcOpts runcoptions.Options runtimeOpts interface{} = &runcOpts ) - cgm, err := cmd.Flags().GetString("cgroup-manager") - if err != nil { - return nil, err - } - if cgm == "systemd" { + if globalOptions.CgroupManager == "systemd" { runcOpts.SystemdCgroup = true } runtimeStr, err := cmd.Flags().GetString("runtime") @@ -51,8 +48,8 @@ func generateRuntimeCOpts(cmd *cobra.Command) ([]containerd.NewContainerOpts, er if strings.HasPrefix(runtimeStr, "io.containerd.") || runtimeStr == "wtf.sbk.runj.v1" { runtime = runtimeStr if !strings.HasPrefix(runtimeStr, "io.containerd.runc.") { - if cgm == "systemd" { - logrus.Warnf("cannot set cgroup manager to %q for runtime %q", cgm, runtimeStr) + if globalOptions.CgroupManager == "systemd" { + logrus.Warnf("cannot set cgroup manager to %q for runtime %q", globalOptions.CgroupManager, runtimeStr) } runtimeOpts = nil } diff --git a/cmd/nerdctl/run_windows.go b/cmd/nerdctl/run_windows.go index 08ccc4e64a4..e6cffe0a9cc 100644 --- a/cmd/nerdctl/run_windows.go +++ b/cmd/nerdctl/run_windows.go @@ -23,6 +23,7 @@ import ( "github.com/containerd/containerd" "github.com/containerd/containerd/containers" "github.com/containerd/containerd/oci" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/docker/go-units" "github.com/spf13/cobra" ) @@ -44,6 +45,7 @@ func runShellComplete(cmd *cobra.Command, args []string, toComplete string) ([]s func setPlatformOptions( ctx context.Context, cmd *cobra.Command, + _ *types.GlobalCommandOptions, client *containerd.Client, id string, internalLabels *internalLabels, diff --git a/cmd/nerdctl/save.go b/cmd/nerdctl/save.go index c09bfd9c220..7dd1ad2901a 100644 --- a/cmd/nerdctl/save.go +++ b/cmd/nerdctl/save.go @@ -63,6 +63,10 @@ func newSaveCommand() *cobra.Command { } func saveAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } if len(args) == 0 { return fmt.Errorf("requires at least 1 argument") } @@ -79,15 +83,7 @@ func saveAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/start.go b/cmd/nerdctl/start.go index 9a3f59af1ad..3985fdbd8fb 100644 --- a/cmd/nerdctl/start.go +++ b/cmd/nerdctl/start.go @@ -57,15 +57,11 @@ func newStartCommand() *cobra.Command { } func startAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/stats.go b/cmd/nerdctl/stats.go index 6ce81264a7a..e1f6136d268 100644 --- a/cmd/nerdctl/stats.go +++ b/cmd/nerdctl/stats.go @@ -31,6 +31,7 @@ import ( eventstypes "github.com/containerd/containerd/api/events" "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/events" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/containerinspector" "github.com/containerd/nerdctl/pkg/eventutil" @@ -106,6 +107,10 @@ func statsAction(cmd *cobra.Command, args []string) error { // NOTE: rootless container does not rely on cgroupv1. // more details about possible ways to resolve this concern: #223 + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } if rootlessutil.IsRootless() && infoutil.CgroupsVersion() == "1" { return errors.New("stats requires cgroup v2 for rootless containers, see https://rootlesscontaine.rs/getting-started/common/cgroup2/") } @@ -149,15 +154,7 @@ func statsAction(cmd *cobra.Command, args []string) error { // waitFirst is a WaitGroup to wait first stat data's reach for each container waitFirst := &sync.WaitGroup{} cStats := stats{} - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -200,7 +197,7 @@ func statsAction(cmd *cobra.Command, args []string) error { s := statsutil.NewStats(c.ID()) if cStats.add(s) { waitFirst.Add(1) - go collect(cmd, s, waitFirst, c.ID(), !noStream) + go collect(cmd, globalOptions, s, waitFirst, c.ID(), !noStream) } } } @@ -231,7 +228,7 @@ func statsAction(cmd *cobra.Command, args []string) error { s := statsutil.NewStats(datacc.ID) if cStats.add(s) { waitFirst.Add(1) - go collect(cmd, s, waitFirst, datacc.ID, !noStream) + go collect(cmd, globalOptions, s, waitFirst, datacc.ID, !noStream) } }) @@ -274,7 +271,7 @@ func statsAction(cmd *cobra.Command, args []string) error { s := statsutil.NewStats(found.Container.ID()) if cStats.add(s) { waitFirst.Add(1) - go collect(cmd, s, waitFirst, found.Container.ID(), !noStream) + go collect(cmd, globalOptions, s, waitFirst, found.Container.ID(), !noStream) } return nil }, @@ -382,8 +379,7 @@ func statsAction(cmd *cobra.Command, args []string) error { return err } -func collect(cmd *cobra.Command, s *statsutil.Stats, waitFirst *sync.WaitGroup, id string, noStream bool) { - +func collect(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions, s *statsutil.Stats, waitFirst *sync.WaitGroup, id string, noStream bool) { logrus.Debugf("collecting stats for %s", s.Container) var ( getFirst = true @@ -397,15 +393,7 @@ func collect(cmd *cobra.Command, s *statsutil.Stats, waitFirst *sync.WaitGroup, waitFirst.Done() } }() - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { s.SetError(err) return diff --git a/cmd/nerdctl/stop.go b/cmd/nerdctl/stop.go index 52f8920ee87..f44c1921608 100644 --- a/cmd/nerdctl/stop.go +++ b/cmd/nerdctl/stop.go @@ -50,6 +50,10 @@ func newStopCommand() *cobra.Command { func stopAction(cmd *cobra.Command, args []string) error { // Time to wait after sending a SIGTERM and before sending a SIGKILL. + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } var timeout *time.Duration if cmd.Flags().Changed("time") { timeValue, err := cmd.Flags().GetInt("time") @@ -59,15 +63,7 @@ func stopAction(cmd *cobra.Command, args []string) error { t := time.Duration(timeValue) * time.Second timeout = &t } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/system_prune.go b/cmd/nerdctl/system_prune.go index fd3fe35bd16..03dd28ca473 100644 --- a/cmd/nerdctl/system_prune.go +++ b/cmd/nerdctl/system_prune.go @@ -43,6 +43,10 @@ func newSystemPruneCommand() *cobra.Command { } func systemPruneAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } all, err := cmd.Flags().GetBool("all") if err != nil { return err @@ -85,35 +89,27 @@ func systemPruneAction(cmd *cobra.Command, args []string) error { return nil } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - if err := containerPrune(ctx, cmd, client); err != nil { + if err := containerPrune(ctx, cmd, globalOptions, client); err != nil { return err } - if err := networkPrune(ctx, cmd, client); err != nil { + if err := networkPrune(ctx, cmd, client, globalOptions); err != nil { return err } if vFlag { - if err := volumePrune(ctx, cmd, client); err != nil { + if err := volumePrune(ctx, cmd, client, globalOptions); err != nil { return err } } if err := imagePrune(ctx, cmd, client); err != nil { return nil } - prunedObjects, err := buildCachePrune(ctx, cmd, all) + prunedObjects, err := buildCachePrune(ctx, cmd, all, globalOptions.Namespace) if err != nil { return err } @@ -135,8 +131,8 @@ type cacheUsageInfo struct { Size int64 } -func buildCachePrune(ctx context.Context, cmd *cobra.Command, pruneAll bool) ([]cacheUsageInfo, error) { - buildkitHost, err := getBuildkitHost(cmd) +func buildCachePrune(ctx context.Context, cmd *cobra.Command, pruneAll bool, namespace string) ([]cacheUsageInfo, error) { + buildkitHost, err := getBuildkitHost(cmd, namespace) if err != nil { return nil, err } diff --git a/cmd/nerdctl/tag.go b/cmd/nerdctl/tag.go index ee6e3c623dc..c1e496328ed 100644 --- a/cmd/nerdctl/tag.go +++ b/cmd/nerdctl/tag.go @@ -42,15 +42,11 @@ func newTagCommand() *cobra.Command { } func tagAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/top.go b/cmd/nerdctl/top.go index c8db571a0ec..50150a6fe0f 100644 --- a/cmd/nerdctl/top.go +++ b/cmd/nerdctl/top.go @@ -78,26 +78,18 @@ func newTopCommand() *cobra.Command { func topAction(cmd *cobra.Command, args []string) error { // NOTE: rootless container does not rely on cgroupv1. // more details about possible ways to resolve this concern: #223 + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } if rootlessutil.IsRootless() && infoutil.CgroupsVersion() == "1" { return fmt.Errorf("top requires cgroup v2 for rootless containers, see https://rootlesscontaine.rs/getting-started/common/cgroup2/") } - cgroupManager, err := cmd.Flags().GetString("cgroup-manager") - if err != nil { - return err - } - if cgroupManager == "none" { + if globalOptions.CgroupManager == "none" { return errors.New("cgroup manager must not be \"none\"") } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/unpause.go b/cmd/nerdctl/unpause.go index e6cf6e448c2..92b1e9e6e5d 100644 --- a/cmd/nerdctl/unpause.go +++ b/cmd/nerdctl/unpause.go @@ -42,15 +42,11 @@ func newUnpauseCommand() *cobra.Command { } func unpauseAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } diff --git a/cmd/nerdctl/update.go b/cmd/nerdctl/update.go index 7b69f7e7735..6a4d7158d4e 100644 --- a/cmd/nerdctl/update.go +++ b/cmd/nerdctl/update.go @@ -27,6 +27,7 @@ import ( "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/log" "github.com/containerd/containerd/pkg/cri/util" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/formatter" "github.com/containerd/nerdctl/pkg/idutil/containerwalker" @@ -86,20 +87,16 @@ func setUpdateFlags(cmd *cobra.Command) { } func updateAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - options, err := getUpdateOption(cmd) + options, err := getUpdateOption(cmd, globalOptions) if err != nil { return err } @@ -124,7 +121,7 @@ func updateAction(cmd *cobra.Command, args []string) error { return nil } -func getUpdateOption(cmd *cobra.Command) (updateResourceOptions, error) { +func getUpdateOption(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) (updateResourceOptions, error) { var options updateResourceOptions cpus, err := cmd.Flags().GetFloat64("cpus") if err != nil { @@ -223,11 +220,7 @@ func getUpdateOption(cmd *cobra.Command) (updateResourceOptions, error) { if err != nil { return options, err } - cgroupManager, err := cmd.Flags().GetString("cgroup-manager") - if err != nil { - return options, err - } - if blkioWeight != 0 && !infoutil.BlockIOWeight(cgroupManager) { + if blkioWeight != 0 && !infoutil.BlockIOWeight(globalOptions.CgroupManager) { return options, fmt.Errorf("kernel support for cgroup blkio weight missing, weight discarded") } if blkioWeight > 0 && blkioWeight < 10 || blkioWeight > 1000 { diff --git a/cmd/nerdctl/version.go b/cmd/nerdctl/version.go index ab9ff73032a..d557a94905a 100644 --- a/cmd/nerdctl/version.go +++ b/cmd/nerdctl/version.go @@ -23,6 +23,7 @@ import ( "os" "text/template" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/containerd/nerdctl/pkg/formatter" "github.com/containerd/nerdctl/pkg/infoutil" @@ -49,7 +50,10 @@ func newVersionCommand() *cobra.Command { func versionAction(cmd *cobra.Command, args []string) error { var w io.Writer = os.Stdout var tmpl *template.Template - + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } format, err := cmd.Flags().GetString("format") if err != nil { return err @@ -62,7 +66,7 @@ func versionAction(cmd *cobra.Command, args []string) error { } } - v, vErr := versionInfo(cmd) + v, vErr := versionInfo(cmd, globalOptions) if tmpl != nil { var b bytes.Buffer if err := tmpl.Execute(&b, v); err != nil { @@ -99,19 +103,12 @@ func versionAction(cmd *cobra.Command, args []string) error { } // versionInfo may return partial VersionInfo on error -func versionInfo(cmd *cobra.Command) (dockercompat.VersionInfo, error) { +func versionInfo(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) (dockercompat.VersionInfo, error) { + v := dockercompat.VersionInfo{ Client: infoutil.ClientVersion(), } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return v, err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return v, err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return v, err } diff --git a/cmd/nerdctl/volume.go b/cmd/nerdctl/volume.go index 0f9fe6e8d18..ec4bd0fbe51 100644 --- a/cmd/nerdctl/volume.go +++ b/cmd/nerdctl/volume.go @@ -17,6 +17,7 @@ package main import ( + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/cmd/volume" "github.com/containerd/nerdctl/pkg/mountutil/volumestore" "github.com/spf13/cobra" @@ -43,18 +44,6 @@ func newVolumeCommand() *cobra.Command { // getVolumeStore returns a volume store // that corresponds to a directory like `/var/lib/nerdctl/1935db59/volumes/default` -func getVolumeStore(cmd *cobra.Command) (volumestore.VolumeStore, error) { - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return nil, err - } - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return nil, err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return nil, err - } - return volume.Store(ns, dataRoot, address) +func getVolumeStore(globalOptions *types.GlobalCommandOptions) (volumestore.VolumeStore, error) { + return volume.Store(globalOptions.Namespace, globalOptions.DataRoot, globalOptions.Address) } diff --git a/cmd/nerdctl/volume_create.go b/cmd/nerdctl/volume_create.go index db832c15df6..2e16f12b53b 100644 --- a/cmd/nerdctl/volume_create.go +++ b/cmd/nerdctl/volume_create.go @@ -39,12 +39,16 @@ func newVolumeCreateCommand() *cobra.Command { } func volumeCreateAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } name := args[0] if err := identifiers.Validate(name); err != nil { return fmt.Errorf("malformed name %s: %w", name, err) } - volStore, err := getVolumeStore(cmd) + volStore, err := getVolumeStore(globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/volume_inspect.go b/cmd/nerdctl/volume_inspect.go index d2fc5bf44f0..fe35b132773 100644 --- a/cmd/nerdctl/volume_inspect.go +++ b/cmd/nerdctl/volume_inspect.go @@ -40,12 +40,16 @@ func newVolumeInspectCommand() *cobra.Command { } func volumeInspectAction(cmd *cobra.Command, args []string) error { - var volumeSize, err = cmd.Flags().GetBool("size") + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } + volumeSize, err := cmd.Flags().GetBool("size") if err != nil { return err } - volStore, err := getVolumeStore(cmd) + volStore, err := getVolumeStore(globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/volume_ls.go b/cmd/nerdctl/volume_ls.go index a310c2e74f6..7aaca28a900 100644 --- a/cmd/nerdctl/volume_ls.go +++ b/cmd/nerdctl/volume_ls.go @@ -17,7 +17,7 @@ package main import ( - types "github.com/containerd/nerdctl/pkg/api/types" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/cmd/volume" "github.com/containerd/nerdctl/pkg/inspecttypes/native" @@ -46,6 +46,11 @@ func newVolumeLsCommand() *cobra.Command { } func volumeLsAction(cmd *cobra.Command, args []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } + options := &types.VolumeLsCommandOptions{} options.Writer = cmd.OutOrStdout() quiet, err := cmd.Flags().GetBool("quiet") @@ -68,40 +73,16 @@ func volumeLsAction(cmd *cobra.Command, args []string) error { return err } options.Filters = filters - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - options.Namespace = ns - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return err - } - options.DataRoot = dataRoot - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - options.Address = address + options.Namespace = globalOptions.Namespace + options.DataRoot = globalOptions.DataRoot + options.Address = globalOptions.Address return volume.Ls(options) } -func getVolumes(cmd *cobra.Command) (map[string]native.Volume, error) { - ns, err := cmd.Flags().GetString("namespace") - if err != nil { - return nil, err - } - dataRoot, err := cmd.Flags().GetString("data-root") - if err != nil { - return nil, err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return nil, err - } +func getVolumes(cmd *cobra.Command, globalOptions *types.GlobalCommandOptions) (map[string]native.Volume, error) { volumeSize, err := cmd.Flags().GetBool("size") if err != nil { return nil, err } - return volume.Volumes(ns, dataRoot, address, volumeSize) + return volume.Volumes(globalOptions.Namespace, globalOptions.DataRoot, globalOptions.Address, volumeSize) } diff --git a/cmd/nerdctl/volume_prune.go b/cmd/nerdctl/volume_prune.go index acdae6ef941..b1779f1e981 100644 --- a/cmd/nerdctl/volume_prune.go +++ b/cmd/nerdctl/volume_prune.go @@ -22,6 +22,7 @@ import ( "strings" "github.com/containerd/containerd" + "github.com/containerd/nerdctl/pkg/api/types" "github.com/containerd/nerdctl/pkg/clientutil" "github.com/spf13/cobra" ) @@ -40,6 +41,10 @@ func newVolumePruneCommand() *cobra.Command { } func volumePruneAction(cmd *cobra.Command, _ []string) error { + globalOptions, err := processRootCmdFlags(cmd) + if err != nil { + return err + } force, err := cmd.Flags().GetBool("force") if err != nil { return err @@ -56,25 +61,17 @@ func volumePruneAction(cmd *cobra.Command, _ []string) error { return nil } } - namespace, err := cmd.Flags().GetString("namespace") - if err != nil { - return err - } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } defer cancel() - return volumePrune(ctx, cmd, client) + return volumePrune(ctx, cmd, client, globalOptions) } -func volumePrune(ctx context.Context, cmd *cobra.Command, client *containerd.Client) error { - volStore, err := getVolumeStore(cmd) +func volumePrune(ctx context.Context, cmd *cobra.Command, client *containerd.Client, globalOptions *types.GlobalCommandOptions) error { + volStore, err := getVolumeStore(globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/volume_rm.go b/cmd/nerdctl/volume_rm.go index 87ca2302d9e..7102bcfad42 100644 --- a/cmd/nerdctl/volume_rm.go +++ b/cmd/nerdctl/volume_rm.go @@ -46,15 +46,11 @@ func newVolumeRmCommand() *cobra.Command { } func volumeRmAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err } @@ -63,7 +59,7 @@ func volumeRmAction(cmd *cobra.Command, args []string) error { if err != nil { return err } - volStore, err := getVolumeStore(cmd) + volStore, err := getVolumeStore(globalOptions) if err != nil { return err } diff --git a/cmd/nerdctl/wait.go b/cmd/nerdctl/wait.go index bcfe7dcde20..0a78e7d0d41 100644 --- a/cmd/nerdctl/wait.go +++ b/cmd/nerdctl/wait.go @@ -42,15 +42,11 @@ func newWaitCommand() *cobra.Command { } func containerWaitAction(cmd *cobra.Command, args []string) error { - namespace, err := cmd.Flags().GetString("namespace") + globalOptions, err := processRootCmdFlags(cmd) if err != nil { return err } - address, err := cmd.Flags().GetString("address") - if err != nil { - return err - } - client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), namespace, address) + client, ctx, cancel, err := clientutil.NewClient(cmd.Context(), globalOptions.Namespace, globalOptions.Address) if err != nil { return err }