Fix incompatibility issues after upgrading compose-go

cli/compose/convert/compose.go

@@ -5,7 +5,6 @@ import (
 	"strings"
 
 	composetypes "github.com/compose-spec/compose-go/v2/types"
-	"github.com/docker/docker/api/types"
 	networktypes "github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/api/types/swarm"
 )
@@ -52,45 +51,45 @@ func AddStackLabel(namespace Namespace, labels map[string]string) map[string]str
 type networkMap map[string]composetypes.NetworkConfig
 
 // Networks from the compose-file type to the engine API type
-func Networks(namespace Namespace, networks composetypes.Networks, servicesNetworks map[string]struct{}) (map[string]types.NetworkCreate, []string) {
+func Networks(namespace Namespace, networks composetypes.Networks, servicesNetworks map[string]struct{}) (map[string]networktypes.CreateOptions, []string) {
 	if networks == nil {
 		networks = make(map[string]composetypes.NetworkConfig)
 	}
 
 	externalNetworks := []string{}
-	result := make(map[string]network.CreateOptions)
+	result := make(map[string]networktypes.CreateOptions)
 	for internalName := range servicesNetworks {
 		network := networks[internalName]
 		if network.External {
 			externalNetworks = append(externalNetworks, network.Name)
 			continue
 		}
 
-		createOpts := network.CreateOptions{
-			Labels:     AddStackLabel(namespace, nw.Labels),
-			Driver:     nw.Driver,
-			Options:    nw.DriverOpts,
-			Internal:   nw.Internal,
-			Attachable: nw.Attachable,
+		createOpts := networktypes.CreateOptions{
+			Labels:     AddStackLabel(namespace, network.Labels),
+			Driver:     network.Driver,
+			Options:    network.DriverOpts,
+			Internal:   network.Internal,
+			Attachable: network.Attachable,
 		}
 
-		if nw.Ipam.Driver != "" || len(nw.Ipam.Config) > 0 {
-			createOpts.IPAM = &network.IPAM{}
+		if network.Ipam.Driver != "" || len(network.Ipam.Config) > 0 {
+			createOpts.IPAM = &networktypes.IPAM{}
 		}
 
-		if nw.Ipam.Driver != "" {
-			createOpts.IPAM.Driver = nw.Ipam.Driver
+		if network.Ipam.Driver != "" {
+			createOpts.IPAM.Driver = network.Ipam.Driver
 		}
-		for _, ipamConfig := range nw.Ipam.Config {
-			config := network.IPAMConfig{
+		for _, ipamConfig := range network.Ipam.Config {
+			config := networktypes.IPAMConfig{
 				Subnet: ipamConfig.Subnet,
 			}
 			createOpts.IPAM.Config = append(createOpts.IPAM.Config, config)
 		}
 
 		networkName := namespace.Scope(internalName)
-		if nw.Name != "" {
-			networkName = nw.Name
+		if network.Name != "" {
+			networkName = network.Name
 		}
 		result[networkName] = createOpts
 	}

cli/compose/convert/service.go

@@ -85,10 +85,7 @@ func Service(
 		return swarm.ServiceSpec{}, err
 	}
 
-	resources, err := convertResources(service.Deploy.Resources)
-	if err != nil {
-		return swarm.ServiceSpec{}, err
-	}
+	resources := convertResources(service.Deploy.Resources)
 
 	restartPolicy, err := convertRestartPolicy(
 		service.Restart, service.Deploy.RestartPolicy)
@@ -535,31 +532,18 @@ func convertUpdateConfig(source *composetypes.UpdateConfig) *swarm.UpdateConfig
 	}
 }
 
-func convertResources(source composetypes.Resources) (*swarm.ResourceRequirements, error) {
+func convertResources(source composetypes.Resources) *swarm.ResourceRequirements {
 	resources := &swarm.ResourceRequirements{}
-	var err error
 	if source.Limits != nil {
-		var cpus int64
-		if source.Limits.NanoCPUs != "" {
-			cpus, err = opts.ParseCPUs(source.Limits.NanoCPUs)
-			if err != nil {
-				return nil, err
-			}
-		}
+		cpus := int64(source.Limits.NanoCPUs * 1e9)
 		resources.Limits = &swarm.Limit{
 			NanoCPUs:    cpus,
 			MemoryBytes: int64(source.Limits.MemoryBytes),
 			Pids:        source.Limits.Pids,
 		}
 	}
 	if source.Reservations != nil {
-		var cpus int64
-		if source.Reservations.NanoCPUs != "" {
-			cpus, err = opts.ParseCPUs(source.Reservations.NanoCPUs)
-			if err != nil {
-				return nil, err
-			}
-		}
+		cpus := int64(source.Reservations.NanoCPUs * 1e9)
 
 		var generic []swarm.GenericResource
 		for _, res := range source.Reservations.GenericResources {
@@ -581,7 +565,7 @@ func convertResources(source composetypes.Resources) (*swarm.ResourceRequirement
 			GenericResources: generic,
 		}
 	}
-	return resources, nil
+	return resources
 }
 
 func convertEndpointSpec(endpointMode string, source []composetypes.ServicePortConfig) (*swarm.EndpointSpec, error) {

cli/compose/convert/service_test.go

@@ -83,16 +83,15 @@ func TestConvertExtraHosts(t *testing.T) {
 func TestConvertResourcesFull(t *testing.T) {
 	source := composetypes.Resources{
 		Limits: &composetypes.Resource{
-			NanoCPUs:    "0.003",
+			NanoCPUs:    0.003,
 			MemoryBytes: composetypes.UnitBytes(300000000),
 		},
 		Reservations: &composetypes.Resource{
-			NanoCPUs:    "0.002",
+			NanoCPUs:    0.002,
 			MemoryBytes: composetypes.UnitBytes(200000000),
 		},
 	}
-	resources, err := convertResources(source)
-	assert.NilError(t, err)
+	resources := convertResources(source)
 
 	expected := &swarm.ResourceRequirements{
 		Limits: &swarm.Limit{
@@ -116,8 +115,7 @@ func TestConvertResourcesOnlyMemory(t *testing.T) {
 			MemoryBytes: composetypes.UnitBytes(200000000),
 		},
 	}
-	resources, err := convertResources(source)
-	assert.NilError(t, err)
+	resources := convertResources(source)
 
 	expected := &swarm.ResourceRequirements{
 		Limits: &swarm.Limit{

cli/compose/convert/volume_test.go

@@ -154,49 +154,6 @@ func TestConvertVolumeToMountConflictingOptionsTmpfsInBind(t *testing.T) {
 	assert.Error(t, err, "tmpfs options are incompatible with type bind")
 }
 
-func TestConvertVolumeToMountConflictingOptionsClusterInVolume(t *testing.T) {
-	namespace := NewNamespace("foo")
-
-	config := composetypes.ServiceVolumeConfig{
-		Type:    "volume",
-		Target:  "/target",
-		Cluster: &composetypes.ServiceVolumeCluster{},
-	}
-	_, err := convertVolumeToMount(config, volumes{}, namespace)
-	assert.Error(t, err, "cluster options are incompatible with type volume")
-}
-
-func TestConvertVolumeToMountConflictingOptionsClusterInBind(t *testing.T) {
-	namespace := NewNamespace("foo")
-
-	config := composetypes.ServiceVolumeConfig{
-		Type:   "bind",
-		Source: "/foo",
-		Target: "/target",
-		Bind: &composetypes.ServiceVolumeBind{
-			Propagation: "slave",
-		},
-		Cluster: &composetypes.ServiceVolumeCluster{},
-	}
-	_, err := convertVolumeToMount(config, volumes{}, namespace)
-	assert.Error(t, err, "cluster options are incompatible with type bind")
-}
-
-func TestConvertVolumeToMountConflictingOptionsClusterInTmpfs(t *testing.T) {
-	namespace := NewNamespace("foo")
-
-	config := composetypes.ServiceVolumeConfig{
-		Type:   "tmpfs",
-		Target: "/target",
-		Tmpfs: &composetypes.ServiceVolumeTmpfs{
-			Size: 1000,
-		},
-		Cluster: &composetypes.ServiceVolumeCluster{},
-	}
-	_, err := convertVolumeToMount(config, volumes{}, namespace)
-	assert.Error(t, err, "cluster options are incompatible with type tmpfs")
-}
-
 func TestConvertVolumeToMountConflictingOptionsBindInTmpfs(t *testing.T) {
 	namespace := NewNamespace("foo")
 

cli/compose/loader/full-struct_test.go

@@ -90,12 +90,12 @@ func services(workingDir, homeDir string) types.Services {
 				},
 				Resources: types.Resources{
 					Limits: &types.Resource{
-						NanoCPUs:    "0.001",
+						NanoCPUs:    0.001,
 						MemoryBytes: 50 * 1024 * 1024,
 						Pids:        100,
 					},
 					Reservations: &types.Resource{
-						NanoCPUs:    "0.0001",
+						NanoCPUs:    0.0001,
 						MemoryBytes: 20 * 1024 * 1024,
 						GenericResources: []types.GenericResource{
 							{
@@ -130,7 +130,9 @@ func services(workingDir, homeDir string) types.Services {
 				},
 				EndpointMode: "dnsrr",
 			},
-			Devices:    []string{"/dev/ttyUSB0:/dev/ttyUSB0"},
+			Devices: []types.DeviceMapping{{
+				Source: "/dev/ttyUSB0", Target: "/dev/ttyUSB0",
+			}},
 			DNS:        []string{"8.8.8.8", "9.9.9.9"},
 			DNSSearch:  []string{"dc1.example.com", "dc2.example.com"},
 			DomainName: "foo.com",