]>
Commit | Line | Data |
---|---|---|
9b12e4fe JC |
1 | // Copyright 2014 Docker authors. All rights reserved. |
2 | // Use of this source code is governed by a BSD-style | |
3 | // license that can be found in the DOCKER-LICENSE file. | |
4 | ||
5 | package docker | |
6 | ||
7 | import ( | |
8 | "encoding/json" | |
9 | "fmt" | |
10 | "io" | |
11 | "strconv" | |
12 | "strings" | |
13 | ) | |
14 | ||
15 | // Env represents a list of key-pair represented in the form KEY=VALUE. | |
16 | type Env []string | |
17 | ||
18 | // Get returns the string value of the given key. | |
19 | func (env *Env) Get(key string) (value string) { | |
20 | return env.Map()[key] | |
21 | } | |
22 | ||
23 | // Exists checks whether the given key is defined in the internal Env | |
24 | // representation. | |
25 | func (env *Env) Exists(key string) bool { | |
26 | _, exists := env.Map()[key] | |
27 | return exists | |
28 | } | |
29 | ||
30 | // GetBool returns a boolean representation of the given key. The key is false | |
31 | // whenever its value if 0, no, false, none or an empty string. Any other value | |
32 | // will be interpreted as true. | |
33 | func (env *Env) GetBool(key string) (value bool) { | |
34 | s := strings.ToLower(strings.Trim(env.Get(key), " \t")) | |
35 | if s == "" || s == "0" || s == "no" || s == "false" || s == "none" { | |
36 | return false | |
37 | } | |
38 | return true | |
39 | } | |
40 | ||
41 | // SetBool defines a boolean value to the given key. | |
42 | func (env *Env) SetBool(key string, value bool) { | |
43 | if value { | |
44 | env.Set(key, "1") | |
45 | } else { | |
46 | env.Set(key, "0") | |
47 | } | |
48 | } | |
49 | ||
50 | // GetInt returns the value of the provided key, converted to int. | |
51 | // | |
52 | // It the value cannot be represented as an integer, it returns -1. | |
53 | func (env *Env) GetInt(key string) int { | |
54 | return int(env.GetInt64(key)) | |
55 | } | |
56 | ||
57 | // SetInt defines an integer value to the given key. | |
58 | func (env *Env) SetInt(key string, value int) { | |
59 | env.Set(key, strconv.Itoa(value)) | |
60 | } | |
61 | ||
62 | // GetInt64 returns the value of the provided key, converted to int64. | |
63 | // | |
64 | // It the value cannot be represented as an integer, it returns -1. | |
65 | func (env *Env) GetInt64(key string) int64 { | |
66 | s := strings.Trim(env.Get(key), " \t") | |
67 | val, err := strconv.ParseInt(s, 10, 64) | |
68 | if err != nil { | |
69 | return -1 | |
70 | } | |
71 | return val | |
72 | } | |
73 | ||
74 | // SetInt64 defines an integer (64-bit wide) value to the given key. | |
75 | func (env *Env) SetInt64(key string, value int64) { | |
76 | env.Set(key, strconv.FormatInt(value, 10)) | |
77 | } | |
78 | ||
79 | // GetJSON unmarshals the value of the provided key in the provided iface. | |
80 | // | |
81 | // iface is a value that can be provided to the json.Unmarshal function. | |
82 | func (env *Env) GetJSON(key string, iface interface{}) error { | |
83 | sval := env.Get(key) | |
84 | if sval == "" { | |
85 | return nil | |
86 | } | |
87 | return json.Unmarshal([]byte(sval), iface) | |
88 | } | |
89 | ||
90 | // SetJSON marshals the given value to JSON format and stores it using the | |
91 | // provided key. | |
92 | func (env *Env) SetJSON(key string, value interface{}) error { | |
93 | sval, err := json.Marshal(value) | |
94 | if err != nil { | |
95 | return err | |
96 | } | |
97 | env.Set(key, string(sval)) | |
98 | return nil | |
99 | } | |
100 | ||
101 | // GetList returns a list of strings matching the provided key. It handles the | |
102 | // list as a JSON representation of a list of strings. | |
103 | // | |
104 | // If the given key matches to a single string, it will return a list | |
105 | // containing only the value that matches the key. | |
106 | func (env *Env) GetList(key string) []string { | |
107 | sval := env.Get(key) | |
108 | if sval == "" { | |
109 | return nil | |
110 | } | |
111 | var l []string | |
112 | if err := json.Unmarshal([]byte(sval), &l); err != nil { | |
113 | l = append(l, sval) | |
114 | } | |
115 | return l | |
116 | } | |
117 | ||
118 | // SetList stores the given list in the provided key, after serializing it to | |
119 | // JSON format. | |
120 | func (env *Env) SetList(key string, value []string) error { | |
121 | return env.SetJSON(key, value) | |
122 | } | |
123 | ||
124 | // Set defines the value of a key to the given string. | |
125 | func (env *Env) Set(key, value string) { | |
126 | *env = append(*env, key+"="+value) | |
127 | } | |
128 | ||
129 | // Decode decodes `src` as a json dictionary, and adds each decoded key-value | |
130 | // pair to the environment. | |
131 | // | |
132 | // If `src` cannot be decoded as a json dictionary, an error is returned. | |
133 | func (env *Env) Decode(src io.Reader) error { | |
134 | m := make(map[string]interface{}) | |
135 | if err := json.NewDecoder(src).Decode(&m); err != nil { | |
136 | return err | |
137 | } | |
138 | for k, v := range m { | |
139 | env.SetAuto(k, v) | |
140 | } | |
141 | return nil | |
142 | } | |
143 | ||
144 | // SetAuto will try to define the Set* method to call based on the given value. | |
145 | func (env *Env) SetAuto(key string, value interface{}) { | |
146 | if fval, ok := value.(float64); ok { | |
147 | env.SetInt64(key, int64(fval)) | |
148 | } else if sval, ok := value.(string); ok { | |
149 | env.Set(key, sval) | |
150 | } else if val, err := json.Marshal(value); err == nil { | |
151 | env.Set(key, string(val)) | |
152 | } else { | |
153 | env.Set(key, fmt.Sprintf("%v", value)) | |
154 | } | |
155 | } | |
156 | ||
157 | // Map returns the map representation of the env. | |
158 | func (env *Env) Map() map[string]string { | |
159 | if len(*env) == 0 { | |
160 | return nil | |
161 | } | |
162 | m := make(map[string]string) | |
163 | for _, kv := range *env { | |
164 | parts := strings.SplitN(kv, "=", 2) | |
165 | m[parts[0]] = parts[1] | |
166 | } | |
167 | return m | |
168 | } |