412 lines
12 KiB
Go
412 lines
12 KiB
Go
/*
|
|
Copyright 2020 Docker Compose CLI authors
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package compose
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
|
|
convert "github.com/docker/compose-cli/local/moby"
|
|
"github.com/docker/compose-cli/progress"
|
|
|
|
"github.com/compose-spec/compose-go/types"
|
|
moby "github.com/docker/docker/api/types"
|
|
"github.com/docker/docker/api/types/container"
|
|
"github.com/docker/docker/api/types/mount"
|
|
"github.com/docker/docker/api/types/network"
|
|
"github.com/docker/docker/api/types/strslice"
|
|
volume_api "github.com/docker/docker/api/types/volume"
|
|
"github.com/docker/docker/errdefs"
|
|
"github.com/docker/go-connections/nat"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
func (s *composeService) Create(ctx context.Context, project *types.Project) error {
|
|
err := s.ensureImagesExists(ctx, project)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for k, network := range project.Networks {
|
|
if !network.External.External && network.Name != "" {
|
|
network.Name = fmt.Sprintf("%s_%s", project.Name, k)
|
|
project.Networks[k] = network
|
|
}
|
|
network.Labels = network.Labels.Add(networkLabel, k)
|
|
network.Labels = network.Labels.Add(projectLabel, project.Name)
|
|
network.Labels = network.Labels.Add(versionLabel, ComposeVersion)
|
|
err := s.ensureNetwork(ctx, network)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for k, volume := range project.Volumes {
|
|
if !volume.External.External && volume.Name != "" {
|
|
volume.Name = fmt.Sprintf("%s_%s", project.Name, k)
|
|
project.Volumes[k] = volume
|
|
}
|
|
volume.Labels = volume.Labels.Add(volumeLabel, k)
|
|
volume.Labels = volume.Labels.Add(projectLabel, project.Name)
|
|
volume.Labels = volume.Labels.Add(versionLabel, ComposeVersion)
|
|
err := s.ensureVolume(ctx, volume)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return InDependencyOrder(ctx, project, func(c context.Context, service types.ServiceConfig) error {
|
|
return s.ensureService(c, project, service)
|
|
})
|
|
}
|
|
|
|
func getContainerCreateOptions(p *types.Project, s types.ServiceConfig, number int, inherit *moby.Container) (*container.Config, *container.HostConfig, *network.NetworkingConfig, error) {
|
|
hash, err := jsonHash(s)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
// TODO: change oneoffLabel value for containers started with `docker compose run`
|
|
labels := map[string]string{
|
|
projectLabel: p.Name,
|
|
serviceLabel: s.Name,
|
|
versionLabel: ComposeVersion,
|
|
oneoffLabel: "False",
|
|
configHashLabel: hash,
|
|
workingDirLabel: p.WorkingDir,
|
|
configFilesLabel: strings.Join(p.ComposeFiles, ","),
|
|
containerNumberLabel: strconv.Itoa(number),
|
|
}
|
|
|
|
var (
|
|
runCmd strslice.StrSlice
|
|
entrypoint strslice.StrSlice
|
|
)
|
|
if len(s.Command) > 0 {
|
|
runCmd = strslice.StrSlice(s.Command)
|
|
}
|
|
if len(s.Entrypoint) > 0 {
|
|
entrypoint = strslice.StrSlice(s.Entrypoint)
|
|
}
|
|
image := s.Image
|
|
if s.Image == "" {
|
|
image = fmt.Sprintf("%s_%s", p.Name, s.Name)
|
|
}
|
|
|
|
var (
|
|
tty = s.Tty
|
|
stdinOpen = s.StdinOpen
|
|
attachStdin = false
|
|
)
|
|
|
|
containerConfig := container.Config{
|
|
Hostname: s.Hostname,
|
|
Domainname: s.DomainName,
|
|
User: s.User,
|
|
ExposedPorts: buildContainerPorts(s),
|
|
Tty: tty,
|
|
OpenStdin: stdinOpen,
|
|
StdinOnce: true,
|
|
AttachStdin: attachStdin,
|
|
AttachStderr: true,
|
|
AttachStdout: true,
|
|
Cmd: runCmd,
|
|
Image: image,
|
|
WorkingDir: s.WorkingDir,
|
|
Entrypoint: entrypoint,
|
|
NetworkDisabled: s.NetworkMode == "disabled",
|
|
MacAddress: s.MacAddress,
|
|
Labels: labels,
|
|
StopSignal: s.StopSignal,
|
|
Env: convert.ToMobyEnv(s.Environment),
|
|
Healthcheck: convert.ToMobyHealthCheck(s.HealthCheck),
|
|
// Volumes: // FIXME unclear to me the overlap with HostConfig.Mounts
|
|
StopTimeout: convert.ToSeconds(s.StopGracePeriod),
|
|
}
|
|
|
|
mountOptions, err := buildContainerMountOptions(s, inherit)
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
bindings := buildContainerBindingOptions(s)
|
|
|
|
networkMode := getNetworkMode(p, s)
|
|
hostConfig := container.HostConfig{
|
|
Mounts: mountOptions,
|
|
CapAdd: strslice.StrSlice(s.CapAdd),
|
|
CapDrop: strslice.StrSlice(s.CapDrop),
|
|
NetworkMode: networkMode,
|
|
Init: s.Init,
|
|
ReadonlyRootfs: s.ReadOnly,
|
|
// ShmSize: , TODO
|
|
Sysctls: s.Sysctls,
|
|
PortBindings: bindings,
|
|
}
|
|
|
|
networkConfig := buildDefaultNetworkConfig(s, networkMode)
|
|
return &containerConfig, &hostConfig, networkConfig, nil
|
|
}
|
|
|
|
func buildContainerPorts(s types.ServiceConfig) nat.PortSet {
|
|
ports := nat.PortSet{}
|
|
for _, p := range s.Ports {
|
|
p := nat.Port(fmt.Sprintf("%d/%s", p.Target, p.Protocol))
|
|
ports[p] = struct{}{}
|
|
}
|
|
return ports
|
|
}
|
|
|
|
func buildContainerBindingOptions(s types.ServiceConfig) nat.PortMap {
|
|
bindings := nat.PortMap{}
|
|
for _, port := range s.Ports {
|
|
p := nat.Port(fmt.Sprintf("%d/%s", port.Target, port.Protocol))
|
|
bind := []nat.PortBinding{}
|
|
binding := nat.PortBinding{}
|
|
if port.Published > 0 {
|
|
binding.HostPort = fmt.Sprint(port.Published)
|
|
}
|
|
bind = append(bind, binding)
|
|
bindings[p] = bind
|
|
}
|
|
return bindings
|
|
}
|
|
|
|
func buildContainerMountOptions(s types.ServiceConfig, inherit *moby.Container) ([]mount.Mount, error) {
|
|
mounts := []mount.Mount{}
|
|
var inherited []string
|
|
if inherit != nil {
|
|
for _, m := range inherit.Mounts {
|
|
if m.Type == "tmpfs" {
|
|
continue
|
|
}
|
|
src := m.Source
|
|
if m.Type == "volume" {
|
|
src = m.Name
|
|
}
|
|
mounts = append(mounts, mount.Mount{
|
|
Type: m.Type,
|
|
Source: src,
|
|
Target: m.Destination,
|
|
ReadOnly: !m.RW,
|
|
})
|
|
inherited = append(inherited, m.Destination)
|
|
}
|
|
}
|
|
|
|
for _, v := range s.Volumes {
|
|
if contains(inherited, v.Target) {
|
|
continue
|
|
}
|
|
mount, err := buildMount(v)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
mounts = append(mounts, mount)
|
|
}
|
|
return mounts, nil
|
|
}
|
|
|
|
func buildMount(volume types.ServiceVolumeConfig) (mount.Mount, error) {
|
|
source := volume.Source
|
|
if volume.Type == "bind" && !filepath.IsAbs(source) {
|
|
// volume source has already been prefixed with workdir if required, by compose-go project loader
|
|
var err error
|
|
source, err = filepath.Abs(source)
|
|
if err != nil {
|
|
return mount.Mount{}, err
|
|
}
|
|
}
|
|
|
|
return mount.Mount{
|
|
Type: mount.Type(volume.Type),
|
|
Source: source,
|
|
Target: volume.Target,
|
|
ReadOnly: volume.ReadOnly,
|
|
Consistency: mount.Consistency(volume.Consistency),
|
|
BindOptions: buildBindOption(volume.Bind),
|
|
VolumeOptions: buildVolumeOptions(volume.Volume),
|
|
TmpfsOptions: buildTmpfsOptions(volume.Tmpfs),
|
|
}, nil
|
|
}
|
|
|
|
func buildBindOption(bind *types.ServiceVolumeBind) *mount.BindOptions {
|
|
if bind == nil {
|
|
return nil
|
|
}
|
|
return &mount.BindOptions{
|
|
Propagation: mount.Propagation(bind.Propagation),
|
|
// NonRecursive: false, FIXME missing from model ?
|
|
}
|
|
}
|
|
|
|
func buildVolumeOptions(vol *types.ServiceVolumeVolume) *mount.VolumeOptions {
|
|
if vol == nil {
|
|
return nil
|
|
}
|
|
return &mount.VolumeOptions{
|
|
NoCopy: vol.NoCopy,
|
|
// Labels: , // FIXME missing from model ?
|
|
// DriverConfig: , // FIXME missing from model ?
|
|
}
|
|
}
|
|
|
|
func buildTmpfsOptions(tmpfs *types.ServiceVolumeTmpfs) *mount.TmpfsOptions {
|
|
if tmpfs == nil {
|
|
return nil
|
|
}
|
|
return &mount.TmpfsOptions{
|
|
SizeBytes: tmpfs.Size,
|
|
// Mode: , // FIXME missing from model ?
|
|
}
|
|
}
|
|
|
|
func buildDefaultNetworkConfig(s types.ServiceConfig, networkMode container.NetworkMode) *network.NetworkingConfig {
|
|
config := map[string]*network.EndpointSettings{}
|
|
net := string(networkMode)
|
|
config[net] = &network.EndpointSettings{
|
|
Aliases: getAliases(s, s.Networks[net]),
|
|
}
|
|
|
|
return &network.NetworkingConfig{
|
|
EndpointsConfig: config,
|
|
}
|
|
}
|
|
|
|
func getAliases(s types.ServiceConfig, c *types.ServiceNetworkConfig) []string {
|
|
aliases := []string{s.Name}
|
|
if c != nil {
|
|
aliases = append(aliases, c.Aliases...)
|
|
}
|
|
return aliases
|
|
}
|
|
|
|
func getNetworkMode(p *types.Project, service types.ServiceConfig) container.NetworkMode {
|
|
mode := service.NetworkMode
|
|
if mode == "" {
|
|
if len(p.Networks) > 0 {
|
|
for name := range getNetworksForService(service) {
|
|
return container.NetworkMode(p.Networks[name].Name)
|
|
}
|
|
}
|
|
return container.NetworkMode("none")
|
|
}
|
|
|
|
// FIXME incomplete implementation
|
|
if strings.HasPrefix(mode, "service:") {
|
|
panic("Not yet implemented")
|
|
}
|
|
if strings.HasPrefix(mode, "container:") {
|
|
panic("Not yet implemented")
|
|
}
|
|
|
|
return container.NetworkMode(mode)
|
|
}
|
|
|
|
func getNetworksForService(s types.ServiceConfig) map[string]*types.ServiceNetworkConfig {
|
|
if len(s.Networks) > 0 {
|
|
return s.Networks
|
|
}
|
|
return map[string]*types.ServiceNetworkConfig{"default": nil}
|
|
}
|
|
|
|
func (s *composeService) ensureNetwork(ctx context.Context, n types.NetworkConfig) error {
|
|
_, err := s.apiClient.NetworkInspect(ctx, n.Name, moby.NetworkInspectOptions{})
|
|
if err != nil {
|
|
if errdefs.IsNotFound(err) {
|
|
if n.External.External {
|
|
return fmt.Errorf("network %s declared as external, but could not be found", n.Name)
|
|
}
|
|
createOpts := moby.NetworkCreate{
|
|
// TODO NameSpace Labels
|
|
Labels: n.Labels,
|
|
Driver: n.Driver,
|
|
Options: n.DriverOpts,
|
|
Internal: n.Internal,
|
|
Attachable: n.Attachable,
|
|
}
|
|
|
|
if n.Ipam.Driver != "" || len(n.Ipam.Config) > 0 {
|
|
createOpts.IPAM = &network.IPAM{}
|
|
}
|
|
|
|
if n.Ipam.Driver != "" {
|
|
createOpts.IPAM.Driver = n.Ipam.Driver
|
|
}
|
|
|
|
for _, ipamConfig := range n.Ipam.Config {
|
|
config := network.IPAMConfig{
|
|
Subnet: ipamConfig.Subnet,
|
|
}
|
|
createOpts.IPAM.Config = append(createOpts.IPAM.Config, config)
|
|
}
|
|
networkEventName := fmt.Sprintf("Network %q", n.Name)
|
|
w := progress.ContextWriter(ctx)
|
|
w.Event(progress.CreatingEvent(networkEventName))
|
|
if _, err := s.apiClient.NetworkCreate(ctx, n.Name, createOpts); err != nil {
|
|
w.Event(progress.ErrorEvent(networkEventName))
|
|
return errors.Wrapf(err, "failed to create network %s", n.Name)
|
|
}
|
|
w.Event(progress.CreatedEvent(networkEventName))
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *composeService) ensureNetworkDown(ctx context.Context, networkID string, networkName string) error {
|
|
w := progress.ContextWriter(ctx)
|
|
eventName := fmt.Sprintf("Network %q", networkName)
|
|
w.Event(progress.RemovingEvent(eventName))
|
|
|
|
if err := s.apiClient.NetworkRemove(ctx, networkID); err != nil {
|
|
w.Event(progress.ErrorEvent(eventName))
|
|
return errors.Wrapf(err, fmt.Sprintf("failed to create network %s", networkID))
|
|
}
|
|
|
|
w.Event(progress.RemovedEvent(eventName))
|
|
return nil
|
|
}
|
|
|
|
func (s *composeService) ensureVolume(ctx context.Context, volume types.VolumeConfig) error {
|
|
// TODO could identify volume by label vs name
|
|
_, err := s.apiClient.VolumeInspect(ctx, volume.Name)
|
|
if err != nil {
|
|
if !errdefs.IsNotFound(err) {
|
|
return err
|
|
}
|
|
eventName := fmt.Sprintf("Volume %q", volume.Name)
|
|
w := progress.ContextWriter(ctx)
|
|
w.Event(progress.CreatingEvent(eventName))
|
|
// TODO we miss support for driver_opts and labels
|
|
_, err := s.apiClient.VolumeCreate(ctx, volume_api.VolumeCreateBody{
|
|
Labels: volume.Labels,
|
|
Name: volume.Name,
|
|
Driver: volume.Driver,
|
|
DriverOpts: volume.DriverOpts,
|
|
})
|
|
if err != nil {
|
|
w.Event(progress.ErrorEvent(eventName))
|
|
return err
|
|
}
|
|
w.Event(progress.CreatedEvent(eventName))
|
|
}
|
|
return nil
|
|
}
|