2019-12-09 18:35:31 +02:00
|
|
|
package http
|
|
|
|
|
|
|
|
import (
|
2020-01-14 11:29:50 +02:00
|
|
|
"bytes"
|
2020-05-25 19:48:59 +02:00
|
|
|
"context"
|
2020-11-09 12:47:03 +02:00
|
|
|
"crypto/tls"
|
2020-07-14 10:58:57 +02:00
|
|
|
"encoding/json"
|
|
|
|
"encoding/xml"
|
2019-12-09 18:35:31 +02:00
|
|
|
"fmt"
|
|
|
|
"io"
|
2020-07-14 10:58:57 +02:00
|
|
|
"io/ioutil"
|
2020-01-14 11:29:50 +02:00
|
|
|
"mime/multipart"
|
2020-03-23 16:02:22 +02:00
|
|
|
"net"
|
2019-12-09 18:35:31 +02:00
|
|
|
"net/http"
|
2020-01-14 11:29:50 +02:00
|
|
|
"os"
|
|
|
|
"strings"
|
2019-12-09 18:35:31 +02:00
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/SAP/jenkins-library/pkg/log"
|
2020-11-11 14:35:53 +02:00
|
|
|
"github.com/hashicorp/go-retryablehttp"
|
2020-05-25 19:48:59 +02:00
|
|
|
"github.com/motemen/go-nuts/roundtime"
|
2019-12-09 18:35:31 +02:00
|
|
|
"github.com/pkg/errors"
|
2020-01-14 11:29:50 +02:00
|
|
|
"github.com/sirupsen/logrus"
|
2019-12-09 18:35:31 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
// Client defines an http client object
|
|
|
|
type Client struct {
|
2020-11-09 12:47:03 +02:00
|
|
|
maxRequestDuration time.Duration
|
2020-11-11 14:35:53 +02:00
|
|
|
maxRetries int
|
2020-11-09 12:47:03 +02:00
|
|
|
transportTimeout time.Duration
|
|
|
|
transportSkipVerification bool
|
|
|
|
username string
|
|
|
|
password string
|
|
|
|
token string
|
|
|
|
logger *logrus.Entry
|
|
|
|
cookieJar http.CookieJar
|
|
|
|
doLogRequestBodyOnDebug bool
|
|
|
|
doLogResponseBodyOnDebug bool
|
2021-02-04 15:58:35 +02:00
|
|
|
useDefaultTransport bool
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// ClientOptions defines the options to be set on the client
|
|
|
|
type ClientOptions struct {
|
2020-03-23 16:02:22 +02:00
|
|
|
// MaxRequestDuration has a default value of "0", meaning "no maximum
|
|
|
|
// request duration". If it is greater than 0, an overall, hard timeout
|
|
|
|
// for the request will be enforced. This should only be used if the
|
|
|
|
// length of the request bodies is known.
|
|
|
|
MaxRequestDuration time.Duration
|
2020-11-11 14:35:53 +02:00
|
|
|
MaxRetries int
|
2020-06-10 11:14:55 +02:00
|
|
|
// TransportTimeout defaults to 3 minutes, if not specified. It is
|
2020-03-23 16:02:22 +02:00
|
|
|
// used for the transport layer and duration of handshakes and such.
|
2020-11-09 12:47:03 +02:00
|
|
|
TransportTimeout time.Duration
|
|
|
|
TransportSkipVerification bool
|
|
|
|
Username string
|
|
|
|
Password string
|
|
|
|
Token string
|
|
|
|
Logger *logrus.Entry
|
|
|
|
CookieJar http.CookieJar
|
|
|
|
DoLogRequestBodyOnDebug bool
|
|
|
|
DoLogResponseBodyOnDebug bool
|
2021-02-04 15:58:35 +02:00
|
|
|
UseDefaultTransport bool
|
2020-05-25 19:48:59 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// TransportWrapper is a wrapper for central logging capabilities
|
|
|
|
type TransportWrapper struct {
|
|
|
|
Transport http.RoundTripper
|
|
|
|
doLogRequestBodyOnDebug bool
|
|
|
|
doLogResponseBodyOnDebug bool
|
|
|
|
}
|
|
|
|
|
|
|
|
// UploadRequestData encapsulates the parameters for calling uploader.Upload()
|
|
|
|
type UploadRequestData struct {
|
|
|
|
// Method is the HTTP method used for the request. Must be one of http.MethodPost or http.MethodPut.
|
|
|
|
Method string
|
|
|
|
// URL for the request
|
|
|
|
URL string
|
|
|
|
// File path to be stored in the created form field.
|
|
|
|
File string
|
|
|
|
// Form field name under which the file name will be stored.
|
|
|
|
FileFieldName string
|
|
|
|
// Additional form fields which will be added to the request if not nil.
|
|
|
|
FormFields map[string]string
|
|
|
|
// Reader from which the file contents will be read.
|
|
|
|
FileContent io.Reader
|
|
|
|
Header http.Header
|
|
|
|
Cookies []*http.Cookie
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
|
|
|
|
2020-01-14 11:29:50 +02:00
|
|
|
// Sender provides an interface to the piper http client for uid/pwd and token authenticated requests
|
2019-12-09 18:35:31 +02:00
|
|
|
type Sender interface {
|
|
|
|
SendRequest(method, url string, body io.Reader, header http.Header, cookies []*http.Cookie) (*http.Response, error)
|
|
|
|
SetOptions(options ClientOptions)
|
|
|
|
}
|
|
|
|
|
2020-01-14 11:29:50 +02:00
|
|
|
// Uploader provides an interface to the piper http client for uid/pwd and token authenticated requests with upload capabilities
|
|
|
|
type Uploader interface {
|
2020-03-23 16:02:22 +02:00
|
|
|
Sender
|
2020-01-22 15:22:04 +02:00
|
|
|
UploadRequest(method, url, file, fieldName string, header http.Header, cookies []*http.Cookie) (*http.Response, error)
|
2020-01-14 11:29:50 +02:00
|
|
|
UploadFile(url, file, fieldName string, header http.Header, cookies []*http.Cookie) (*http.Response, error)
|
2020-05-25 19:48:59 +02:00
|
|
|
Upload(data UploadRequestData) (*http.Response, error)
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// UploadFile uploads a file's content as multipart-form POST request to the specified URL
|
2020-05-25 19:48:59 +02:00
|
|
|
func (c *Client) UploadFile(url, file, fileFieldName string, header http.Header, cookies []*http.Cookie) (*http.Response, error) {
|
|
|
|
return c.UploadRequest(http.MethodPost, url, file, fileFieldName, header, cookies)
|
2020-01-22 15:22:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// UploadRequest uploads a file's content as multipart-form with given http method request to the specified URL
|
2020-05-25 19:48:59 +02:00
|
|
|
func (c *Client) UploadRequest(method, url, file, fileFieldName string, header http.Header, cookies []*http.Cookie) (*http.Response, error) {
|
|
|
|
fileHandle, err := os.Open(file)
|
|
|
|
if err != nil {
|
|
|
|
return &http.Response{}, errors.Wrapf(err, "unable to locate file %v", file)
|
|
|
|
}
|
|
|
|
defer fileHandle.Close()
|
|
|
|
return c.Upload(UploadRequestData{
|
|
|
|
Method: method,
|
|
|
|
URL: url,
|
|
|
|
File: file,
|
|
|
|
FileFieldName: fileFieldName,
|
|
|
|
FileContent: fileHandle,
|
|
|
|
Header: header,
|
|
|
|
Cookies: cookies,
|
|
|
|
})
|
|
|
|
}
|
2020-01-22 16:10:40 +02:00
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
// Upload uploads a file's content as multipart-form with given http method request to the specified URL
|
|
|
|
func (c *Client) Upload(data UploadRequestData) (*http.Response, error) {
|
|
|
|
if data.Method != http.MethodPost && data.Method != http.MethodPut {
|
|
|
|
return nil, errors.New(fmt.Sprintf("Http method %v is not allowed. Possible values are %v or %v", data.Method, http.MethodPost, http.MethodPut))
|
2020-01-22 16:10:40 +02:00
|
|
|
}
|
|
|
|
|
2020-01-14 11:29:50 +02:00
|
|
|
bodyBuffer := &bytes.Buffer{}
|
|
|
|
bodyWriter := multipart.NewWriter(bodyBuffer)
|
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
if data.FormFields != nil {
|
|
|
|
for fieldName, fieldValue := range data.FormFields {
|
|
|
|
err := bodyWriter.WriteField(fieldName, fieldValue)
|
|
|
|
if err != nil {
|
|
|
|
return &http.Response{}, errors.Wrapf(err, "error writing form field %v with value %v", fieldName, fieldValue)
|
|
|
|
}
|
|
|
|
}
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
fileWriter, err := bodyWriter.CreateFormFile(data.FileFieldName, data.File)
|
2020-01-14 11:29:50 +02:00
|
|
|
if err != nil {
|
2020-05-25 19:48:59 +02:00
|
|
|
return &http.Response{}, errors.Wrapf(err, "error creating form file %v for field %v", data.File, data.FileFieldName)
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
_, err = io.Copy(fileWriter, data.FileContent)
|
2020-01-14 11:29:50 +02:00
|
|
|
if err != nil {
|
2020-05-25 19:48:59 +02:00
|
|
|
return &http.Response{}, errors.Wrapf(err, "unable to copy file content of %v into request body", data.File)
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
err = bodyWriter.Close()
|
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
request, err := c.createRequest(data.Method, data.URL, bodyBuffer, &data.Header, data.Cookies)
|
2020-01-14 11:29:50 +02:00
|
|
|
if err != nil {
|
2020-05-25 19:48:59 +02:00
|
|
|
c.logger.Debugf("New %v request to %v", data.Method, data.URL)
|
|
|
|
return &http.Response{}, errors.Wrapf(err, "error creating %v request to %v", data.Method, data.URL)
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
startBoundary := strings.Index(bodyWriter.FormDataContentType(), "=") + 1
|
|
|
|
boundary := bodyWriter.FormDataContentType()[startBoundary:]
|
|
|
|
|
|
|
|
request.Header.Add("Content-Type", "multipart/form-data; boundary=\""+boundary+"\"")
|
|
|
|
request.Header.Add("Connection", "Keep-Alive")
|
|
|
|
|
2021-02-08 15:26:15 +02:00
|
|
|
return c.Send(request)
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
|
2019-12-09 18:35:31 +02:00
|
|
|
// SendRequest sends an http request with a defined method
|
2021-01-12 16:26:45 +02:00
|
|
|
//
|
|
|
|
// On error, any Response can be ignored and the Response.Body
|
|
|
|
// does not need to be closed.
|
2019-12-09 18:35:31 +02:00
|
|
|
func (c *Client) SendRequest(method, url string, body io.Reader, header http.Header, cookies []*http.Cookie) (*http.Response, error) {
|
2020-01-14 11:29:50 +02:00
|
|
|
request, err := c.createRequest(method, url, body, &header, cookies)
|
|
|
|
if err != nil {
|
|
|
|
return &http.Response{}, errors.Wrapf(err, "error creating %v request to %v", method, url)
|
|
|
|
}
|
2019-12-09 18:35:31 +02:00
|
|
|
|
2021-02-08 15:26:15 +02:00
|
|
|
return c.Send(request)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Send sends an http request
|
|
|
|
func (c *Client) Send(request *http.Request) (*http.Response, error) {
|
|
|
|
httpClient := c.initialize()
|
2020-01-14 11:29:50 +02:00
|
|
|
response, err := httpClient.Do(request)
|
|
|
|
if err != nil {
|
2021-02-08 15:26:15 +02:00
|
|
|
return response, errors.Wrapf(err, "HTTP %v request to %v failed", request.Method, request.URL)
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
2021-02-08 15:26:15 +02:00
|
|
|
return c.handleResponse(response, request.URL.String())
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// SetOptions sets options used for the http client
|
|
|
|
func (c *Client) SetOptions(options ClientOptions) {
|
2020-05-25 19:48:59 +02:00
|
|
|
c.doLogRequestBodyOnDebug = options.DoLogRequestBodyOnDebug
|
|
|
|
c.doLogResponseBodyOnDebug = options.DoLogResponseBodyOnDebug
|
2021-02-04 15:58:35 +02:00
|
|
|
c.useDefaultTransport = options.UseDefaultTransport
|
2020-03-23 16:02:22 +02:00
|
|
|
c.transportTimeout = options.TransportTimeout
|
2020-11-09 12:47:03 +02:00
|
|
|
c.transportSkipVerification = options.TransportSkipVerification
|
2020-03-23 16:02:22 +02:00
|
|
|
c.maxRequestDuration = options.MaxRequestDuration
|
2020-01-14 11:29:50 +02:00
|
|
|
c.username = options.Username
|
|
|
|
c.password = options.Password
|
|
|
|
c.token = options.Token
|
2020-11-11 14:35:53 +02:00
|
|
|
c.maxRetries = options.MaxRetries
|
2020-02-06 17:16:34 +02:00
|
|
|
|
|
|
|
if options.Logger != nil {
|
|
|
|
c.logger = options.Logger
|
|
|
|
} else {
|
|
|
|
c.logger = log.Entry().WithField("package", "SAP/jenkins-library/pkg/http")
|
|
|
|
}
|
2020-02-04 12:43:27 +02:00
|
|
|
c.cookieJar = options.CookieJar
|
2020-01-14 11:29:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) initialize() *http.Client {
|
2019-12-09 18:35:31 +02:00
|
|
|
c.applyDefaults()
|
2020-01-29 14:17:54 +02:00
|
|
|
c.logger = log.Entry().WithField("package", "SAP/jenkins-library/pkg/http")
|
2019-12-09 18:35:31 +02:00
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
var transport = &TransportWrapper{
|
|
|
|
Transport: &http.Transport{
|
|
|
|
DialContext: (&net.Dialer{
|
|
|
|
Timeout: c.transportTimeout,
|
|
|
|
}).DialContext,
|
|
|
|
ResponseHeaderTimeout: c.transportTimeout,
|
|
|
|
ExpectContinueTimeout: c.transportTimeout,
|
|
|
|
TLSHandshakeTimeout: c.transportTimeout,
|
2020-11-09 12:47:03 +02:00
|
|
|
TLSClientConfig: &tls.Config{
|
|
|
|
InsecureSkipVerify: c.transportSkipVerification,
|
|
|
|
},
|
2020-05-25 19:48:59 +02:00
|
|
|
},
|
|
|
|
doLogRequestBodyOnDebug: c.doLogRequestBodyOnDebug,
|
|
|
|
doLogResponseBodyOnDebug: c.doLogResponseBodyOnDebug,
|
2020-03-23 16:02:22 +02:00
|
|
|
}
|
2020-11-11 14:35:53 +02:00
|
|
|
|
|
|
|
var httpClient *http.Client
|
|
|
|
if c.maxRetries > 0 {
|
|
|
|
retryClient := retryablehttp.NewClient()
|
|
|
|
retryClient.HTTPClient.Timeout = c.maxRequestDuration
|
|
|
|
retryClient.HTTPClient.Jar = c.cookieJar
|
|
|
|
retryClient.RetryMax = c.maxRetries
|
2021-02-04 15:58:35 +02:00
|
|
|
if !c.useDefaultTransport {
|
|
|
|
retryClient.HTTPClient.Transport = transport
|
|
|
|
}
|
2021-03-09 14:41:07 +02:00
|
|
|
retryClient.CheckRetry = func(ctx context.Context, resp *http.Response, err error) (bool, error) {
|
|
|
|
if err != nil && strings.Contains(err.Error(), "timeout") {
|
|
|
|
// Assuming timeouts could be retried
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
return retryablehttp.DefaultRetryPolicy(ctx, resp, err)
|
|
|
|
}
|
2020-11-11 14:35:53 +02:00
|
|
|
httpClient = retryClient.StandardClient()
|
|
|
|
} else {
|
|
|
|
httpClient = &http.Client{}
|
|
|
|
httpClient.Timeout = c.maxRequestDuration
|
|
|
|
httpClient.Jar = c.cookieJar
|
2021-02-04 15:58:35 +02:00
|
|
|
if !c.useDefaultTransport {
|
|
|
|
httpClient.Transport = transport
|
|
|
|
}
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
2020-11-11 14:35:53 +02:00
|
|
|
|
2020-11-09 12:47:03 +02:00
|
|
|
if c.transportSkipVerification {
|
|
|
|
c.logger.Debugf("TLS verification disabled")
|
|
|
|
}
|
2020-11-11 14:35:53 +02:00
|
|
|
|
2020-03-23 16:02:22 +02:00
|
|
|
c.logger.Debugf("Transport timeout: %v, max request duration: %v", c.transportTimeout, c.maxRequestDuration)
|
2020-01-14 11:29:50 +02:00
|
|
|
|
|
|
|
return httpClient
|
|
|
|
}
|
2019-12-09 18:35:31 +02:00
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
type contextKey struct {
|
|
|
|
name string
|
|
|
|
}
|
|
|
|
|
|
|
|
var contextKeyRequestStart = &contextKey{"RequestStart"}
|
|
|
|
|
|
|
|
// RoundTrip is the core part of this module and implements http.RoundTripper.
|
|
|
|
// Executes HTTP request with request/response logging.
|
|
|
|
func (t *TransportWrapper) RoundTrip(req *http.Request) (*http.Response, error) {
|
|
|
|
ctx := context.WithValue(req.Context(), contextKeyRequestStart, time.Now())
|
|
|
|
req = req.WithContext(ctx)
|
|
|
|
|
|
|
|
t.logRequest(req)
|
|
|
|
resp, err := t.Transport.RoundTrip(req)
|
|
|
|
t.logResponse(resp)
|
|
|
|
|
|
|
|
return resp, err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *TransportWrapper) logRequest(req *http.Request) {
|
|
|
|
log.Entry().Debug("--------------------------------")
|
|
|
|
log.Entry().Debugf("--> %v request to %v", req.Method, req.URL)
|
2021-01-04 11:06:28 +02:00
|
|
|
log.Entry().Debugf("headers: %v", transformHeaders(req.Header))
|
2020-05-25 19:48:59 +02:00
|
|
|
log.Entry().Debugf("cookies: %v", transformCookies(req.Cookies()))
|
|
|
|
if t.doLogRequestBodyOnDebug {
|
|
|
|
log.Entry().Debugf("body: %v", transformBody(req.Body))
|
|
|
|
}
|
|
|
|
log.Entry().Debug("--------------------------------")
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *TransportWrapper) logResponse(resp *http.Response) {
|
|
|
|
if resp != nil {
|
|
|
|
ctx := resp.Request.Context()
|
|
|
|
if start, ok := ctx.Value(contextKeyRequestStart).(time.Time); ok {
|
|
|
|
log.Entry().Debugf("<-- response %v %v (%v)", resp.StatusCode, resp.Request.URL, roundtime.Duration(time.Now().Sub(start), 2))
|
|
|
|
} else {
|
|
|
|
log.Entry().Debugf("<-- response %v %v", resp.StatusCode, resp.Request.URL)
|
|
|
|
}
|
|
|
|
if t.doLogResponseBodyOnDebug {
|
|
|
|
log.Entry().Debugf("body: %v", transformBody(resp.Body))
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
log.Entry().Debug("response <nil>")
|
|
|
|
}
|
|
|
|
log.Entry().Debug("--------------------------------")
|
|
|
|
}
|
|
|
|
|
2021-01-04 11:06:28 +02:00
|
|
|
func transformHeaders(header http.Header) http.Header {
|
|
|
|
var h http.Header = map[string][]string{}
|
|
|
|
for name, value := range header {
|
|
|
|
if name == "Authorization" {
|
|
|
|
for _, v := range value {
|
|
|
|
// The format of the Authorization header value is: <type> <cred>.
|
|
|
|
// We don't register the full string since only the part after
|
|
|
|
// the first token is the secret in the narrower sense (applies at
|
|
|
|
// least for basic auth)
|
|
|
|
log.RegisterSecret(strings.Join(strings.Split(v, " ")[1:], " "))
|
|
|
|
}
|
|
|
|
// Since
|
|
|
|
// 1.) The auth header type itself might serve as a vector for an
|
|
|
|
// intrusion
|
|
|
|
// 2.) We cannot make assumtions about the structure of the auth
|
|
|
|
// header value since that depends on the type, e.g. several tokens
|
|
|
|
// where only some of the tokens define the secret
|
|
|
|
// we hide the full auth header value anyway in order to be on the
|
|
|
|
// save side.
|
|
|
|
value = []string{"<set>"}
|
|
|
|
}
|
|
|
|
h[name] = value
|
|
|
|
}
|
|
|
|
return h
|
|
|
|
}
|
|
|
|
|
2020-05-25 19:48:59 +02:00
|
|
|
func transformCookies(cookies []*http.Cookie) string {
|
|
|
|
result := ""
|
|
|
|
for _, c := range cookies {
|
|
|
|
result = fmt.Sprintf("%v %v", result, c.String())
|
|
|
|
}
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
|
|
|
func transformBody(body io.ReadCloser) string {
|
|
|
|
if body == nil {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
buf := new(bytes.Buffer)
|
|
|
|
buf.ReadFrom(body)
|
|
|
|
return buf.String()
|
|
|
|
}
|
|
|
|
|
2020-01-14 11:29:50 +02:00
|
|
|
func (c *Client) createRequest(method, url string, body io.Reader, header *http.Header, cookies []*http.Cookie) (*http.Request, error) {
|
2019-12-09 18:35:31 +02:00
|
|
|
request, err := http.NewRequest(method, url, body)
|
|
|
|
if err != nil {
|
2020-01-14 11:29:50 +02:00
|
|
|
return &http.Request{}, err
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if header != nil {
|
2020-01-14 11:29:50 +02:00
|
|
|
for name, headers := range *header {
|
2019-12-09 18:35:31 +02:00
|
|
|
for _, h := range headers {
|
|
|
|
request.Header.Add(name, h)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if cookies != nil {
|
|
|
|
for _, cookie := range cookies {
|
|
|
|
request.AddCookie(cookie)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-03 20:36:52 +02:00
|
|
|
if len(c.username) > 0 {
|
2019-12-09 18:35:31 +02:00
|
|
|
request.SetBasicAuth(c.username, c.password)
|
2020-01-14 11:29:50 +02:00
|
|
|
c.logger.Debug("Using Basic Authentication ****/****")
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
|
|
|
|
2020-01-14 11:29:50 +02:00
|
|
|
if len(c.token) > 0 {
|
|
|
|
request.Header.Add("Authorization", c.token)
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
|
|
|
|
2020-01-14 11:29:50 +02:00
|
|
|
return request, nil
|
|
|
|
}
|
|
|
|
|
2020-12-16 09:55:22 +02:00
|
|
|
func (c *Client) handleResponse(response *http.Response, url string) (*http.Response, error) {
|
2019-12-09 18:35:31 +02:00
|
|
|
// 2xx codes do not create an error
|
|
|
|
if response.StatusCode >= 200 && response.StatusCode < 300 {
|
|
|
|
return response, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
switch response.StatusCode {
|
|
|
|
case http.StatusUnauthorized:
|
2020-01-14 11:29:50 +02:00
|
|
|
c.logger.WithField("HTTP Error", "401 (Unauthorized)").Error("Credentials invalid, please check your user credentials!")
|
2019-12-09 18:35:31 +02:00
|
|
|
case http.StatusForbidden:
|
2020-01-14 11:29:50 +02:00
|
|
|
c.logger.WithField("HTTP Error", "403 (Forbidden)").Error("Permission issue, please check your user permissions!")
|
2019-12-09 18:35:31 +02:00
|
|
|
case http.StatusNotFound:
|
2020-12-16 09:55:22 +02:00
|
|
|
c.logger.WithField("HTTP Error", "404 (Not Found)").Errorf("Requested resource ('%s') could not be found", url)
|
2019-12-09 18:35:31 +02:00
|
|
|
case http.StatusInternalServerError:
|
2020-05-25 19:48:59 +02:00
|
|
|
c.logger.WithField("HTTP Error", "500 (Internal Server Error)").Error("Unknown error occurred.")
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
|
|
|
|
2020-03-09 20:25:40 +02:00
|
|
|
return response, fmt.Errorf("Request to %v returned with response %v", response.Request.URL, response.Status)
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) applyDefaults() {
|
2020-03-23 16:02:22 +02:00
|
|
|
if c.transportTimeout == 0 {
|
2020-06-10 11:14:55 +02:00
|
|
|
c.transportTimeout = 3 * time.Minute
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
2020-01-28 00:40:53 +02:00
|
|
|
if c.logger == nil {
|
|
|
|
c.logger = log.Entry().WithField("package", "SAP/jenkins-library/pkg/http")
|
|
|
|
}
|
2019-12-09 18:35:31 +02:00
|
|
|
}
|
2020-07-14 10:58:57 +02:00
|
|
|
|
2020-09-24 07:41:06 +02:00
|
|
|
// ParseHTTPResponseBodyXML parses a XML http response into a given interface
|
2020-07-14 10:58:57 +02:00
|
|
|
func ParseHTTPResponseBodyXML(resp *http.Response, response interface{}) error {
|
|
|
|
if resp == nil {
|
|
|
|
return errors.Errorf("cannot parse HTTP response with value <nil>")
|
|
|
|
}
|
|
|
|
|
|
|
|
bodyText, readErr := ioutil.ReadAll(resp.Body)
|
|
|
|
if readErr != nil {
|
|
|
|
return errors.Wrap(readErr, "HTTP response body could not be read")
|
|
|
|
}
|
|
|
|
|
|
|
|
marshalErr := xml.Unmarshal(bodyText, &response)
|
|
|
|
if marshalErr != nil {
|
|
|
|
return errors.Wrapf(marshalErr, "HTTP response body could not be parsed as XML: %v", string(bodyText))
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-09-24 07:41:06 +02:00
|
|
|
// ParseHTTPResponseBodyJSON parses a JSON http response into a given interface
|
2020-07-14 10:58:57 +02:00
|
|
|
func ParseHTTPResponseBodyJSON(resp *http.Response, response interface{}) error {
|
|
|
|
if resp == nil {
|
|
|
|
return errors.Errorf("cannot parse HTTP response with value <nil>")
|
|
|
|
}
|
|
|
|
|
|
|
|
bodyText, readErr := ioutil.ReadAll(resp.Body)
|
|
|
|
if readErr != nil {
|
|
|
|
return errors.Wrapf(readErr, "HTTP response body could not be read")
|
|
|
|
}
|
|
|
|
|
|
|
|
marshalErr := json.Unmarshal(bodyText, &response)
|
|
|
|
if marshalErr != nil {
|
|
|
|
return errors.Wrapf(marshalErr, "HTTP response body could not be parsed as JSON: %v", string(bodyText))
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|