2013-12-08 10:06:05 +04:00
|
|
|
package engine
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
2013-12-12 05:03:48 +04:00
|
|
|
"encoding/json"
|
2013-12-08 10:06:05 +04:00
|
|
|
"fmt"
|
2013-12-12 05:03:48 +04:00
|
|
|
"io"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
2015-03-10 21:25:47 +03:00
|
|
|
"time"
|
2015-01-19 03:27:14 +03:00
|
|
|
|
|
|
|
"github.com/docker/docker/utils"
|
2013-12-08 10:06:05 +04:00
|
|
|
)
|
|
|
|
|
|
|
|
type Env []string
|
|
|
|
|
2014-09-11 06:20:20 +04:00
|
|
|
// Get returns the last value associated with the given key. If there are no
|
|
|
|
// values associated with the key, Get returns the empty string.
|
2013-12-08 10:06:05 +04:00
|
|
|
func (env *Env) Get(key string) (value string) {
|
2014-09-11 06:20:20 +04:00
|
|
|
// not using Map() because of the extra allocations https://github.com/docker/docker/pull/7488#issuecomment-51638315
|
2013-12-08 10:06:05 +04:00
|
|
|
for _, kv := range *env {
|
|
|
|
if strings.Index(kv, "=") == -1 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
parts := strings.SplitN(kv, "=", 2)
|
|
|
|
if parts[0] != key {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if len(parts) < 2 {
|
|
|
|
value = ""
|
|
|
|
} else {
|
|
|
|
value = parts[1]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) Exists(key string) bool {
|
|
|
|
_, exists := env.Map()[key]
|
|
|
|
return exists
|
|
|
|
}
|
|
|
|
|
2014-04-28 10:57:41 +04:00
|
|
|
// Len returns the number of keys in the environment.
|
|
|
|
// Note that len(env) might be different from env.Len(),
|
|
|
|
// because the same key might be set multiple times.
|
|
|
|
func (env *Env) Len() int {
|
|
|
|
return len(env.Map())
|
|
|
|
}
|
|
|
|
|
2014-02-16 03:05:28 +04:00
|
|
|
func (env *Env) Init(src *Env) {
|
2014-02-25 00:08:37 +04:00
|
|
|
(*env) = make([]string, 0, len(*src))
|
2014-02-16 03:05:28 +04:00
|
|
|
for _, val := range *src {
|
|
|
|
(*env) = append((*env), val)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-08 10:06:05 +04:00
|
|
|
func (env *Env) GetBool(key string) (value bool) {
|
|
|
|
s := strings.ToLower(strings.Trim(env.Get(key), " \t"))
|
|
|
|
if s == "" || s == "0" || s == "no" || s == "false" || s == "none" {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) SetBool(key string, value bool) {
|
|
|
|
if value {
|
|
|
|
env.Set(key, "1")
|
|
|
|
} else {
|
|
|
|
env.Set(key, "0")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-10 21:25:47 +03:00
|
|
|
func (env *Env) GetTime(key string) (time.Time, error) {
|
|
|
|
t, err := time.Parse(time.RFC3339Nano, env.Get(key))
|
|
|
|
return t, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) SetTime(key string, t time.Time) {
|
|
|
|
env.Set(key, t.Format(time.RFC3339Nano))
|
|
|
|
}
|
|
|
|
|
2013-12-13 01:35:50 +04:00
|
|
|
func (env *Env) GetInt(key string) int {
|
|
|
|
return int(env.GetInt64(key))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) GetInt64(key string) int64 {
|
2013-12-08 10:06:05 +04:00
|
|
|
s := strings.Trim(env.Get(key), " \t")
|
|
|
|
val, err := strconv.ParseInt(s, 10, 64)
|
|
|
|
if err != nil {
|
2014-01-31 06:06:08 +04:00
|
|
|
return 0
|
2013-12-08 10:06:05 +04:00
|
|
|
}
|
|
|
|
return val
|
|
|
|
}
|
|
|
|
|
2013-12-13 01:35:50 +04:00
|
|
|
func (env *Env) SetInt(key string, value int) {
|
|
|
|
env.Set(key, fmt.Sprintf("%d", value))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) SetInt64(key string, value int64) {
|
2013-12-08 10:06:05 +04:00
|
|
|
env.Set(key, fmt.Sprintf("%d", value))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Returns nil if key not found
|
|
|
|
func (env *Env) GetList(key string) []string {
|
|
|
|
sval := env.Get(key)
|
|
|
|
if sval == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
l := make([]string, 0, 1)
|
|
|
|
if err := json.Unmarshal([]byte(sval), &l); err != nil {
|
|
|
|
l = append(l, sval)
|
|
|
|
}
|
|
|
|
return l
|
|
|
|
}
|
|
|
|
|
2014-01-28 07:26:24 +04:00
|
|
|
func (env *Env) GetSubEnv(key string) *Env {
|
|
|
|
sval := env.Get(key)
|
|
|
|
if sval == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
buf := bytes.NewBufferString(sval)
|
|
|
|
var sub Env
|
|
|
|
if err := sub.Decode(buf); err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return &sub
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) SetSubEnv(key string, sub *Env) error {
|
|
|
|
var buf bytes.Buffer
|
|
|
|
if err := sub.Encode(&buf); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
env.Set(key, string(buf.Bytes()))
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-12-14 03:01:54 +04:00
|
|
|
func (env *Env) GetJson(key string, iface interface{}) error {
|
2013-12-12 05:03:48 +04:00
|
|
|
sval := env.Get(key)
|
|
|
|
if sval == "" {
|
|
|
|
return nil
|
|
|
|
}
|
2013-12-14 03:01:54 +04:00
|
|
|
return json.Unmarshal([]byte(sval), iface)
|
2013-12-12 05:03:48 +04:00
|
|
|
}
|
|
|
|
|
2013-12-08 10:06:05 +04:00
|
|
|
func (env *Env) SetJson(key string, value interface{}) error {
|
|
|
|
sval, err := json.Marshal(value)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
env.Set(key, string(sval))
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) SetList(key string, value []string) error {
|
|
|
|
return env.SetJson(key, value)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) Set(key, value string) {
|
|
|
|
*env = append(*env, key+"="+value)
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewDecoder(src io.Reader) *Decoder {
|
|
|
|
return &Decoder{
|
|
|
|
json.NewDecoder(src),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type Decoder struct {
|
|
|
|
*json.Decoder
|
|
|
|
}
|
|
|
|
|
|
|
|
func (decoder *Decoder) Decode() (*Env, error) {
|
|
|
|
m := make(map[string]interface{})
|
|
|
|
if err := decoder.Decoder.Decode(&m); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
env := &Env{}
|
|
|
|
for key, value := range m {
|
|
|
|
env.SetAuto(key, value)
|
|
|
|
}
|
|
|
|
return env, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// DecodeEnv decodes `src` as a json dictionary, and adds
|
|
|
|
// each decoded key-value pair to the environment.
|
|
|
|
//
|
|
|
|
// If `src` cannot be decoded as a json dictionary, an error
|
|
|
|
// is returned.
|
|
|
|
func (env *Env) Decode(src io.Reader) error {
|
|
|
|
m := make(map[string]interface{})
|
|
|
|
if err := json.NewDecoder(src).Decode(&m); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for k, v := range m {
|
|
|
|
env.SetAuto(k, v)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) SetAuto(k string, v interface{}) {
|
2014-09-29 06:45:03 +04:00
|
|
|
// Issue 7941 - if the value in the incoming JSON is null then treat it
|
|
|
|
// as if they never specified the property at all.
|
|
|
|
if v == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2013-12-08 10:06:05 +04:00
|
|
|
// FIXME: we fix-convert float values to int, because
|
|
|
|
// encoding/json decodes integers to float64, but cannot encode them back.
|
|
|
|
// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
|
|
|
|
if fval, ok := v.(float64); ok {
|
2013-12-13 01:35:50 +04:00
|
|
|
env.SetInt64(k, int64(fval))
|
2013-12-08 10:06:05 +04:00
|
|
|
} else if sval, ok := v.(string); ok {
|
|
|
|
env.Set(k, sval)
|
|
|
|
} else if val, err := json.Marshal(v); err == nil {
|
|
|
|
env.Set(k, string(val))
|
|
|
|
} else {
|
|
|
|
env.Set(k, fmt.Sprintf("%v", v))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-07 14:05:23 +04:00
|
|
|
func changeFloats(v interface{}) interface{} {
|
|
|
|
switch v := v.(type) {
|
|
|
|
case float64:
|
|
|
|
return int(v)
|
|
|
|
case map[string]interface{}:
|
|
|
|
for key, val := range v {
|
|
|
|
v[key] = changeFloats(val)
|
|
|
|
}
|
|
|
|
case []interface{}:
|
|
|
|
for idx, val := range v {
|
|
|
|
v[idx] = changeFloats(val)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
|
2013-12-08 10:06:05 +04:00
|
|
|
func (env *Env) Encode(dst io.Writer) error {
|
2014-04-04 22:29:56 +04:00
|
|
|
m := make(map[string]interface{})
|
|
|
|
for k, v := range env.Map() {
|
|
|
|
var val interface{}
|
|
|
|
if err := json.Unmarshal([]byte(v), &val); err == nil {
|
|
|
|
// FIXME: we fix-convert float values to int, because
|
|
|
|
// encoding/json decodes integers to float64, but cannot encode them back.
|
|
|
|
// (See http://golang.org/src/pkg/encoding/json/decode.go#L46)
|
2014-06-07 14:05:23 +04:00
|
|
|
m[k] = changeFloats(val)
|
2014-04-04 22:29:56 +04:00
|
|
|
} else {
|
|
|
|
m[k] = v
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if err := json.NewEncoder(dst).Encode(&m); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
2013-12-08 10:06:05 +04:00
|
|
|
}
|
|
|
|
|
2015-01-19 03:27:14 +03:00
|
|
|
func (env *Env) WriteTo(dst io.Writer) (int64, error) {
|
|
|
|
wc := utils.NewWriteCounter(dst)
|
|
|
|
err := env.Encode(wc)
|
|
|
|
return wc.Count, err
|
2013-12-08 10:06:05 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) Import(src interface{}) (err error) {
|
|
|
|
defer func() {
|
|
|
|
if err != nil {
|
|
|
|
err = fmt.Errorf("ImportEnv: %s", err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
var buf bytes.Buffer
|
|
|
|
if err := json.NewEncoder(&buf).Encode(src); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err := env.Decode(&buf); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (env *Env) Map() map[string]string {
|
|
|
|
m := make(map[string]string)
|
|
|
|
for _, kv := range *env {
|
|
|
|
parts := strings.SplitN(kv, "=", 2)
|
|
|
|
m[parts[0]] = parts[1]
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
2014-05-10 04:06:32 +04:00
|
|
|
|
|
|
|
// MultiMap returns a representation of env as a
|
|
|
|
// map of string arrays, keyed by string.
|
|
|
|
// This is the same structure as http headers for example,
|
|
|
|
// which allow each key to have multiple values.
|
|
|
|
func (env *Env) MultiMap() map[string][]string {
|
|
|
|
m := make(map[string][]string)
|
|
|
|
for _, kv := range *env {
|
|
|
|
parts := strings.SplitN(kv, "=", 2)
|
|
|
|
m[parts[0]] = append(m[parts[0]], parts[1])
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
|
|
|
// InitMultiMap removes all values in env, then initializes
|
|
|
|
// new values from the contents of m.
|
|
|
|
func (env *Env) InitMultiMap(m map[string][]string) {
|
|
|
|
(*env) = make([]string, 0, len(m))
|
|
|
|
for k, vals := range m {
|
|
|
|
for _, v := range vals {
|
|
|
|
env.Set(k, v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|