func unmarshalError(r *aws.Request) { defer r.HTTPResponse.Body.Close() if r.HTTPResponse.ContentLength == int64(0) { // No body, use status code to generate an awserr.Error r.Error = apierr.NewRequestError( apierr.New(strings.Replace(r.HTTPResponse.Status, " ", "", -1), r.HTTPResponse.Status, nil), r.HTTPResponse.StatusCode, "", ) return } resp := &xmlErrorResponse{} err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp) if err != nil && err != io.EOF { r.Error = apierr.New("Unmarshal", "failed to decode S3 XML error response", nil) } else { r.Error = apierr.NewRequestError( apierr.New(resp.Code, resp.Message, nil), r.HTTPResponse.StatusCode, "", ) } }
// UnmarshalError unmarshals a response error for the REST JSON protocol. func UnmarshalError(r *aws.Request) { code := r.HTTPResponse.Header.Get("X-Amzn-Errortype") bodyBytes, err := ioutil.ReadAll(r.HTTPResponse.Body) if err != nil { r.Error = apierr.New("Unmarshal", "failed reading REST JSON error response", err) return } if len(bodyBytes) == 0 { r.Error = apierr.NewRequestError( apierr.New("Unmarshal", r.HTTPResponse.Status, nil), r.HTTPResponse.StatusCode, "", ) return } var jsonErr jsonErrorResponse if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil { r.Error = apierr.New("Unmarshal", "failed decoding REST JSON error response", err) return } if code == "" { code = jsonErr.Code } codes := strings.SplitN(code, ":", 2) r.Error = apierr.NewRequestError( apierr.New(codes[0], jsonErr.Message, nil), r.HTTPResponse.StatusCode, "", ) }
// Unmarshal unmarshals the REST component of a response in a REST service. func Unmarshal(r *aws.Request) { if r.DataFilled() { v := reflect.Indirect(reflect.ValueOf(r.Data)) unmarshalBody(r, v) unmarshalLocationElements(r, v) } }
// Build builds the REST component of a service request. func Build(r *aws.Request) { if r.ParamsFilled() { v := reflect.ValueOf(r.Params).Elem() buildLocationElements(r, v) buildBody(r, v) } }
// UnmarshalError unmarshals an error response for a JSON RPC service. func UnmarshalError(req *aws.Request) { defer req.HTTPResponse.Body.Close() bodyBytes, err := ioutil.ReadAll(req.HTTPResponse.Body) if err != nil { req.Error = apierr.New("Unmarshal", "failed reading JSON RPC error response", err) return } if len(bodyBytes) == 0 { req.Error = apierr.NewRequestError( apierr.New("Unmarshal", req.HTTPResponse.Status, nil), req.HTTPResponse.StatusCode, "", ) return } var jsonErr jsonErrorResponse if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil { req.Error = apierr.New("Unmarshal", "failed decoding JSON RPC error response", err) return } codes := strings.SplitN(jsonErr.Code, "#", 2) req.Error = apierr.NewRequestError( apierr.New(codes[len(codes)-1], jsonErr.Message, nil), req.HTTPResponse.StatusCode, "", ) }
// Build builds a JSON payload for a JSON RPC request. func Build(req *aws.Request) { var buf []byte var err error if req.ParamsFilled() { buf, err = jsonutil.BuildJSON(req.Params) if err != nil { req.Error = apierr.New("Marshal", "failed encoding JSON RPC request", err) return } } else { buf = emptyJSON } if req.Service.TargetPrefix != "" || string(buf) != "{}" { req.SetBufferBody(buf) } if req.Service.TargetPrefix != "" { target := req.Service.TargetPrefix + "." + req.Operation.Name req.HTTPRequest.Header.Add("X-Amz-Target", target) } if req.Service.JSONVersion != "" { jsonVersion := req.Service.JSONVersion req.HTTPRequest.Header.Add("Content-Type", "application/x-amz-json-"+jsonVersion) } }
func UnmarshalError(req *aws.Request) { bodyBytes, err := ioutil.ReadAll(req.HTTPResponse.Body) if err != nil { req.Error = err return } if len(bodyBytes) == 0 { req.Error = aws.APIError{ StatusCode: req.HTTPResponse.StatusCode, Message: req.HTTPResponse.Status, } return } var jsonErr jsonErrorResponse if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil { req.Error = err return } codes := strings.SplitN(jsonErr.Code, "#", 2) req.Error = aws.APIError{ StatusCode: req.HTTPResponse.StatusCode, Code: codes[len(codes)-1], Message: jsonErr.Message, } }
func assertMD5(t *testing.T, req *aws.Request) { err := req.Build() assert.NoError(t, err) b, _ := ioutil.ReadAll(req.HTTPRequest.Body) out := md5.Sum(b) assert.NotEmpty(t, b) assert.Equal(t, base64.StdEncoding.EncodeToString(out[:]), req.HTTPRequest.Header.Get("Content-MD5")) }
func Unmarshal(req *aws.Request) { if req.DataFilled() { err := jsonutil.UnmarshalJSON(req.Data, req.HTTPResponse.Body) if err != nil { req.Error = err } } return }
// Unmarshal unmarshals a response for a JSON RPC service. func Unmarshal(req *aws.Request) { defer req.HTTPResponse.Body.Close() if req.DataFilled() { err := jsonutil.UnmarshalJSON(req.Data, req.HTTPResponse.Body) if err != nil { req.Error = apierr.New("Unmarshal", "failed decoding JSON RPC response", err) } } return }
func verifySendMessage(r *aws.Request) { if r.DataFilled() && r.ParamsFilled() { in := r.Params.(*SendMessageInput) out := r.Data.(*SendMessageOutput) err := checksumsMatch(in.MessageBody, out.MD5OfMessageBody) if err != nil { setChecksumError(r, err.Error()) } } }
func addAccountID(r *aws.Request) { if !r.ParamsFilled() { return } v := reflect.Indirect(reflect.ValueOf(r.Params)) if f := v.FieldByName("AccountID"); f.IsNil() { f.Set(reflect.ValueOf(&defaultAccountID)) } }
func Unmarshal(r *aws.Request) { defer r.HTTPResponse.Body.Close() if r.DataFilled() { decoder := xml.NewDecoder(r.HTTPResponse.Body) err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result") if err != nil { r.Error = err return } } }
// Unmarshal unmarshals a response for an AWS Query service. func Unmarshal(r *aws.Request) { defer r.HTTPResponse.Body.Close() if r.DataFilled() { decoder := xml.NewDecoder(r.HTTPResponse.Body) err := xmlutil.UnmarshalXML(r.Data, decoder, r.Operation.Name+"Result") if err != nil { r.Error = apierr.New("Unmarshal", "failed decoding Query response", err) return } } }
func populateLocationConstraint(r *aws.Request) { if r.ParamsFilled() && r.Config.Region != "us-east-1" { in := r.Params.(*CreateBucketInput) if in.CreateBucketConfiguration == nil { r.Params = awsutil.CopyOf(r.Params) in = r.Params.(*CreateBucketInput) in.CreateBucketConfiguration = &CreateBucketConfiguration{ LocationConstraint: &r.Config.Region, } } } }
func Build(r *aws.Request) { rest.Build(r) if t := rest.PayloadType(r.Params); t == "structure" || t == "" { var buf bytes.Buffer err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf)) if err != nil { r.Error = err return } r.SetBufferBody(buf.Bytes()) } }
// Build builds a request payload for the REST XML protocol. func Build(r *aws.Request) { rest.Build(r) if t := rest.PayloadType(r.Params); t == "structure" || t == "" { var buf bytes.Buffer err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf)) if err != nil { r.Error = apierr.New("Marshal", "failed to enode rest XML request", err) return } r.SetBufferBody(buf.Bytes()) } }
func unmarshalError(r *aws.Request) { defer r.HTTPResponse.Body.Close() resp := &xmlErrorResponse{} err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp) if err != nil && err != io.EOF { r.Error = err } else { r.Error = aws.APIError{ StatusCode: r.HTTPResponse.StatusCode, Code: resp.Code, Message: resp.Message, } } }
// UnmarshalError unmarshals an error response for an AWS Query service. func UnmarshalError(r *aws.Request) { defer r.HTTPResponse.Body.Close() resp := &xmlErrorResponse{} err := xml.NewDecoder(r.HTTPResponse.Body).Decode(resp) if err != nil && err != io.EOF { r.Error = apierr.New("Unmarshal", "failed to decode query XML error response", err) } else { r.Error = apierr.NewRequestError( apierr.New(resp.Code, resp.Message, nil), r.HTTPResponse.StatusCode, resp.RequestID, ) } }
func verifyReceiveMessage(r *aws.Request) { if r.DataFilled() && r.ParamsFilled() { ids := []string{} out := r.Data.(*ReceiveMessageOutput) for _, msg := range out.Messages { err := checksumsMatch(msg.Body, msg.MD5OfBody) if err != nil { ids = append(ids, *msg.MessageID) } } if len(ids) > 0 { setChecksumError(r, "invalid messages: %s", strings.Join(ids, ", ")) } } }
func buildGetBucketLocation(r *aws.Request) { if r.DataFilled() { out := r.Data.(*GetBucketLocationOutput) b, err := ioutil.ReadAll(r.HTTPResponse.Body) if err != nil { r.Error = apierr.New("Unmarshal", "failed reading response body", err) return } match := reBucketLocation.FindSubmatch(b) if len(match) > 1 { loc := string(match[1]) out.LocationConstraint = &loc } } }
// Sign requests with signature version 4. func Sign(req *aws.Request) { creds, err := req.Service.Config.Credentials.Credentials() if err != nil { req.Error = err return } region := req.Service.SigningRegion if region == "" { region = req.Service.Config.Region } s := signer{ Request: req.HTTPRequest, Time: req.Time, ExpireTime: req.ExpireTime, Query: req.HTTPRequest.URL.Query(), Body: req.Body, ServiceName: req.Service.ServiceName, Region: region, AccessKeyID: creds.AccessKeyID, SecretAccessKey: creds.SecretAccessKey, SessionToken: creds.SessionToken, Debug: req.Service.Config.LogLevel, Logger: req.Service.Config.Logger, } s.sign() return }
func buildQueryString(r *aws.Request, v reflect.Value, name string, query url.Values) { str, err := convertType(v) if err != nil { r.Error = apierr.New("Marshal", "failed to encode REST request", err) } else if str != nil { query.Set(name, *str) } }
func buildHeader(r *aws.Request, v reflect.Value, name string) { str, err := convertType(v) if err != nil { r.Error = apierr.New("Marshal", "failed to encode REST request", err) } else if str != nil { r.HTTPRequest.Header.Add(name, *str) } }
func buildHeader(r *aws.Request, v reflect.Value, name string) { str, err := convertType(v) if err != nil { r.Error = err } else if str != nil { r.HTTPRequest.Header.Add(name, *str) } }
func buildQueryString(r *aws.Request, v reflect.Value, name string, query url.Values) { str, err := convertType(v) if err != nil { r.Error = err } else if str != nil { query.Set(name, *str) } }
func validateSSERequiresSSL(r *aws.Request) { if r.HTTPRequest.URL.Scheme != "https" { p := awsutil.ValuesAtPath(r.Params, "SSECustomerKey||CopySourceSSECustomerKey") if len(p) > 0 { r.Error = errSSERequiresSSL } } }
// Build builds a request for the EC2 protocol. func Build(r *aws.Request) { body := url.Values{ "Action": {r.Operation.Name}, "Version": {r.Service.APIVersion}, } if err := queryutil.Parse(body, r.Params, true); err != nil { r.Error = apierr.New("Marshal", "failed encoding EC2 Query request", err) } if r.ExpireTime == 0 { r.HTTPRequest.Method = "POST" r.HTTPRequest.Header.Set("Content-Type", "application/x-www-form-urlencoded; charset=utf-8") r.SetBufferBody([]byte(body.Encode())) } else { // This is a pre-signed request r.HTTPRequest.Method = "GET" r.HTTPRequest.URL.RawQuery = body.Encode() } }
func buildHeaderMap(r *aws.Request, v reflect.Value, prefix string) { for _, key := range v.MapKeys() { str, err := convertType(v.MapIndex(key)) if err != nil { r.Error = apierr.New("Marshal", "failed to encode REST request", err) } else if str != nil { r.HTTPRequest.Header.Add(prefix+key.String(), *str) } } }
func buildURI(r *aws.Request, v reflect.Value, name string) { value, err := convertType(v) if err != nil { r.Error = apierr.New("Marshal", "failed to encode REST request", err) } else if value != nil { uri := r.HTTPRequest.URL.Path uri = strings.Replace(uri, "{"+name+"}", EscapePath(*value, true), -1) uri = strings.Replace(uri, "{"+name+"+}", EscapePath(*value, false), -1) r.HTTPRequest.URL.Path = uri } }