Jamie Hannaford | 4baa123 | 2014-09-23 15:23:04 +0200 | [diff] [blame] | 1 | package gophercloud |
Jamie Hannaford | b3120f5 | 2014-09-23 15:17:57 +0200 | [diff] [blame] | 2 | |
Ash Wilson | e8192ac | 2014-10-21 09:02:01 -0400 | [diff] [blame] | 3 | import ( |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 4 | "bytes" |
Ash Wilson | e8192ac | 2014-10-21 09:02:01 -0400 | [diff] [blame] | 5 | "encoding/json" |
jrperritt | 613bea2 | 2016-11-08 16:58:10 -0600 | [diff] [blame] | 6 | "fmt" |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 7 | "io" |
Ash Wilson | e8192ac | 2014-10-21 09:02:01 -0400 | [diff] [blame] | 8 | "net/http" |
jrperritt | 613bea2 | 2016-11-08 16:58:10 -0600 | [diff] [blame] | 9 | "reflect" |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 10 | "strconv" |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 11 | "time" |
Ash Wilson | e8192ac | 2014-10-21 09:02:01 -0400 | [diff] [blame] | 12 | ) |
Ash Wilson | eab6a70 | 2014-10-20 08:18:30 -0400 | [diff] [blame] | 13 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 14 | /* |
Ash Wilson | 64ba49f | 2014-10-31 15:31:46 -0400 | [diff] [blame] | 15 | Result is an internal type to be used by individual resource packages, but its |
| 16 | methods will be available on a wide variety of user-facing embedding types. |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 17 | |
| 18 | It acts as a base struct that other Result types, returned from request |
| 19 | functions, can embed for convenience. All Results capture basic information |
| 20 | from the HTTP transaction that was performed, including the response body, |
| 21 | HTTP headers, and any errors that happened. |
| 22 | |
| 23 | Generally, each Result type will have an Extract method that can be used to |
| 24 | further interpret the result's payload in a specific context. Extensions or |
| 25 | providers can then provide additional extraction functions to pull out |
| 26 | provider- or extension-specific information as well. |
| 27 | */ |
Ash Wilson | eab6a70 | 2014-10-20 08:18:30 -0400 | [diff] [blame] | 28 | type Result struct { |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 29 | // Body is the payload of the HTTP response from the server. In most cases, |
| 30 | // this will be the deserialized JSON structure. |
Ash Wilson | d3dc254 | 2014-10-20 10:10:48 -0400 | [diff] [blame] | 31 | Body interface{} |
Ash Wilson | eab6a70 | 2014-10-20 08:18:30 -0400 | [diff] [blame] | 32 | |
Ash Wilson | 72e4d2c | 2014-10-20 10:27:30 -0400 | [diff] [blame] | 33 | // Header contains the HTTP header structure from the original response. |
| 34 | Header http.Header |
Ash Wilson | eab6a70 | 2014-10-20 08:18:30 -0400 | [diff] [blame] | 35 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 36 | // Err is an error that occurred during the operation. It's deferred until |
| 37 | // extraction to make it easier to chain the Extract call. |
Ash Wilson | eab6a70 | 2014-10-20 08:18:30 -0400 | [diff] [blame] | 38 | Err error |
Jamie Hannaford | b3120f5 | 2014-09-23 15:17:57 +0200 | [diff] [blame] | 39 | } |
Ash Wilson | a6b0831 | 2014-10-02 15:27:45 -0400 | [diff] [blame] | 40 | |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 41 | // ExtractInto allows users to provide an object into which `Extract` will extract |
| 42 | // the `Result.Body`. This would be useful for OpenStack providers that have |
| 43 | // different fields in the response object than OpenStack proper. |
| 44 | func (r Result) ExtractInto(to interface{}) error { |
| 45 | if r.Err != nil { |
| 46 | return r.Err |
| 47 | } |
| 48 | |
| 49 | if reader, ok := r.Body.(io.Reader); ok { |
| 50 | if readCloser, ok := reader.(io.Closer); ok { |
| 51 | defer readCloser.Close() |
| 52 | } |
Jon Perritt | a33da23 | 2016-03-02 04:43:08 -0600 | [diff] [blame] | 53 | return json.NewDecoder(reader).Decode(to) |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | b, err := json.Marshal(r.Body) |
| 57 | if err != nil { |
| 58 | return err |
| 59 | } |
| 60 | err = json.Unmarshal(b, to) |
| 61 | |
| 62 | return err |
| 63 | } |
| 64 | |
jrperritt | 613bea2 | 2016-11-08 16:58:10 -0600 | [diff] [blame] | 65 | func (r Result) extractIntoPtr(to interface{}, label string) error { |
| 66 | if r.Err != nil { |
| 67 | return r.Err |
| 68 | } |
| 69 | |
| 70 | t := reflect.TypeOf(to) |
| 71 | if k := t.Kind(); k != reflect.Ptr { |
| 72 | return fmt.Errorf("Expected pointer, got %v", k) |
| 73 | } |
| 74 | t = t.Elem() |
| 75 | switch t.Kind() { |
| 76 | case reflect.Struct, reflect.Slice: |
| 77 | default: |
| 78 | return fmt.Errorf("Invalid type: %v", t) |
| 79 | } |
| 80 | |
| 81 | var ( |
| 82 | b []byte |
| 83 | err error |
| 84 | ) |
| 85 | |
| 86 | switch label { |
| 87 | case "": |
| 88 | var m interface{} |
| 89 | err = r.ExtractInto(&m) |
| 90 | if err != nil { |
| 91 | return err |
| 92 | } |
| 93 | b, err = json.Marshal(m) |
| 94 | default: |
| 95 | var m map[string]interface{} |
| 96 | err = r.ExtractInto(&m) |
| 97 | if err != nil { |
| 98 | return err |
| 99 | } |
| 100 | b, err = json.Marshal(m[label]) |
| 101 | } |
| 102 | if err != nil { |
| 103 | return err |
| 104 | } |
| 105 | |
| 106 | err = json.Unmarshal(b, &to) |
| 107 | return err |
| 108 | } |
| 109 | |
| 110 | func (r Result) ExtractIntoStructPtr(to interface{}, label string) error { |
| 111 | return r.extractIntoPtr(to, label) |
| 112 | } |
| 113 | |
| 114 | func (r Result) ExtractIntoSlicePtr(to interface{}, label string) error { |
| 115 | return r.extractIntoPtr(to, label) |
| 116 | } |
| 117 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 118 | // PrettyPrintJSON creates a string containing the full response body as |
| 119 | // pretty-printed JSON. It's useful for capturing test fixtures and for |
Ash Wilson | 0fe6c96 | 2014-10-31 15:34:24 -0400 | [diff] [blame] | 120 | // debugging extraction bugs. If you include its output in an issue related to |
| 121 | // a buggy extraction function, we will all love you forever. |
Ash Wilson | e8192ac | 2014-10-21 09:02:01 -0400 | [diff] [blame] | 122 | func (r Result) PrettyPrintJSON() string { |
| 123 | pretty, err := json.MarshalIndent(r.Body, "", " ") |
| 124 | if err != nil { |
| 125 | panic(err.Error()) |
| 126 | } |
| 127 | return string(pretty) |
| 128 | } |
| 129 | |
Ash Wilson | 64ba49f | 2014-10-31 15:31:46 -0400 | [diff] [blame] | 130 | // ErrResult is an internal type to be used by individual resource packages, but |
| 131 | // its methods will be available on a wide variety of user-facing embedding |
| 132 | // types. |
| 133 | // |
| 134 | // It represents results that only contain a potential error and |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 135 | // nothing else. Usually, if the operation executed successfully, the Err field |
| 136 | // will be nil; otherwise it will be stocked with a relevant error. Use the |
Ash Wilson | 64ba49f | 2014-10-31 15:31:46 -0400 | [diff] [blame] | 137 | // ExtractErr method |
| 138 | // to cleanly pull it out. |
Jon Perritt | ba2395e | 2014-10-27 15:23:21 -0500 | [diff] [blame] | 139 | type ErrResult struct { |
Jon Perritt | 0c2b037 | 2014-10-27 15:57:29 -0500 | [diff] [blame] | 140 | Result |
Jamie Hannaford | 021b35c | 2014-10-27 14:01:53 +0100 | [diff] [blame] | 141 | } |
| 142 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 143 | // ExtractErr is a function that extracts error information, or nil, from a result. |
Jon Perritt | ba2395e | 2014-10-27 15:23:21 -0500 | [diff] [blame] | 144 | func (r ErrResult) ExtractErr() error { |
Jamie Hannaford | 021b35c | 2014-10-27 14:01:53 +0100 | [diff] [blame] | 145 | return r.Err |
| 146 | } |
| 147 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 148 | /* |
Ash Wilson | 64ba49f | 2014-10-31 15:31:46 -0400 | [diff] [blame] | 149 | HeaderResult is an internal type to be used by individual resource packages, but |
| 150 | its methods will be available on a wide variety of user-facing embedding types. |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 151 | |
| 152 | It represents a result that only contains an error (possibly nil) and an |
| 153 | http.Header. This is used, for example, by the objectstorage packages in |
| 154 | openstack, because most of the operations don't return response bodies, but do |
| 155 | have relevant information in headers. |
| 156 | */ |
Jon Perritt | d50f93e | 2014-10-27 14:19:27 -0500 | [diff] [blame] | 157 | type HeaderResult struct { |
Jon Perritt | 0c2b037 | 2014-10-27 15:57:29 -0500 | [diff] [blame] | 158 | Result |
Jon Perritt | d50f93e | 2014-10-27 14:19:27 -0500 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | // ExtractHeader will return the http.Header and error from the HeaderResult. |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 162 | // |
| 163 | // header, err := objects.Create(client, "my_container", objects.CreateOpts{}).ExtractHeader() |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 164 | func (r HeaderResult) ExtractInto(to interface{}) error { |
| 165 | if r.Err != nil { |
| 166 | return r.Err |
Jon Perritt | 63e7a48 | 2014-12-04 09:47:23 -0700 | [diff] [blame] | 167 | } |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 168 | |
| 169 | tmpHeaderMap := map[string]string{} |
| 170 | for k, v := range r.Header { |
Jon Perritt | 31b6646 | 2016-02-25 22:25:30 -0600 | [diff] [blame] | 171 | if len(v) > 0 { |
| 172 | tmpHeaderMap[k] = v[0] |
| 173 | } |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 174 | } |
| 175 | |
| 176 | b, err := json.Marshal(tmpHeaderMap) |
Jon Perritt | 63e7a48 | 2014-12-04 09:47:23 -0700 | [diff] [blame] | 177 | if err != nil { |
| 178 | return err |
| 179 | } |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 180 | err = json.Unmarshal(b, to) |
| 181 | |
| 182 | return err |
Jon Perritt | 63e7a48 | 2014-12-04 09:47:23 -0700 | [diff] [blame] | 183 | } |
| 184 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 185 | // RFC3339Milli describes a common time format used by some API responses. |
Ash Wilson | a6b0831 | 2014-10-02 15:27:45 -0400 | [diff] [blame] | 186 | const RFC3339Milli = "2006-01-02T15:04:05.999999Z" |
Jamie Hannaford | 369c9c6 | 2014-10-08 15:14:43 +0200 | [diff] [blame] | 187 | |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 188 | type JSONRFC3339Milli time.Time |
| 189 | |
| 190 | func (jt *JSONRFC3339Milli) UnmarshalJSON(data []byte) error { |
| 191 | b := bytes.NewBuffer(data) |
| 192 | dec := json.NewDecoder(b) |
| 193 | var s string |
| 194 | if err := dec.Decode(&s); err != nil { |
| 195 | return err |
| 196 | } |
| 197 | t, err := time.Parse(RFC3339Milli, s) |
| 198 | if err != nil { |
| 199 | return err |
| 200 | } |
| 201 | *jt = JSONRFC3339Milli(t) |
| 202 | return nil |
| 203 | } |
| 204 | |
jrperritt | 9b7b9e6 | 2016-07-11 22:30:50 -0500 | [diff] [blame] | 205 | const RFC3339MilliNoZ = "2006-01-02T15:04:05.999999" |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 206 | |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 207 | type JSONRFC3339MilliNoZ time.Time |
| 208 | |
| 209 | func (jt *JSONRFC3339MilliNoZ) UnmarshalJSON(data []byte) error { |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 210 | var s string |
Jon Perritt | 82583e7 | 2016-02-25 06:41:51 -0600 | [diff] [blame] | 211 | if err := json.Unmarshal(data, &s); err != nil { |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 212 | return err |
| 213 | } |
Jon Perritt | 82583e7 | 2016-02-25 06:41:51 -0600 | [diff] [blame] | 214 | if s == "" { |
| 215 | return nil |
| 216 | } |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 217 | t, err := time.Parse(RFC3339MilliNoZ, s) |
| 218 | if err != nil { |
| 219 | return err |
| 220 | } |
| 221 | *jt = JSONRFC3339MilliNoZ(t) |
| 222 | return nil |
| 223 | } |
| 224 | |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 225 | type JSONRFC1123 time.Time |
| 226 | |
| 227 | func (jt *JSONRFC1123) UnmarshalJSON(data []byte) error { |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 228 | var s string |
Jon Perritt | 82583e7 | 2016-02-25 06:41:51 -0600 | [diff] [blame] | 229 | if err := json.Unmarshal(data, &s); err != nil { |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 230 | return err |
| 231 | } |
Jon Perritt | 82583e7 | 2016-02-25 06:41:51 -0600 | [diff] [blame] | 232 | if s == "" { |
| 233 | return nil |
| 234 | } |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 235 | t, err := time.Parse(time.RFC1123, s) |
| 236 | if err != nil { |
| 237 | return err |
| 238 | } |
| 239 | *jt = JSONRFC1123(t) |
| 240 | return nil |
| 241 | } |
| 242 | |
| 243 | type JSONUnix time.Time |
| 244 | |
| 245 | func (jt *JSONUnix) UnmarshalJSON(data []byte) error { |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 246 | var s string |
Jon Perritt | 82583e7 | 2016-02-25 06:41:51 -0600 | [diff] [blame] | 247 | if err := json.Unmarshal(data, &s); err != nil { |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 248 | return err |
| 249 | } |
Jon Perritt | 82583e7 | 2016-02-25 06:41:51 -0600 | [diff] [blame] | 250 | if s == "" { |
| 251 | return nil |
| 252 | } |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 253 | unix, err := strconv.ParseInt(s, 10, 64) |
| 254 | if err != nil { |
| 255 | return err |
| 256 | } |
| 257 | t = time.Unix(unix, 0) |
| 258 | *jt = JSONUnix(t) |
| 259 | return nil |
| 260 | } |
| 261 | |
Jon Perritt | 31b6646 | 2016-02-25 22:25:30 -0600 | [diff] [blame] | 262 | // RFC3339NoZ is the time format used in Heat (Orchestration). |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 263 | const RFC3339NoZ = "2006-01-02T15:04:05" |
| 264 | |
| 265 | type JSONRFC3339NoZ time.Time |
| 266 | |
| 267 | func (jt *JSONRFC3339NoZ) UnmarshalJSON(data []byte) error { |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 268 | var s string |
Jon Perritt | 82583e7 | 2016-02-25 06:41:51 -0600 | [diff] [blame] | 269 | if err := json.Unmarshal(data, &s); err != nil { |
Jon Perritt | 6682282 | 2016-02-25 03:06:56 -0600 | [diff] [blame] | 270 | return err |
| 271 | } |
| 272 | if s == "" { |
| 273 | return nil |
| 274 | } |
| 275 | t, err := time.Parse(RFC3339NoZ, s) |
| 276 | if err != nil { |
| 277 | return err |
| 278 | } |
| 279 | *jt = JSONRFC3339NoZ(t) |
| 280 | return nil |
| 281 | } |
Pratik Mallya | e1b6cbb | 2015-09-09 14:24:14 -0500 | [diff] [blame] | 282 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 283 | /* |
| 284 | Link is an internal type to be used in packages of collection resources that are |
| 285 | paginated in a certain way. |
| 286 | |
| 287 | It's a response substructure common to many paginated collection results that is |
| 288 | used to point to related pages. Usually, the one we care about is the one with |
| 289 | Rel field set to "next". |
| 290 | */ |
Jamie Hannaford | 369c9c6 | 2014-10-08 15:14:43 +0200 | [diff] [blame] | 291 | type Link struct { |
Jon Perritt | 1239521 | 2016-02-24 10:41:17 -0600 | [diff] [blame] | 292 | Href string `json:"href"` |
| 293 | Rel string `json:"rel"` |
Jamie Hannaford | 369c9c6 | 2014-10-08 15:14:43 +0200 | [diff] [blame] | 294 | } |
| 295 | |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 296 | /* |
| 297 | ExtractNextURL is an internal function useful for packages of collection |
| 298 | resources that are paginated in a certain way. |
| 299 | |
jrperritt | b101323 | 2016-02-10 19:01:53 -0600 | [diff] [blame] | 300 | It attempts to extract the "next" URL from slice of Link structs, or |
Ash Wilson | 3ce1bd8 | 2014-10-31 12:20:00 -0400 | [diff] [blame] | 301 | "" if no such URL is present. |
| 302 | */ |
Jamie Hannaford | 369c9c6 | 2014-10-08 15:14:43 +0200 | [diff] [blame] | 303 | func ExtractNextURL(links []Link) (string, error) { |
| 304 | var url string |
| 305 | |
| 306 | for _, l := range links { |
| 307 | if l.Rel == "next" { |
| 308 | url = l.Href |
| 309 | } |
| 310 | } |
| 311 | |
| 312 | if url == "" { |
| 313 | return "", nil |
| 314 | } |
| 315 | |
| 316 | return url, nil |
| 317 | } |