pkg/compose: use negotiated API version for network setup

Signed-off-by: Guillaume Lours <glours@users.noreply.github.com>

Author: glours

pkg/compose/compose.go

@@ -215,6 +215,9 @@ type composeService struct {
 	clock          clockwork.Clock
 	maxConcurrency int
 	dryRun         bool
+
+	runtimeVersion    runtimeVersionCache
+	currentAPIVersion runtimeVersionCache
 }
 
 // Close releases any connections/resources held by the underlying clients.
@@ -497,16 +500,42 @@ type runtimeVersionCache struct {
 	err  error
 }
 
-var runtimeVersion runtimeVersionCache
-
 func (s *composeService) RuntimeVersion(ctx context.Context) (string, error) {
-	// TODO(thaJeztah): this should use Client.ClientVersion), which has the negotiated version.
-	runtimeVersion.once.Do(func() {
+	// RuntimeVersion returns the raw API version reported by the daemon.
+	// Callers that need the negotiated/effective client API version should use
+	// CurrentAPIVersion instead.
+	s.runtimeVersion.once.Do(func() {
 		version, err := s.apiClient().ServerVersion(ctx, client.ServerVersionOptions{})
 		if err != nil {
-			runtimeVersion.err = err
+			s.runtimeVersion.err = err
+			return
 		}
-		runtimeVersion.val = version.APIVersion
+		s.runtimeVersion.val = version.APIVersion
 	})
-	return runtimeVersion.val, runtimeVersion.err
+	return s.runtimeVersion.val, s.runtimeVersion.err
+}
+
+// CurrentAPIVersion returns the API version currently used by the Docker client.
+// Trigger negotiation first so version-gated request shaping matches the version
+// that subsequent API calls will actually use.
+func (s *composeService) CurrentAPIVersion(ctx context.Context) (string, error) {
+	s.currentAPIVersion.once.Do(func() {
+		_, err := s.apiClient().Ping(ctx, client.PingOptions{NegotiateAPIVersion: true})
+		if err != nil {
+			s.currentAPIVersion.err = err
+			return
+		}
+
+		version := s.apiClient().ClientVersion()
+		if version != "" {
+			s.currentAPIVersion.val = version
+			return
+		}
+
+		// Defensive fallback for unexpected client implementations or mocks that
+		// do not populate ClientVersion after a successful negotiated ping.
+		s.currentAPIVersion.val, s.currentAPIVersion.err = s.RuntimeVersion(ctx)
+	})
+
+	return s.currentAPIVersion.val, s.currentAPIVersion.err
 }

pkg/compose/convergence_test.go

@@ -411,11 +411,10 @@ func TestCreateMobyContainer(t *testing.T) {
 	apiClient.EXPECT().DaemonHost().Return("").AnyTimes()
 	apiClient.EXPECT().ImageInspect(anyCancellableContext(), gomock.Any()).Return(client.ImageInspectResult{}, nil).AnyTimes()
 
-	// force `RuntimeVersion` to fetch fresh version
-	runtimeVersion = runtimeVersionCache{}
-	apiClient.EXPECT().ServerVersion(gomock.Any(), gomock.Any()).Return(client.ServerVersionResult{
+	apiClient.EXPECT().Ping(gomock.Any(), client.PingOptions{NegotiateAPIVersion: true}).Return(client.PingResult{
 		APIVersion: "1.44",
 	}, nil).AnyTimes()
+	apiClient.EXPECT().ClientVersion().Return("1.44").AnyTimes()
 
 	service := types.ServiceConfig{
 		Name: "test",
@@ -498,3 +497,27 @@ func TestCreateMobyContainer(t *testing.T) {
 	assert.DeepEqual(t, want, got, cmpopts.EquateComparable(netip.Addr{}), cmpopts.EquateEmpty())
 	assert.NilError(t, err)
 }
+
+func TestCurrentAPIVersionCachesNegotiation(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	defer mockCtrl.Finish()
+
+	apiClient := mocks.NewMockAPIClient(mockCtrl)
+	cli := mocks.NewMockCli(mockCtrl)
+	tested := &composeService{dockerCli: cli}
+
+	cli.EXPECT().Client().Return(apiClient).AnyTimes()
+
+	apiClient.EXPECT().Ping(gomock.Any(), client.PingOptions{NegotiateAPIVersion: true}).Return(client.PingResult{
+		APIVersion: "1.44",
+	}, nil).Times(1)
+	apiClient.EXPECT().ClientVersion().Return("1.43").Times(1)
+
+	version, err := tested.CurrentAPIVersion(t.Context())
+	assert.NilError(t, err)
+	assert.Equal(t, version, "1.43")
+
+	version, err = tested.CurrentAPIVersion(t.Context())
+	assert.NilError(t, err)
+	assert.Equal(t, version, "1.43")
+}

pkg/compose/create.go

@@ -252,7 +252,7 @@ func (s *composeService) getCreateConfigs(ctx context.Context,
 	if err != nil {
 		return createConfigs{}, err
 	}
-	apiVersion, err := s.RuntimeVersion(ctx)
+	apiVersion, err := s.CurrentAPIVersion(ctx)
 	if err != nil {
 		return createConfigs{}, err
 	}
@@ -897,6 +897,8 @@ func (s *composeService) buildContainerVolumes(
 				}
 			}
 		case mount.TypeImage:
+			// This is a daemon capability check for mount type=image support, so
+			// use the raw server version rather than the negotiated request version.
 			version, err := s.RuntimeVersion(ctx)
 			if err != nil {
 				return nil, nil, err

pkg/compose/images.go

@@ -56,6 +56,8 @@ func (s *composeService) Images(ctx context.Context, projectName string, options
 		containers = allContainers.Items
 	}
 
+	// This is a daemon capability check for the ImageInspect platform field, so
+	// use the raw server version rather than the negotiated request version.
 	version, err := s.RuntimeVersion(ctx)
 	if err != nil {
 		return nil, err