diff options
Diffstat (limited to 'vendor/github.com/fsouza/go-dockerclient/external/github.com/docker/docker/opts/opts.go')
-rw-r--r-- | vendor/github.com/fsouza/go-dockerclient/external/github.com/docker/docker/opts/opts.go | 252 |
1 files changed, 0 insertions, 252 deletions
diff --git a/vendor/github.com/fsouza/go-dockerclient/external/github.com/docker/docker/opts/opts.go b/vendor/github.com/fsouza/go-dockerclient/external/github.com/docker/docker/opts/opts.go deleted file mode 100644 index b244f5a..0000000 --- a/vendor/github.com/fsouza/go-dockerclient/external/github.com/docker/docker/opts/opts.go +++ /dev/null | |||
@@ -1,252 +0,0 @@ | |||
1 | package opts | ||
2 | |||
3 | import ( | ||
4 | "fmt" | ||
5 | "net" | ||
6 | "os" | ||
7 | "regexp" | ||
8 | "strings" | ||
9 | ) | ||
10 | |||
11 | var ( | ||
12 | alphaRegexp = regexp.MustCompile(`[a-zA-Z]`) | ||
13 | domainRegexp = regexp.MustCompile(`^(:?(:?[a-zA-Z0-9]|(:?[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9]))(:?\.(:?[a-zA-Z0-9]|(:?[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])))*)\.?\s*$`) | ||
14 | ) | ||
15 | |||
16 | // ListOpts holds a list of values and a validation function. | ||
17 | type ListOpts struct { | ||
18 | values *[]string | ||
19 | validator ValidatorFctType | ||
20 | } | ||
21 | |||
22 | // NewListOpts creates a new ListOpts with the specified validator. | ||
23 | func NewListOpts(validator ValidatorFctType) ListOpts { | ||
24 | var values []string | ||
25 | return *NewListOptsRef(&values, validator) | ||
26 | } | ||
27 | |||
28 | // NewListOptsRef creates a new ListOpts with the specified values and validator. | ||
29 | func NewListOptsRef(values *[]string, validator ValidatorFctType) *ListOpts { | ||
30 | return &ListOpts{ | ||
31 | values: values, | ||
32 | validator: validator, | ||
33 | } | ||
34 | } | ||
35 | |||
36 | func (opts *ListOpts) String() string { | ||
37 | return fmt.Sprintf("%v", []string((*opts.values))) | ||
38 | } | ||
39 | |||
40 | // Set validates if needed the input value and add it to the | ||
41 | // internal slice. | ||
42 | func (opts *ListOpts) Set(value string) error { | ||
43 | if opts.validator != nil { | ||
44 | v, err := opts.validator(value) | ||
45 | if err != nil { | ||
46 | return err | ||
47 | } | ||
48 | value = v | ||
49 | } | ||
50 | (*opts.values) = append((*opts.values), value) | ||
51 | return nil | ||
52 | } | ||
53 | |||
54 | // Delete removes the specified element from the slice. | ||
55 | func (opts *ListOpts) Delete(key string) { | ||
56 | for i, k := range *opts.values { | ||
57 | if k == key { | ||
58 | (*opts.values) = append((*opts.values)[:i], (*opts.values)[i+1:]...) | ||
59 | return | ||
60 | } | ||
61 | } | ||
62 | } | ||
63 | |||
64 | // GetMap returns the content of values in a map in order to avoid | ||
65 | // duplicates. | ||
66 | func (opts *ListOpts) GetMap() map[string]struct{} { | ||
67 | ret := make(map[string]struct{}) | ||
68 | for _, k := range *opts.values { | ||
69 | ret[k] = struct{}{} | ||
70 | } | ||
71 | return ret | ||
72 | } | ||
73 | |||
74 | // GetAll returns the values of slice. | ||
75 | func (opts *ListOpts) GetAll() []string { | ||
76 | return (*opts.values) | ||
77 | } | ||
78 | |||
79 | // GetAllOrEmpty returns the values of the slice | ||
80 | // or an empty slice when there are no values. | ||
81 | func (opts *ListOpts) GetAllOrEmpty() []string { | ||
82 | v := *opts.values | ||
83 | if v == nil { | ||
84 | return make([]string, 0) | ||
85 | } | ||
86 | return v | ||
87 | } | ||
88 | |||
89 | // Get checks the existence of the specified key. | ||
90 | func (opts *ListOpts) Get(key string) bool { | ||
91 | for _, k := range *opts.values { | ||
92 | if k == key { | ||
93 | return true | ||
94 | } | ||
95 | } | ||
96 | return false | ||
97 | } | ||
98 | |||
99 | // Len returns the amount of element in the slice. | ||
100 | func (opts *ListOpts) Len() int { | ||
101 | return len((*opts.values)) | ||
102 | } | ||
103 | |||
104 | //MapOpts holds a map of values and a validation function. | ||
105 | type MapOpts struct { | ||
106 | values map[string]string | ||
107 | validator ValidatorFctType | ||
108 | } | ||
109 | |||
110 | // Set validates if needed the input value and add it to the | ||
111 | // internal map, by splitting on '='. | ||
112 | func (opts *MapOpts) Set(value string) error { | ||
113 | if opts.validator != nil { | ||
114 | v, err := opts.validator(value) | ||
115 | if err != nil { | ||
116 | return err | ||
117 | } | ||
118 | value = v | ||
119 | } | ||
120 | vals := strings.SplitN(value, "=", 2) | ||
121 | if len(vals) == 1 { | ||
122 | (opts.values)[vals[0]] = "" | ||
123 | } else { | ||
124 | (opts.values)[vals[0]] = vals[1] | ||
125 | } | ||
126 | return nil | ||
127 | } | ||
128 | |||
129 | // GetAll returns the values of MapOpts as a map. | ||
130 | func (opts *MapOpts) GetAll() map[string]string { | ||
131 | return opts.values | ||
132 | } | ||
133 | |||
134 | func (opts *MapOpts) String() string { | ||
135 | return fmt.Sprintf("%v", map[string]string((opts.values))) | ||
136 | } | ||
137 | |||
138 | // NewMapOpts creates a new MapOpts with the specified map of values and a validator. | ||
139 | func NewMapOpts(values map[string]string, validator ValidatorFctType) *MapOpts { | ||
140 | if values == nil { | ||
141 | values = make(map[string]string) | ||
142 | } | ||
143 | return &MapOpts{ | ||
144 | values: values, | ||
145 | validator: validator, | ||
146 | } | ||
147 | } | ||
148 | |||
149 | // ValidatorFctType defines a validator function that returns a validated string and/or an error. | ||
150 | type ValidatorFctType func(val string) (string, error) | ||
151 | |||
152 | // ValidatorFctListType defines a validator function that returns a validated list of string and/or an error | ||
153 | type ValidatorFctListType func(val string) ([]string, error) | ||
154 | |||
155 | // ValidateAttach validates that the specified string is a valid attach option. | ||
156 | func ValidateAttach(val string) (string, error) { | ||
157 | s := strings.ToLower(val) | ||
158 | for _, str := range []string{"stdin", "stdout", "stderr"} { | ||
159 | if s == str { | ||
160 | return s, nil | ||
161 | } | ||
162 | } | ||
163 | return val, fmt.Errorf("valid streams are STDIN, STDOUT and STDERR") | ||
164 | } | ||
165 | |||
166 | // ValidateEnv validates an environment variable and returns it. | ||
167 | // If no value is specified, it returns the current value using os.Getenv. | ||
168 | // | ||
169 | // As on ParseEnvFile and related to #16585, environment variable names | ||
170 | // are not validate what so ever, it's up to application inside docker | ||
171 | // to validate them or not. | ||
172 | func ValidateEnv(val string) (string, error) { | ||
173 | arr := strings.Split(val, "=") | ||
174 | if len(arr) > 1 { | ||
175 | return val, nil | ||
176 | } | ||
177 | if !doesEnvExist(val) { | ||
178 | return val, nil | ||
179 | } | ||
180 | return fmt.Sprintf("%s=%s", val, os.Getenv(val)), nil | ||
181 | } | ||
182 | |||
183 | // ValidateIPAddress validates an Ip address. | ||
184 | func ValidateIPAddress(val string) (string, error) { | ||
185 | var ip = net.ParseIP(strings.TrimSpace(val)) | ||
186 | if ip != nil { | ||
187 | return ip.String(), nil | ||
188 | } | ||
189 | return "", fmt.Errorf("%s is not an ip address", val) | ||
190 | } | ||
191 | |||
192 | // ValidateMACAddress validates a MAC address. | ||
193 | func ValidateMACAddress(val string) (string, error) { | ||
194 | _, err := net.ParseMAC(strings.TrimSpace(val)) | ||
195 | if err != nil { | ||
196 | return "", err | ||
197 | } | ||
198 | return val, nil | ||
199 | } | ||
200 | |||
201 | // ValidateDNSSearch validates domain for resolvconf search configuration. | ||
202 | // A zero length domain is represented by a dot (.). | ||
203 | func ValidateDNSSearch(val string) (string, error) { | ||
204 | if val = strings.Trim(val, " "); val == "." { | ||
205 | return val, nil | ||
206 | } | ||
207 | return validateDomain(val) | ||
208 | } | ||
209 | |||
210 | func validateDomain(val string) (string, error) { | ||
211 | if alphaRegexp.FindString(val) == "" { | ||
212 | return "", fmt.Errorf("%s is not a valid domain", val) | ||
213 | } | ||
214 | ns := domainRegexp.FindSubmatch([]byte(val)) | ||
215 | if len(ns) > 0 && len(ns[1]) < 255 { | ||
216 | return string(ns[1]), nil | ||
217 | } | ||
218 | return "", fmt.Errorf("%s is not a valid domain", val) | ||
219 | } | ||
220 | |||
221 | // ValidateExtraHost validates that the specified string is a valid extrahost and returns it. | ||
222 | // ExtraHost are in the form of name:ip where the ip has to be a valid ip (ipv4 or ipv6). | ||
223 | func ValidateExtraHost(val string) (string, error) { | ||
224 | // allow for IPv6 addresses in extra hosts by only splitting on first ":" | ||
225 | arr := strings.SplitN(val, ":", 2) | ||
226 | if len(arr) != 2 || len(arr[0]) == 0 { | ||
227 | return "", fmt.Errorf("bad format for add-host: %q", val) | ||
228 | } | ||
229 | if _, err := ValidateIPAddress(arr[1]); err != nil { | ||
230 | return "", fmt.Errorf("invalid IP address in add-host: %q", arr[1]) | ||
231 | } | ||
232 | return val, nil | ||
233 | } | ||
234 | |||
235 | // ValidateLabel validates that the specified string is a valid label, and returns it. | ||
236 | // Labels are in the form on key=value. | ||
237 | func ValidateLabel(val string) (string, error) { | ||
238 | if strings.Count(val, "=") < 1 { | ||
239 | return "", fmt.Errorf("bad attribute format: %s", val) | ||
240 | } | ||
241 | return val, nil | ||
242 | } | ||
243 | |||
244 | func doesEnvExist(name string) bool { | ||
245 | for _, entry := range os.Environ() { | ||
246 | parts := strings.SplitN(entry, "=", 2) | ||
247 | if parts[0] == name { | ||
248 | return true | ||
249 | } | ||
250 | } | ||
251 | return false | ||
252 | } | ||