docker / cli

Command Structure

Overview

The command package is responsible for defining and executing Docker commands. It provides a structured way to handle user input, validate arguments, and interact with the Docker API.

Key Concepts

  • Commands: Represent individual Docker commands, such as run, build, or pull. Each command is defined as a struct with methods for handling specific operations.
  • Subcommands: Allow for hierarchical organization of commands. For example, the image command can have subcommands like push, pull, and build.
  • Flags: Options that modify the behavior of a command. Flags can be either boolean or string values.
  • Options: A grouping of flags for a specific command.
  • Args: Remaining arguments passed to a command after flags have been parsed.
  • Context: A container for shared state and configuration used by commands.

Structure

package command
          
          type Command struct {
            Name       string
            Usage       string
            Description string
            Flags       Flags
            Subcommands []Command
          }
          
          func (c Command) Run(ctx context.Context, args []string) error {
            // ...
          }

Command Definition

// Example: Define the "run" command
          var runCommand = Command{
            Name:       "run",
            Usage:       "run a command in a container",
            Description: "Run a command in a new container.",
            Flags:       runFlags, // A set of flags defined elsewhere
          }

Command Execution

// Example: Execute the "run" command
          func runCommandAction(ctx context.Context, cmd Command, args []string) error {
            // ...
          }

Flags

// Example: Define a flag
          type Flag struct {
            Name  string
            Value string
          }
          
          // Example: Define a set of flags for the "run" command
          var runFlags = Flags{
            "detach": Flag{
              Name:  "detach",
              Value: "false", // Default value
            },
          }

Options

// Example: Define a set of options for the "run" command
          var runOptions = Options{
            "detach": Flag{
              Name:  "detach",
              Value: "false", // Default value
            },
            "interactive": Flag{
              Name:  "interactive",
              Value: "false", // Default value
            },
          }

Subcommands

// Example: Define the "build" subcommand for the "image" command
          var buildCommand = Command{
            Name:       "build",
            Usage:       "build an image from a Dockerfile",
            Description: "Build an image from a Dockerfile.",
            Flags:       buildFlags,
            Subcommands: []Command{},
          }

Command Structure in the CLI Framework

The command package integrates with the Docker CLI framework. The framework is responsible for parsing user input, validating arguments, and dispatching commands to the appropriate handlers.

Reference

Example

# Run a container
          docker run -d nginx:latest
          
          # Build an image
          docker build -t my-image .
          
          # Push an image
          docker push my-image