Skip to content

Modern Docker Management, Designed for Everyone

12.5 KB
Raw Blame
package swarm

import (
	"cmp"
	"context"
	"fmt"
	"maps"
	"slices"
	"strings"

	composegotypes "github.com/compose-spec/compose-go/v2/types"
	cerrdefs "github.com/containerd/errdefs"
	"github.com/moby/moby/api/types/swarm"
	dockerclient "github.com/moby/moby/client"
)

type resourceMeta struct {
	ID   string
	Name string
}

type managedFileResourceSpecInternal struct {
	Name           string
	Labels         map[string]string
	Data           []byte
	Driver         string
	DriverOpts     map[string]string
	TemplateDriver string
}

type plannedFileResourceInternal struct {
	Meta       resourceMeta
	BaseName   string
	Hash       string
	Config     composegotypes.FileObjectConfig
	Labels     map[string]string
	Data       []byte
	IsExternal bool
}

type fileResourceAdapterInternal struct {
	ResourceType string
	Inspect      func(context.Context, string) (resourceMeta, error)
	Create       func(context.Context, managedFileResourceSpecInternal) (resourceMeta, error)
	List         func(context.Context, dockerclient.Filters) ([]staleManagedResourceInternal, error)
	Remove       func(context.Context, string) error
}

func planNetworksInternal(project *composegotypes.Project, ns namespace) map[string]string {
	result := make(map[string]string, len(project.Networks))
	for key, config := range project.Networks {
		result[key] = ns.Resolve(key, config.Name)
	}
	return result
}

func planVolumesInternal(project *composegotypes.Project, ns namespace) map[string]string {
	result := make(map[string]string, len(project.Volumes))
	for key, config := range project.Volumes {
		result[key] = ns.Resolve(key, config.Name)
	}
	return result
}

func planConfigsInternal(project *composegotypes.Project, ns namespace) (map[string]plannedFileResourceInternal, error) {
	configs := make(map[string]composegotypes.FileObjectConfig, len(project.Configs))
	for key, config := range project.Configs {
		configs[key] = composegotypes.FileObjectConfig(config)
	}
	return planManagedFileResourcesInternal(configs, ns, project.WorkingDir, project.Environment, "config")
}

func planSecretsInternal(project *composegotypes.Project, ns namespace) (map[string]plannedFileResourceInternal, error) {
	secrets := make(map[string]composegotypes.FileObjectConfig, len(project.Secrets))
	for key, secret := range project.Secrets {
		secrets[key] = composegotypes.FileObjectConfig(secret)
	}
	return planManagedFileResourcesInternal(secrets, ns, project.WorkingDir, project.Environment, "secret")
}

func planManagedFileResourcesInternal(
	resources map[string]composegotypes.FileObjectConfig,
	ns namespace,
	workingDir string,
	environment composegotypes.Mapping,
	resourceType string,
) (map[string]plannedFileResourceInternal, error) {
	result := make(map[string]plannedFileResourceInternal, len(resources))
	for _, key := range slices.Sorted(maps.Keys(resources)) {
		resource := resources[key]
		baseName := ns.Resolve(key, resource.Name)
		plan := plannedFileResourceInternal{
			Meta:       resourceMeta{Name: baseName},
			BaseName:   baseName,
			Config:     resource,
			Labels:     resource.Labels,
			IsExternal: bool(resource.External),
		}
		if resource.External {
			result[key] = plan
			continue
		}
		if resourceType == "config" && resource.Driver != "" {
			return nil, fmt.Errorf("config driver %q is not supported by the Docker swarm API", resource.Driver)
		}

		var data []byte
		if resource.Driver == "" {
			resolvedData, err := resolveFileObjectContentInternal(resource, workingDir, environment)
			if err != nil {
				return nil, fmt.Errorf("failed to load %s %s: %w", resourceType, baseName, err)
			}
			data = resolvedData
		}
		plan.Data = data
		plan.Hash = hashManagedFileResourceInternal(resource, data)
		plan.Meta.Name = managedResourceNameInternal(baseName, plan.Hash)
		result[key] = plan
	}
	return result, nil
}

func ensureSwarmNetworksInternal(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, ns namespace, stackLabels map[string]string) (map[string]string, error) {
	result := planNetworksInternal(project, ns)
	for _, key := range slices.Sorted(maps.Keys(project.Networks)) {
		cfg := project.Networks[key]
		networkName := result[key]

		if cfg.External {
			if networkName == "bridge" || networkName == "host" || networkName == "none" {
				continue
			}
			inspected, err := dockerClient.NetworkInspect(ctx, networkName, dockerclient.NetworkInspectOptions{Scope: "swarm"})
			if err != nil {
				return nil, invalidStackErrorInternal(fmt.Errorf("external network %s is unavailable: %w", networkName, err))
			}
			if inspected.Network.Scope != "swarm" {
				return nil, invalidStackErrorInternal(fmt.Errorf("external network %q has scope %q, expected swarm", networkName, inspected.Network.Scope))
			}
			continue
		}

		_, err := dockerClient.NetworkInspect(ctx, networkName, dockerclient.NetworkInspectOptions{Scope: "swarm"})
		if err == nil {
			continue
		}
		if !cerrdefs.IsNotFound(err) {
			return nil, fmt.Errorf("failed to inspect network %s: %w", networkName, err)
		}

		driver := cmp.Or(strings.TrimSpace(cfg.Driver), "overlay")

		labels := mergeLabelsInternal(cfg.Labels, stackLabels)
		createOpts := dockerclient.NetworkCreateOptions{
			Driver:     driver,
			Scope:      "swarm",
			EnableIPv4: cfg.EnableIPv4,
			EnableIPv6: cfg.EnableIPv6,
			Internal:   cfg.Internal,
			Attachable: cfg.Attachable,
			Options:    cfg.DriverOpts,
			Labels:     labels,
			IPAM:       convertIPAMInternal(cfg.Ipam),
		}

		if _, networkCreateErr := dockerClient.NetworkCreate(ctx, networkName, createOpts); networkCreateErr != nil {
			return nil, fmt.Errorf("failed to create network %s: %w", networkName, networkCreateErr)
		}
	}

	return result, nil
}

// ensureSwarmVolumesInternal pre-creates named volumes that carry a driver or
// driver_opts so that Swarm services pick up the correct volume configuration.
// Without this step Docker creates a plain local volume on first use and the
// driver options are silently ignored — the root cause of issue #2376.
func ensureSwarmVolumesInternal(ctx context.Context, dockerClient *dockerclient.Client, project *composegotypes.Project, ns namespace, stackLabels map[string]string) error {
	volumeNameByKey := planVolumesInternal(project, ns)
	for _, key := range slices.Sorted(maps.Keys(project.Volumes)) {
		cfg := project.Volumes[key]
		// External volumes must already exist; nothing to create.
		if cfg.External {
			continue
		}
		// Only act when driver or driver_opts are explicitly set.
		if cfg.Driver == "" && len(cfg.DriverOpts) == 0 {
			continue
		}

		name := volumeNameByKey[key]

		// If the volume already exists, leave it as-is to avoid disrupting
		// running services that may be attached to it.
		if _, err := dockerClient.VolumeInspect(ctx, name, dockerclient.VolumeInspectOptions{}); err == nil {
			continue
		} else if !cerrdefs.IsNotFound(err) {
			return fmt.Errorf("failed to inspect volume %s: %w", name, err)
		}

		driver := cmp.Or(cfg.Driver, "local")
		labels := mergeLabelsInternal(cfg.Labels, stackLabels)
		if _, err := dockerClient.VolumeCreate(ctx, dockerclient.VolumeCreateOptions{
			Name:       name,
			Driver:     driver,
			DriverOpts: cfg.DriverOpts,
			Labels:     labels,
		}); err != nil {
			return fmt.Errorf("failed to create volume %s: %w", name, err)
		}
	}
	return nil
}

func configFileResourceAdapterInternal(dockerClient *dockerclient.Client) fileResourceAdapterInternal {
	return fileResourceAdapterInternal{
		ResourceType: "config",
		Inspect: func(ctx context.Context, name string) (resourceMeta, error) {
			configResult, err := dockerClient.ConfigInspect(ctx, name, dockerclient.ConfigInspectOptions{})
			if err != nil {
				return resourceMeta{}, err
			}
			config := configResult.Config
			return resourceMeta{ID: config.ID, Name: config.Spec.Name}, nil
		},
		Create: func(ctx context.Context, resource managedFileResourceSpecInternal) (resourceMeta, error) {
			spec := swarm.ConfigSpec{
				Name: resource.Name, Labels: resource.Labels,
				Data: resource.Data,
			}
			if resource.TemplateDriver != "" {
				spec.Templating = &swarm.Driver{Name: resource.TemplateDriver}
			}
			response, err := dockerClient.ConfigCreate(ctx, dockerclient.ConfigCreateOptions{Spec: spec})
			if err != nil {
				return resourceMeta{}, fmt.Errorf("failed to create config %s: %w", resource.Name, err)
			}
			return resourceMeta{ID: response.ID, Name: resource.Name}, nil
		},
		List: func(ctx context.Context, filters dockerclient.Filters) ([]staleManagedResourceInternal, error) {
			configsResult, err := dockerClient.ConfigList(ctx, dockerclient.ConfigListOptions{Filters: filters})
			if err != nil {
				return nil, fmt.Errorf("failed to list stack configs: %w", err)
			}
			return collectStaleManagedResourcesInternal(configsResult.Items, func(cfg swarm.Config) staleManagedResourceInternal {
				return staleManagedResourceInternal{ID: cfg.ID, Name: cfg.Spec.Name}
			}), nil
		},
		Remove: func(ctx context.Context, id string) error {
			_, err := dockerClient.ConfigRemove(ctx, id, dockerclient.ConfigRemoveOptions{})
			return err
		},
	}
}

func secretFileResourceAdapterInternal(dockerClient *dockerclient.Client) fileResourceAdapterInternal {
	return fileResourceAdapterInternal{
		ResourceType: "secret",
		Inspect: func(ctx context.Context, name string) (resourceMeta, error) {
			secretResult, err := dockerClient.SecretInspect(ctx, name, dockerclient.SecretInspectOptions{})
			if err != nil {
				return resourceMeta{}, err
			}
			secret := secretResult.Secret
			return resourceMeta{ID: secret.ID, Name: secret.Spec.Name}, nil
		},
		Create: func(ctx context.Context, resource managedFileResourceSpecInternal) (resourceMeta, error) {
			spec := swarm.SecretSpec{
				Name: resource.Name, Labels: resource.Labels,
				Data: resource.Data,
			}
			if resource.Driver != "" {
				spec.Driver = &swarm.Driver{Name: resource.Driver, Options: resource.DriverOpts}
			}
			if resource.TemplateDriver != "" {
				spec.Templating = &swarm.Driver{Name: resource.TemplateDriver}
			}
			response, err := dockerClient.SecretCreate(ctx, dockerclient.SecretCreateOptions{Spec: spec})
			if err != nil {
				return resourceMeta{}, fmt.Errorf("failed to create secret %s: %w", resource.Name, err)
			}
			return resourceMeta{ID: response.ID, Name: resource.Name}, nil
		},
		List: func(ctx context.Context, filters dockerclient.Filters) ([]staleManagedResourceInternal, error) {
			secretsResult, err := dockerClient.SecretList(ctx, dockerclient.SecretListOptions{Filters: filters})
			if err != nil {
				return nil, fmt.Errorf("failed to list stack secrets: %w", err)
			}
			return collectStaleManagedResourcesInternal(secretsResult.Items, func(secret swarm.Secret) staleManagedResourceInternal {
				return staleManagedResourceInternal{ID: secret.ID, Name: secret.Spec.Name}
			}), nil
		},
		Remove: func(ctx context.Context, id string) error {
			_, err := dockerClient.SecretRemove(ctx, id, dockerclient.SecretRemoveOptions{})
			return err
		},
	}
}

func ensurePlannedFileResourcesInternal(
	ctx context.Context,
	plans map[string]plannedFileResourceInternal,
	stackLabels map[string]string,
	adapter fileResourceAdapterInternal,
) (map[string]resourceMeta, error) {
	result := make(map[string]resourceMeta, len(plans))
	for _, key := range slices.Sorted(maps.Keys(plans)) {
		plan := plans[key]
		if plan.IsExternal {
			meta, err := adapter.Inspect(ctx, plan.Meta.Name)
			if err != nil {
				return nil, invalidStackErrorInternal(fmt.Errorf("external %s %s is unavailable: %w", adapter.ResourceType,
					plan.Meta.Name, err),
				)
			}
			result[key] = meta
			continue
		}

		meta, err := ensureManagedFileResourceInternal(ctx, plan, stackLabels, adapter)
		if err != nil {
			return nil, err
		}
		result[key] = meta
	}
	return result, nil
}

func ensureManagedFileResourceInternal(
	ctx context.Context,
	plan plannedFileResourceInternal,
	stackLabels map[string]string,
	adapter fileResourceAdapterInternal,
) (resourceMeta, error) {
	if meta, err := adapter.Inspect(ctx, plan.Meta.Name); err == nil {
		return meta, nil
	} else if !cerrdefs.IsNotFound(err) {
		return resourceMeta{}, fmt.Errorf("failed to inspect %s %s: %w", adapter.ResourceType, plan.Meta.Name, err)
	}

	resourceLabels := mergeLabelsInternal(plan.Labels, stackLabels)
	resourceLabels[resourceTypeLabel] = adapter.ResourceType
	resourceLabels[resourceNameLabel] = plan.BaseName
	resourceLabels[resourceHashLabel] = plan.Hash
	return adapter.Create(ctx, managedFileResourceSpecInternal{
		Name:           plan.Meta.Name,
		Labels:         resourceLabels,
		Data:           plan.Data,
		Driver:         plan.Config.Driver,
		DriverOpts:     plan.Config.DriverOpts,
		TemplateDriver: plan.Config.TemplateDriver,
	})
}