2017-12-06 02:58:09 +01:00
|
|
|
/*
|
2019-10-04 19:35:33 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2017-2019 MinIO, Inc.
|
2017-12-06 02:58:09 +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 cmd
|
|
|
|
|
|
|
|
import (
|
2019-11-02 00:58:11 +01:00
|
|
|
"context"
|
2017-12-06 02:58:09 +01:00
|
|
|
"net/http"
|
2019-01-05 23:16:43 +01:00
|
|
|
"strings"
|
2019-11-02 00:58:11 +01:00
|
|
|
"time"
|
2017-12-06 02:58:09 +01:00
|
|
|
|
2019-10-04 19:35:33 +02:00
|
|
|
"github.com/minio/minio/cmd/config"
|
2019-07-03 07:34:32 +02:00
|
|
|
xhttp "github.com/minio/minio/cmd/http"
|
2019-01-05 23:16:43 +01:00
|
|
|
"github.com/minio/minio/cmd/logger"
|
2019-10-04 19:35:33 +02:00
|
|
|
"github.com/minio/minio/pkg/env"
|
2017-12-06 02:58:09 +01:00
|
|
|
"github.com/minio/minio/pkg/hash"
|
2019-09-13 01:44:51 +02:00
|
|
|
xnet "github.com/minio/minio/pkg/net"
|
2017-12-06 02:58:09 +01:00
|
|
|
|
2019-05-30 01:35:12 +02:00
|
|
|
minio "github.com/minio/minio-go/v6"
|
2017-12-06 02:58:09 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
// CanonicalizeETag provides canonicalizeETag function alias.
|
|
|
|
CanonicalizeETag = canonicalizeETag
|
|
|
|
|
|
|
|
// MustGetUUID function alias.
|
|
|
|
MustGetUUID = mustGetUUID
|
2019-01-05 23:16:43 +01:00
|
|
|
|
|
|
|
// CleanMetadataKeys provides cleanMetadataKeys function alias.
|
|
|
|
CleanMetadataKeys = cleanMetadataKeys
|
2019-04-17 18:52:08 +02:00
|
|
|
|
|
|
|
// PathJoin function alias.
|
|
|
|
PathJoin = pathJoin
|
|
|
|
|
|
|
|
// ListObjects function alias.
|
|
|
|
ListObjects = listObjects
|
|
|
|
|
2019-05-02 07:06:57 +02:00
|
|
|
// FilterMatchingPrefix function alias.
|
|
|
|
FilterMatchingPrefix = filterMatchingPrefix
|
2019-04-17 18:52:08 +02:00
|
|
|
|
|
|
|
// IsStringEqual is string equal.
|
|
|
|
IsStringEqual = isStringEqual
|
2017-12-06 02:58:09 +01:00
|
|
|
)
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
// StatInfo - alias for statInfo
|
|
|
|
type StatInfo struct {
|
|
|
|
statInfo
|
|
|
|
}
|
|
|
|
|
2017-12-06 02:58:09 +01:00
|
|
|
// AnonErrToObjectErr - converts standard http codes into meaningful object layer errors.
|
|
|
|
func AnonErrToObjectErr(statusCode int, params ...string) error {
|
|
|
|
bucket := ""
|
|
|
|
object := ""
|
|
|
|
if len(params) >= 1 {
|
|
|
|
bucket = params[0]
|
|
|
|
}
|
|
|
|
if len(params) == 2 {
|
|
|
|
object = params[1]
|
|
|
|
}
|
|
|
|
|
|
|
|
switch statusCode {
|
|
|
|
case http.StatusNotFound:
|
|
|
|
if object != "" {
|
|
|
|
return ObjectNotFound{bucket, object}
|
|
|
|
}
|
|
|
|
return BucketNotFound{Bucket: bucket}
|
|
|
|
case http.StatusBadRequest:
|
|
|
|
if object != "" {
|
|
|
|
return ObjectNameInvalid{bucket, object}
|
|
|
|
}
|
|
|
|
return BucketNameInvalid{Bucket: bucket}
|
|
|
|
case http.StatusForbidden:
|
|
|
|
fallthrough
|
|
|
|
case http.StatusUnauthorized:
|
|
|
|
return AllAccessDisabled{bucket, object}
|
|
|
|
}
|
|
|
|
|
|
|
|
return errUnexpected
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientMetadata converts minio metadata to map[string]string
|
|
|
|
func FromMinioClientMetadata(metadata map[string][]string) map[string]string {
|
|
|
|
mm := map[string]string{}
|
|
|
|
for k, v := range metadata {
|
|
|
|
mm[http.CanonicalHeaderKey(k)] = v[0]
|
|
|
|
}
|
|
|
|
return mm
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientObjectPart converts minio ObjectPart to PartInfo
|
|
|
|
func FromMinioClientObjectPart(op minio.ObjectPart) PartInfo {
|
|
|
|
return PartInfo{
|
|
|
|
Size: op.Size,
|
|
|
|
ETag: canonicalizeETag(op.ETag),
|
|
|
|
LastModified: op.LastModified,
|
|
|
|
PartNumber: op.PartNumber,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientListPartsInfo converts minio ListObjectPartsResult to ListPartsInfo
|
|
|
|
func FromMinioClientListPartsInfo(lopr minio.ListObjectPartsResult) ListPartsInfo {
|
|
|
|
// Convert minio ObjectPart to PartInfo
|
|
|
|
fromMinioClientObjectParts := func(parts []minio.ObjectPart) []PartInfo {
|
|
|
|
toParts := make([]PartInfo, len(parts))
|
|
|
|
for i, part := range parts {
|
|
|
|
toParts[i] = FromMinioClientObjectPart(part)
|
|
|
|
}
|
|
|
|
return toParts
|
|
|
|
}
|
|
|
|
|
|
|
|
return ListPartsInfo{
|
|
|
|
UploadID: lopr.UploadID,
|
|
|
|
Bucket: lopr.Bucket,
|
|
|
|
Object: lopr.Key,
|
|
|
|
StorageClass: "",
|
|
|
|
PartNumberMarker: lopr.PartNumberMarker,
|
|
|
|
NextPartNumberMarker: lopr.NextPartNumberMarker,
|
|
|
|
MaxParts: lopr.MaxParts,
|
|
|
|
IsTruncated: lopr.IsTruncated,
|
|
|
|
EncodingType: lopr.EncodingType,
|
|
|
|
Parts: fromMinioClientObjectParts(lopr.ObjectParts),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientListMultipartsInfo converts minio ListMultipartUploadsResult to ListMultipartsInfo
|
|
|
|
func FromMinioClientListMultipartsInfo(lmur minio.ListMultipartUploadsResult) ListMultipartsInfo {
|
|
|
|
uploads := make([]MultipartInfo, len(lmur.Uploads))
|
|
|
|
|
|
|
|
for i, um := range lmur.Uploads {
|
|
|
|
uploads[i] = MultipartInfo{
|
|
|
|
Object: um.Key,
|
|
|
|
UploadID: um.UploadID,
|
|
|
|
Initiated: um.Initiated,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
commonPrefixes := make([]string, len(lmur.CommonPrefixes))
|
|
|
|
for i, cp := range lmur.CommonPrefixes {
|
|
|
|
commonPrefixes[i] = cp.Prefix
|
|
|
|
}
|
|
|
|
|
|
|
|
return ListMultipartsInfo{
|
|
|
|
KeyMarker: lmur.KeyMarker,
|
|
|
|
UploadIDMarker: lmur.UploadIDMarker,
|
|
|
|
NextKeyMarker: lmur.NextKeyMarker,
|
|
|
|
NextUploadIDMarker: lmur.NextUploadIDMarker,
|
|
|
|
MaxUploads: int(lmur.MaxUploads),
|
|
|
|
IsTruncated: lmur.IsTruncated,
|
|
|
|
Uploads: uploads,
|
|
|
|
Prefix: lmur.Prefix,
|
|
|
|
Delimiter: lmur.Delimiter,
|
|
|
|
CommonPrefixes: commonPrefixes,
|
|
|
|
EncodingType: lmur.EncodingType,
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientObjectInfo converts minio ObjectInfo to gateway ObjectInfo
|
|
|
|
func FromMinioClientObjectInfo(bucket string, oi minio.ObjectInfo) ObjectInfo {
|
|
|
|
userDefined := FromMinioClientMetadata(oi.Metadata)
|
2019-07-03 07:34:32 +02:00
|
|
|
userDefined[xhttp.ContentType] = oi.ContentType
|
2017-12-06 02:58:09 +01:00
|
|
|
|
|
|
|
return ObjectInfo{
|
|
|
|
Bucket: bucket,
|
|
|
|
Name: oi.Key,
|
|
|
|
ModTime: oi.LastModified,
|
|
|
|
Size: oi.Size,
|
|
|
|
ETag: canonicalizeETag(oi.ETag),
|
|
|
|
UserDefined: userDefined,
|
|
|
|
ContentType: oi.ContentType,
|
2019-07-03 07:34:32 +02:00
|
|
|
ContentEncoding: oi.Metadata.Get(xhttp.ContentEncoding),
|
2018-06-19 20:22:08 +02:00
|
|
|
StorageClass: oi.StorageClass,
|
2019-02-28 20:01:25 +01:00
|
|
|
Expires: oi.Expires,
|
2017-12-06 02:58:09 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientListBucketV2Result converts minio ListBucketResult to ListObjectsInfo
|
|
|
|
func FromMinioClientListBucketV2Result(bucket string, result minio.ListBucketV2Result) ListObjectsV2Info {
|
|
|
|
objects := make([]ObjectInfo, len(result.Contents))
|
|
|
|
|
|
|
|
for i, oi := range result.Contents {
|
|
|
|
objects[i] = FromMinioClientObjectInfo(bucket, oi)
|
|
|
|
}
|
|
|
|
|
|
|
|
prefixes := make([]string, len(result.CommonPrefixes))
|
|
|
|
for i, p := range result.CommonPrefixes {
|
|
|
|
prefixes[i] = p.Prefix
|
|
|
|
}
|
|
|
|
|
|
|
|
return ListObjectsV2Info{
|
|
|
|
IsTruncated: result.IsTruncated,
|
|
|
|
Prefixes: prefixes,
|
|
|
|
Objects: objects,
|
|
|
|
|
|
|
|
ContinuationToken: result.ContinuationToken,
|
|
|
|
NextContinuationToken: result.NextContinuationToken,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientListBucketResult converts minio ListBucketResult to ListObjectsInfo
|
|
|
|
func FromMinioClientListBucketResult(bucket string, result minio.ListBucketResult) ListObjectsInfo {
|
|
|
|
objects := make([]ObjectInfo, len(result.Contents))
|
|
|
|
|
|
|
|
for i, oi := range result.Contents {
|
|
|
|
objects[i] = FromMinioClientObjectInfo(bucket, oi)
|
|
|
|
}
|
|
|
|
|
|
|
|
prefixes := make([]string, len(result.CommonPrefixes))
|
|
|
|
for i, p := range result.CommonPrefixes {
|
|
|
|
prefixes[i] = p.Prefix
|
|
|
|
}
|
|
|
|
|
|
|
|
return ListObjectsInfo{
|
|
|
|
IsTruncated: result.IsTruncated,
|
|
|
|
NextMarker: result.NextMarker,
|
|
|
|
Prefixes: prefixes,
|
|
|
|
Objects: objects,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// FromMinioClientListBucketResultToV2Info converts minio ListBucketResult to ListObjectsV2Info
|
|
|
|
func FromMinioClientListBucketResultToV2Info(bucket string, result minio.ListBucketResult) ListObjectsV2Info {
|
|
|
|
objects := make([]ObjectInfo, len(result.Contents))
|
|
|
|
|
|
|
|
for i, oi := range result.Contents {
|
|
|
|
objects[i] = FromMinioClientObjectInfo(bucket, oi)
|
|
|
|
}
|
|
|
|
|
|
|
|
prefixes := make([]string, len(result.CommonPrefixes))
|
|
|
|
for i, p := range result.CommonPrefixes {
|
|
|
|
prefixes[i] = p.Prefix
|
|
|
|
}
|
|
|
|
|
|
|
|
return ListObjectsV2Info{
|
|
|
|
IsTruncated: result.IsTruncated,
|
|
|
|
Prefixes: prefixes,
|
|
|
|
Objects: objects,
|
|
|
|
ContinuationToken: result.Marker,
|
|
|
|
NextContinuationToken: result.NextMarker,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-12 21:25:59 +02:00
|
|
|
// ToMinioClientObjectInfoMetadata convertes metadata to map[string][]string
|
|
|
|
func ToMinioClientObjectInfoMetadata(metadata map[string]string) map[string][]string {
|
|
|
|
mm := make(map[string][]string, len(metadata))
|
|
|
|
for k, v := range metadata {
|
|
|
|
mm[http.CanonicalHeaderKey(k)] = []string{v}
|
|
|
|
}
|
|
|
|
return mm
|
|
|
|
}
|
|
|
|
|
|
|
|
// ToMinioClientMetadata converts metadata to map[string]string
|
2017-12-06 02:58:09 +01:00
|
|
|
func ToMinioClientMetadata(metadata map[string]string) map[string]string {
|
|
|
|
mm := make(map[string]string)
|
|
|
|
for k, v := range metadata {
|
|
|
|
mm[http.CanonicalHeaderKey(k)] = v
|
|
|
|
}
|
|
|
|
return mm
|
|
|
|
}
|
|
|
|
|
|
|
|
// ToMinioClientCompletePart converts CompletePart to minio CompletePart
|
|
|
|
func ToMinioClientCompletePart(part CompletePart) minio.CompletePart {
|
|
|
|
return minio.CompletePart{
|
|
|
|
ETag: part.ETag,
|
|
|
|
PartNumber: part.PartNumber,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// ToMinioClientCompleteParts converts []CompletePart to minio []CompletePart
|
|
|
|
func ToMinioClientCompleteParts(parts []CompletePart) []minio.CompletePart {
|
|
|
|
mparts := make([]minio.CompletePart, len(parts))
|
|
|
|
for i, part := range parts {
|
|
|
|
mparts[i] = ToMinioClientCompletePart(part)
|
|
|
|
}
|
|
|
|
return mparts
|
|
|
|
}
|
|
|
|
|
2019-11-02 00:58:11 +01:00
|
|
|
// IsBackendOnline - verifies if the backend is reachable
|
|
|
|
// by performing a GET request on the URL. returns 'true'
|
|
|
|
// if backend is reachable.
|
|
|
|
func IsBackendOnline(ctx context.Context, clnt *http.Client, urlStr string) bool {
|
|
|
|
ctx, cancel := context.WithTimeout(ctx, 1*time.Second)
|
|
|
|
defer cancel()
|
|
|
|
|
|
|
|
// never follow redirects
|
|
|
|
clnt.CheckRedirect = func(*http.Request, []*http.Request) error {
|
|
|
|
return http.ErrUseLastResponse
|
|
|
|
}
|
|
|
|
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, urlStr, nil)
|
|
|
|
if err != nil {
|
|
|
|
return false
|
|
|
|
}
|
2020-01-21 11:46:58 +01:00
|
|
|
resp, err := clnt.Do(req)
|
|
|
|
if err != nil {
|
|
|
|
clnt.CloseIdleConnections()
|
2019-11-02 00:58:11 +01:00
|
|
|
return !xnet.IsNetworkOrHostDown(err)
|
|
|
|
}
|
2020-01-21 11:46:58 +01:00
|
|
|
xhttp.DrainBody(resp.Body)
|
2019-11-02 00:58:11 +01:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2019-04-09 20:39:42 +02:00
|
|
|
// ErrorRespToObjectError converts MinIO errors to minio object layer errors.
|
2017-12-06 02:58:09 +01:00
|
|
|
func ErrorRespToObjectError(err error, params ...string) error {
|
|
|
|
if err == nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
bucket := ""
|
|
|
|
object := ""
|
|
|
|
if len(params) >= 1 {
|
|
|
|
bucket = params[0]
|
|
|
|
}
|
|
|
|
if len(params) == 2 {
|
|
|
|
object = params[1]
|
|
|
|
}
|
|
|
|
|
2019-09-13 01:44:51 +02:00
|
|
|
if xnet.IsNetworkOrHostDown(err) {
|
2018-04-06 00:04:40 +02:00
|
|
|
return BackendDown{}
|
2018-03-28 23:14:06 +02:00
|
|
|
}
|
|
|
|
|
2017-12-06 02:58:09 +01:00
|
|
|
minioErr, ok := err.(minio.ErrorResponse)
|
|
|
|
if !ok {
|
2019-04-09 20:39:42 +02:00
|
|
|
// We don't interpret non MinIO errors. As minio errors will
|
2017-12-06 02:58:09 +01:00
|
|
|
// have StatusCode to help to convert to object errors.
|
2018-04-06 00:04:40 +02:00
|
|
|
return err
|
2017-12-06 02:58:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
switch minioErr.Code {
|
|
|
|
case "BucketAlreadyOwnedByYou":
|
|
|
|
err = BucketAlreadyOwnedByYou{}
|
|
|
|
case "BucketNotEmpty":
|
|
|
|
err = BucketNotEmpty{}
|
|
|
|
case "NoSuchBucketPolicy":
|
2018-04-25 00:53:30 +02:00
|
|
|
err = BucketPolicyNotFound{}
|
2020-02-08 12:16:59 +01:00
|
|
|
case "NoSuchLifecycleConfiguration":
|
2019-07-19 22:20:33 +02:00
|
|
|
err = BucketLifecycleNotFound{}
|
2017-12-06 02:58:09 +01:00
|
|
|
case "InvalidBucketName":
|
|
|
|
err = BucketNameInvalid{Bucket: bucket}
|
2018-10-17 18:20:58 +02:00
|
|
|
case "InvalidPart":
|
|
|
|
err = InvalidPart{}
|
2017-12-06 02:58:09 +01:00
|
|
|
case "NoSuchBucket":
|
|
|
|
err = BucketNotFound{Bucket: bucket}
|
|
|
|
case "NoSuchKey":
|
|
|
|
if object != "" {
|
|
|
|
err = ObjectNotFound{Bucket: bucket, Object: object}
|
|
|
|
} else {
|
|
|
|
err = BucketNotFound{Bucket: bucket}
|
|
|
|
}
|
|
|
|
case "XMinioInvalidObjectName":
|
|
|
|
err = ObjectNameInvalid{}
|
|
|
|
case "AccessDenied":
|
|
|
|
err = PrefixAccessDenied{
|
|
|
|
Bucket: bucket,
|
|
|
|
Object: object,
|
|
|
|
}
|
|
|
|
case "XAmzContentSHA256Mismatch":
|
|
|
|
err = hash.SHA256Mismatch{}
|
|
|
|
case "NoSuchUpload":
|
|
|
|
err = InvalidUploadID{}
|
|
|
|
case "EntityTooSmall":
|
|
|
|
err = PartTooSmall{}
|
|
|
|
}
|
|
|
|
|
2018-04-06 00:04:40 +02:00
|
|
|
return err
|
2017-12-06 02:58:09 +01:00
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
|
2019-04-18 08:50:25 +02:00
|
|
|
// ComputeCompleteMultipartMD5 calculates MD5 ETag for complete multipart responses
|
2019-05-09 03:35:40 +02:00
|
|
|
func ComputeCompleteMultipartMD5(parts []CompletePart) string {
|
|
|
|
return getCompleteMultipartMD5(parts)
|
2019-04-18 08:50:25 +02:00
|
|
|
}
|
|
|
|
|
2019-01-05 23:16:43 +01:00
|
|
|
// parse gateway sse env variable
|
|
|
|
func parseGatewaySSE(s string) (gatewaySSE, error) {
|
|
|
|
l := strings.Split(s, ";")
|
|
|
|
var gwSlice = make([]string, 0)
|
|
|
|
for _, val := range l {
|
|
|
|
v := strings.ToUpper(val)
|
|
|
|
if v == gatewaySSES3 || v == gatewaySSEC {
|
|
|
|
gwSlice = append(gwSlice, v)
|
|
|
|
continue
|
|
|
|
}
|
2019-10-04 19:35:33 +02:00
|
|
|
return nil, config.ErrInvalidGWSSEValue(nil).Msg("gateway SSE cannot be (%s) ", v)
|
2019-01-05 23:16:43 +01:00
|
|
|
}
|
|
|
|
return gatewaySSE(gwSlice), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// handle gateway env vars
|
2019-11-01 23:53:16 +01:00
|
|
|
func gatewayHandleEnvVars() {
|
|
|
|
// Handle common env vars.
|
|
|
|
handleCommonEnvVars()
|
|
|
|
|
|
|
|
if !globalActiveCred.IsValid() {
|
|
|
|
logger.Fatal(config.ErrInvalidCredentials(nil),
|
2019-10-23 07:59:13 +02:00
|
|
|
"Unable to validate credentials inherited from the shell environment")
|
|
|
|
}
|
2019-10-31 07:39:09 +01:00
|
|
|
|
|
|
|
gwsseVal := env.Get("MINIO_GATEWAY_SSE", "")
|
|
|
|
if len(gwsseVal) != 0 {
|
|
|
|
var err error
|
|
|
|
GlobalGatewaySSE, err = parseGatewaySSE(gwsseVal)
|
|
|
|
if err != nil {
|
|
|
|
logger.Fatal(err, "Unable to parse MINIO_GATEWAY_SSE value (`%s`)", gwsseVal)
|
|
|
|
}
|
|
|
|
}
|
2019-01-05 23:16:43 +01:00
|
|
|
}
|
2020-02-11 16:38:01 +01:00
|
|
|
|
|
|
|
// shouldMeterRequest checks whether incoming request should be added to prometheus gateway metrics
|
|
|
|
func shouldMeterRequest(req *http.Request) bool {
|
|
|
|
return !(guessIsBrowserReq(req) || guessIsHealthCheckReq(req) || guessIsMetricsReq(req))
|
|
|
|
}
|
|
|
|
|
|
|
|
// MetricsTransport is a custom wrapper around Transport to track metrics
|
|
|
|
type MetricsTransport struct {
|
|
|
|
Transport *http.Transport
|
|
|
|
Metrics *Metrics
|
|
|
|
}
|
|
|
|
|
|
|
|
// RoundTrip implements the RoundTrip method for MetricsTransport
|
|
|
|
func (m MetricsTransport) RoundTrip(r *http.Request) (*http.Response, error) {
|
|
|
|
metered := shouldMeterRequest(r)
|
2020-04-01 21:52:31 +02:00
|
|
|
if metered && (r.Method == http.MethodPost || r.Method == http.MethodPut) {
|
2020-02-11 16:38:01 +01:00
|
|
|
m.Metrics.IncRequests(r.Method)
|
2020-02-12 05:45:00 +01:00
|
|
|
if r.ContentLength > 0 {
|
|
|
|
m.Metrics.IncBytesSent(uint64(r.ContentLength))
|
|
|
|
}
|
2020-02-11 16:38:01 +01:00
|
|
|
}
|
|
|
|
// Make the request to the server.
|
|
|
|
resp, err := m.Transport.RoundTrip(r)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if metered && (r.Method == http.MethodGet || r.Method == http.MethodHead) {
|
2020-04-01 21:52:31 +02:00
|
|
|
m.Metrics.IncRequests(r.Method)
|
|
|
|
if resp.ContentLength > 0 {
|
2020-02-12 05:45:00 +01:00
|
|
|
m.Metrics.IncBytesReceived(uint64(resp.ContentLength))
|
|
|
|
}
|
2020-02-11 16:38:01 +01:00
|
|
|
}
|
|
|
|
return resp, nil
|
|
|
|
}
|