2015-02-23 19:46:48 -05:00
|
|
|
/*
|
2019-04-09 14:39:42 -04:00
|
|
|
* MinIO Cloud Storage, (C) 2015, 2016, 2017, 2018 MinIO, Inc.
|
2015-02-23 19:46:48 -05: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.
|
|
|
|
*/
|
|
|
|
|
2016-08-18 19:23:42 -04:00
|
|
|
package cmd
|
2015-02-15 20:03:27 -05:00
|
|
|
|
|
|
|
import (
|
2019-02-13 19:07:21 -05:00
|
|
|
"context"
|
2019-10-01 16:09:29 -04:00
|
|
|
"encoding/base64"
|
2016-02-19 19:04:29 -05:00
|
|
|
"encoding/xml"
|
2015-04-22 19:28:13 -04:00
|
|
|
"net/http"
|
2017-01-06 03:37:00 -05:00
|
|
|
"net/url"
|
2016-06-21 02:25:18 -04:00
|
|
|
"path"
|
2019-06-12 00:04:52 -04:00
|
|
|
"strconv"
|
2018-05-15 21:20:22 -04:00
|
|
|
"strings"
|
2016-02-27 06:04:52 -05:00
|
|
|
"time"
|
2018-03-02 18:23:04 -05:00
|
|
|
|
2019-07-03 01:34:32 -04:00
|
|
|
xhttp "github.com/minio/minio/cmd/http"
|
2019-02-13 19:07:21 -05:00
|
|
|
"github.com/minio/minio/cmd/logger"
|
2018-03-02 18:23:04 -05:00
|
|
|
"github.com/minio/minio/pkg/handlers"
|
2015-02-15 20:03:27 -05:00
|
|
|
)
|
|
|
|
|
2015-02-23 19:46:48 -05:00
|
|
|
const (
|
2016-10-17 11:44:55 -04:00
|
|
|
timeFormatAMZLong = "2006-01-02T15:04:05.000Z" // Reply date format with nanosecond precision.
|
|
|
|
maxObjectList = 1000 // Limit number of objects in a listObjectsResponse.
|
|
|
|
maxUploadsList = 1000 // Limit number of uploads in a listUploadsResponse.
|
|
|
|
maxPartsList = 1000 // Limit number of parts in a listPartsResponse.
|
2015-02-23 19:46:48 -05:00
|
|
|
)
|
|
|
|
|
2016-02-19 19:04:29 -05:00
|
|
|
// LocationResponse - format for location response.
|
|
|
|
type LocationResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ LocationConstraint" json:"-"`
|
|
|
|
Location string `xml:",chardata"`
|
|
|
|
}
|
|
|
|
|
2019-08-19 17:02:54 -04:00
|
|
|
// ListVersionsResponse - format for list bucket versions response.
|
|
|
|
type ListVersionsResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListVersionsResult" json:"-"`
|
|
|
|
|
|
|
|
Name string
|
|
|
|
Prefix string
|
|
|
|
KeyMarker string
|
|
|
|
|
|
|
|
// When response is truncated (the IsTruncated element value in the response
|
|
|
|
// is true), you can use the key name in this field as marker in the subsequent
|
|
|
|
// request to get next set of objects. Server lists objects in alphabetical
|
|
|
|
// order Note: This element is returned only if you have delimiter request parameter
|
|
|
|
// specified. If response does not include the NextMaker and it is truncated,
|
|
|
|
// you can use the value of the last Key in the response as the marker in the
|
|
|
|
// subsequent request to get the next set of object keys.
|
|
|
|
NextKeyMarker string `xml:"NextKeyMarker,omitempty"`
|
|
|
|
|
|
|
|
// When the number of responses exceeds the value of MaxKeys,
|
|
|
|
// NextVersionIdMarker specifies the first object version not
|
|
|
|
// returned that satisfies the search criteria. Use this value
|
|
|
|
// for the version-id-marker request parameter in a subsequent request.
|
|
|
|
NextVersionIDMarker string `xml:"NextVersionIdMarker"`
|
|
|
|
|
|
|
|
// Marks the last version of the Key returned in a truncated response.
|
|
|
|
VersionIDMarker string `xml:"VersionIdMarker"`
|
|
|
|
|
|
|
|
MaxKeys int
|
|
|
|
Delimiter string
|
|
|
|
// A flag that indicates whether or not ListObjects returned all of the results
|
|
|
|
// that satisfied the search criteria.
|
|
|
|
IsTruncated bool
|
|
|
|
|
|
|
|
CommonPrefixes []CommonPrefix
|
|
|
|
Versions []ObjectVersion
|
|
|
|
|
|
|
|
// Encoding type used to encode object keys in the response.
|
|
|
|
EncodingType string `xml:"EncodingType,omitempty"`
|
|
|
|
}
|
|
|
|
|
2016-02-19 19:04:29 -05:00
|
|
|
// ListObjectsResponse - format for list objects response.
|
|
|
|
type ListObjectsResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListBucketResult" json:"-"`
|
|
|
|
|
2016-10-05 23:12:47 -04:00
|
|
|
Name string
|
|
|
|
Prefix string
|
|
|
|
Marker string
|
2016-02-19 19:04:29 -05:00
|
|
|
|
|
|
|
// When response is truncated (the IsTruncated element value in the response
|
|
|
|
// is true), you can use the key name in this field as marker in the subsequent
|
|
|
|
// request to get next set of objects. Server lists objects in alphabetical
|
|
|
|
// order Note: This element is returned only if you have delimiter request parameter
|
|
|
|
// specified. If response does not include the NextMaker and it is truncated,
|
|
|
|
// you can use the value of the last Key in the response as the marker in the
|
|
|
|
// subsequent request to get the next set of object keys.
|
2016-10-05 23:12:47 -04:00
|
|
|
NextMarker string `xml:"NextMarker,omitempty"`
|
2016-02-19 19:04:29 -05:00
|
|
|
|
2016-10-05 23:12:47 -04:00
|
|
|
MaxKeys int
|
|
|
|
Delimiter string
|
|
|
|
// A flag that indicates whether or not ListObjects returned all of the results
|
|
|
|
// that satisfied the search criteria.
|
|
|
|
IsTruncated bool
|
2016-06-01 01:10:55 -04:00
|
|
|
|
|
|
|
Contents []Object
|
2016-10-05 23:12:47 -04:00
|
|
|
CommonPrefixes []CommonPrefix
|
2016-06-01 01:10:55 -04:00
|
|
|
|
|
|
|
// Encoding type used to encode object keys in the response.
|
2016-10-05 23:12:47 -04:00
|
|
|
EncodingType string `xml:"EncodingType,omitempty"`
|
|
|
|
}
|
2016-06-01 01:10:55 -04:00
|
|
|
|
2016-10-05 23:12:47 -04:00
|
|
|
// ListObjectsV2Response - format for list objects response.
|
|
|
|
type ListObjectsV2Response struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListBucketResult" json:"-"`
|
2016-06-01 01:10:55 -04:00
|
|
|
|
2016-10-05 23:12:47 -04:00
|
|
|
Name string
|
|
|
|
Prefix string
|
|
|
|
StartAfter string `xml:"StartAfter,omitempty"`
|
2016-06-01 01:10:55 -04:00
|
|
|
// When response is truncated (the IsTruncated element value in the response
|
|
|
|
// is true), you can use the key name in this field as marker in the subsequent
|
|
|
|
// request to get next set of objects. Server lists objects in alphabetical
|
|
|
|
// order Note: This element is returned only if you have delimiter request parameter
|
|
|
|
// specified. If response does not include the NextMaker and it is truncated,
|
|
|
|
// you can use the value of the last Key in the response as the marker in the
|
|
|
|
// subsequent request to get the next set of object keys.
|
2016-10-05 23:12:47 -04:00
|
|
|
ContinuationToken string `xml:"ContinuationToken,omitempty"`
|
|
|
|
NextContinuationToken string `xml:"NextContinuationToken,omitempty"`
|
|
|
|
|
|
|
|
KeyCount int
|
|
|
|
MaxKeys int
|
|
|
|
Delimiter string
|
|
|
|
// A flag that indicates whether or not ListObjects returned all of the results
|
|
|
|
// that satisfied the search criteria.
|
|
|
|
IsTruncated bool
|
|
|
|
|
|
|
|
Contents []Object
|
|
|
|
CommonPrefixes []CommonPrefix
|
|
|
|
|
|
|
|
// Encoding type used to encode object keys in the response.
|
|
|
|
EncodingType string `xml:"EncodingType,omitempty"`
|
2016-06-01 01:10:55 -04:00
|
|
|
}
|
|
|
|
|
2016-02-19 19:04:29 -05:00
|
|
|
// Part container for part metadata.
|
|
|
|
type Part struct {
|
|
|
|
PartNumber int
|
|
|
|
LastModified string
|
2016-10-05 23:12:47 -04:00
|
|
|
ETag string
|
2016-02-19 19:04:29 -05:00
|
|
|
Size int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// ListPartsResponse - format for list parts response.
|
|
|
|
type ListPartsResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListPartsResult" json:"-"`
|
|
|
|
|
|
|
|
Bucket string
|
|
|
|
Key string
|
|
|
|
UploadID string `xml:"UploadId"`
|
|
|
|
|
|
|
|
Initiator Initiator
|
|
|
|
Owner Owner
|
|
|
|
|
|
|
|
// The class of storage used to store the object.
|
|
|
|
StorageClass string
|
|
|
|
|
|
|
|
PartNumberMarker int
|
|
|
|
NextPartNumberMarker int
|
|
|
|
MaxParts int
|
|
|
|
IsTruncated bool
|
|
|
|
|
|
|
|
// List of parts.
|
|
|
|
Parts []Part `xml:"Part"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// ListMultipartUploadsResponse - format for list multipart uploads response.
|
|
|
|
type ListMultipartUploadsResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListMultipartUploadsResult" json:"-"`
|
|
|
|
|
|
|
|
Bucket string
|
|
|
|
KeyMarker string
|
|
|
|
UploadIDMarker string `xml:"UploadIdMarker"`
|
|
|
|
NextKeyMarker string
|
|
|
|
NextUploadIDMarker string `xml:"NextUploadIdMarker"`
|
2016-10-05 23:12:47 -04:00
|
|
|
Delimiter string
|
|
|
|
Prefix string
|
|
|
|
EncodingType string `xml:"EncodingType,omitempty"`
|
2016-02-19 19:04:29 -05:00
|
|
|
MaxUploads int
|
|
|
|
IsTruncated bool
|
2016-10-05 23:12:47 -04:00
|
|
|
|
|
|
|
// List of pending uploads.
|
|
|
|
Uploads []Upload `xml:"Upload"`
|
|
|
|
|
|
|
|
// Delimed common prefixes.
|
|
|
|
CommonPrefixes []CommonPrefix
|
2016-02-19 19:04:29 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// ListBucketsResponse - format for list buckets response
|
|
|
|
type ListBucketsResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ ListAllMyBucketsResult" json:"-"`
|
2016-10-05 23:12:47 -04:00
|
|
|
|
|
|
|
Owner Owner
|
|
|
|
|
2016-02-19 19:04:29 -05:00
|
|
|
// Container for one or more buckets.
|
|
|
|
Buckets struct {
|
|
|
|
Buckets []Bucket `xml:"Bucket"`
|
|
|
|
} // Buckets are nested
|
|
|
|
}
|
|
|
|
|
|
|
|
// Upload container for in progress multipart upload
|
|
|
|
type Upload struct {
|
2018-01-22 17:54:55 -05:00
|
|
|
Key string
|
|
|
|
UploadID string `xml:"UploadId"`
|
|
|
|
Initiator Initiator
|
|
|
|
Owner Owner
|
|
|
|
StorageClass string
|
|
|
|
Initiated string
|
2016-02-19 19:04:29 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// CommonPrefix container for prefix response in ListObjectsResponse
|
|
|
|
type CommonPrefix struct {
|
|
|
|
Prefix string
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bucket container for bucket metadata
|
|
|
|
type Bucket struct {
|
2018-01-22 17:54:55 -05:00
|
|
|
Name string
|
|
|
|
CreationDate string // time string of format "2006-01-02T15:04:05.000Z"
|
2016-02-19 19:04:29 -05:00
|
|
|
}
|
|
|
|
|
2019-08-19 17:02:54 -04:00
|
|
|
// ObjectVersion container for object version metadata
|
|
|
|
type ObjectVersion struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ Version" json:"-"`
|
|
|
|
Object
|
|
|
|
VersionID string `xml:"VersionId"`
|
|
|
|
IsLatest bool
|
|
|
|
}
|
|
|
|
|
2016-02-19 19:04:29 -05:00
|
|
|
// Object container for object metadata
|
|
|
|
type Object struct {
|
|
|
|
Key string
|
|
|
|
LastModified string // time string of format "2006-01-02T15:04:05.000Z"
|
2016-10-05 23:12:47 -04:00
|
|
|
ETag string
|
2016-02-19 19:04:29 -05:00
|
|
|
Size int64
|
|
|
|
|
2016-10-05 23:12:47 -04:00
|
|
|
// Owner of the object.
|
2016-02-19 19:04:29 -05:00
|
|
|
Owner Owner
|
|
|
|
|
|
|
|
// The class of storage used to store the object.
|
2018-01-22 17:54:55 -05:00
|
|
|
StorageClass string
|
2016-02-19 19:04:29 -05:00
|
|
|
}
|
|
|
|
|
2016-10-05 23:12:47 -04:00
|
|
|
// CopyObjectResponse container returns ETag and LastModified of the successfully copied object
|
2016-02-27 06:04:52 -05:00
|
|
|
type CopyObjectResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CopyObjectResult" json:"-"`
|
2016-10-05 23:12:47 -04:00
|
|
|
LastModified string // time string of format "2006-01-02T15:04:05.000Z"
|
|
|
|
ETag string // md5sum of the copied object.
|
2016-02-27 06:04:52 -05:00
|
|
|
}
|
|
|
|
|
2017-01-31 12:38:34 -05:00
|
|
|
// CopyObjectPartResponse container returns ETag and LastModified of the successfully copied object
|
|
|
|
type CopyObjectPartResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CopyPartResult" json:"-"`
|
|
|
|
LastModified string // time string of format "2006-01-02T15:04:05.000Z"
|
|
|
|
ETag string // md5sum of the copied object part.
|
|
|
|
}
|
|
|
|
|
2016-02-19 19:04:29 -05:00
|
|
|
// Initiator inherit from Owner struct, fields are same
|
|
|
|
type Initiator Owner
|
|
|
|
|
|
|
|
// Owner - bucket owner/principal
|
|
|
|
type Owner struct {
|
|
|
|
ID string
|
|
|
|
DisplayName string
|
|
|
|
}
|
|
|
|
|
|
|
|
// InitiateMultipartUploadResponse container for InitiateMultiPartUpload response, provides uploadID to start MultiPart upload
|
|
|
|
type InitiateMultipartUploadResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ InitiateMultipartUploadResult" json:"-"`
|
|
|
|
|
|
|
|
Bucket string
|
|
|
|
Key string
|
|
|
|
UploadID string `xml:"UploadId"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// CompleteMultipartUploadResponse container for completed multipart upload response
|
|
|
|
type CompleteMultipartUploadResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CompleteMultipartUploadResult" json:"-"`
|
|
|
|
|
|
|
|
Location string
|
|
|
|
Bucket string
|
2016-05-04 18:24:10 -04:00
|
|
|
Key string
|
|
|
|
ETag string
|
|
|
|
}
|
|
|
|
|
2016-03-05 19:43:48 -05:00
|
|
|
// DeleteError structure.
|
|
|
|
type DeleteError struct {
|
|
|
|
Code string
|
|
|
|
Message string
|
|
|
|
Key string
|
|
|
|
}
|
|
|
|
|
|
|
|
// DeleteObjectsResponse container for multiple object deletes.
|
|
|
|
type DeleteObjectsResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ DeleteResult" json:"-"`
|
|
|
|
|
|
|
|
// Collection of all deleted objects
|
|
|
|
DeletedObjects []ObjectIdentifier `xml:"Deleted,omitempty"`
|
|
|
|
|
|
|
|
// Collection of errors deleting certain objects.
|
|
|
|
Errors []DeleteError `xml:"Error,omitempty"`
|
|
|
|
}
|
|
|
|
|
2016-12-18 16:39:56 -05:00
|
|
|
// PostResponse container for POST object request when success_action_status is set to 201
|
|
|
|
type PostResponse struct {
|
|
|
|
Bucket string
|
|
|
|
Key string
|
|
|
|
ETag string
|
|
|
|
Location string
|
|
|
|
}
|
|
|
|
|
2017-09-24 19:43:21 -04:00
|
|
|
// returns "https" if the tls boolean is true, "http" otherwise.
|
|
|
|
func getURLScheme(tls bool) string {
|
|
|
|
if tls {
|
|
|
|
return httpsScheme
|
|
|
|
}
|
|
|
|
return httpScheme
|
|
|
|
}
|
|
|
|
|
|
|
|
// getObjectLocation gets the fully qualified URL of an object.
|
2019-02-22 22:18:01 -05:00
|
|
|
func getObjectLocation(r *http.Request, domains []string, bucket, object string) string {
|
2018-03-23 16:46:57 -04:00
|
|
|
// unit tests do not have host set.
|
|
|
|
if r.Host == "" {
|
|
|
|
return path.Clean(r.URL.Path)
|
|
|
|
}
|
2018-03-02 18:23:04 -05:00
|
|
|
proto := handlers.GetSourceScheme(r)
|
2017-09-24 19:43:21 -04:00
|
|
|
if proto == "" {
|
|
|
|
proto = getURLScheme(globalIsSSL)
|
|
|
|
}
|
2018-03-02 18:23:04 -05:00
|
|
|
u := &url.URL{
|
|
|
|
Host: r.Host,
|
2019-08-06 15:08:58 -04:00
|
|
|
Path: path.Join(SlashSeparator, bucket, object),
|
2017-09-24 19:43:21 -04:00
|
|
|
Scheme: proto,
|
|
|
|
}
|
2018-03-02 18:23:04 -05:00
|
|
|
// If domain is set then we need to use bucket DNS style.
|
2019-02-22 22:18:01 -05:00
|
|
|
for _, domain := range domains {
|
2018-05-15 21:20:22 -04:00
|
|
|
if strings.Contains(r.Host, domain) {
|
|
|
|
u.Host = bucket + "." + r.Host
|
2019-08-06 15:08:58 -04:00
|
|
|
u.Path = path.Join(SlashSeparator, object)
|
2019-02-22 22:18:01 -05:00
|
|
|
break
|
2018-05-15 21:20:22 -04:00
|
|
|
}
|
2018-03-02 18:23:04 -05:00
|
|
|
}
|
2017-09-24 19:43:21 -04:00
|
|
|
return u.String()
|
2016-05-04 18:24:10 -04:00
|
|
|
}
|
|
|
|
|
2016-11-21 16:51:05 -05:00
|
|
|
// generates ListBucketsResponse from array of BucketInfo which can be
|
|
|
|
// serialized to match XML and JSON API spec output.
|
fs: Break fs package to top-level and introduce ObjectAPI interface.
ObjectAPI interface brings in changes needed for XL ObjectAPI layer.
The new interface for any ObjectAPI layer is as below
```
// ObjectAPI interface.
type ObjectAPI interface {
// Bucket resource API.
DeleteBucket(bucket string) *probe.Error
ListBuckets() ([]BucketInfo, *probe.Error)
MakeBucket(bucket string) *probe.Error
GetBucketInfo(bucket string) (BucketInfo, *probe.Error)
// Bucket query API.
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsResult, *probe.Error)
ListMultipartUploads(bucket string, resources BucketMultipartResourcesMetadata) (BucketMultipartResourcesMetadata, *probe.Error)
// Object resource API.
GetObject(bucket, object string, startOffset int64) (io.ReadCloser, *probe.Error)
GetObjectInfo(bucket, object string) (ObjectInfo, *probe.Error)
PutObject(bucket string, object string, size int64, data io.Reader, metadata map[string]string) (ObjectInfo, *probe.Error)
DeleteObject(bucket, object string) *probe.Error
// Object query API.
NewMultipartUpload(bucket, object string) (string, *probe.Error)
PutObjectPart(bucket, object, uploadID string, partID int, size int64, data io.Reader, md5Hex string) (string, *probe.Error)
ListObjectParts(bucket, object string, resources ObjectResourcesMetadata) (ObjectResourcesMetadata, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []CompletePart) (ObjectInfo, *probe.Error)
AbortMultipartUpload(bucket, object, uploadID string) *probe.Error
}
```
2016-03-30 19:15:28 -04:00
|
|
|
func generateListBucketsResponse(buckets []BucketInfo) ListBucketsResponse {
|
2016-02-19 19:04:29 -05:00
|
|
|
var listbuckets []Bucket
|
2015-04-29 18:28:04 -04:00
|
|
|
var data = ListBucketsResponse{}
|
2015-02-15 20:03:27 -05:00
|
|
|
var owner = Owner{}
|
|
|
|
|
2017-01-18 15:24:34 -05:00
|
|
|
owner.ID = globalMinioDefaultOwnerID
|
2015-02-15 20:03:27 -05:00
|
|
|
for _, bucket := range buckets {
|
2016-02-19 19:04:29 -05:00
|
|
|
var listbucket = Bucket{}
|
2015-02-15 20:03:27 -05:00
|
|
|
listbucket.Name = bucket.Name
|
2017-10-03 13:34:51 -04:00
|
|
|
listbucket.CreationDate = bucket.Created.UTC().Format(timeFormatAMZLong)
|
2015-02-15 20:03:27 -05:00
|
|
|
listbuckets = append(listbuckets, listbucket)
|
|
|
|
}
|
|
|
|
|
|
|
|
data.Owner = owner
|
2016-02-19 19:04:29 -05:00
|
|
|
data.Buckets.Buckets = listbuckets
|
2015-02-15 20:03:27 -05:00
|
|
|
|
|
|
|
return data
|
|
|
|
}
|
|
|
|
|
2019-08-19 17:02:54 -04:00
|
|
|
// generates an ListBucketVersions response for the said bucket with other enumerated options.
|
|
|
|
func generateListVersionsResponse(bucket, prefix, marker, delimiter, encodingType string, maxKeys int, resp ListObjectsInfo) ListVersionsResponse {
|
|
|
|
var versions []ObjectVersion
|
|
|
|
var prefixes []CommonPrefix
|
|
|
|
var owner = Owner{}
|
|
|
|
var data = ListVersionsResponse{}
|
|
|
|
|
|
|
|
owner.ID = globalMinioDefaultOwnerID
|
|
|
|
for _, object := range resp.Objects {
|
|
|
|
var content = ObjectVersion{}
|
|
|
|
if object.Name == "" {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
content.Key = s3EncodeName(object.Name, encodingType)
|
|
|
|
content.LastModified = object.ModTime.UTC().Format(timeFormatAMZLong)
|
|
|
|
if object.ETag != "" {
|
|
|
|
content.ETag = "\"" + object.ETag + "\""
|
|
|
|
}
|
|
|
|
content.Size = object.Size
|
|
|
|
content.StorageClass = object.StorageClass
|
|
|
|
content.Owner = owner
|
|
|
|
content.VersionID = "null"
|
|
|
|
content.IsLatest = true
|
|
|
|
versions = append(versions, content)
|
|
|
|
}
|
|
|
|
data.Name = bucket
|
|
|
|
data.Versions = versions
|
|
|
|
|
|
|
|
data.EncodingType = encodingType
|
|
|
|
data.Prefix = s3EncodeName(prefix, encodingType)
|
|
|
|
data.KeyMarker = s3EncodeName(marker, encodingType)
|
|
|
|
data.Delimiter = s3EncodeName(delimiter, encodingType)
|
|
|
|
data.MaxKeys = maxKeys
|
|
|
|
|
|
|
|
data.NextKeyMarker = s3EncodeName(resp.NextMarker, encodingType)
|
|
|
|
data.IsTruncated = resp.IsTruncated
|
|
|
|
|
|
|
|
for _, prefix := range resp.Prefixes {
|
|
|
|
var prefixItem = CommonPrefix{}
|
|
|
|
prefixItem.Prefix = s3EncodeName(prefix, encodingType)
|
|
|
|
prefixes = append(prefixes, prefixItem)
|
|
|
|
}
|
|
|
|
data.CommonPrefixes = prefixes
|
|
|
|
return data
|
|
|
|
}
|
|
|
|
|
2016-07-17 15:32:05 -04:00
|
|
|
// generates an ListObjectsV1 response for the said bucket with other enumerated options.
|
2019-02-24 01:14:24 -05:00
|
|
|
func generateListObjectsV1Response(bucket, prefix, marker, delimiter, encodingType string, maxKeys int, resp ListObjectsInfo) ListObjectsResponse {
|
2016-02-19 19:04:29 -05:00
|
|
|
var contents []Object
|
|
|
|
var prefixes []CommonPrefix
|
2015-02-15 20:03:27 -05:00
|
|
|
var owner = Owner{}
|
2015-04-29 18:28:04 -04:00
|
|
|
var data = ListObjectsResponse{}
|
2015-02-15 20:03:27 -05:00
|
|
|
|
2017-01-18 15:24:34 -05:00
|
|
|
owner.ID = globalMinioDefaultOwnerID
|
2015-11-10 06:10:11 -05:00
|
|
|
for _, object := range resp.Objects {
|
2016-02-19 19:04:29 -05:00
|
|
|
var content = Object{}
|
2016-03-11 19:31:24 -05:00
|
|
|
if object.Name == "" {
|
2015-02-28 17:44:26 -05:00
|
|
|
continue
|
|
|
|
}
|
2019-02-24 01:14:24 -05:00
|
|
|
content.Key = s3EncodeName(object.Name, encodingType)
|
2016-10-17 11:44:55 -04:00
|
|
|
content.LastModified = object.ModTime.UTC().Format(timeFormatAMZLong)
|
2017-05-14 15:05:51 -04:00
|
|
|
if object.ETag != "" {
|
|
|
|
content.ETag = "\"" + object.ETag + "\""
|
2016-02-01 15:19:54 -05:00
|
|
|
}
|
2015-02-15 20:03:27 -05:00
|
|
|
content.Size = object.Size
|
2018-04-05 13:56:28 -04:00
|
|
|
content.StorageClass = object.StorageClass
|
2015-02-15 20:03:27 -05:00
|
|
|
content.Owner = owner
|
|
|
|
contents = append(contents, content)
|
|
|
|
}
|
|
|
|
data.Name = bucket
|
|
|
|
data.Contents = contents
|
2015-11-10 06:10:11 -05:00
|
|
|
|
2019-02-24 01:14:24 -05:00
|
|
|
data.EncodingType = encodingType
|
|
|
|
data.Prefix = s3EncodeName(prefix, encodingType)
|
|
|
|
data.Marker = s3EncodeName(marker, encodingType)
|
|
|
|
data.Delimiter = s3EncodeName(delimiter, encodingType)
|
2016-01-19 20:49:48 -05:00
|
|
|
data.MaxKeys = maxKeys
|
2015-11-10 06:10:11 -05:00
|
|
|
|
2019-02-24 01:14:24 -05:00
|
|
|
data.NextMarker = s3EncodeName(resp.NextMarker, encodingType)
|
2015-11-10 06:10:11 -05:00
|
|
|
data.IsTruncated = resp.IsTruncated
|
2016-06-01 01:10:55 -04:00
|
|
|
for _, prefix := range resp.Prefixes {
|
|
|
|
var prefixItem = CommonPrefix{}
|
2019-02-24 01:14:24 -05:00
|
|
|
prefixItem.Prefix = s3EncodeName(prefix, encodingType)
|
2016-06-01 01:10:55 -04:00
|
|
|
prefixes = append(prefixes, prefixItem)
|
|
|
|
}
|
|
|
|
data.CommonPrefixes = prefixes
|
|
|
|
return data
|
|
|
|
}
|
|
|
|
|
2016-07-17 15:32:05 -04:00
|
|
|
// generates an ListObjectsV2 response for the said bucket with other enumerated options.
|
2019-02-24 01:14:24 -05:00
|
|
|
func generateListObjectsV2Response(bucket, prefix, token, nextToken, startAfter, delimiter, encodingType string, fetchOwner, isTruncated bool, maxKeys int, objects []ObjectInfo, prefixes []string) ListObjectsV2Response {
|
2016-06-01 01:10:55 -04:00
|
|
|
var contents []Object
|
2017-06-17 01:17:00 -04:00
|
|
|
var commonPrefixes []CommonPrefix
|
2016-06-01 01:10:55 -04:00
|
|
|
var owner = Owner{}
|
|
|
|
var data = ListObjectsV2Response{}
|
|
|
|
|
2016-09-10 13:44:38 -04:00
|
|
|
if fetchOwner {
|
2017-01-18 15:24:34 -05:00
|
|
|
owner.ID = globalMinioDefaultOwnerID
|
2016-09-10 13:44:38 -04:00
|
|
|
}
|
2016-06-01 01:10:55 -04:00
|
|
|
|
2017-06-17 01:17:00 -04:00
|
|
|
for _, object := range objects {
|
2016-06-01 01:10:55 -04:00
|
|
|
var content = Object{}
|
|
|
|
if object.Name == "" {
|
|
|
|
continue
|
|
|
|
}
|
2019-02-24 01:14:24 -05:00
|
|
|
content.Key = s3EncodeName(object.Name, encodingType)
|
2016-10-17 11:44:55 -04:00
|
|
|
content.LastModified = object.ModTime.UTC().Format(timeFormatAMZLong)
|
2017-05-14 15:05:51 -04:00
|
|
|
if object.ETag != "" {
|
|
|
|
content.ETag = "\"" + object.ETag + "\""
|
2016-06-01 01:10:55 -04:00
|
|
|
}
|
|
|
|
content.Size = object.Size
|
2018-04-05 13:56:28 -04:00
|
|
|
content.StorageClass = object.StorageClass
|
2016-06-01 01:10:55 -04:00
|
|
|
content.Owner = owner
|
|
|
|
contents = append(contents, content)
|
|
|
|
}
|
|
|
|
data.Name = bucket
|
|
|
|
data.Contents = contents
|
|
|
|
|
2019-02-24 01:14:24 -05:00
|
|
|
data.EncodingType = encodingType
|
2019-02-24 21:50:28 -05:00
|
|
|
data.StartAfter = s3EncodeName(startAfter, encodingType)
|
2019-02-24 01:14:24 -05:00
|
|
|
data.Delimiter = s3EncodeName(delimiter, encodingType)
|
|
|
|
data.Prefix = s3EncodeName(prefix, encodingType)
|
2016-06-01 01:10:55 -04:00
|
|
|
data.MaxKeys = maxKeys
|
2019-10-01 16:09:29 -04:00
|
|
|
data.ContinuationToken = base64.StdEncoding.EncodeToString([]byte(token))
|
|
|
|
data.NextContinuationToken = base64.StdEncoding.EncodeToString([]byte(nextToken))
|
2017-06-17 01:17:00 -04:00
|
|
|
data.IsTruncated = isTruncated
|
|
|
|
for _, prefix := range prefixes {
|
2016-02-19 19:04:29 -05:00
|
|
|
var prefixItem = CommonPrefix{}
|
2019-02-24 01:14:24 -05:00
|
|
|
prefixItem.Prefix = s3EncodeName(prefix, encodingType)
|
2017-06-17 01:17:00 -04:00
|
|
|
commonPrefixes = append(commonPrefixes, prefixItem)
|
2015-02-28 17:44:26 -05:00
|
|
|
}
|
2017-06-17 01:17:00 -04:00
|
|
|
data.CommonPrefixes = commonPrefixes
|
2016-10-05 23:12:47 -04:00
|
|
|
data.KeyCount = len(data.Contents) + len(data.CommonPrefixes)
|
2015-02-15 20:03:27 -05:00
|
|
|
return data
|
|
|
|
}
|
2015-04-22 19:28:13 -04:00
|
|
|
|
2016-11-21 16:51:05 -05:00
|
|
|
// generates CopyObjectResponse from etag and lastModified time.
|
2016-02-27 06:04:52 -05:00
|
|
|
func generateCopyObjectResponse(etag string, lastModified time.Time) CopyObjectResponse {
|
|
|
|
return CopyObjectResponse{
|
2017-01-31 12:38:34 -05:00
|
|
|
ETag: "\"" + etag + "\"",
|
|
|
|
LastModified: lastModified.UTC().Format(timeFormatAMZLong),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// generates CopyObjectPartResponse from etag and lastModified time.
|
|
|
|
func generateCopyObjectPartResponse(etag string, lastModified time.Time) CopyObjectPartResponse {
|
|
|
|
return CopyObjectPartResponse{
|
2016-02-27 06:04:52 -05:00
|
|
|
ETag: "\"" + etag + "\"",
|
2016-10-17 11:44:55 -04:00
|
|
|
LastModified: lastModified.UTC().Format(timeFormatAMZLong),
|
2016-02-27 06:04:52 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-21 16:51:05 -05:00
|
|
|
// generates InitiateMultipartUploadResponse for given bucket, key and uploadID.
|
2015-07-09 22:01:15 -04:00
|
|
|
func generateInitiateMultipartUploadResponse(bucket, key, uploadID string) InitiateMultipartUploadResponse {
|
|
|
|
return InitiateMultipartUploadResponse{
|
2015-05-07 22:55:30 -04:00
|
|
|
Bucket: bucket,
|
|
|
|
Key: key,
|
|
|
|
UploadID: uploadID,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-21 16:51:05 -05:00
|
|
|
// generates CompleteMultipartUploadResponse for given bucket, key, location and ETag.
|
2015-07-09 22:01:15 -04:00
|
|
|
func generateCompleteMultpartUploadResponse(bucket, key, location, etag string) CompleteMultipartUploadResponse {
|
|
|
|
return CompleteMultipartUploadResponse{
|
2015-05-08 01:43:19 -04:00
|
|
|
Location: location,
|
|
|
|
Bucket: bucket,
|
|
|
|
Key: key,
|
|
|
|
ETag: etag,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-21 16:51:05 -05:00
|
|
|
// generates ListPartsResponse from ListPartsInfo.
|
2019-02-24 01:14:24 -05:00
|
|
|
func generateListPartsResponse(partsInfo ListPartsInfo, encodingType string) ListPartsResponse {
|
2015-05-09 14:41:26 -04:00
|
|
|
listPartsResponse := ListPartsResponse{}
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 04:34:20 -04:00
|
|
|
listPartsResponse.Bucket = partsInfo.Bucket
|
2019-02-24 01:14:24 -05:00
|
|
|
listPartsResponse.Key = s3EncodeName(partsInfo.Object, encodingType)
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 04:34:20 -04:00
|
|
|
listPartsResponse.UploadID = partsInfo.UploadID
|
2017-01-18 15:24:34 -05:00
|
|
|
listPartsResponse.StorageClass = globalMinioDefaultStorageClass
|
|
|
|
listPartsResponse.Initiator.ID = globalMinioDefaultOwnerID
|
|
|
|
listPartsResponse.Owner.ID = globalMinioDefaultOwnerID
|
2015-05-09 14:41:26 -04:00
|
|
|
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 04:34:20 -04:00
|
|
|
listPartsResponse.MaxParts = partsInfo.MaxParts
|
|
|
|
listPartsResponse.PartNumberMarker = partsInfo.PartNumberMarker
|
|
|
|
listPartsResponse.IsTruncated = partsInfo.IsTruncated
|
|
|
|
listPartsResponse.NextPartNumberMarker = partsInfo.NextPartNumberMarker
|
2015-05-09 14:41:26 -04:00
|
|
|
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 04:34:20 -04:00
|
|
|
listPartsResponse.Parts = make([]Part, len(partsInfo.Parts))
|
|
|
|
for index, part := range partsInfo.Parts {
|
2016-02-19 19:04:29 -05:00
|
|
|
newPart := Part{}
|
2015-05-09 14:41:26 -04:00
|
|
|
newPart.PartNumber = part.PartNumber
|
2015-06-09 04:12:32 -04:00
|
|
|
newPart.ETag = "\"" + part.ETag + "\""
|
2015-05-09 14:41:26 -04:00
|
|
|
newPart.Size = part.Size
|
2016-10-17 11:44:55 -04:00
|
|
|
newPart.LastModified = part.LastModified.UTC().Format(timeFormatAMZLong)
|
2016-03-20 02:44:43 -04:00
|
|
|
listPartsResponse.Parts[index] = newPart
|
2015-05-09 14:41:26 -04:00
|
|
|
}
|
|
|
|
return listPartsResponse
|
|
|
|
}
|
|
|
|
|
2016-11-21 16:51:05 -05:00
|
|
|
// generates ListMultipartUploadsResponse for given bucket and ListMultipartsInfo.
|
2019-02-24 01:14:24 -05:00
|
|
|
func generateListMultipartUploadsResponse(bucket string, multipartsInfo ListMultipartsInfo, encodingType string) ListMultipartUploadsResponse {
|
2015-05-14 17:36:41 -04:00
|
|
|
listMultipartUploadsResponse := ListMultipartUploadsResponse{}
|
|
|
|
listMultipartUploadsResponse.Bucket = bucket
|
2019-02-24 01:14:24 -05:00
|
|
|
listMultipartUploadsResponse.Delimiter = s3EncodeName(multipartsInfo.Delimiter, encodingType)
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 04:34:20 -04:00
|
|
|
listMultipartUploadsResponse.IsTruncated = multipartsInfo.IsTruncated
|
2019-02-24 01:14:24 -05:00
|
|
|
listMultipartUploadsResponse.EncodingType = encodingType
|
|
|
|
listMultipartUploadsResponse.Prefix = s3EncodeName(multipartsInfo.Prefix, encodingType)
|
|
|
|
listMultipartUploadsResponse.KeyMarker = s3EncodeName(multipartsInfo.KeyMarker, encodingType)
|
|
|
|
listMultipartUploadsResponse.NextKeyMarker = s3EncodeName(multipartsInfo.NextKeyMarker, encodingType)
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 04:34:20 -04:00
|
|
|
listMultipartUploadsResponse.MaxUploads = multipartsInfo.MaxUploads
|
|
|
|
listMultipartUploadsResponse.NextUploadIDMarker = multipartsInfo.NextUploadIDMarker
|
|
|
|
listMultipartUploadsResponse.UploadIDMarker = multipartsInfo.UploadIDMarker
|
2016-04-05 18:08:59 -04:00
|
|
|
listMultipartUploadsResponse.CommonPrefixes = make([]CommonPrefix, len(multipartsInfo.CommonPrefixes))
|
|
|
|
for index, commonPrefix := range multipartsInfo.CommonPrefixes {
|
|
|
|
listMultipartUploadsResponse.CommonPrefixes[index] = CommonPrefix{
|
2019-02-24 01:14:24 -05:00
|
|
|
Prefix: s3EncodeName(commonPrefix, encodingType),
|
2016-04-05 18:08:59 -04:00
|
|
|
}
|
|
|
|
}
|
objectAPI: Fix object API interface, remove unnecessary structs.
ObjectAPI changes.
```
ListObjects(bucket, prefix, marker, delimiter string, maxKeys int) (ListObjectsInfo, *probe.Error)
ListMultipartUploads(bucket, objectPrefix, keyMarker, uploadIDMarker, delimiter string, maxUploads int) (ListMultipartsInfo, *probe.Error)
ListObjectParts(bucket, object, uploadID string, partNumberMarker, maxParts int) (ListPartsInfo, *probe.Error)
CompleteMultipartUpload(bucket string, object string, uploadID string, parts []completePart) (ObjectInfo, *probe.Error)
```
2016-04-03 04:34:20 -04:00
|
|
|
listMultipartUploadsResponse.Uploads = make([]Upload, len(multipartsInfo.Uploads))
|
|
|
|
for index, upload := range multipartsInfo.Uploads {
|
2016-02-19 19:04:29 -05:00
|
|
|
newUpload := Upload{}
|
2015-05-14 17:36:41 -04:00
|
|
|
newUpload.UploadID = upload.UploadID
|
2019-02-24 01:14:24 -05:00
|
|
|
newUpload.Key = s3EncodeName(upload.Object, encodingType)
|
2016-10-17 11:44:55 -04:00
|
|
|
newUpload.Initiated = upload.Initiated.UTC().Format(timeFormatAMZLong)
|
2016-03-20 02:44:43 -04:00
|
|
|
listMultipartUploadsResponse.Uploads[index] = newUpload
|
2015-05-14 17:36:41 -04:00
|
|
|
}
|
|
|
|
return listMultipartUploadsResponse
|
|
|
|
}
|
|
|
|
|
2016-03-05 19:43:48 -05:00
|
|
|
// generate multi objects delete response.
|
|
|
|
func generateMultiDeleteResponse(quiet bool, deletedObjects []ObjectIdentifier, errs []DeleteError) DeleteObjectsResponse {
|
|
|
|
deleteResp := DeleteObjectsResponse{}
|
|
|
|
if !quiet {
|
|
|
|
deleteResp.DeletedObjects = deletedObjects
|
|
|
|
}
|
|
|
|
deleteResp.Errors = errs
|
|
|
|
return deleteResp
|
|
|
|
}
|
|
|
|
|
2017-01-06 03:37:00 -05:00
|
|
|
func writeResponse(w http.ResponseWriter, statusCode int, response []byte, mType mimeType) {
|
2016-01-08 03:40:06 -05:00
|
|
|
setCommonHeaders(w)
|
2017-01-06 03:37:00 -05:00
|
|
|
if mType != mimeNone {
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Set(xhttp.ContentType, string(mType))
|
2017-01-06 03:37:00 -05:00
|
|
|
}
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Set(xhttp.ContentLength, strconv.Itoa(len(response)))
|
2016-12-18 16:39:56 -05:00
|
|
|
w.WriteHeader(statusCode)
|
2017-01-06 03:37:00 -05:00
|
|
|
if response != nil {
|
|
|
|
w.Write(response)
|
|
|
|
w.(http.Flusher).Flush()
|
2016-01-08 03:40:06 -05:00
|
|
|
}
|
2015-04-29 13:51:59 -04:00
|
|
|
}
|
|
|
|
|
2017-01-06 03:37:00 -05:00
|
|
|
// mimeType represents various MIME type used API responses.
|
|
|
|
type mimeType string
|
|
|
|
|
|
|
|
const (
|
|
|
|
// Means no response type.
|
|
|
|
mimeNone mimeType = ""
|
|
|
|
// Means response type is JSON.
|
|
|
|
mimeJSON mimeType = "application/json"
|
|
|
|
// Means response type is XML.
|
|
|
|
mimeXML mimeType = "application/xml"
|
|
|
|
)
|
|
|
|
|
|
|
|
// writeSuccessResponseJSON writes success headers and response if any,
|
|
|
|
// with content-type set to `application/json`.
|
|
|
|
func writeSuccessResponseJSON(w http.ResponseWriter, response []byte) {
|
|
|
|
writeResponse(w, http.StatusOK, response, mimeJSON)
|
|
|
|
}
|
|
|
|
|
|
|
|
// writeSuccessResponseXML writes success headers and response if any,
|
|
|
|
// with content-type set to `application/xml`.
|
|
|
|
func writeSuccessResponseXML(w http.ResponseWriter, response []byte) {
|
|
|
|
writeResponse(w, http.StatusOK, response, mimeXML)
|
2016-12-18 16:39:56 -05:00
|
|
|
}
|
|
|
|
|
2016-12-20 12:32:17 -05:00
|
|
|
// writeSuccessNoContent writes success headers with http status 204
|
2015-10-16 23:02:37 -04:00
|
|
|
func writeSuccessNoContent(w http.ResponseWriter) {
|
2017-01-06 03:37:00 -05:00
|
|
|
writeResponse(w, http.StatusNoContent, nil, mimeNone)
|
2015-10-16 23:02:37 -04:00
|
|
|
}
|
|
|
|
|
2016-12-20 12:32:17 -05:00
|
|
|
// writeRedirectSeeOther writes Location header with http status 303
|
|
|
|
func writeRedirectSeeOther(w http.ResponseWriter, location string) {
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Set(xhttp.Location, location)
|
2017-01-06 03:37:00 -05:00
|
|
|
writeResponse(w, http.StatusSeeOther, nil, mimeNone)
|
2016-12-20 12:32:17 -05:00
|
|
|
}
|
|
|
|
|
2017-01-06 03:37:00 -05:00
|
|
|
func writeSuccessResponseHeadersOnly(w http.ResponseWriter) {
|
|
|
|
writeResponse(w, http.StatusOK, nil, mimeNone)
|
2016-06-15 23:31:06 -04:00
|
|
|
}
|
|
|
|
|
2017-01-06 03:37:00 -05:00
|
|
|
// writeErrorRespone writes error headers
|
2019-02-13 19:07:21 -05:00
|
|
|
func writeErrorResponse(ctx context.Context, w http.ResponseWriter, err APIError, reqURL *url.URL, browser bool) {
|
2019-02-12 04:25:52 -05:00
|
|
|
switch err.Code {
|
|
|
|
case "SlowDown", "XMinioServerNotInitialized", "XMinioReadQuorum", "XMinioWriteQuorum":
|
2017-12-20 03:00:14 -05:00
|
|
|
// Set retry-after header to indicate user-agents to retry request after 120secs.
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Set(xhttp.RetryAfter, "120")
|
2019-02-12 04:25:52 -05:00
|
|
|
case "AccessDenied":
|
2018-12-04 02:38:24 -05:00
|
|
|
// The request is from browser and also if browser
|
|
|
|
// is enabled we need to redirect.
|
2019-07-15 15:01:17 -04:00
|
|
|
if browser && globalIsBrowserEnabled {
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Set(xhttp.Location, minioReservedBucketPath+reqURL.Path)
|
2018-11-26 15:15:12 -05:00
|
|
|
w.WriteHeader(http.StatusTemporaryRedirect)
|
|
|
|
return
|
|
|
|
}
|
2017-12-20 03:00:14 -05:00
|
|
|
}
|
2018-11-26 15:15:12 -05:00
|
|
|
|
2016-06-28 17:51:49 -04:00
|
|
|
// Generate error response.
|
2019-02-21 01:20:15 -05:00
|
|
|
errorResponse := getAPIErrorResponse(ctx, err, reqURL.Path,
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Get(xhttp.AmzRequestID), globalDeploymentID)
|
2016-06-15 23:31:06 -04:00
|
|
|
encodedErrorResponse := encodeResponse(errorResponse)
|
2019-02-12 04:25:52 -05:00
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeXML)
|
2017-01-06 03:37:00 -05:00
|
|
|
}
|
|
|
|
|
2019-02-12 04:25:52 -05:00
|
|
|
func writeErrorResponseHeadersOnly(w http.ResponseWriter, err APIError) {
|
|
|
|
writeResponse(w, err.HTTPStatusCode, nil, mimeNone)
|
2015-04-22 19:28:13 -04:00
|
|
|
}
|
2018-01-22 17:54:55 -05:00
|
|
|
|
|
|
|
// writeErrorResponseJSON - writes error response in JSON format;
|
|
|
|
// useful for admin APIs.
|
2019-02-13 19:07:21 -05:00
|
|
|
func writeErrorResponseJSON(ctx context.Context, w http.ResponseWriter, err APIError, reqURL *url.URL) {
|
2018-01-22 17:54:55 -05:00
|
|
|
// Generate error response.
|
2019-07-03 01:34:32 -04:00
|
|
|
errorResponse := getAPIErrorResponse(ctx, err, reqURL.Path, w.Header().Get(xhttp.AmzRequestID), globalDeploymentID)
|
2018-01-22 17:54:55 -05:00
|
|
|
encodedErrorResponse := encodeResponseJSON(errorResponse)
|
2019-02-12 04:25:52 -05:00
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeJSON)
|
2018-01-22 17:54:55 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// writeCustomErrorResponseJSON - similar to writeErrorResponseJSON,
|
|
|
|
// but accepts the error message directly (this allows messages to be
|
|
|
|
// dynamically generated.)
|
2019-02-13 19:07:21 -05:00
|
|
|
func writeCustomErrorResponseJSON(ctx context.Context, w http.ResponseWriter, err APIError,
|
2018-01-22 17:54:55 -05:00
|
|
|
errBody string, reqURL *url.URL) {
|
|
|
|
|
2019-02-13 19:07:21 -05:00
|
|
|
reqInfo := logger.GetReqInfo(ctx)
|
2018-01-22 17:54:55 -05:00
|
|
|
errorResponse := APIErrorResponse{
|
2019-02-13 19:07:21 -05:00
|
|
|
Code: err.Code,
|
|
|
|
Message: errBody,
|
|
|
|
Resource: reqURL.Path,
|
|
|
|
BucketName: reqInfo.BucketName,
|
|
|
|
Key: reqInfo.ObjectName,
|
2019-07-03 01:34:32 -04:00
|
|
|
RequestID: w.Header().Get(xhttp.AmzRequestID),
|
2019-07-01 15:22:01 -04:00
|
|
|
HostID: globalDeploymentID,
|
2018-01-22 17:54:55 -05:00
|
|
|
}
|
|
|
|
encodedErrorResponse := encodeResponseJSON(errorResponse)
|
2019-02-12 04:25:52 -05:00
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeJSON)
|
2018-01-22 17:54:55 -05:00
|
|
|
}
|
2019-03-05 15:10:47 -05:00
|
|
|
|
|
|
|
// writeCustomErrorResponseXML - similar to writeErrorResponse,
|
|
|
|
// but accepts the error message directly (this allows messages to be
|
|
|
|
// dynamically generated.)
|
|
|
|
func writeCustomErrorResponseXML(ctx context.Context, w http.ResponseWriter, err APIError, errBody string, reqURL *url.URL, browser bool) {
|
|
|
|
|
|
|
|
switch err.Code {
|
|
|
|
case "SlowDown", "XMinioServerNotInitialized", "XMinioReadQuorum", "XMinioWriteQuorum":
|
|
|
|
// Set retry-after header to indicate user-agents to retry request after 120secs.
|
|
|
|
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Set(xhttp.RetryAfter, "120")
|
2019-03-05 15:10:47 -05:00
|
|
|
case "AccessDenied":
|
|
|
|
// The request is from browser and also if browser
|
|
|
|
// is enabled we need to redirect.
|
|
|
|
if browser && globalIsBrowserEnabled {
|
2019-07-03 01:34:32 -04:00
|
|
|
w.Header().Set(xhttp.Location, minioReservedBucketPath+reqURL.Path)
|
2019-03-05 15:10:47 -05:00
|
|
|
w.WriteHeader(http.StatusTemporaryRedirect)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
reqInfo := logger.GetReqInfo(ctx)
|
|
|
|
errorResponse := APIErrorResponse{
|
|
|
|
Code: err.Code,
|
|
|
|
Message: errBody,
|
|
|
|
Resource: reqURL.Path,
|
|
|
|
BucketName: reqInfo.BucketName,
|
|
|
|
Key: reqInfo.ObjectName,
|
2019-07-03 01:34:32 -04:00
|
|
|
RequestID: w.Header().Get(xhttp.AmzRequestID),
|
2019-07-01 15:22:01 -04:00
|
|
|
HostID: globalDeploymentID,
|
2019-03-05 15:10:47 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
encodedErrorResponse := encodeResponse(errorResponse)
|
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeXML)
|
|
|
|
}
|