diff options
Diffstat (limited to 'vendor/github.com/fsouza/go-dockerclient/env.go')
-rw-r--r-- | vendor/github.com/fsouza/go-dockerclient/env.go | 168 |
1 files changed, 0 insertions, 168 deletions
diff --git a/vendor/github.com/fsouza/go-dockerclient/env.go b/vendor/github.com/fsouza/go-dockerclient/env.go deleted file mode 100644 index c54b0b0..0000000 --- a/vendor/github.com/fsouza/go-dockerclient/env.go +++ /dev/null | |||
@@ -1,168 +0,0 @@ | |||
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 | } | ||