dotcloud/docker

package links // import "github.com/docker/docker/daemon/links"

import (
    "fmt"
    "path"
    "strings"

    "github.com/docker/go-connections/nat"
)

// Link struct holds information about parent/child linked container
type Link struct {
    // Parent container IP address
    ParentIP string
    // Child container IP address
    ChildIP string
    // Link name
    Name string
    // Child environments variables
    ChildEnvironment []string
    // Child exposed ports
    Ports []nat.Port
}

// NewLink initializes a new Link struct with the provided options.
func NewLink(parentIP, childIP, name string, env []string, exposedPorts map[nat.Port]struct{}) *Link {
    var (
        i     int
        ports = make([]nat.Port, len(exposedPorts))
    )

    for p := range exposedPorts {
        ports[i] = p
        i++
    }

    return &Link{
        Name:             name,
        ChildIP:          childIP,
        ParentIP:         parentIP,
        ChildEnvironment: env,
        Ports:            ports,
    }
}

// ToEnv creates a string's slice containing child container information in
// the form of environment variables which will be later exported on container
// startup.
func (l *Link) ToEnv() []string {
    env := []string{}

    _, n := path.Split(l.Name)
    alias := strings.ReplaceAll(strings.ToUpper(n), "-", "_")

    if p := l.getDefaultPort(); p != nil {
        env = append(env, fmt.Sprintf("%s_PORT=%s://%s:%s", alias, p.Proto(), l.ChildIP, p.Port()))
    }

    // sort the ports so that we can bulk the continuous ports together
    nat.Sort(l.Ports, func(ip, jp nat.Port) bool {
        // If the two ports have the same number, tcp takes priority
        // Sort in desc order
        return ip.Int() < jp.Int() || (ip.Int() == jp.Int() && strings.ToLower(ip.Proto()) == "tcp")
    })

    for i := 0; i < len(l.Ports); {
        p := l.Ports[i]
        j := nextContiguous(l.Ports, p.Int(), i)
        if j > i+1 {
            env = append(env, fmt.Sprintf("%s_PORT_%s_%s_START=%s://%s:%s", alias, p.Port(), strings.ToUpper(p.Proto()), p.Proto(), l.ChildIP, p.Port()))
            env = append(env, fmt.Sprintf("%s_PORT_%s_%s_ADDR=%s", alias, p.Port(), strings.ToUpper(p.Proto()), l.ChildIP))
            env = append(env, fmt.Sprintf("%s_PORT_%s_%s_PROTO=%s", alias, p.Port(), strings.ToUpper(p.Proto()), p.Proto()))
            env = append(env, fmt.Sprintf("%s_PORT_%s_%s_PORT_START=%s", alias, p.Port(), strings.ToUpper(p.Proto()), p.Port()))

            q := l.Ports[j]
            env = append(env, fmt.Sprintf("%s_PORT_%s_%s_END=%s://%s:%s", alias, p.Port(), strings.ToUpper(q.Proto()), q.Proto(), l.ChildIP, q.Port()))
            env = append(env, fmt.Sprintf("%s_PORT_%s_%s_PORT_END=%s", alias, p.Port(), strings.ToUpper(q.Proto()), q.Port()))

            i = j + 1
            continue
        } else {
            i++
        }
    }
    for _, p := range l.Ports {
        env = append(env, fmt.Sprintf("%s_PORT_%s_%s=%s://%s:%s", alias, p.Port(), strings.ToUpper(p.Proto()), p.Proto(), l.ChildIP, p.Port()))
        env = append(env, fmt.Sprintf("%s_PORT_%s_%s_ADDR=%s", alias, p.Port(), strings.ToUpper(p.Proto()), l.ChildIP))
        env = append(env, fmt.Sprintf("%s_PORT_%s_%s_PORT=%s", alias, p.Port(), strings.ToUpper(p.Proto()), p.Port()))
        env = append(env, fmt.Sprintf("%s_PORT_%s_%s_PROTO=%s", alias, p.Port(), strings.ToUpper(p.Proto()), p.Proto()))
    }

    // Load the linked container's name into the environment
    env = append(env, fmt.Sprintf("%s_NAME=%s", alias, l.Name))

    if l.ChildEnvironment != nil {
        for _, v := range l.ChildEnvironment {
            name, val, ok := strings.Cut(v, "=")
            if !ok {
                continue
            }
            // Ignore a few variables that are added during docker build (and not really relevant to linked containers)
            if name == "HOME" || name == "PATH" {
                continue
            }
            env = append(env, fmt.Sprintf("%s_ENV_%s=%s", alias, name, val))
        }
    }
    return env
}

func nextContiguous(ports []nat.Port, value int, index int) int {
    if index+1 == len(ports) {
        return index
    }
    for i := index + 1; i < len(ports); i++ {
        if ports[i].Int() > value+1 {
            return i - 1
        }

        value++
    }
    return len(ports) - 1
}

// Default port rules
func (l *Link) getDefaultPort() *nat.Port {
    var p nat.Port
    i := len(l.Ports)

    if i == 0 {
        return nil
    } else if i > 1 {
        nat.Sort(l.Ports, func(ip, jp nat.Port) bool {
            // If the two ports have the same number, tcp takes priority
            // Sort in desc order
            return ip.Int() < jp.Int() || (ip.Int() == jp.Int() && strings.ToLower(ip.Proto()) == "tcp")
        })
    }
    p = l.Ports[0]
    return &p
}