github.com/kaisenlinux/docker.io@v0.0.0-20230510090727-ea55db55fac7/swarmkit/cmd/swarmctl/service/flagparser/flags.go (about)

     1  package flagparser
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  
     7  	"github.com/docker/swarmkit/api"
     8  	"github.com/docker/swarmkit/cmd/swarmctl/common"
     9  	"github.com/spf13/cobra"
    10  	"github.com/spf13/pflag"
    11  )
    12  
    13  // AddServiceFlags add all supported service flags to the flagset.
    14  func AddServiceFlags(flags *pflag.FlagSet) {
    15  	flags.String("name", "", "service name")
    16  	flags.StringSlice("label", nil, "service label (key=value)")
    17  
    18  	flags.Uint64("replicas", 1, "number of replicas for the service (only works in replicated service mode)")
    19  	flags.Uint64("replicas-max-per-node", 0, "maximum number of replicas for per node (only works in replicated service mode) (default 0 = unlimited)")
    20  
    21  	flags.String("image", "", "container image")
    22  	flags.String("hostname", "", "container hostname")
    23  	flags.StringSlice("command", nil, "override entrypoint")
    24  	flags.StringSlice("args", nil, "container args")
    25  	flags.StringSlice("env", nil, "container env")
    26  	flags.Bool("tty", false, "open a tty on standard streams")
    27  	flags.Bool("open-stdin", false, "open standard input")
    28  
    29  	flags.StringSlice("ports", nil, "ports")
    30  	flags.String("network", "", "network name")
    31  
    32  	flags.String("memory-reservation", "", "amount of reserved memory (e.g. 512m)")
    33  	flags.String("memory-limit", "", "memory limit (e.g. 512m)")
    34  	flags.String("cpu-reservation", "", "number of CPU cores reserved (e.g. 0.5)")
    35  	flags.String("cpu-limit", "", "CPU cores limit (e.g. 0.5)")
    36  	flags.String("generic-resources", "", "user defined resources request (e.g. gpu=3,fpga=1)")
    37  	flags.StringSlice("ulimit", []string{}, "ulimit options")
    38  
    39  	flags.Uint64("update-parallelism", 0, "task update parallelism (0 = all at once)")
    40  	flags.String("update-delay", "0s", "delay between task updates (0s = none)")
    41  	flags.String("update-on-failure", "pause", "action on failure during update (pause|continue|rollback)")
    42  	flags.String("update-order", "stop-first", "order of shutting down old task and starting updated task (stop-first|start-first)")
    43  
    44  	flags.Uint64("rollback-parallelism", 0, "task update parallelism during rollback (0 = all at once)")
    45  	flags.String("rollback-delay", "0s", "delay between task updates during rollback (0s = none)")
    46  	flags.String("rollback-on-failure", "pause", "action on failure during rollback (pause|continue)")
    47  	flags.String("rollback-order", "stop-first", "order of shutting down old task and starting rolled-back task (stop-first|start-first)")
    48  
    49  	flags.String("restart-condition", "any", "condition to restart the task (any, failure, none)")
    50  	flags.String("restart-delay", "5s", "delay between task restarts")
    51  	flags.Uint64("restart-max-attempts", 0, "maximum number of restart attempts (0 = unlimited)")
    52  	flags.String("restart-window", "0s", "time window to evaluate restart attempts (0 = unbound)")
    53  
    54  	flags.StringSlice("constraint", nil, "Placement constraint (e.g. node.labels.key==value)")
    55  
    56  	// TODO(stevvooe): Replace these with a more interesting mount flag.
    57  	flags.StringSlice("bind", nil, "define a bind mount")
    58  	flags.StringSlice("volume", nil, "define a volume mount")
    59  	flags.StringSlice("tmpfs", nil, "define a tmpfs mount")
    60  	flags.StringSlice("npipe", nil, "define a npipe mount")
    61  
    62  	flags.String("log-driver", "", "specify a log driver")
    63  	flags.StringSlice("log-opt", nil, "log driver options, as key value pairs")
    64  
    65  	flags.Bool("init", false, "Run an init inside the container that forwards signals and reaps processes")
    66  }
    67  
    68  // Merge merges a flagset into a service spec.
    69  func Merge(cmd *cobra.Command, spec *api.ServiceSpec, c api.ControlClient) error {
    70  	flags := cmd.Flags()
    71  
    72  	if flags.Changed("force") {
    73  		force, err := flags.GetBool("force")
    74  		if err != nil {
    75  			return err
    76  		}
    77  		if force {
    78  			spec.Task.ForceUpdate++
    79  		}
    80  	}
    81  
    82  	if flags.Changed("name") {
    83  		name, err := flags.GetString("name")
    84  		if err != nil {
    85  			return err
    86  		}
    87  		spec.Annotations.Name = name
    88  	}
    89  
    90  	if flags.Changed("label") {
    91  		labels, err := flags.GetStringSlice("label")
    92  		if err != nil {
    93  			return err
    94  		}
    95  		spec.Annotations.Labels = map[string]string{}
    96  		for _, l := range labels {
    97  			parts := strings.SplitN(l, "=", 2)
    98  			if len(parts) != 2 {
    99  				return fmt.Errorf("malformed label: %s", l)
   100  			}
   101  			spec.Annotations.Labels[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
   102  		}
   103  	}
   104  
   105  	if err := parseMode(flags, spec); err != nil {
   106  		return err
   107  	}
   108  
   109  	if err := parseContainer(flags, spec); err != nil {
   110  		return err
   111  	}
   112  
   113  	if err := parseResource(flags, spec); err != nil {
   114  		return err
   115  	}
   116  
   117  	if err := parsePorts(flags, spec); err != nil {
   118  		return err
   119  	}
   120  
   121  	if err := parseNetworks(cmd, spec, c); err != nil {
   122  		return err
   123  	}
   124  
   125  	if err := parseRestart(flags, spec); err != nil {
   126  		return err
   127  	}
   128  
   129  	if err := parseUpdate(flags, spec); err != nil {
   130  		return err
   131  	}
   132  
   133  	if err := parsePlacement(flags, spec); err != nil {
   134  		return err
   135  	}
   136  
   137  	if err := parseBind(flags, spec); err != nil {
   138  		return err
   139  	}
   140  
   141  	if err := parseVolume(flags, spec); err != nil {
   142  		return err
   143  	}
   144  
   145  	if err := parseTmpfs(flags, spec); err != nil {
   146  		return err
   147  	}
   148  
   149  	if err := parseNpipe(flags, spec); err != nil {
   150  		return err
   151  	}
   152  
   153  	driver, err := common.ParseLogDriverFlags(flags)
   154  	if err != nil {
   155  		return err
   156  	}
   157  	spec.Task.LogDriver = driver
   158  
   159  	return nil
   160  }