1 // Package azure provides Azure-specific implementations used with AutoRest.
2 // See the included examples for more detail.
3 package azure
4 5 // Copyright 2017 Microsoft Corporation
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 // http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 19 import (
20 "bytes"
21 "encoding/json"
22 "fmt"
23 "io"
24 "net/http"
25 "regexp"
26 "strconv"
27 "strings"
28 29 "github.com/Azure/go-autorest/autorest"
30 )
31 32 const (
33 // HeaderClientID is the Azure extension header to set a user-specified request ID.
34 HeaderClientID = "x-ms-client-request-id"
35 36 // HeaderReturnClientID is the Azure extension header to set if the user-specified request ID
37 // should be included in the response.
38 HeaderReturnClientID = "x-ms-return-client-request-id"
39 40 // HeaderContentType is the type of the content in the HTTP response.
41 HeaderContentType = "Content-Type"
42 43 // HeaderRequestID is the Azure extension header of the service generated request ID returned
44 // in the response.
45 HeaderRequestID = "x-ms-request-id"
46 )
47 48 // ServiceError encapsulates the error response from an Azure service.
49 // It adhears to the OData v4 specification for error responses.
50 type ServiceError struct {
51 Code string `json:"code"`
52 Message string `json:"message"`
53 Target *string `json:"target"`
54 Details []map[string]interface{} `json:"details"`
55 InnerError map[string]interface{} `json:"innererror"`
56 AdditionalInfo []map[string]interface{} `json:"additionalInfo"`
57 }
58 59 func (se ServiceError) Error() string {
60 result := fmt.Sprintf("Code=%q Message=%q", se.Code, se.Message)
61 62 if se.Target != nil {
63 result += fmt.Sprintf(" Target=%q", *se.Target)
64 }
65 66 if se.Details != nil {
67 d, err := json.Marshal(se.Details)
68 if err != nil {
69 result += fmt.Sprintf(" Details=%v", se.Details)
70 }
71 result += fmt.Sprintf(" Details=%s", d)
72 }
73 74 if se.InnerError != nil {
75 d, err := json.Marshal(se.InnerError)
76 if err != nil {
77 result += fmt.Sprintf(" InnerError=%v", se.InnerError)
78 }
79 result += fmt.Sprintf(" InnerError=%s", d)
80 }
81 82 if se.AdditionalInfo != nil {
83 d, err := json.Marshal(se.AdditionalInfo)
84 if err != nil {
85 result += fmt.Sprintf(" AdditionalInfo=%v", se.AdditionalInfo)
86 }
87 result += fmt.Sprintf(" AdditionalInfo=%s", d)
88 }
89 90 return result
91 }
92 93 // UnmarshalJSON implements the json.Unmarshaler interface for the ServiceError type.
94 func (se *ServiceError) UnmarshalJSON(b []byte) error {
95 // http://docs.oasis-open.org/odata/odata-json-format/v4.0/os/odata-json-format-v4.0-os.html#_Toc372793091
96 97 type serviceErrorInternal struct {
98 Code string `json:"code"`
99 Message string `json:"message"`
100 Target *string `json:"target,omitempty"`
101 AdditionalInfo []map[string]interface{} `json:"additionalInfo,omitempty"`
102 // not all services conform to the OData v4 spec.
103 // the following fields are where we've seen discrepancies
104 105 // spec calls for []map[string]interface{} but have seen map[string]interface{}
106 Details interface{} `json:"details,omitempty"`
107 108 // spec calls for map[string]interface{} but have seen []map[string]interface{} and string
109 InnerError interface{} `json:"innererror,omitempty"`
110 }
111 112 sei := serviceErrorInternal{}
113 if err := json.Unmarshal(b, &sei); err != nil {
114 return err
115 }
116 117 // copy the fields we know to be correct
118 se.AdditionalInfo = sei.AdditionalInfo
119 se.Code = sei.Code
120 se.Message = sei.Message
121 se.Target = sei.Target
122 123 // converts an []interface{} to []map[string]interface{}
124 arrayOfObjs := func(v interface{}) ([]map[string]interface{}, bool) {
125 arrayOf, ok := v.([]interface{})
126 if !ok {
127 return nil, false
128 }
129 final := []map[string]interface{}{}
130 for _, item := range arrayOf {
131 as, ok := item.(map[string]interface{})
132 if !ok {
133 return nil, false
134 }
135 final = append(final, as)
136 }
137 return final, true
138 }
139 140 // convert the remaining fields, falling back to raw JSON if necessary
141 142 if c, ok := arrayOfObjs(sei.Details); ok {
143 se.Details = c
144 } else if c, ok := sei.Details.(map[string]interface{}); ok {
145 se.Details = []map[string]interface{}{c}
146 } else if sei.Details != nil {
147 // stuff into Details
148 se.Details = []map[string]interface{}{
149 {"raw": sei.Details},
150 }
151 }
152 153 if c, ok := sei.InnerError.(map[string]interface{}); ok {
154 se.InnerError = c
155 } else if c, ok := arrayOfObjs(sei.InnerError); ok {
156 // if there's only one error extract it
157 if len(c) == 1 {
158 se.InnerError = c[0]
159 } else {
160 // multiple errors, stuff them into the value
161 se.InnerError = map[string]interface{}{
162 "multi": c,
163 }
164 }
165 } else if c, ok := sei.InnerError.(string); ok {
166 se.InnerError = map[string]interface{}{"error": c}
167 } else if sei.InnerError != nil {
168 // stuff into InnerError
169 se.InnerError = map[string]interface{}{
170 "raw": sei.InnerError,
171 }
172 }
173 return nil
174 }
175 176 // RequestError describes an error response returned by Azure service.
177 type RequestError struct {
178 autorest.DetailedError
179 180 // The error returned by the Azure service.
181 ServiceError *ServiceError `json:"error" xml:"Error"`
182 183 // The request id (from the x-ms-request-id-header) of the request.
184 RequestID string
185 }
186 187 // Error returns a human-friendly error message from service error.
188 func (e RequestError) Error() string {
189 return fmt.Sprintf("autorest/azure: Service returned an error. Status=%v %v",
190 e.StatusCode, e.ServiceError)
191 }
192 193 // IsAzureError returns true if the passed error is an Azure Service error; false otherwise.
194 func IsAzureError(e error) bool {
195 _, ok := e.(*RequestError)
196 return ok
197 }
198 199 // Resource contains details about an Azure resource.
200 type Resource struct {
201 SubscriptionID string
202 ResourceGroup string
203 Provider string
204 ResourceType string
205 ResourceName string
206 }
207 208 // String function returns a string in form of azureResourceID
209 func (r Resource) String() string {
210 return fmt.Sprintf("/subscriptions/%s/resourceGroups/%s/providers/%s/%s/%s", r.SubscriptionID, r.ResourceGroup, r.Provider, r.ResourceType, r.ResourceName)
211 }
212 213 // ParseResourceID parses a resource ID into a ResourceDetails struct.
214 // See https://docs.microsoft.com/en-us/azure/azure-resource-manager/templates/template-functions-resource?tabs=json#resourceid.
215 func ParseResourceID(resourceID string) (Resource, error) {
216 217 const resourceIDPatternText = `(?i)^/subscriptions/(.+)/resourceGroups/(.+)/providers/(.+?)/(.+?)/(.+)$`
218 resourceIDPattern := regexp.MustCompile(resourceIDPatternText)
219 match := resourceIDPattern.FindStringSubmatch(resourceID)
220 221 if len(match) == 0 {
222 return Resource{}, fmt.Errorf("parsing failed for %s. Invalid resource Id format", resourceID)
223 }
224 225 v := strings.Split(match[5], "/")
226 resourceName := v[len(v)-1]
227 228 result := Resource{
229 SubscriptionID: match[1],
230 ResourceGroup: match[2],
231 Provider: match[3],
232 ResourceType: match[4],
233 ResourceName: resourceName,
234 }
235 236 return result, nil
237 }
238 239 // NewErrorWithError creates a new Error conforming object from the
240 // passed packageType, method, statusCode of the given resp (UndefinedStatusCode
241 // if resp is nil), message, and original error. message is treated as a format
242 // string to which the optional args apply.
243 func NewErrorWithError(original error, packageType string, method string, resp *http.Response, message string, args ...interface{}) RequestError {
244 if v, ok := original.(*RequestError); ok {
245 return *v
246 }
247 248 statusCode := autorest.UndefinedStatusCode
249 if resp != nil {
250 statusCode = resp.StatusCode
251 }
252 return RequestError{
253 DetailedError: autorest.DetailedError{
254 Original: original,
255 PackageType: packageType,
256 Method: method,
257 StatusCode: statusCode,
258 Message: fmt.Sprintf(message, args...),
259 },
260 }
261 }
262 263 // WithReturningClientID returns a PrepareDecorator that adds an HTTP extension header of
264 // x-ms-client-request-id whose value is the passed, undecorated UUID (e.g.,
265 // "0F39878C-5F76-4DB8-A25D-61D2C193C3CA"). It also sets the x-ms-return-client-request-id
266 // header to true such that UUID accompanies the http.Response.
267 func WithReturningClientID(uuid string) autorest.PrepareDecorator {
268 preparer := autorest.CreatePreparer(
269 WithClientID(uuid),
270 WithReturnClientID(true))
271 272 return func(p autorest.Preparer) autorest.Preparer {
273 return autorest.PreparerFunc(func(r *http.Request) (*http.Request, error) {
274 r, err := p.Prepare(r)
275 if err != nil {
276 return r, err
277 }
278 return preparer.Prepare(r)
279 })
280 }
281 }
282 283 // WithClientID returns a PrepareDecorator that adds an HTTP extension header of
284 // x-ms-client-request-id whose value is passed, undecorated UUID (e.g.,
285 // "0F39878C-5F76-4DB8-A25D-61D2C193C3CA").
286 func WithClientID(uuid string) autorest.PrepareDecorator {
287 return autorest.WithHeader(HeaderClientID, uuid)
288 }
289 290 // WithReturnClientID returns a PrepareDecorator that adds an HTTP extension header of
291 // x-ms-return-client-request-id whose boolean value indicates if the value of the
292 // x-ms-client-request-id header should be included in the http.Response.
293 func WithReturnClientID(b bool) autorest.PrepareDecorator {
294 return autorest.WithHeader(HeaderReturnClientID, strconv.FormatBool(b))
295 }
296 297 // ExtractClientID extracts the client identifier from the x-ms-client-request-id header set on the
298 // http.Request sent to the service (and returned in the http.Response)
299 func ExtractClientID(resp *http.Response) string {
300 return autorest.ExtractHeaderValue(HeaderClientID, resp)
301 }
302 303 // ExtractRequestID extracts the Azure server generated request identifier from the
304 // x-ms-request-id header.
305 func ExtractRequestID(resp *http.Response) string {
306 return autorest.ExtractHeaderValue(HeaderRequestID, resp)
307 }
308 309 // WithErrorUnlessStatusCode returns a RespondDecorator that emits an
310 // azure.RequestError by reading the response body unless the response HTTP status code
311 // is among the set passed.
312 //
313 // If there is a chance service may return responses other than the Azure error
314 // format and the response cannot be parsed into an error, a decoding error will
315 // be returned containing the response body. In any case, the Responder will
316 // return an error if the status code is not satisfied.
317 //
318 // If this Responder returns an error, the response body will be replaced with
319 // an in-memory reader, which needs no further closing.
320 func WithErrorUnlessStatusCode(codes ...int) autorest.RespondDecorator {
321 return func(r autorest.Responder) autorest.Responder {
322 return autorest.ResponderFunc(func(resp *http.Response) error {
323 err := r.Respond(resp)
324 if err == nil && !autorest.ResponseHasStatusCode(resp, codes...) {
325 var e RequestError
326 defer resp.Body.Close()
327 328 encodedAs := autorest.EncodedAsJSON
329 if strings.Contains(resp.Header.Get("Content-Type"), "xml") {
330 encodedAs = autorest.EncodedAsXML
331 }
332 333 // Copy and replace the Body in case it does not contain an error object.
334 // This will leave the Body available to the caller.
335 b, decodeErr := autorest.CopyAndDecode(encodedAs, resp.Body, &e)
336 resp.Body = io.NopCloser(&b)
337 if decodeErr != nil {
338 return fmt.Errorf("autorest/azure: error response cannot be parsed: %q error: %v", b, decodeErr)
339 }
340 if e.ServiceError == nil {
341 // Check if error is unwrapped ServiceError
342 decoder := autorest.NewDecoder(encodedAs, bytes.NewReader(b.Bytes()))
343 if err := decoder.Decode(&e.ServiceError); err != nil {
344 return fmt.Errorf("autorest/azure: error response cannot be parsed: %q error: %v", b, err)
345 }
346 347 // for example, should the API return the literal value `null` as the response
348 if e.ServiceError == nil {
349 e.ServiceError = &ServiceError{
350 Code: "Unknown",
351 Message: "Unknown service error",
352 Details: []map[string]interface{}{
353 {
354 "HttpResponse.Body": b.String(),
355 },
356 },
357 }
358 }
359 }
360 361 if e.ServiceError != nil && e.ServiceError.Message == "" {
362 // if we're here it means the returned error wasn't OData v4 compliant.
363 // try to unmarshal the body in hopes of getting something.
364 rawBody := map[string]interface{}{}
365 decoder := autorest.NewDecoder(encodedAs, bytes.NewReader(b.Bytes()))
366 if err := decoder.Decode(&rawBody); err != nil {
367 return fmt.Errorf("autorest/azure: error response cannot be parsed: %q error: %v", b, err)
368 }
369 370 e.ServiceError = &ServiceError{
371 Code: "Unknown",
372 Message: "Unknown service error",
373 }
374 if len(rawBody) > 0 {
375 e.ServiceError.Details = []map[string]interface{}{rawBody}
376 }
377 }
378 e.Response = resp
379 e.RequestID = ExtractRequestID(resp)
380 if e.StatusCode == nil {
381 e.StatusCode = resp.StatusCode
382 }
383 err = &e
384 }
385 return err
386 })
387 }
388 }
389