352 lines
8.7 KiB
Go
352 lines
8.7 KiB
Go
package docker
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/dotcloud/docker/namesgenerator"
|
|
"github.com/dotcloud/docker/utils"
|
|
"io/ioutil"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// Compare two Config struct. Do not compare the "Image" nor "Hostname" fields
|
|
// If OpenStdin is set, then it differs
|
|
func CompareConfig(a, b *Config) bool {
|
|
if a == nil || b == nil ||
|
|
a.OpenStdin || b.OpenStdin {
|
|
return false
|
|
}
|
|
if a.AttachStdout != b.AttachStdout ||
|
|
a.AttachStderr != b.AttachStderr ||
|
|
a.User != b.User ||
|
|
a.Memory != b.Memory ||
|
|
a.MemorySwap != b.MemorySwap ||
|
|
a.CpuShares != b.CpuShares ||
|
|
a.OpenStdin != b.OpenStdin ||
|
|
a.Tty != b.Tty ||
|
|
a.VolumesFrom != b.VolumesFrom {
|
|
return false
|
|
}
|
|
if len(a.Cmd) != len(b.Cmd) ||
|
|
len(a.Dns) != len(b.Dns) ||
|
|
len(a.Env) != len(b.Env) ||
|
|
len(a.PortSpecs) != len(b.PortSpecs) ||
|
|
len(a.ExposedPorts) != len(b.ExposedPorts) ||
|
|
len(a.Entrypoint) != len(b.Entrypoint) ||
|
|
len(a.Volumes) != len(b.Volumes) {
|
|
return false
|
|
}
|
|
|
|
for i := 0; i < len(a.Cmd); i++ {
|
|
if a.Cmd[i] != b.Cmd[i] {
|
|
return false
|
|
}
|
|
}
|
|
for i := 0; i < len(a.Dns); i++ {
|
|
if a.Dns[i] != b.Dns[i] {
|
|
return false
|
|
}
|
|
}
|
|
for i := 0; i < len(a.Env); i++ {
|
|
if a.Env[i] != b.Env[i] {
|
|
return false
|
|
}
|
|
}
|
|
for i := 0; i < len(a.PortSpecs); i++ {
|
|
if a.PortSpecs[i] != b.PortSpecs[i] {
|
|
return false
|
|
}
|
|
}
|
|
for k := range a.ExposedPorts {
|
|
if _, exists := b.ExposedPorts[k]; !exists {
|
|
return false
|
|
}
|
|
}
|
|
for i := 0; i < len(a.Entrypoint); i++ {
|
|
if a.Entrypoint[i] != b.Entrypoint[i] {
|
|
return false
|
|
}
|
|
}
|
|
for key := range a.Volumes {
|
|
if _, exists := b.Volumes[key]; !exists {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func MergeConfig(userConf, imageConf *Config) error {
|
|
if userConf.User == "" {
|
|
userConf.User = imageConf.User
|
|
}
|
|
if userConf.Memory == 0 {
|
|
userConf.Memory = imageConf.Memory
|
|
}
|
|
if userConf.MemorySwap == 0 {
|
|
userConf.MemorySwap = imageConf.MemorySwap
|
|
}
|
|
if userConf.CpuShares == 0 {
|
|
userConf.CpuShares = imageConf.CpuShares
|
|
}
|
|
if userConf.ExposedPorts == nil || len(userConf.ExposedPorts) == 0 {
|
|
userConf.ExposedPorts = imageConf.ExposedPorts
|
|
} else if imageConf.ExposedPorts != nil {
|
|
if userConf.ExposedPorts == nil {
|
|
userConf.ExposedPorts = make(map[Port]struct{})
|
|
}
|
|
for port := range imageConf.ExposedPorts {
|
|
if _, exists := userConf.ExposedPorts[port]; !exists {
|
|
userConf.ExposedPorts[port] = struct{}{}
|
|
}
|
|
}
|
|
}
|
|
|
|
if userConf.PortSpecs != nil && len(userConf.PortSpecs) > 0 {
|
|
if userConf.ExposedPorts == nil {
|
|
userConf.ExposedPorts = make(map[Port]struct{})
|
|
}
|
|
ports, _, err := parsePortSpecs(userConf.PortSpecs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for port := range ports {
|
|
if _, exists := userConf.ExposedPorts[port]; !exists {
|
|
userConf.ExposedPorts[port] = struct{}{}
|
|
}
|
|
}
|
|
userConf.PortSpecs = nil
|
|
}
|
|
if imageConf.PortSpecs != nil && len(imageConf.PortSpecs) > 0 {
|
|
utils.Debugf("Migrating image port specs to containter: %s", strings.Join(imageConf.PortSpecs, ", "))
|
|
if userConf.ExposedPorts == nil {
|
|
userConf.ExposedPorts = make(map[Port]struct{})
|
|
}
|
|
|
|
ports, _, err := parsePortSpecs(imageConf.PortSpecs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for port := range ports {
|
|
if _, exists := userConf.ExposedPorts[port]; !exists {
|
|
userConf.ExposedPorts[port] = struct{}{}
|
|
}
|
|
}
|
|
}
|
|
if !userConf.Tty {
|
|
userConf.Tty = imageConf.Tty
|
|
}
|
|
if !userConf.OpenStdin {
|
|
userConf.OpenStdin = imageConf.OpenStdin
|
|
}
|
|
if !userConf.StdinOnce {
|
|
userConf.StdinOnce = imageConf.StdinOnce
|
|
}
|
|
if userConf.Env == nil || len(userConf.Env) == 0 {
|
|
userConf.Env = imageConf.Env
|
|
} else {
|
|
for _, imageEnv := range imageConf.Env {
|
|
found := false
|
|
imageEnvKey := strings.Split(imageEnv, "=")[0]
|
|
for _, userEnv := range userConf.Env {
|
|
userEnvKey := strings.Split(userEnv, "=")[0]
|
|
if imageEnvKey == userEnvKey {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
userConf.Env = append(userConf.Env, imageEnv)
|
|
}
|
|
}
|
|
}
|
|
if userConf.Cmd == nil || len(userConf.Cmd) == 0 {
|
|
userConf.Cmd = imageConf.Cmd
|
|
}
|
|
if userConf.Dns == nil || len(userConf.Dns) == 0 {
|
|
userConf.Dns = imageConf.Dns
|
|
} else {
|
|
//duplicates aren't an issue here
|
|
userConf.Dns = append(userConf.Dns, imageConf.Dns...)
|
|
}
|
|
if userConf.Entrypoint == nil || len(userConf.Entrypoint) == 0 {
|
|
userConf.Entrypoint = imageConf.Entrypoint
|
|
}
|
|
if userConf.WorkingDir == "" {
|
|
userConf.WorkingDir = imageConf.WorkingDir
|
|
}
|
|
if userConf.VolumesFrom == "" {
|
|
userConf.VolumesFrom = imageConf.VolumesFrom
|
|
}
|
|
if userConf.Volumes == nil || len(userConf.Volumes) == 0 {
|
|
userConf.Volumes = imageConf.Volumes
|
|
} else {
|
|
for k, v := range imageConf.Volumes {
|
|
userConf.Volumes[k] = v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func parseLxcConfOpts(opts utils.ListOpts) ([]KeyValuePair, error) {
|
|
out := make([]KeyValuePair, len(opts))
|
|
for i, o := range opts {
|
|
k, v, err := parseLxcOpt(o)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out[i] = KeyValuePair{Key: k, Value: v}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func parseLxcOpt(opt string) (string, string, error) {
|
|
parts := strings.SplitN(opt, "=", 2)
|
|
if len(parts) != 2 {
|
|
return "", "", fmt.Errorf("Unable to parse lxc conf option: %s", opt)
|
|
}
|
|
return strings.TrimSpace(parts[0]), strings.TrimSpace(parts[1]), nil
|
|
}
|
|
|
|
// FIXME: network related stuff (including parsing) should be grouped in network file
|
|
const (
|
|
PortSpecTemplate = "ip:hostPort:containerPort"
|
|
PortSpecTemplateFormat = "ip:hostPort:containerPort | ip::containerPort | hostPort:containerPort"
|
|
)
|
|
|
|
// We will receive port specs in the format of ip:public:private/proto and these need to be
|
|
// parsed in the internal types
|
|
func parsePortSpecs(ports []string) (map[Port]struct{}, map[Port][]PortBinding, error) {
|
|
var (
|
|
exposedPorts = make(map[Port]struct{}, len(ports))
|
|
bindings = make(map[Port][]PortBinding)
|
|
)
|
|
|
|
for _, rawPort := range ports {
|
|
proto := "tcp"
|
|
|
|
if i := strings.LastIndex(rawPort, "/"); i != -1 {
|
|
proto = rawPort[i+1:]
|
|
rawPort = rawPort[:i]
|
|
}
|
|
if !strings.Contains(rawPort, ":") {
|
|
rawPort = fmt.Sprintf("::%s", rawPort)
|
|
} else if len(strings.Split(rawPort, ":")) == 2 {
|
|
rawPort = fmt.Sprintf(":%s", rawPort)
|
|
}
|
|
|
|
parts, err := utils.PartParser(PortSpecTemplate, rawPort)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
var (
|
|
containerPort = parts["containerPort"]
|
|
rawIp = parts["ip"]
|
|
hostPort = parts["hostPort"]
|
|
)
|
|
|
|
if containerPort == "" {
|
|
return nil, nil, fmt.Errorf("No port specified: %s<empty>", rawPort)
|
|
}
|
|
if _, err := strconv.ParseUint(containerPort, 10, 16); err != nil {
|
|
return nil, nil, fmt.Errorf("Invalid containerPort: %s", containerPort)
|
|
}
|
|
if _, err := strconv.ParseUint(hostPort, 10, 16); hostPort != "" && err != nil {
|
|
return nil, nil, fmt.Errorf("Invalid hostPort: %s", hostPort)
|
|
}
|
|
|
|
port := NewPort(proto, containerPort)
|
|
if _, exists := exposedPorts[port]; !exists {
|
|
exposedPorts[port] = struct{}{}
|
|
}
|
|
|
|
binding := PortBinding{
|
|
HostIp: rawIp,
|
|
HostPort: hostPort,
|
|
}
|
|
bslice, exists := bindings[port]
|
|
if !exists {
|
|
bslice = []PortBinding{}
|
|
}
|
|
bindings[port] = append(bslice, binding)
|
|
}
|
|
return exposedPorts, bindings, nil
|
|
}
|
|
|
|
// Splits a port in the format of port/proto
|
|
func splitProtoPort(rawPort string) (string, string) {
|
|
parts := strings.Split(rawPort, "/")
|
|
l := len(parts)
|
|
if l == 0 {
|
|
return "", ""
|
|
}
|
|
if l == 1 {
|
|
return "tcp", rawPort
|
|
}
|
|
return parts[0], parts[1]
|
|
}
|
|
|
|
func parsePort(rawPort string) (int, error) {
|
|
port, err := strconv.ParseUint(rawPort, 10, 16)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return int(port), nil
|
|
}
|
|
|
|
func migratePortMappings(config *Config, hostConfig *HostConfig) error {
|
|
if config.PortSpecs != nil {
|
|
ports, bindings, err := parsePortSpecs(config.PortSpecs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
config.PortSpecs = nil
|
|
if len(bindings) > 0 {
|
|
if hostConfig == nil {
|
|
hostConfig = &HostConfig{}
|
|
}
|
|
hostConfig.PortBindings = bindings
|
|
}
|
|
|
|
if config.ExposedPorts == nil {
|
|
config.ExposedPorts = make(map[Port]struct{}, len(ports))
|
|
}
|
|
for k, v := range ports {
|
|
config.ExposedPorts[k] = v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Links come in the format of
|
|
// name:alias
|
|
func parseLink(rawLink string) (map[string]string, error) {
|
|
return utils.PartParser("name:alias", rawLink)
|
|
}
|
|
|
|
func RootIsShared() bool {
|
|
if data, err := ioutil.ReadFile("/proc/self/mountinfo"); err == nil {
|
|
for _, line := range strings.Split(string(data), "\n") {
|
|
cols := strings.Split(line, " ")
|
|
if len(cols) >= 6 && cols[4] == "/" {
|
|
return strings.HasPrefix(cols[6], "shared")
|
|
}
|
|
}
|
|
}
|
|
|
|
// No idea, probably safe to assume so
|
|
return true
|
|
}
|
|
|
|
type checker struct {
|
|
runtime *Runtime
|
|
}
|
|
|
|
func (c *checker) Exists(name string) bool {
|
|
return c.runtime.containerGraph.Exists("/" + name)
|
|
}
|
|
|
|
// Generate a random and unique name
|
|
func generateRandomName(runtime *Runtime) (string, error) {
|
|
return namesgenerator.GenerateRandomName(&checker{runtime})
|
|
}
|