2016-12-20 23:45:17 +01:00
|
|
|
/*
|
2019-04-09 20:39:42 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2016, 2017 MinIO, Inc.
|
2016-12-20 23:45:17 +01:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
package madmin
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
2020-03-20 23:00:44 +01:00
|
|
|
"context"
|
2016-12-20 23:45:17 +01:00
|
|
|
"encoding/hex"
|
2020-03-20 23:00:44 +01:00
|
|
|
"errors"
|
2016-12-20 23:45:17 +01:00
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"io/ioutil"
|
2019-05-10 02:41:54 +02:00
|
|
|
"math/rand"
|
2016-12-20 23:45:17 +01:00
|
|
|
"net/http"
|
2020-04-01 22:34:20 +02:00
|
|
|
"net/http/cookiejar"
|
2016-12-20 23:45:17 +01:00
|
|
|
"net/http/httputil"
|
|
|
|
"net/url"
|
|
|
|
"os"
|
|
|
|
"regexp"
|
|
|
|
"runtime"
|
|
|
|
"strings"
|
2019-05-10 02:41:54 +02:00
|
|
|
"time"
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
"github.com/minio/minio-go/v6/pkg/credentials"
|
2019-05-30 01:35:12 +02:00
|
|
|
"github.com/minio/minio-go/v6/pkg/s3utils"
|
2020-04-15 01:53:16 +02:00
|
|
|
"github.com/minio/minio-go/v6/pkg/signer"
|
2020-04-01 22:34:20 +02:00
|
|
|
"golang.org/x/net/publicsuffix"
|
2016-12-20 23:45:17 +01:00
|
|
|
)
|
|
|
|
|
2016-12-21 03:49:48 +01:00
|
|
|
// AdminClient implements Amazon S3 compatible methods.
|
|
|
|
type AdminClient struct {
|
2016-12-20 23:45:17 +01:00
|
|
|
/// Standard options.
|
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
// Parsed endpoint url provided by the user.
|
|
|
|
endpointURL *url.URL
|
|
|
|
|
|
|
|
// Holds various credential providers.
|
|
|
|
credsProvider *credentials.Credentials
|
2016-12-20 23:45:17 +01:00
|
|
|
|
|
|
|
// User supplied.
|
|
|
|
appInfo struct {
|
|
|
|
appName string
|
|
|
|
appVersion string
|
|
|
|
}
|
|
|
|
|
|
|
|
// Indicate whether we are using https or not
|
|
|
|
secure bool
|
|
|
|
|
|
|
|
// Needs allocation.
|
|
|
|
httpClient *http.Client
|
|
|
|
|
2019-05-10 02:41:54 +02:00
|
|
|
random *rand.Rand
|
|
|
|
|
2016-12-20 23:45:17 +01:00
|
|
|
// Advanced functionality.
|
|
|
|
isTraceEnabled bool
|
|
|
|
traceOutput io.Writer
|
|
|
|
}
|
|
|
|
|
|
|
|
// Global constants.
|
|
|
|
const (
|
|
|
|
libraryName = "madmin-go"
|
|
|
|
libraryVersion = "0.0.1"
|
2018-01-22 23:54:55 +01:00
|
|
|
|
|
|
|
libraryAdminURLPrefix = "/minio/admin"
|
2016-12-20 23:45:17 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
// User Agent should always following the below style.
|
|
|
|
// Please open an issue to discuss any new changes here.
|
|
|
|
//
|
2019-04-09 20:39:42 +02:00
|
|
|
// MinIO (OS; ARCH) LIB/VER APP/VER
|
2016-12-20 23:45:17 +01:00
|
|
|
const (
|
2019-04-09 20:39:42 +02:00
|
|
|
libraryUserAgentPrefix = "MinIO (" + runtime.GOOS + "; " + runtime.GOARCH + ") "
|
2016-12-20 23:45:17 +01:00
|
|
|
libraryUserAgent = libraryUserAgentPrefix + libraryName + "/" + libraryVersion
|
|
|
|
)
|
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
// Options for New method
|
|
|
|
type Options struct {
|
|
|
|
Creds *credentials.Credentials
|
|
|
|
Secure bool
|
|
|
|
// Add future fields here
|
|
|
|
}
|
|
|
|
|
|
|
|
// New - instantiate minio admin client
|
2016-12-21 03:49:48 +01:00
|
|
|
func New(endpoint string, accessKeyID, secretAccessKey string, secure bool) (*AdminClient, error) {
|
2020-04-01 22:34:20 +02:00
|
|
|
creds := credentials.NewStaticV4(accessKeyID, secretAccessKey, "")
|
|
|
|
|
|
|
|
clnt, err := privateNew(endpoint, creds, secure)
|
2016-12-20 23:45:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return clnt, nil
|
|
|
|
}
|
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
// NewWithOptions - instantiate minio admin client with options.
|
|
|
|
func NewWithOptions(endpoint string, opts *Options) (*AdminClient, error) {
|
|
|
|
clnt, err := privateNew(endpoint, opts.Creds, opts.Secure)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return clnt, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func privateNew(endpoint string, creds *credentials.Credentials, secure bool) (*AdminClient, error) {
|
|
|
|
// Initialize cookies to preserve server sent cookies if any and replay
|
|
|
|
// them upon each request.
|
|
|
|
jar, err := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2016-12-20 23:45:17 +01:00
|
|
|
// construct endpoint.
|
|
|
|
endpointURL, err := getEndpointURL(endpoint, secure)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
clnt := new(AdminClient)
|
|
|
|
|
|
|
|
// Save the credentials.
|
|
|
|
clnt.credsProvider = creds
|
|
|
|
|
|
|
|
// Remember whether we are using https or not
|
|
|
|
clnt.secure = secure
|
|
|
|
|
|
|
|
// Save endpoint URL, user agent for future uses.
|
|
|
|
clnt.endpointURL = endpointURL
|
|
|
|
|
|
|
|
// Instantiate http client and bucket location cache.
|
|
|
|
clnt.httpClient = &http.Client{
|
|
|
|
Jar: jar,
|
|
|
|
Transport: DefaultTransport(secure),
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
// Add locked pseudo-random number generator.
|
|
|
|
clnt.random = rand.New(&lockedRandSource{src: rand.NewSource(time.Now().UTC().UnixNano())})
|
|
|
|
|
2016-12-20 23:45:17 +01:00
|
|
|
// Return.
|
|
|
|
return clnt, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetAppInfo - add application details to user agent.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm *AdminClient) SetAppInfo(appName string, appVersion string) {
|
2016-12-20 23:45:17 +01:00
|
|
|
// if app name and version is not set, we do not a new user
|
|
|
|
// agent.
|
|
|
|
if appName != "" && appVersion != "" {
|
2019-02-13 13:59:36 +01:00
|
|
|
adm.appInfo.appName = appName
|
|
|
|
adm.appInfo.appVersion = appVersion
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetCustomTransport - set new custom transport.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm *AdminClient) SetCustomTransport(customHTTPTransport http.RoundTripper) {
|
2016-12-20 23:45:17 +01:00
|
|
|
// Set this to override default transport
|
|
|
|
// ``http.DefaultTransport``.
|
|
|
|
//
|
|
|
|
// This transport is usually needed for debugging OR to add your
|
|
|
|
// own custom TLS certificates on the client transport, for custom
|
|
|
|
// CA's and certs which are not part of standard certificate
|
|
|
|
// authority follow this example :-
|
|
|
|
//
|
|
|
|
// tr := &http.Transport{
|
|
|
|
// TLSClientConfig: &tls.Config{RootCAs: pool},
|
|
|
|
// DisableCompression: true,
|
|
|
|
// }
|
|
|
|
// api.SetTransport(tr)
|
|
|
|
//
|
2019-02-13 13:59:36 +01:00
|
|
|
if adm.httpClient != nil {
|
|
|
|
adm.httpClient.Transport = customHTTPTransport
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TraceOn - enable HTTP tracing.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm *AdminClient) TraceOn(outputStream io.Writer) {
|
2016-12-20 23:45:17 +01:00
|
|
|
// if outputStream is nil then default to os.Stdout.
|
|
|
|
if outputStream == nil {
|
|
|
|
outputStream = os.Stdout
|
|
|
|
}
|
|
|
|
// Sets a new output stream.
|
2019-02-13 13:59:36 +01:00
|
|
|
adm.traceOutput = outputStream
|
2016-12-20 23:45:17 +01:00
|
|
|
|
|
|
|
// Enable tracing.
|
2019-02-13 13:59:36 +01:00
|
|
|
adm.isTraceEnabled = true
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// TraceOff - disable HTTP tracing.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm *AdminClient) TraceOff() {
|
2016-12-20 23:45:17 +01:00
|
|
|
// Disable tracing.
|
2019-02-13 13:59:36 +01:00
|
|
|
adm.isTraceEnabled = false
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// requestMetadata - is container for all the values to make a
|
|
|
|
// request.
|
|
|
|
type requestData struct {
|
|
|
|
customHeaders http.Header
|
|
|
|
queryValues url.Values
|
2018-09-27 06:02:05 +02:00
|
|
|
relPath string // URL path relative to admin API base endpoint
|
2018-05-30 23:49:03 +02:00
|
|
|
content []byte
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Filter out signature value from Authorization header.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm AdminClient) filterSignature(req *http.Request) {
|
2016-12-20 23:45:17 +01:00
|
|
|
/// Signature V4 authorization header.
|
|
|
|
|
|
|
|
// Save the original auth.
|
|
|
|
origAuth := req.Header.Get("Authorization")
|
|
|
|
// Strip out accessKeyID from:
|
|
|
|
// Credential=<access-key-id>/<date>/<aws-region>/<aws-service>/aws4_request
|
|
|
|
regCred := regexp.MustCompile("Credential=([A-Z0-9]+)/")
|
|
|
|
newAuth := regCred.ReplaceAllString(origAuth, "Credential=**REDACTED**/")
|
|
|
|
|
|
|
|
// Strip out 256-bit signature from: Signature=<256-bit signature>
|
|
|
|
regSign := regexp.MustCompile("Signature=([[0-9a-f]+)")
|
|
|
|
newAuth = regSign.ReplaceAllString(newAuth, "Signature=**REDACTED**")
|
|
|
|
|
|
|
|
// Set a temporary redacted auth
|
|
|
|
req.Header.Set("Authorization", newAuth)
|
|
|
|
}
|
|
|
|
|
|
|
|
// dumpHTTP - dump HTTP request and response.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm AdminClient) dumpHTTP(req *http.Request, resp *http.Response) error {
|
2016-12-20 23:45:17 +01:00
|
|
|
// Starts http dump.
|
2019-02-13 13:59:36 +01:00
|
|
|
_, err := fmt.Fprintln(adm.traceOutput, "---------START-HTTP---------")
|
2016-12-20 23:45:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Filter out Signature field from Authorization header.
|
2019-02-13 13:59:36 +01:00
|
|
|
adm.filterSignature(req)
|
2016-12-20 23:45:17 +01:00
|
|
|
|
|
|
|
// Only display request header.
|
|
|
|
reqTrace, err := httputil.DumpRequestOut(req, false)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write request to trace output.
|
2019-02-13 13:59:36 +01:00
|
|
|
_, err = fmt.Fprint(adm.traceOutput, string(reqTrace))
|
2016-12-20 23:45:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Only display response header.
|
|
|
|
var respTrace []byte
|
|
|
|
|
|
|
|
// For errors we make sure to dump response body as well.
|
|
|
|
if resp.StatusCode != http.StatusOK &&
|
|
|
|
resp.StatusCode != http.StatusPartialContent &&
|
|
|
|
resp.StatusCode != http.StatusNoContent {
|
|
|
|
respTrace, err = httputil.DumpResponse(resp, true)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// WORKAROUND for https://github.com/golang/go/issues/13942.
|
|
|
|
// httputil.DumpResponse does not print response headers for
|
|
|
|
// all successful calls which have response ContentLength set
|
|
|
|
// to zero. Keep this workaround until the above bug is fixed.
|
|
|
|
if resp.ContentLength == 0 {
|
|
|
|
var buffer bytes.Buffer
|
|
|
|
if err = resp.Header.Write(&buffer); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
respTrace = buffer.Bytes()
|
|
|
|
respTrace = append(respTrace, []byte("\r\n")...)
|
|
|
|
} else {
|
|
|
|
respTrace, err = httputil.DumpResponse(resp, false)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Write response to trace output.
|
2019-02-13 13:59:36 +01:00
|
|
|
_, err = fmt.Fprint(adm.traceOutput, strings.TrimSuffix(string(respTrace), "\r\n"))
|
2016-12-20 23:45:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ends the http dump.
|
2019-02-13 13:59:36 +01:00
|
|
|
_, err = fmt.Fprintln(adm.traceOutput, "---------END-HTTP---------")
|
2017-03-09 19:13:30 +01:00
|
|
|
return err
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// do - execute http request.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm AdminClient) do(req *http.Request) (*http.Response, error) {
|
2020-03-20 23:00:44 +01:00
|
|
|
resp, err := adm.httpClient.Do(req)
|
|
|
|
if err != nil {
|
|
|
|
// Handle this specifically for now until future Golang versions fix this issue properly.
|
|
|
|
if urlErr, ok := err.(*url.Error); ok {
|
|
|
|
if strings.Contains(urlErr.Err.Error(), "EOF") {
|
2016-12-20 23:45:17 +01:00
|
|
|
return nil, &url.Error{
|
|
|
|
Op: urlErr.Op,
|
|
|
|
URL: urlErr.URL,
|
2020-03-20 23:00:44 +01:00
|
|
|
Err: errors.New("Connection closed by foreign host " + urlErr.URL + ". Retry again."),
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-03-20 23:00:44 +01:00
|
|
|
return nil, err
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Response cannot be non-nil, report if its the case.
|
|
|
|
if resp == nil {
|
|
|
|
msg := "Response is empty. " // + reportIssue
|
|
|
|
return nil, ErrInvalidArgument(msg)
|
|
|
|
}
|
|
|
|
|
|
|
|
// If trace is enabled, dump http request and response.
|
2019-02-13 13:59:36 +01:00
|
|
|
if adm.isTraceEnabled {
|
|
|
|
err = adm.dumpHTTP(req, resp)
|
2016-12-20 23:45:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return resp, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// List of success status.
|
|
|
|
var successStatus = []int{
|
|
|
|
http.StatusOK,
|
|
|
|
http.StatusNoContent,
|
|
|
|
http.StatusPartialContent,
|
|
|
|
}
|
|
|
|
|
|
|
|
// executeMethod - instantiates a given method, and retries the
|
|
|
|
// request upon any error up to maxRetries attempts in a binomially
|
|
|
|
// delayed manner using a standard back off algorithm.
|
2020-03-20 23:00:44 +01:00
|
|
|
func (adm AdminClient) executeMethod(ctx context.Context, method string, reqData requestData) (res *http.Response, err error) {
|
2019-05-10 02:41:54 +02:00
|
|
|
var reqRetry = MaxRetry // Indicates how many times we can retry the request
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2020-03-20 23:00:44 +01:00
|
|
|
defer func() {
|
|
|
|
if err != nil {
|
|
|
|
// close idle connections before returning, upon error.
|
|
|
|
adm.httpClient.CloseIdleConnections()
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
// Create cancel context to control 'newRetryTimer' go routine.
|
|
|
|
retryCtx, cancel := context.WithCancel(ctx)
|
2016-12-20 23:45:17 +01:00
|
|
|
|
|
|
|
// Indicate to our routine to exit cleanly upon return.
|
2020-03-20 23:00:44 +01:00
|
|
|
defer cancel()
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2020-03-20 23:00:44 +01:00
|
|
|
for range adm.newRetryTimer(retryCtx, reqRetry, DefaultRetryUnit, DefaultRetryCap, MaxJitter) {
|
2019-05-10 02:41:54 +02:00
|
|
|
// Instantiate a new request.
|
|
|
|
var req *http.Request
|
|
|
|
req, err = adm.newRequest(method, reqData)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2020-03-20 23:00:44 +01:00
|
|
|
// Add context to request
|
|
|
|
req = req.WithContext(ctx)
|
|
|
|
|
2019-05-10 02:41:54 +02:00
|
|
|
// Initiate the request.
|
|
|
|
res, err = adm.do(req)
|
|
|
|
if err != nil {
|
2020-04-07 02:50:14 +02:00
|
|
|
if err == context.Canceled || err == context.DeadlineExceeded {
|
|
|
|
return nil, err
|
2019-05-10 02:41:54 +02:00
|
|
|
}
|
2020-04-07 02:50:14 +02:00
|
|
|
// retry all network errors.
|
|
|
|
continue
|
2019-05-10 02:41:54 +02:00
|
|
|
}
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2019-05-10 02:41:54 +02:00
|
|
|
// For any known successful http status, return quickly.
|
|
|
|
for _, httpStatus := range successStatus {
|
|
|
|
if httpStatus == res.StatusCode {
|
|
|
|
return res, nil
|
|
|
|
}
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
|
2019-05-10 02:41:54 +02:00
|
|
|
// Read the body to be saved later.
|
|
|
|
errBodyBytes, err := ioutil.ReadAll(res.Body)
|
|
|
|
// res.Body should be closed
|
|
|
|
closeResponse(res)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2019-05-10 02:41:54 +02:00
|
|
|
// Save the body.
|
|
|
|
errBodySeeker := bytes.NewReader(errBodyBytes)
|
|
|
|
res.Body = ioutil.NopCloser(errBodySeeker)
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2019-05-10 02:41:54 +02:00
|
|
|
// For errors verify if its retryable otherwise fail quickly.
|
|
|
|
errResponse := ToErrorResponse(httpRespToErrorResponse(res))
|
|
|
|
|
|
|
|
// Save the body back again.
|
|
|
|
errBodySeeker.Seek(0, 0) // Seek back to starting point.
|
|
|
|
res.Body = ioutil.NopCloser(errBodySeeker)
|
|
|
|
|
|
|
|
// Verify if error response code is retryable.
|
|
|
|
if isS3CodeRetryable(errResponse.Code) {
|
|
|
|
continue // Retry.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verify if http status code is retryable.
|
|
|
|
if isHTTPStatusRetryable(res.StatusCode) {
|
|
|
|
continue // Retry.
|
|
|
|
}
|
|
|
|
|
|
|
|
break
|
|
|
|
}
|
2020-04-07 02:50:14 +02:00
|
|
|
|
|
|
|
// Return an error when retry is canceled or deadlined
|
|
|
|
if e := retryCtx.Err(); e != nil {
|
|
|
|
return nil, e
|
|
|
|
}
|
|
|
|
|
2016-12-20 23:45:17 +01:00
|
|
|
return res, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// set User agent.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm AdminClient) setUserAgent(req *http.Request) {
|
2016-12-20 23:45:17 +01:00
|
|
|
req.Header.Set("User-Agent", libraryUserAgent)
|
2019-02-13 13:59:36 +01:00
|
|
|
if adm.appInfo.appName != "" && adm.appInfo.appVersion != "" {
|
|
|
|
req.Header.Set("User-Agent", libraryUserAgent+" "+adm.appInfo.appName+"/"+adm.appInfo.appVersion)
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
func (adm AdminClient) getSecretKey() string {
|
|
|
|
value, err := adm.credsProvider.Get()
|
|
|
|
if err != nil {
|
|
|
|
// Return empty, call will fail.
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
return value.SecretAccessKey
|
|
|
|
}
|
|
|
|
|
2016-12-20 23:45:17 +01:00
|
|
|
// newRequest - instantiate a new HTTP request for a given method.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm AdminClient) newRequest(method string, reqData requestData) (req *http.Request, err error) {
|
2016-12-20 23:45:17 +01:00
|
|
|
// If no method is supplied default to 'POST'.
|
|
|
|
if method == "" {
|
|
|
|
method = "POST"
|
|
|
|
}
|
|
|
|
|
2018-06-07 19:37:31 +02:00
|
|
|
// Default all requests to ""
|
|
|
|
location := ""
|
2016-12-20 23:45:17 +01:00
|
|
|
|
|
|
|
// Construct a new target URL.
|
2019-02-13 13:59:36 +01:00
|
|
|
targetURL, err := adm.makeTargetURL(reqData)
|
2016-12-20 23:45:17 +01:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize a new HTTP request for the method.
|
|
|
|
req, err = http.NewRequest(method, targetURL.String(), nil)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2020-04-01 22:34:20 +02:00
|
|
|
value, err := adm.credsProvider.Get()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
var (
|
|
|
|
accessKeyID = value.AccessKeyID
|
|
|
|
secretAccessKey = value.SecretAccessKey
|
|
|
|
sessionToken = value.SessionToken
|
|
|
|
)
|
|
|
|
|
2019-02-13 13:59:36 +01:00
|
|
|
adm.setUserAgent(req)
|
2016-12-20 23:45:17 +01:00
|
|
|
for k, v := range reqData.customHeaders {
|
|
|
|
req.Header.Set(k, v[0])
|
|
|
|
}
|
2018-05-30 23:49:03 +02:00
|
|
|
if length := len(reqData.content); length > 0 {
|
|
|
|
req.ContentLength = int64(length)
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
2018-05-30 23:49:03 +02:00
|
|
|
req.Header.Set("X-Amz-Content-Sha256", hex.EncodeToString(sum256(reqData.content)))
|
|
|
|
req.Body = ioutil.NopCloser(bytes.NewReader(reqData.content))
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2020-04-15 01:53:16 +02:00
|
|
|
req = signer.SignV4(*req, accessKeyID, secretAccessKey, sessionToken, location)
|
2016-12-20 23:45:17 +01:00
|
|
|
return req, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// makeTargetURL make a new target url.
|
2019-02-13 13:59:36 +01:00
|
|
|
func (adm AdminClient) makeTargetURL(r requestData) (*url.URL, error) {
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2019-02-13 13:59:36 +01:00
|
|
|
host := adm.endpointURL.Host
|
|
|
|
scheme := adm.endpointURL.Scheme
|
2016-12-20 23:45:17 +01:00
|
|
|
|
2018-01-22 23:54:55 +01:00
|
|
|
urlStr := scheme + "://" + host + libraryAdminURLPrefix + r.relPath
|
2016-12-20 23:45:17 +01:00
|
|
|
|
|
|
|
// If there are any query values, add them to the end.
|
2018-01-22 23:54:55 +01:00
|
|
|
if len(r.queryValues) > 0 {
|
|
|
|
urlStr = urlStr + "?" + s3utils.QueryEncode(r.queryValues)
|
2016-12-20 23:45:17 +01:00
|
|
|
}
|
|
|
|
u, err := url.Parse(urlStr)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return u, nil
|
|
|
|
}
|