feat: add DisableMemorySwappiness flag for Podman compatibility

Add `--disable-memory-swappiness` flag to set container MemorySwappiness to nil, addressing Podman compatibility with crun and cgroupv2, as proposed by containrrr#2072.

Changes include:
- Implemented flag logic to set MemorySwappiness to nil
- Added flag parsing and validation
- Updated CLI command configuration
- Added unit tests for flag functionality
- Documented flag in arguments

Author: nicholas-fedor

cmd/root.go

@@ -252,6 +252,7 @@ func preRun(cmd *cobra.Command, _ []string) {
 	reviveStopped, _ := flagsSet.GetBool("revive-stopped")
 	removeVolumes, _ := flagsSet.GetBool("remove-volumes")
 	warnOnHeadPullFailed, _ := flagsSet.GetString("warn-on-head-failure")
+	disableMemorySwappiness, _ := flagsSet.GetBool("disable-memory-swappiness")
 
 	// Warn about potential redundancy in flag combinations that could result in no action.
 	if monitorOnly && noPull {
@@ -263,11 +264,12 @@ func preRun(cmd *cobra.Command, _ []string) {
 
 	// Initialize the Docker client with options reflecting the desired container handling behavior.
 	client = container.NewClient(container.ClientOptions{
-		IncludeStopped:    includeStopped,
-		ReviveStopped:     reviveStopped,
-		RemoveVolumes:     removeVolumes,
-		IncludeRestarting: includeRestarting,
-		WarnOnHeadFailed:  container.WarningStrategy(warnOnHeadPullFailed),
+		IncludeStopped:          includeStopped,
+		ReviveStopped:           reviveStopped,
+		RemoveVolumes:           removeVolumes,
+		IncludeRestarting:       includeRestarting,
+		DisableMemorySwappiness: disableMemorySwappiness,
+		WarnOnHeadFailed:        container.WarningStrategy(warnOnHeadPullFailed),
 	})
 
 	// Set up the notification system with types specified via flags (e.g., email, Slack).

docs/arguments.md

@@ -510,3 +510,15 @@ Environment Variable: WATCHTOWER_PORCELAIN
      Possible values: v1
              Default: -
 ```
+
+## Compatibility with podman (Disable memory swappiness)
+
+Disable memory swappiness. By default, podman sets the memory-swappiness value to 0 when no memory-swappiness is defined
+When this flag is specified, watchtower will set the memory-swappiness to nil, fixing a compatibility issue with podman running with crun and cgroupv2
+
+```text
+            Argument: --disable-memory-swappiness
+Environment Variable: WATCHTOWER_DISABLE_MEMORY_SWAPPINESS
+                Type: Boolean
+             Default: false
+```

internal/flags/flags.go

@@ -260,6 +260,13 @@ func RegisterSystemFlags(rootCmd *cobra.Command) {
 		"",
 		envBool("WATCHTOWER_LABEL_TAKE_PRECEDENCE"),
 		"Label applied to containers take precedence over arguments")
+
+	flags.BoolP(
+		"disable-memory-swappiness",
+		"",
+		envBool("WATCHTOWER_DISABLE_MEMORY_SWAPPINESS"),
+		"Label used for setting memory swappiness as nil when recreating the container, used for compatibility with podman",
+	)
 }
 
 // RegisterNotificationFlags adds notification flags to the root command.
@@ -526,6 +533,7 @@ func SetDefaults() {
 	viper.SetDefault("WATCHTOWER_NOTIFICATION_SLACK_IDENTIFIER", "watchtower")
 	viper.SetDefault("WATCHTOWER_LOG_LEVEL", "info")
 	viper.SetDefault("WATCHTOWER_LOG_FORMAT", "auto")
+	viper.SetDefault("WATCHTOWER_DISABLE_MEMORY_SWAPPINESS", false)
 }
 
 // EnvConfig sets Docker environment variables from flags.

internal/flags/flags_test.go

@@ -626,3 +626,17 @@ func testGetSecretsFromFiles(t *testing.T, flagName string, expected string, arg
 
 	assert.Equal(t, expected, value)
 }
+
+func TestDisableMemorySwappinessFlag(t *testing.T) {
+	cmd := new(cobra.Command)
+
+	SetDefaults()
+	RegisterSystemFlags(cmd)
+
+	err := cmd.ParseFlags([]string{"--disable-memory-swappiness"})
+	require.NoError(t, err)
+
+	disableMemorySwappiness, err := cmd.PersistentFlags().GetBool("disable-memory-swappiness")
+	require.NoError(t, err)
+	assert.True(t, disableMemorySwappiness, "disable-memory-swappiness flag should be true")
+}

pkg/container/client.go

@@ -85,11 +85,12 @@ type client struct {
 //
 // It controls container management and warning behaviors.
 type ClientOptions struct {
-	RemoveVolumes     bool
-	IncludeStopped    bool
-	ReviveStopped     bool
-	IncludeRestarting bool
-	WarnOnHeadFailed  WarningStrategy
+	RemoveVolumes           bool
+	IncludeStopped          bool
+	ReviveStopped           bool
+	IncludeRestarting       bool
+	DisableMemorySwappiness bool
+	WarnOnHeadFailed        WarningStrategy
 }
 
 // NewClient initializes a new Client instance for Docker API interactions.
@@ -223,6 +224,7 @@ func (c client) StartContainer(container types.Container) (types.ContainerID, er
 		c.ReviveStopped,
 		clientVersion,
 		flags.DockerAPIMinVersion,
+		c.DisableMemorySwappiness,
 	)
 	if err != nil {
 		logrus.WithFields(fields).WithError(err).Debug("Failed to start new container")

pkg/container/container_target.go

@@ -24,6 +24,7 @@ import (
 //   - reviveStopped: Whether to start stopped containers.
 //   - clientVersion: API version of the client.
 //   - minSupportedVersion: Minimum API version for full features.
+//   - disableMemorySwappiness: Whether to disable memory swappiness for Podman compatibility.
 //
 // Returns:
 //   - types.ContainerID: ID of the new container.
@@ -35,6 +36,7 @@ func StartTargetContainer(
 	reviveStopped bool,
 	clientVersion string,
 	minSupportedVersion string,
+	disableMemorySwappiness bool,
 ) (types.ContainerID, error) {
 	ctx := context.Background()
 	clog := logrus.WithFields(logrus.Fields{
@@ -46,6 +48,13 @@ func StartTargetContainer(
 	config := sourceContainer.GetCreateConfig()
 	hostConfig := sourceContainer.GetCreateHostConfig()
 
+	// Set MemorySwappiness to nil for Podman compatibility if flag is enabled.
+	if disableMemorySwappiness {
+		hostConfig.MemorySwappiness = nil
+
+		clog.Debug("Disabled memory swappiness for Podman compatibility")
+	}
+
 	// Log network details for debugging.
 	isHostNetwork := sourceContainer.ContainerInfo().HostConfig.NetworkMode.IsHost()
 	debugLogMacAddress(

pkg/container/container_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/sirupsen/logrus"
 
 	dockerContainerType "github.com/docker/docker/api/types/container"
+	dockerImageType "github.com/docker/docker/api/types/image"
 	dockerNetworkType "github.com/docker/docker/api/types/network"
 	dockerNat "github.com/docker/go-connections/nat"
 
@@ -79,6 +80,7 @@ var _ = ginkgo.Describe("the container", func() {
 			},
 		)
 	})
+
 	ginkgo.Describe("GetCreateConfig", func() {
 		ginkgo.When("container healthcheck config is equal to image config", func() {
 			ginkgo.It("should return empty healthcheck values", func() {
@@ -174,6 +176,7 @@ var _ = ginkgo.Describe("the container", func() {
 			})
 		})
 	})
+
 	ginkgo.When("asked for metadata", func() {
 		var container *Container
 		ginkgo.BeforeEach(func() {
@@ -635,4 +638,85 @@ var _ = ginkgo.Describe("the container", func() {
 			})
 		})
 	})
+
+	ginkgo.Describe("DisableMemorySwappiness Configuration", func() {
+		var mockContainer *Container
+		var defaultMemorySwappiness int64 = 60
+		containerName := "test-container"
+		containerID := "test-container-id"
+
+		WithMemorySwappiness := func(swappiness int64) MockContainerUpdate {
+			return func(c *dockerContainerType.InspectResponse, _ *dockerImageType.InspectResponse) {
+				if c.HostConfig == nil {
+					c.HostConfig = &dockerContainerType.HostConfig{}
+				}
+				c.HostConfig.MemorySwappiness = &swappiness
+			}
+		}
+
+		ginkgo.BeforeEach(func() {
+			mockContainer = MockContainer(WithMemorySwappiness(defaultMemorySwappiness))
+			inspectResponse := dockerContainerType.InspectResponse{
+				ContainerJSONBase: &dockerContainerType.ContainerJSONBase{
+					ID:         containerID,
+					Name:       "/" + containerName,
+					HostConfig: mockContainer.GetCreateHostConfig(),
+					State:      &dockerContainerType.State{Running: true},
+				},
+				Config: &dockerContainerType.Config{},
+			}
+			mockContainer.containerInfo = &inspectResponse
+		})
+
+		ginkgo.When("DisableMemorySwappiness is true", func() {
+			ginkgo.It("sets MemorySwappiness to nil and logs debug message", func() {
+				logOutput := &bytes.Buffer{}
+				logrus.SetOutput(logOutput)
+				logrus.SetLevel(logrus.DebugLevel)
+
+				clog := logrus.WithFields(logrus.Fields{
+					"container": mockContainer.Name(),
+					"id":        mockContainer.ID().ShortID(),
+				})
+				hostConfig := mockContainer.GetCreateHostConfig()
+				disableMemorySwappiness := true
+
+				if disableMemorySwappiness {
+					hostConfig.MemorySwappiness = nil
+					clog.Debug("Disabled memory swappiness for Podman compatibility")
+				}
+
+				gomega.Expect(hostConfig.MemorySwappiness).To(gomega.BeNil(),
+					"MemorySwappiness should be nil when DisableMemorySwappiness is true")
+				gomega.Expect(logOutput.String()).To(gomega.ContainSubstring(
+					"Disabled memory swappiness for Podman compatibility"))
+			})
+		})
+
+		ginkgo.When("DisableMemorySwappiness is false", func() {
+			ginkgo.It("preserves MemorySwappiness and does not log debug message", func() {
+				logOutput := &bytes.Buffer{}
+				logrus.SetOutput(logOutput)
+				logrus.SetLevel(logrus.DebugLevel)
+
+				clog := logrus.WithFields(logrus.Fields{
+					"container": mockContainer.Name(),
+					"id":        mockContainer.ID().ShortID(),
+				})
+				hostConfig := mockContainer.GetCreateHostConfig()
+				disableMemorySwappiness := false
+
+				if disableMemorySwappiness {
+					hostConfig.MemorySwappiness = nil
+					clog.Debug("Disabled memory swappiness for Podman compatibility")
+				}
+
+				gomega.Expect(hostConfig.MemorySwappiness).
+					To(gomega.Equal(&defaultMemorySwappiness),
+						"MemorySwappiness should remain unchanged when DisableMemorySwappiness is false")
+				gomega.Expect(logOutput.String()).NotTo(gomega.ContainSubstring(
+					"Disabled memory swappiness for Podman compatibility"))
+			})
+		})
+	})
 })