141 lines
4.2 KiB
Go
141 lines
4.2 KiB
Go
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.Replace(strings.ToUpper(n), "-", "_", -1)
|
|
|
|
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 {
|
|
parts := strings.SplitN(v, "=", 2)
|
|
if len(parts) < 2 {
|
|
continue
|
|
}
|
|
// Ignore a few variables that are added during docker build (and not really relevant to linked containers)
|
|
if parts[0] == "HOME" || parts[0] == "PATH" {
|
|
continue
|
|
}
|
|
env = append(env, fmt.Sprintf("%s_ENV_%s=%s", alias, parts[0], parts[1]))
|
|
}
|
|
}
|
|
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
|
|
}
|