Update traefik dependencies (docker/docker and related) (#1823)
Update traefik dependencies (docker/docker and related) - Update dependencies - Fix compilation problems - Remove vdemeester/docker-events (in docker api now) - Remove `integration/vendor` - Use `testImport` - update some deps. - regenerate the lock from scratch (after a `glide cc`)
This commit is contained in:
Vincent Demeester
Ludovic Fernandez
parent
7d178f49b4
commit
b7daa2f3a4
1301 changed files with 21476 additions and 150099 deletions
117
vendor/github.com/docker/libcompose/yaml/build.go
generated
vendored
Normal file
117
vendor/github.com/docker/libcompose/yaml/build.go
generated
vendored
Normal file
|
|
@ -0,0 +1,117 @@
|
|||
package yaml
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Build represents a build element in compose file.
|
||||
// It can take multiple form in the compose file, hence this special type
|
||||
type Build struct {
|
||||
Context string
|
||||
Dockerfile string
|
||||
Args map[string]*string
|
||||
}
|
||||
|
||||
// MarshalYAML implements the Marshaller interface.
|
||||
func (b Build) MarshalYAML() (interface{}, error) {
|
||||
m := map[string]interface{}{}
|
||||
if b.Context != "" {
|
||||
m["context"] = b.Context
|
||||
}
|
||||
if b.Dockerfile != "" {
|
||||
m["dockerfile"] = b.Dockerfile
|
||||
}
|
||||
if len(b.Args) > 0 {
|
||||
m["args"] = b.Args
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (b *Build) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var stringType string
|
||||
if err := unmarshal(&stringType); err == nil {
|
||||
b.Context = stringType
|
||||
return nil
|
||||
}
|
||||
|
||||
var mapType map[interface{}]interface{}
|
||||
if err := unmarshal(&mapType); err == nil {
|
||||
for mapKey, mapValue := range mapType {
|
||||
switch mapKey {
|
||||
case "context":
|
||||
b.Context = mapValue.(string)
|
||||
case "dockerfile":
|
||||
b.Dockerfile = mapValue.(string)
|
||||
case "args":
|
||||
args, err := handleBuildArgs(mapValue)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
b.Args = args
|
||||
default:
|
||||
// Ignore unknown keys
|
||||
continue
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal Build")
|
||||
}
|
||||
|
||||
func handleBuildArgs(value interface{}) (map[string]*string, error) {
|
||||
var args map[string]*string
|
||||
switch v := value.(type) {
|
||||
case map[interface{}]interface{}:
|
||||
return handleBuildArgMap(v)
|
||||
case []interface{}:
|
||||
return handleBuildArgSlice(v)
|
||||
default:
|
||||
return args, fmt.Errorf("Failed to unmarshal Build args: %#v", value)
|
||||
}
|
||||
}
|
||||
|
||||
func handleBuildArgSlice(s []interface{}) (map[string]*string, error) {
|
||||
var args = map[string]*string{}
|
||||
for _, arg := range s {
|
||||
// check if a value is provided
|
||||
switch v := strings.SplitN(arg.(string), "=", 2); len(v) {
|
||||
case 1:
|
||||
// if we have not specified a a value for this build arg, we assign it an ascii null value and query the environment
|
||||
// later when we build the service
|
||||
str := "\x00"
|
||||
args[v[0]] = &str
|
||||
case 2:
|
||||
// if we do have a value provided, we use it
|
||||
args[v[0]] = &v[1]
|
||||
}
|
||||
}
|
||||
return args, nil
|
||||
}
|
||||
|
||||
func handleBuildArgMap(m map[interface{}]interface{}) (map[string]*string, error) {
|
||||
args := map[string]*string{}
|
||||
for mapKey, mapValue := range m {
|
||||
var argValue string
|
||||
name, ok := mapKey.(string)
|
||||
if !ok {
|
||||
return args, fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", name, name)
|
||||
}
|
||||
switch a := mapValue.(type) {
|
||||
case string:
|
||||
argValue = a
|
||||
case int:
|
||||
argValue = strconv.Itoa(a)
|
||||
case int64:
|
||||
argValue = strconv.Itoa(int(a))
|
||||
default:
|
||||
return args, fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", mapValue, mapValue)
|
||||
}
|
||||
args[name] = &argValue
|
||||
}
|
||||
return args, nil
|
||||
}
|
||||
42
vendor/github.com/docker/libcompose/yaml/command.go
generated
vendored
Normal file
42
vendor/github.com/docker/libcompose/yaml/command.go
generated
vendored
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
package yaml
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/docker/docker/api/types/strslice"
|
||||
"github.com/flynn/go-shlex"
|
||||
)
|
||||
|
||||
// Command represents a docker command, can be a string or an array of strings.
|
||||
type Command strslice.StrSlice
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *Command) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var stringType string
|
||||
if err := unmarshal(&stringType); err == nil {
|
||||
parts, err := shlex.Split(stringType)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
var sliceType []interface{}
|
||||
if err := unmarshal(&sliceType); err == nil {
|
||||
parts, err := toStrings(sliceType)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
var interfaceType interface{}
|
||||
if err := unmarshal(&interfaceType); err == nil {
|
||||
fmt.Println(interfaceType)
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal Command")
|
||||
}
|
||||
37
vendor/github.com/docker/libcompose/yaml/external.go
generated
vendored
Normal file
37
vendor/github.com/docker/libcompose/yaml/external.go
generated
vendored
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
package yaml
|
||||
|
||||
// External represents an external network entry in compose file.
|
||||
// It can be a boolean (true|false) or have a name
|
||||
type External struct {
|
||||
External bool
|
||||
Name string
|
||||
}
|
||||
|
||||
// MarshalYAML implements the Marshaller interface.
|
||||
func (n External) MarshalYAML() (interface{}, error) {
|
||||
if n.Name == "" {
|
||||
return n.External, nil
|
||||
}
|
||||
return map[string]interface{}{
|
||||
"name": n.Name,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (n *External) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
if err := unmarshal(&n.External); err == nil {
|
||||
return nil
|
||||
}
|
||||
var dummyExternal struct {
|
||||
Name string
|
||||
}
|
||||
|
||||
err := unmarshal(&dummyExternal)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
n.Name = dummyExternal.Name
|
||||
n.External = true
|
||||
|
||||
return nil
|
||||
}
|
||||
139
vendor/github.com/docker/libcompose/yaml/network.go
generated
vendored
Normal file
139
vendor/github.com/docker/libcompose/yaml/network.go
generated
vendored
Normal file
|
|
@ -0,0 +1,139 @@
|
|||
package yaml
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Networks represents a list of service networks in compose file.
|
||||
// It has several representation, hence this specific struct.
|
||||
type Networks struct {
|
||||
Networks []*Network
|
||||
}
|
||||
|
||||
// Network represents a service network in compose file.
|
||||
type Network struct {
|
||||
Name string `yaml:"-"`
|
||||
RealName string `yaml:"-"`
|
||||
Aliases []string `yaml:"aliases,omitempty"`
|
||||
IPv4Address string `yaml:"ipv4_address,omitempty"`
|
||||
IPv6Address string `yaml:"ipv6_address,omitempty"`
|
||||
}
|
||||
|
||||
// Generate a hash string to detect service network config changes
|
||||
func (n *Networks) HashString() string {
|
||||
if n == nil {
|
||||
return ""
|
||||
}
|
||||
result := []string{}
|
||||
for _, net := range n.Networks {
|
||||
result = append(result, net.HashString())
|
||||
}
|
||||
sort.Strings(result)
|
||||
return strings.Join(result, ",")
|
||||
}
|
||||
|
||||
// Generate a hash string to detect service network config changes
|
||||
func (n *Network) HashString() string {
|
||||
if n == nil {
|
||||
return ""
|
||||
}
|
||||
result := []string{}
|
||||
result = append(result, n.Name)
|
||||
result = append(result, n.RealName)
|
||||
sort.Strings(n.Aliases)
|
||||
result = append(result, strings.Join(n.Aliases, ","))
|
||||
result = append(result, n.IPv4Address)
|
||||
result = append(result, n.IPv6Address)
|
||||
sort.Strings(result)
|
||||
return strings.Join(result, ",")
|
||||
}
|
||||
|
||||
// MarshalYAML implements the Marshaller interface.
|
||||
func (n Networks) MarshalYAML() (interface{}, error) {
|
||||
m := map[string]*Network{}
|
||||
for _, network := range n.Networks {
|
||||
m[network.Name] = network
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (n *Networks) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var sliceType []interface{}
|
||||
if err := unmarshal(&sliceType); err == nil {
|
||||
n.Networks = []*Network{}
|
||||
for _, network := range sliceType {
|
||||
name, ok := network.(string)
|
||||
if !ok {
|
||||
return fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", name, name)
|
||||
}
|
||||
n.Networks = append(n.Networks, &Network{
|
||||
Name: name,
|
||||
})
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
var mapType map[interface{}]interface{}
|
||||
if err := unmarshal(&mapType); err == nil {
|
||||
n.Networks = []*Network{}
|
||||
for mapKey, mapValue := range mapType {
|
||||
name, ok := mapKey.(string)
|
||||
if !ok {
|
||||
return fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", name, name)
|
||||
}
|
||||
network, err := handleNetwork(name, mapValue)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
n.Networks = append(n.Networks, network)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal Networks")
|
||||
}
|
||||
|
||||
func handleNetwork(name string, value interface{}) (*Network, error) {
|
||||
if value == nil {
|
||||
return &Network{
|
||||
Name: name,
|
||||
}, nil
|
||||
}
|
||||
switch v := value.(type) {
|
||||
case map[interface{}]interface{}:
|
||||
network := &Network{
|
||||
Name: name,
|
||||
}
|
||||
for mapKey, mapValue := range v {
|
||||
name, ok := mapKey.(string)
|
||||
if !ok {
|
||||
return &Network{}, fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", name, name)
|
||||
}
|
||||
switch name {
|
||||
case "aliases":
|
||||
aliases, ok := mapValue.([]interface{})
|
||||
if !ok {
|
||||
return &Network{}, fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", aliases, aliases)
|
||||
}
|
||||
network.Aliases = []string{}
|
||||
for _, alias := range aliases {
|
||||
network.Aliases = append(network.Aliases, alias.(string))
|
||||
}
|
||||
case "ipv4_address":
|
||||
network.IPv4Address = mapValue.(string)
|
||||
case "ipv6_address":
|
||||
network.IPv6Address = mapValue.(string)
|
||||
default:
|
||||
// Ignorer unknown keys ?
|
||||
continue
|
||||
}
|
||||
}
|
||||
return network, nil
|
||||
default:
|
||||
return &Network{}, fmt.Errorf("Failed to unmarshal Network: %#v", value)
|
||||
}
|
||||
}
|
||||
257
vendor/github.com/docker/libcompose/yaml/types_yaml.go
generated
vendored
Normal file
257
vendor/github.com/docker/libcompose/yaml/types_yaml.go
generated
vendored
Normal file
|
|
@ -0,0 +1,257 @@
|
|||
package yaml
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/docker/docker/api/types/strslice"
|
||||
"github.com/docker/go-units"
|
||||
)
|
||||
|
||||
// StringorInt represents a string or an integer.
|
||||
type StringorInt int64
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *StringorInt) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var intType int64
|
||||
if err := unmarshal(&intType); err == nil {
|
||||
*s = StringorInt(intType)
|
||||
return nil
|
||||
}
|
||||
|
||||
var stringType string
|
||||
if err := unmarshal(&stringType); err == nil {
|
||||
intType, err := strconv.ParseInt(stringType, 10, 64)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = StringorInt(intType)
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal StringorInt")
|
||||
}
|
||||
|
||||
// MemStringorInt represents a string or an integer
|
||||
// the String supports notations like 10m for then Megabyte of memory
|
||||
type MemStringorInt int64
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *MemStringorInt) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var intType int64
|
||||
if err := unmarshal(&intType); err == nil {
|
||||
*s = MemStringorInt(intType)
|
||||
return nil
|
||||
}
|
||||
|
||||
var stringType string
|
||||
if err := unmarshal(&stringType); err == nil {
|
||||
intType, err := units.RAMInBytes(stringType)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = MemStringorInt(intType)
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal MemStringorInt")
|
||||
}
|
||||
|
||||
// Stringorslice represents
|
||||
// Using engine-api Strslice and augment it with YAML marshalling stuff. a string or an array of strings.
|
||||
type Stringorslice strslice.StrSlice
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *Stringorslice) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var stringType string
|
||||
if err := unmarshal(&stringType); err == nil {
|
||||
*s = []string{stringType}
|
||||
return nil
|
||||
}
|
||||
|
||||
var sliceType []interface{}
|
||||
if err := unmarshal(&sliceType); err == nil {
|
||||
parts, err := toStrings(sliceType)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal Stringorslice")
|
||||
}
|
||||
|
||||
// SliceorMap represents a slice or a map of strings.
|
||||
type SliceorMap map[string]string
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *SliceorMap) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
|
||||
var sliceType []interface{}
|
||||
if err := unmarshal(&sliceType); err == nil {
|
||||
parts := map[string]string{}
|
||||
for _, s := range sliceType {
|
||||
if str, ok := s.(string); ok {
|
||||
str := strings.TrimSpace(str)
|
||||
keyValueSlice := strings.SplitN(str, "=", 2)
|
||||
|
||||
key := keyValueSlice[0]
|
||||
val := ""
|
||||
if len(keyValueSlice) == 2 {
|
||||
val = keyValueSlice[1]
|
||||
}
|
||||
parts[key] = val
|
||||
} else {
|
||||
return fmt.Errorf("Cannot unmarshal '%v' of type %T into a string value", s, s)
|
||||
}
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
var mapType map[interface{}]interface{}
|
||||
if err := unmarshal(&mapType); err == nil {
|
||||
parts := map[string]string{}
|
||||
for k, v := range mapType {
|
||||
if sk, ok := k.(string); ok {
|
||||
if sv, ok := v.(string); ok {
|
||||
parts[sk] = sv
|
||||
} else {
|
||||
return fmt.Errorf("Cannot unmarshal '%v' of type %T into a string value", v, v)
|
||||
}
|
||||
} else {
|
||||
return fmt.Errorf("Cannot unmarshal '%v' of type %T into a string value", k, k)
|
||||
}
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal SliceorMap")
|
||||
}
|
||||
|
||||
// MaporEqualSlice represents a slice of strings that gets unmarshal from a
|
||||
// YAML map into 'key=value' string.
|
||||
type MaporEqualSlice []string
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *MaporEqualSlice) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
parts, err := unmarshalToStringOrSepMapParts(unmarshal, "=")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
// ToMap returns the list of string as a map splitting using = the key=value
|
||||
func (s *MaporEqualSlice) ToMap() map[string]string {
|
||||
return toMap(*s, "=")
|
||||
}
|
||||
|
||||
// MaporColonSlice represents a slice of strings that gets unmarshal from a
|
||||
// YAML map into 'key:value' string.
|
||||
type MaporColonSlice []string
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *MaporColonSlice) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
parts, err := unmarshalToStringOrSepMapParts(unmarshal, ":")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
// ToMap returns the list of string as a map splitting using = the key=value
|
||||
func (s *MaporColonSlice) ToMap() map[string]string {
|
||||
return toMap(*s, ":")
|
||||
}
|
||||
|
||||
// MaporSpaceSlice represents a slice of strings that gets unmarshal from a
|
||||
// YAML map into 'key value' string.
|
||||
type MaporSpaceSlice []string
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (s *MaporSpaceSlice) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
parts, err := unmarshalToStringOrSepMapParts(unmarshal, " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
*s = parts
|
||||
return nil
|
||||
}
|
||||
|
||||
// ToMap returns the list of string as a map splitting using = the key=value
|
||||
func (s *MaporSpaceSlice) ToMap() map[string]string {
|
||||
return toMap(*s, " ")
|
||||
}
|
||||
|
||||
func unmarshalToStringOrSepMapParts(unmarshal func(interface{}) error, key string) ([]string, error) {
|
||||
var sliceType []interface{}
|
||||
if err := unmarshal(&sliceType); err == nil {
|
||||
return toStrings(sliceType)
|
||||
}
|
||||
var mapType map[interface{}]interface{}
|
||||
if err := unmarshal(&mapType); err == nil {
|
||||
return toSepMapParts(mapType, key)
|
||||
}
|
||||
return nil, errors.New("Failed to unmarshal MaporSlice")
|
||||
}
|
||||
|
||||
func toSepMapParts(value map[interface{}]interface{}, sep string) ([]string, error) {
|
||||
if len(value) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
parts := make([]string, 0, len(value))
|
||||
for k, v := range value {
|
||||
if sk, ok := k.(string); ok {
|
||||
if sv, ok := v.(string); ok {
|
||||
parts = append(parts, sk+sep+sv)
|
||||
} else if sv, ok := v.(int); ok {
|
||||
parts = append(parts, sk+sep+strconv.Itoa(sv))
|
||||
} else if sv, ok := v.(int64); ok {
|
||||
parts = append(parts, sk+sep+strconv.FormatInt(sv, 10))
|
||||
} else if sv, ok := v.(float64); ok {
|
||||
parts = append(parts, sk+sep+strconv.FormatFloat(sv, 'f', -1, 64))
|
||||
} else if v == nil {
|
||||
parts = append(parts, sk)
|
||||
} else {
|
||||
return nil, fmt.Errorf("Cannot unmarshal '%v' of type %T into a string value", v, v)
|
||||
}
|
||||
} else {
|
||||
return nil, fmt.Errorf("Cannot unmarshal '%v' of type %T into a string value", k, k)
|
||||
}
|
||||
}
|
||||
return parts, nil
|
||||
}
|
||||
|
||||
func toStrings(s []interface{}) ([]string, error) {
|
||||
if len(s) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
r := make([]string, len(s))
|
||||
for k, v := range s {
|
||||
if sv, ok := v.(string); ok {
|
||||
r[k] = sv
|
||||
} else {
|
||||
return nil, fmt.Errorf("Cannot unmarshal '%v' of type %T into a string value", v, v)
|
||||
}
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
func toMap(s []string, sep string) map[string]string {
|
||||
m := map[string]string{}
|
||||
for _, v := range s {
|
||||
// Return everything past first sep
|
||||
values := strings.Split(v, sep)
|
||||
m[values[0]] = strings.SplitN(v, sep, 2)[1]
|
||||
}
|
||||
return m
|
||||
}
|
||||
108
vendor/github.com/docker/libcompose/yaml/ulimit.go
generated
vendored
Normal file
108
vendor/github.com/docker/libcompose/yaml/ulimit.go
generated
vendored
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
package yaml
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
)
|
||||
|
||||
// Ulimits represents a list of Ulimit.
|
||||
// It is, however, represented in yaml as keys (and thus map in Go)
|
||||
type Ulimits struct {
|
||||
Elements []Ulimit
|
||||
}
|
||||
|
||||
// MarshalYAML implements the Marshaller interface.
|
||||
func (u Ulimits) MarshalYAML() (interface{}, error) {
|
||||
ulimitMap := make(map[string]Ulimit)
|
||||
for _, ulimit := range u.Elements {
|
||||
ulimitMap[ulimit.Name] = ulimit
|
||||
}
|
||||
return ulimitMap, nil
|
||||
}
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (u *Ulimits) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
ulimits := make(map[string]Ulimit)
|
||||
|
||||
var mapType map[interface{}]interface{}
|
||||
if err := unmarshal(&mapType); err == nil {
|
||||
for mapKey, mapValue := range mapType {
|
||||
name, ok := mapKey.(string)
|
||||
if !ok {
|
||||
return fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", name, name)
|
||||
}
|
||||
var soft, hard int64
|
||||
switch mv := mapValue.(type) {
|
||||
case int:
|
||||
soft = int64(mv)
|
||||
hard = int64(mv)
|
||||
case map[interface{}]interface{}:
|
||||
if len(mv) != 2 {
|
||||
return fmt.Errorf("Failed to unmarshal Ulimit: %#v", mapValue)
|
||||
}
|
||||
for mkey, mvalue := range mv {
|
||||
switch mkey {
|
||||
case "soft":
|
||||
soft = int64(mvalue.(int))
|
||||
case "hard":
|
||||
hard = int64(mvalue.(int))
|
||||
default:
|
||||
// FIXME(vdemeester) Should we ignore or fail ?
|
||||
continue
|
||||
}
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("Failed to unmarshal Ulimit: %v, %T", mapValue, mapValue)
|
||||
}
|
||||
ulimits[name] = Ulimit{
|
||||
Name: name,
|
||||
ulimitValues: ulimitValues{
|
||||
Soft: soft,
|
||||
Hard: hard,
|
||||
},
|
||||
}
|
||||
}
|
||||
keys := make([]string, 0, len(ulimits))
|
||||
for key := range ulimits {
|
||||
keys = append(keys, key)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
for _, key := range keys {
|
||||
u.Elements = append(u.Elements, ulimits[key])
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal Ulimit")
|
||||
}
|
||||
|
||||
// Ulimit represents ulimit information.
|
||||
type Ulimit struct {
|
||||
ulimitValues
|
||||
Name string
|
||||
}
|
||||
|
||||
type ulimitValues struct {
|
||||
Soft int64 `yaml:"soft"`
|
||||
Hard int64 `yaml:"hard"`
|
||||
}
|
||||
|
||||
// MarshalYAML implements the Marshaller interface.
|
||||
func (u Ulimit) MarshalYAML() (interface{}, error) {
|
||||
if u.Soft == u.Hard {
|
||||
return u.Soft, nil
|
||||
}
|
||||
return u.ulimitValues, nil
|
||||
}
|
||||
|
||||
// NewUlimit creates a Ulimit based on the specified parts.
|
||||
func NewUlimit(name string, soft int64, hard int64) Ulimit {
|
||||
return Ulimit{
|
||||
Name: name,
|
||||
ulimitValues: ulimitValues{
|
||||
Soft: soft,
|
||||
Hard: hard,
|
||||
},
|
||||
}
|
||||
}
|
||||
97
vendor/github.com/docker/libcompose/yaml/volume.go
generated
vendored
Normal file
97
vendor/github.com/docker/libcompose/yaml/volume.go
generated
vendored
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
package yaml
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Volumes represents a list of service volumes in compose file.
|
||||
// It has several representation, hence this specific struct.
|
||||
type Volumes struct {
|
||||
Volumes []*Volume
|
||||
}
|
||||
|
||||
// Volume represent a service volume
|
||||
type Volume struct {
|
||||
Source string `yaml:"-"`
|
||||
Destination string `yaml:"-"`
|
||||
AccessMode string `yaml:"-"`
|
||||
}
|
||||
|
||||
// Generate a hash string to detect service volume config changes
|
||||
func (v *Volumes) HashString() string {
|
||||
if v == nil {
|
||||
return ""
|
||||
}
|
||||
result := []string{}
|
||||
for _, vol := range v.Volumes {
|
||||
result = append(result, vol.String())
|
||||
}
|
||||
sort.Strings(result)
|
||||
return strings.Join(result, ",")
|
||||
}
|
||||
|
||||
// String implements the Stringer interface.
|
||||
func (v *Volume) String() string {
|
||||
var paths []string
|
||||
if v.Source != "" {
|
||||
paths = []string{v.Source, v.Destination}
|
||||
} else {
|
||||
paths = []string{v.Destination}
|
||||
}
|
||||
if v.AccessMode != "" {
|
||||
paths = append(paths, v.AccessMode)
|
||||
}
|
||||
return strings.Join(paths, ":")
|
||||
}
|
||||
|
||||
// MarshalYAML implements the Marshaller interface.
|
||||
func (v Volumes) MarshalYAML() (interface{}, error) {
|
||||
vs := []string{}
|
||||
for _, volume := range v.Volumes {
|
||||
vs = append(vs, volume.String())
|
||||
}
|
||||
return vs, nil
|
||||
}
|
||||
|
||||
// UnmarshalYAML implements the Unmarshaller interface.
|
||||
func (v *Volumes) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
||||
var sliceType []interface{}
|
||||
if err := unmarshal(&sliceType); err == nil {
|
||||
v.Volumes = []*Volume{}
|
||||
for _, volume := range sliceType {
|
||||
name, ok := volume.(string)
|
||||
if !ok {
|
||||
return fmt.Errorf("Cannot unmarshal '%v' to type %T into a string value", name, name)
|
||||
}
|
||||
elts := strings.SplitN(name, ":", 3)
|
||||
var vol *Volume
|
||||
switch {
|
||||
case len(elts) == 1:
|
||||
vol = &Volume{
|
||||
Destination: elts[0],
|
||||
}
|
||||
case len(elts) == 2:
|
||||
vol = &Volume{
|
||||
Source: elts[0],
|
||||
Destination: elts[1],
|
||||
}
|
||||
case len(elts) == 3:
|
||||
vol = &Volume{
|
||||
Source: elts[0],
|
||||
Destination: elts[1],
|
||||
AccessMode: elts[2],
|
||||
}
|
||||
default:
|
||||
// FIXME
|
||||
return fmt.Errorf("")
|
||||
}
|
||||
v.Volumes = append(v.Volumes, vol)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
return errors.New("Failed to unmarshal Volumes")
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue