swarm: Add memory swap support (no stack/compose support)

Signed-off-by: Paweł Gronowski <pawel.gronowski@docker.com>

Author: vvoland

cli/command/service/opts.go

@@ -235,15 +235,17 @@ type resourceOptions struct {
 	resCPU              opts.NanoCPUs
 	resMemBytes         opts.MemBytes
 	resGenericResources []string
+	swapBytes           opts.MemBytes
+	memSwappiness       int64
 }
 
-func (r *resourceOptions) ToResourceRequirements() (*swarm.ResourceRequirements, error) {
+func (r *resourceOptions) ToResourceRequirements(flags *pflag.FlagSet) (*swarm.ResourceRequirements, error) {
 	generic, err := ParseGenericResources(r.resGenericResources)
 	if err != nil {
 		return nil, err
 	}
 
-	return &swarm.ResourceRequirements{
+	resreq := &swarm.ResourceRequirements{
 		Limits: &swarm.Limit{
 			NanoCPUs:    r.limitCPU.Value(),
 			MemoryBytes: r.limitMemBytes.Value(),
@@ -254,7 +256,20 @@ func (r *resourceOptions) ToResourceRequirements() (*swarm.ResourceRequirements,
 			MemoryBytes:      r.resMemBytes.Value(),
 			GenericResources: generic,
 		},
-	}, nil
+	}
+
+	// SwapBytes and MemorySwappiness are *int64 (pointers), so we need to have
+	// a variable we can take a pointer to. Additionally, we need to ensure
+	// that these values are only set if they are set as options.
+	if flags.Changed(flagSwapBytes) {
+		swapBytes := r.swapBytes.Value()
+		resreq.SwapBytes = &swapBytes
+	}
+	if flags.Changed(flagMemSwappiness) {
+		resreq.MemorySwappiness = &r.memSwappiness
+	}
+
+	return resreq, nil
 }
 
 type restartPolicyOptions struct {
@@ -734,7 +749,7 @@ func (options *serviceOptions) ToService(ctx context.Context, apiClient client.N
 		return networks[i].Target < networks[j].Target
 	})
 
-	resources, err := options.resources.ToResourceRequirements()
+	resources, err := options.resources.ToResourceRequirements(flags)
 	if err != nil {
 		return service, err
 	}
@@ -889,6 +904,10 @@ func addServiceFlags(flags *pflag.FlagSet, options *serviceOptions, defaultFlagV
 	flags.Var(&options.resources.resMemBytes, flagReserveMemory, "Reserve Memory")
 	flags.Int64Var(&options.resources.limitPids, flagLimitPids, 0, "Limit maximum number of processes (default 0 = unlimited)")
 	flags.SetAnnotation(flagLimitPids, "version", []string{"1.41"})
+	flags.Var(&options.resources.swapBytes, flagSwapBytes, "Swap Bytes (-1 for unlimited)")
+	flags.SetAnnotation(flagLimitPids, "version", []string{"1.52"})
+	flags.Int64Var(&options.resources.memSwappiness, flagMemSwappiness, -1, "Tune memory swappiness (0-100), -1 to reset to default")
+	flags.SetAnnotation(flagLimitPids, "version", []string{"1.52"})
 
 	flags.Var(&options.stopGrace, flagStopGracePeriod, flagDesc(flagStopGracePeriod, "Time to wait before force killing a container (ns|us|ms|s|m|h)"))
 	flags.Var(&options.replicas, flagReplicas, "Number of tasks")
@@ -1073,6 +1092,8 @@ const (
 	flagUlimitAdd               = "ulimit-add"
 	flagUlimitRemove            = "ulimit-rm"
 	flagOomScoreAdj             = "oom-score-adj"
+	flagSwapBytes               = "memory-swap"
+	flagMemSwappiness           = "memory-swappiness"
 )
 
 func toNetipAddrSlice(ips []string) []netip.Addr {

cli/command/service/opts_test.go

@@ -163,8 +163,10 @@ func TestResourceOptionsToResourceRequirements(t *testing.T) {
 		},
 	}
 
+	flags := newCreateCommand(nil).Flags()
+
 	for _, opt := range incorrectOptions {
-		_, err := opt.ToResourceRequirements()
+		_, err := opt.ToResourceRequirements(flags)
 		assert.Check(t, is.ErrorContains(err, ""))
 	}
 
@@ -178,12 +180,41 @@ func TestResourceOptionsToResourceRequirements(t *testing.T) {
 	}
 
 	for _, opt := range correctOptions {
-		r, err := opt.ToResourceRequirements()
+		r, err := opt.ToResourceRequirements(flags)
 		assert.NilError(t, err)
 		assert.Check(t, is.Len(r.Reservations.GenericResources, len(opt.resGenericResources)))
 	}
 }
 
+func TestResourceOptionsToResourceRequirementsSwap(t *testing.T) {
+	// first, check that no flag set means no field set in the return
+	flags := newCreateCommand(nil).Flags()
+
+	// These should be the default values of the field.
+	swapOptions := resourceOptions{
+		swapBytes:     0,
+		memSwappiness: -1,
+	}
+
+	r, err := swapOptions.ToResourceRequirements(flags)
+	assert.NilError(t, err)
+	assert.Check(t, is.Nil(r.SwapBytes))
+	assert.Check(t, is.Nil(r.MemorySwappiness))
+
+	// now set the flags and some values
+	flags.Set(flagSwapBytes, "86000")
+	flags.Set(flagMemSwappiness, "23")
+	swapOptions.swapBytes = 86000
+	swapOptions.memSwappiness = 23
+
+	r, err = swapOptions.ToResourceRequirements(flags)
+	assert.NilError(t, err)
+	assert.Check(t, r.SwapBytes != nil)
+	assert.Check(t, is.Equal(*(r.SwapBytes), int64(86000)))
+	assert.Check(t, r.MemorySwappiness != nil)
+	assert.Check(t, is.Equal(*(r.MemorySwappiness), int64(23)))
+}
+
 func TestToServiceNetwork(t *testing.T) {
 	nws := []network.Inspect{
 		{

docs/reference/commandline/service_create.md

@@ -40,6 +40,8 @@ Create a new service
 | `--log-driver`                                      | `string`          |              | Logging driver for service                                                                          |
 | `--log-opt`                                         | `list`            |              | Logging driver options                                                                              |
 | `--max-concurrent`                                  | `uint`            |              | Number of job tasks to run concurrently (default equal to --replicas)                               |
+| `--memory-swap`                                     | `bytes`           | `0`          | Swap Bytes (-1 for unlimited)                                                                       |
+| `--memory-swappiness`                               | `int64`           | `-1`         | Tune memory swappiness (0-100), -1 to reset to default                                              |
 | `--mode`                                            | `string`          | `replicated` | Service mode (`replicated`, `global`, `replicated-job`, `global-job`)                               |
 | [`--mount`](#mount)                                 | `mount`           |              | Attach a filesystem mount to the service                                                            |
 | `--name`                                            | `string`          |              | Service name                                                                                        |

docs/reference/commandline/service_update.md

@@ -53,6 +53,8 @@ Update a service
 | `--log-driver`                                | `string`          |         | Logging driver for service                                                                          |
 | `--log-opt`                                   | `list`            |         | Logging driver options                                                                              |
 | `--max-concurrent`                            | `uint`            |         | Number of job tasks to run concurrently (default equal to --replicas)                               |
+| `--memory-swap`                               | `bytes`           | `0`     | Swap Bytes (-1 for unlimited)                                                                       |
+| `--memory-swappiness`                         | `int64`           | `-1`    | Tune memory swappiness (0-100), -1 to reset to default                                              |
 | [`--mount-add`](#mount-add)                   | `mount`           |         | Add or update a mount on a service                                                                  |
 | `--mount-rm`                                  | `list`            |         | Remove a mount by its target path                                                                   |
 | [`--network-add`](#network-add)               | `network`         |         | Add a network                                                                                       |