2015-02-24 01:46:48 +01:00
|
|
|
/*
|
2019-04-09 20:39:42 +02:00
|
|
|
* MinIO Cloud Storage, (C) 2015, 2016, 2017, 2018 MinIO, Inc.
|
2015-02-24 01:46:48 +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.
|
|
|
|
*/
|
|
|
|
|
2016-08-19 01:23:42 +02:00
|
|
|
package cmd
|
2015-02-16 02:03:27 +01:00
|
|
|
|
|
|
|
import (
|
2019-02-14 01:07:21 +01:00
|
|
|
"context"
|
2019-10-01 22:09:29 +02:00
|
|
|
"encoding/base64"
|
2016-02-20 01:04:29 +01:00
|
|
|
"encoding/xml"
|
2015-04-23 01:28:13 +02:00
|
|
|
"net/http"
|
2017-01-06 09:37:00 +01:00
|
|
|
"net/url"
|
2016-06-21 08:25:18 +02:00
|
|
|
"path"
|
2019-06-12 06:04:52 +02:00
|
|
|
"strconv"
|
2018-05-16 03:20:22 +02:00
|
|
|
"strings"
|
2016-02-27 12:04:52 +01:00
|
|
|
"time"
|
2018-03-03 00:23:04 +01:00
|
|
|
|
2019-07-03 07:34:32 +02:00
|
|
|
xhttp "github.com/minio/minio/cmd/http"
|
2019-02-14 01:07:21 +01:00
|
|
|
"github.com/minio/minio/cmd/logger"
|
2018-03-03 00:23:04 +01:00
|
|
|
"github.com/minio/minio/pkg/handlers"
|
2015-02-16 02:03:27 +01:00
|
|
|
)
|
|
|
|
|
2015-02-24 01:46:48 +01:00
|
|
|
const (
|
2016-10-17 17:44:55 +02:00
|
|
|
timeFormatAMZLong = "2006-01-02T15:04:05.000Z" // Reply date format with nanosecond precision.
|
2019-10-28 18:36:15 +01:00
|
|
|
maxObjectList = 10000 // Limit number of objects in a listObjectsResponse.
|
|
|
|
maxUploadsList = 10000 // Limit number of uploads in a listUploadsResponse.
|
|
|
|
maxPartsList = 10000 // Limit number of parts in a listPartsResponse.
|
2015-02-24 01:46:48 +01:00
|
|
|
)
|
|
|
|
|
2016-02-20 01:04:29 +01: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 23:02:54 +02: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-20 01:04:29 +01: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-06 05:12:47 +02:00
|
|
|
Name string
|
|
|
|
Prefix string
|
|
|
|
Marker string
|
2016-02-20 01:04:29 +01: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-06 05:12:47 +02:00
|
|
|
NextMarker string `xml:"NextMarker,omitempty"`
|
2016-02-20 01:04:29 +01:00
|
|
|
|
2016-10-06 05:12:47 +02: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 07:10:55 +02:00
|
|
|
|
|
|
|
Contents []Object
|
2016-10-06 05:12:47 +02:00
|
|
|
CommonPrefixes []CommonPrefix
|
2016-06-01 07:10:55 +02:00
|
|
|
|
|
|
|
// Encoding type used to encode object keys in the response.
|
2016-10-06 05:12:47 +02:00
|
|
|
EncodingType string `xml:"EncodingType,omitempty"`
|
|
|
|
}
|
2016-06-01 07:10:55 +02:00
|
|
|
|
2016-10-06 05:12:47 +02: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 07:10:55 +02:00
|
|
|
|
2016-10-06 05:12:47 +02:00
|
|
|
Name string
|
|
|
|
Prefix string
|
|
|
|
StartAfter string `xml:"StartAfter,omitempty"`
|
2016-06-01 07:10:55 +02: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-06 05:12:47 +02: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 07:10:55 +02:00
|
|
|
}
|
|
|
|
|
2016-02-20 01:04:29 +01:00
|
|
|
// Part container for part metadata.
|
|
|
|
type Part struct {
|
|
|
|
PartNumber int
|
|
|
|
LastModified string
|
2016-10-06 05:12:47 +02:00
|
|
|
ETag string
|
2016-02-20 01:04:29 +01: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-06 05:12:47 +02:00
|
|
|
Delimiter string
|
|
|
|
Prefix string
|
|
|
|
EncodingType string `xml:"EncodingType,omitempty"`
|
2016-02-20 01:04:29 +01:00
|
|
|
MaxUploads int
|
|
|
|
IsTruncated bool
|
2016-10-06 05:12:47 +02:00
|
|
|
|
|
|
|
// List of pending uploads.
|
|
|
|
Uploads []Upload `xml:"Upload"`
|
|
|
|
|
|
|
|
// Delimed common prefixes.
|
|
|
|
CommonPrefixes []CommonPrefix
|
2016-02-20 01:04:29 +01: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-06 05:12:47 +02:00
|
|
|
|
|
|
|
Owner Owner
|
|
|
|
|
2016-02-20 01:04:29 +01: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 23:54:55 +01:00
|
|
|
Key string
|
|
|
|
UploadID string `xml:"UploadId"`
|
|
|
|
Initiator Initiator
|
|
|
|
Owner Owner
|
|
|
|
StorageClass string
|
|
|
|
Initiated string
|
2016-02-20 01:04:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// CommonPrefix container for prefix response in ListObjectsResponse
|
|
|
|
type CommonPrefix struct {
|
|
|
|
Prefix string
|
|
|
|
}
|
|
|
|
|
|
|
|
// Bucket container for bucket metadata
|
|
|
|
type Bucket struct {
|
2018-01-22 23:54:55 +01:00
|
|
|
Name string
|
|
|
|
CreationDate string // time string of format "2006-01-02T15:04:05.000Z"
|
2016-02-20 01:04:29 +01:00
|
|
|
}
|
|
|
|
|
2019-08-19 23:02:54 +02: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
|
|
|
|
}
|
|
|
|
|
2019-11-21 10:54:49 +01:00
|
|
|
// StringMap is a map[string]string.
|
|
|
|
type StringMap map[string]string
|
|
|
|
|
|
|
|
// MarshalXML - StringMap marshals into XML.
|
|
|
|
func (s StringMap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
|
|
|
|
|
|
|
tokens := []xml.Token{start}
|
|
|
|
|
|
|
|
for key, value := range s {
|
|
|
|
t := xml.StartElement{}
|
|
|
|
t.Name = xml.Name{
|
|
|
|
Space: "",
|
|
|
|
Local: key,
|
|
|
|
}
|
|
|
|
tokens = append(tokens, t, xml.CharData(value), xml.EndElement{Name: t.Name})
|
|
|
|
}
|
|
|
|
|
|
|
|
tokens = append(tokens, xml.EndElement{
|
|
|
|
Name: start.Name,
|
|
|
|
})
|
|
|
|
|
|
|
|
for _, t := range tokens {
|
|
|
|
if err := e.EncodeToken(t); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// flush to ensure tokens are written
|
|
|
|
return e.Flush()
|
|
|
|
}
|
|
|
|
|
2016-02-20 01:04:29 +01: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-06 05:12:47 +02:00
|
|
|
ETag string
|
2016-02-20 01:04:29 +01:00
|
|
|
Size int64
|
|
|
|
|
2016-10-06 05:12:47 +02:00
|
|
|
// Owner of the object.
|
2016-02-20 01:04:29 +01:00
|
|
|
Owner Owner
|
|
|
|
|
|
|
|
// The class of storage used to store the object.
|
2018-01-22 23:54:55 +01:00
|
|
|
StorageClass string
|
2019-11-21 10:54:49 +01:00
|
|
|
|
|
|
|
// UserMetadata user-defined metadata
|
|
|
|
UserMetadata StringMap `xml:"UserMetadata,omitempty"`
|
2016-02-20 01:04:29 +01:00
|
|
|
}
|
|
|
|
|
2016-10-06 05:12:47 +02:00
|
|
|
// CopyObjectResponse container returns ETag and LastModified of the successfully copied object
|
2016-02-27 12:04:52 +01:00
|
|
|
type CopyObjectResponse struct {
|
|
|
|
XMLName xml.Name `xml:"http://s3.amazonaws.com/doc/2006-03-01/ CopyObjectResult" json:"-"`
|
2016-10-06 05:12:47 +02:00
|
|
|
LastModified string // time string of format "2006-01-02T15:04:05.000Z"
|
|
|
|
ETag string // md5sum of the copied object.
|
2016-02-27 12:04:52 +01:00
|
|
|
}
|
|
|
|
|
2017-01-31 18:38:34 +01: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-20 01:04:29 +01: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-05 00:24:10 +02:00
|
|
|
Key string
|
|
|
|
ETag string
|
|
|
|
}
|
|
|
|
|
2016-03-06 01:43:48 +01: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 22:39:56 +01: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-25 01:43:21 +02: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-23 04:18:01 +01:00
|
|
|
func getObjectLocation(r *http.Request, domains []string, bucket, object string) string {
|
2018-03-23 21:46:57 +01:00
|
|
|
// unit tests do not have host set.
|
|
|
|
if r.Host == "" {
|
|
|
|
return path.Clean(r.URL.Path)
|
|
|
|
}
|
2018-03-03 00:23:04 +01:00
|
|
|
proto := handlers.GetSourceScheme(r)
|
2017-09-25 01:43:21 +02:00
|
|
|
if proto == "" {
|
|
|
|
proto = getURLScheme(globalIsSSL)
|
|
|
|
}
|
2018-03-03 00:23:04 +01:00
|
|
|
u := &url.URL{
|
|
|
|
Host: r.Host,
|
2019-08-06 21:08:58 +02:00
|
|
|
Path: path.Join(SlashSeparator, bucket, object),
|
2017-09-25 01:43:21 +02:00
|
|
|
Scheme: proto,
|
|
|
|
}
|
2018-03-03 00:23:04 +01:00
|
|
|
// If domain is set then we need to use bucket DNS style.
|
2019-02-23 04:18:01 +01:00
|
|
|
for _, domain := range domains {
|
2018-05-16 03:20:22 +02:00
|
|
|
if strings.Contains(r.Host, domain) {
|
|
|
|
u.Host = bucket + "." + r.Host
|
2019-08-06 21:08:58 +02:00
|
|
|
u.Path = path.Join(SlashSeparator, object)
|
2019-02-23 04:18:01 +01:00
|
|
|
break
|
2018-05-16 03:20:22 +02:00
|
|
|
}
|
2018-03-03 00:23:04 +01:00
|
|
|
}
|
2017-09-25 01:43:21 +02:00
|
|
|
return u.String()
|
2016-05-05 00:24:10 +02:00
|
|
|
}
|
|
|
|
|
2016-11-21 22:51:05 +01: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-31 01:15:28 +02:00
|
|
|
func generateListBucketsResponse(buckets []BucketInfo) ListBucketsResponse {
|
2016-02-20 01:04:29 +01:00
|
|
|
var listbuckets []Bucket
|
2015-04-30 00:28:04 +02:00
|
|
|
var data = ListBucketsResponse{}
|
2015-02-16 02:03:27 +01:00
|
|
|
var owner = Owner{}
|
|
|
|
|
2017-01-18 21:24:34 +01:00
|
|
|
owner.ID = globalMinioDefaultOwnerID
|
2015-02-16 02:03:27 +01:00
|
|
|
for _, bucket := range buckets {
|
2016-02-20 01:04:29 +01:00
|
|
|
var listbucket = Bucket{}
|
2015-02-16 02:03:27 +01:00
|
|
|
listbucket.Name = bucket.Name
|
2017-10-03 19:34:51 +02:00
|
|
|
listbucket.CreationDate = bucket.Created.UTC().Format(timeFormatAMZLong)
|
2015-02-16 02:03:27 +01:00
|
|
|
listbuckets = append(listbuckets, listbucket)
|
|
|
|
}
|
|
|
|
|
|
|
|
data.Owner = owner
|
2016-02-20 01:04:29 +01:00
|
|
|
data.Buckets.Buckets = listbuckets
|
2015-02-16 02:03:27 +01:00
|
|
|
|
|
|
|
return data
|
|
|
|
}
|
|
|
|
|
2019-08-19 23:02:54 +02: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
|
2020-04-02 09:23:09 +02:00
|
|
|
if object.StorageClass != "" {
|
|
|
|
content.StorageClass = object.StorageClass
|
|
|
|
} else {
|
|
|
|
content.StorageClass = globalMinioDefaultStorageClass
|
|
|
|
}
|
|
|
|
|
2019-08-19 23:02:54 +02:00
|
|
|
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 21:32:05 +02:00
|
|
|
// generates an ListObjectsV1 response for the said bucket with other enumerated options.
|
2019-02-24 07:14:24 +01:00
|
|
|
func generateListObjectsV1Response(bucket, prefix, marker, delimiter, encodingType string, maxKeys int, resp ListObjectsInfo) ListObjectsResponse {
|
2016-02-20 01:04:29 +01:00
|
|
|
var contents []Object
|
|
|
|
var prefixes []CommonPrefix
|
2015-02-16 02:03:27 +01:00
|
|
|
var owner = Owner{}
|
2015-04-30 00:28:04 +02:00
|
|
|
var data = ListObjectsResponse{}
|
2015-02-16 02:03:27 +01:00
|
|
|
|
2017-01-18 21:24:34 +01:00
|
|
|
owner.ID = globalMinioDefaultOwnerID
|
2015-11-10 12:10:11 +01:00
|
|
|
for _, object := range resp.Objects {
|
2016-02-20 01:04:29 +01:00
|
|
|
var content = Object{}
|
2016-03-12 01:31:24 +01:00
|
|
|
if object.Name == "" {
|
2015-02-28 23:44:26 +01:00
|
|
|
continue
|
|
|
|
}
|
2019-02-24 07:14:24 +01:00
|
|
|
content.Key = s3EncodeName(object.Name, encodingType)
|
2016-10-17 17:44:55 +02:00
|
|
|
content.LastModified = object.ModTime.UTC().Format(timeFormatAMZLong)
|
2017-05-14 21:05:51 +02:00
|
|
|
if object.ETag != "" {
|
|
|
|
content.ETag = "\"" + object.ETag + "\""
|
2016-02-01 21:19:54 +01:00
|
|
|
}
|
2015-02-16 02:03:27 +01:00
|
|
|
content.Size = object.Size
|
2020-04-02 09:23:09 +02:00
|
|
|
if object.StorageClass != "" {
|
|
|
|
content.StorageClass = object.StorageClass
|
|
|
|
} else {
|
|
|
|
content.StorageClass = globalMinioDefaultStorageClass
|
|
|
|
}
|
2015-02-16 02:03:27 +01:00
|
|
|
content.Owner = owner
|
|
|
|
contents = append(contents, content)
|
|
|
|
}
|
|
|
|
data.Name = bucket
|
|
|
|
data.Contents = contents
|
2015-11-10 12:10:11 +01:00
|
|
|
|
2019-02-24 07:14:24 +01:00
|
|
|
data.EncodingType = encodingType
|
|
|
|
data.Prefix = s3EncodeName(prefix, encodingType)
|
|
|
|
data.Marker = s3EncodeName(marker, encodingType)
|
|
|
|
data.Delimiter = s3EncodeName(delimiter, encodingType)
|
2016-01-20 02:49:48 +01:00
|
|
|
data.MaxKeys = maxKeys
|
2015-11-10 12:10:11 +01:00
|
|
|
|
2019-02-24 07:14:24 +01:00
|
|
|
data.NextMarker = s3EncodeName(resp.NextMarker, encodingType)
|
2015-11-10 12:10:11 +01:00
|
|
|
data.IsTruncated = resp.IsTruncated
|
2016-06-01 07:10:55 +02:00
|
|
|
for _, prefix := range resp.Prefixes {
|
|
|
|
var prefixItem = CommonPrefix{}
|
2019-02-24 07:14:24 +01:00
|
|
|
prefixItem.Prefix = s3EncodeName(prefix, encodingType)
|
2016-06-01 07:10:55 +02:00
|
|
|
prefixes = append(prefixes, prefixItem)
|
|
|
|
}
|
|
|
|
data.CommonPrefixes = prefixes
|
|
|
|
return data
|
|
|
|
}
|
|
|
|
|
2016-07-17 21:32:05 +02:00
|
|
|
// generates an ListObjectsV2 response for the said bucket with other enumerated options.
|
2019-11-21 10:54:49 +01:00
|
|
|
func generateListObjectsV2Response(bucket, prefix, token, nextToken, startAfter, delimiter, encodingType string, fetchOwner, isTruncated bool, maxKeys int, objects []ObjectInfo, prefixes []string, metadata bool) ListObjectsV2Response {
|
2016-06-01 07:10:55 +02:00
|
|
|
var contents []Object
|
2017-06-17 07:17:00 +02:00
|
|
|
var commonPrefixes []CommonPrefix
|
2016-06-01 07:10:55 +02:00
|
|
|
var owner = Owner{}
|
|
|
|
var data = ListObjectsV2Response{}
|
|
|
|
|
2016-09-10 19:44:38 +02:00
|
|
|
if fetchOwner {
|
2017-01-18 21:24:34 +01:00
|
|
|
owner.ID = globalMinioDefaultOwnerID
|
2016-09-10 19:44:38 +02:00
|
|
|
}
|
2016-06-01 07:10:55 +02:00
|
|
|
|
2017-06-17 07:17:00 +02:00
|
|
|
for _, object := range objects {
|
2016-06-01 07:10:55 +02:00
|
|
|
var content = Object{}
|
|
|
|
if object.Name == "" {
|
|
|
|
continue
|
|
|
|
}
|
2019-02-24 07:14:24 +01:00
|
|
|
content.Key = s3EncodeName(object.Name, encodingType)
|
2016-10-17 17:44:55 +02:00
|
|
|
content.LastModified = object.ModTime.UTC().Format(timeFormatAMZLong)
|
2017-05-14 21:05:51 +02:00
|
|
|
if object.ETag != "" {
|
|
|
|
content.ETag = "\"" + object.ETag + "\""
|
2016-06-01 07:10:55 +02:00
|
|
|
}
|
|
|
|
content.Size = object.Size
|
2020-04-02 09:23:09 +02:00
|
|
|
if object.StorageClass != "" {
|
|
|
|
content.StorageClass = object.StorageClass
|
|
|
|
} else {
|
|
|
|
content.StorageClass = globalMinioDefaultStorageClass
|
|
|
|
}
|
2016-06-01 07:10:55 +02:00
|
|
|
content.Owner = owner
|
2019-11-21 10:54:49 +01:00
|
|
|
if metadata {
|
|
|
|
content.UserMetadata = make(StringMap)
|
|
|
|
for k, v := range CleanMinioInternalMetadataKeys(object.UserDefined) {
|
2019-12-06 08:16:06 +01:00
|
|
|
if HasPrefix(k, ReservedMetadataPrefix) {
|
2019-11-21 10:54:49 +01:00
|
|
|
// Do not need to send any internal metadata
|
|
|
|
// values to client.
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
content.UserMetadata[k] = v
|
|
|
|
}
|
|
|
|
}
|
2016-06-01 07:10:55 +02:00
|
|
|
contents = append(contents, content)
|
|
|
|
}
|
|
|
|
data.Name = bucket
|
|
|
|
data.Contents = contents
|
|
|
|
|
2019-02-24 07:14:24 +01:00
|
|
|
data.EncodingType = encodingType
|
2019-02-25 03:50:28 +01:00
|
|
|
data.StartAfter = s3EncodeName(startAfter, encodingType)
|
2019-02-24 07:14:24 +01:00
|
|
|
data.Delimiter = s3EncodeName(delimiter, encodingType)
|
|
|
|
data.Prefix = s3EncodeName(prefix, encodingType)
|
2016-06-01 07:10:55 +02:00
|
|
|
data.MaxKeys = maxKeys
|
2019-10-01 22:09:29 +02:00
|
|
|
data.ContinuationToken = base64.StdEncoding.EncodeToString([]byte(token))
|
|
|
|
data.NextContinuationToken = base64.StdEncoding.EncodeToString([]byte(nextToken))
|
2017-06-17 07:17:00 +02:00
|
|
|
data.IsTruncated = isTruncated
|
|
|
|
for _, prefix := range prefixes {
|
2016-02-20 01:04:29 +01:00
|
|
|
var prefixItem = CommonPrefix{}
|
2019-02-24 07:14:24 +01:00
|
|
|
prefixItem.Prefix = s3EncodeName(prefix, encodingType)
|
2017-06-17 07:17:00 +02:00
|
|
|
commonPrefixes = append(commonPrefixes, prefixItem)
|
2015-02-28 23:44:26 +01:00
|
|
|
}
|
2017-06-17 07:17:00 +02:00
|
|
|
data.CommonPrefixes = commonPrefixes
|
2016-10-06 05:12:47 +02:00
|
|
|
data.KeyCount = len(data.Contents) + len(data.CommonPrefixes)
|
2015-02-16 02:03:27 +01:00
|
|
|
return data
|
|
|
|
}
|
2015-04-23 01:28:13 +02:00
|
|
|
|
2016-11-21 22:51:05 +01:00
|
|
|
// generates CopyObjectResponse from etag and lastModified time.
|
2016-02-27 12:04:52 +01:00
|
|
|
func generateCopyObjectResponse(etag string, lastModified time.Time) CopyObjectResponse {
|
|
|
|
return CopyObjectResponse{
|
2017-01-31 18:38:34 +01: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 12:04:52 +01:00
|
|
|
ETag: "\"" + etag + "\"",
|
2016-10-17 17:44:55 +02:00
|
|
|
LastModified: lastModified.UTC().Format(timeFormatAMZLong),
|
2016-02-27 12:04:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-21 22:51:05 +01:00
|
|
|
// generates InitiateMultipartUploadResponse for given bucket, key and uploadID.
|
2015-07-10 04:01:15 +02:00
|
|
|
func generateInitiateMultipartUploadResponse(bucket, key, uploadID string) InitiateMultipartUploadResponse {
|
|
|
|
return InitiateMultipartUploadResponse{
|
2015-05-08 04:55:30 +02:00
|
|
|
Bucket: bucket,
|
|
|
|
Key: key,
|
|
|
|
UploadID: uploadID,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-21 22:51:05 +01:00
|
|
|
// generates CompleteMultipartUploadResponse for given bucket, key, location and ETag.
|
2015-07-10 04:01:15 +02:00
|
|
|
func generateCompleteMultpartUploadResponse(bucket, key, location, etag string) CompleteMultipartUploadResponse {
|
|
|
|
return CompleteMultipartUploadResponse{
|
2015-05-08 07:43:19 +02:00
|
|
|
Location: location,
|
|
|
|
Bucket: bucket,
|
|
|
|
Key: key,
|
2020-05-06 02:47:54 +02:00
|
|
|
// AWS S3 quotes the ETag in XML, make sure we are compatible here.
|
|
|
|
ETag: "\"" + etag + "\"",
|
2015-05-08 07:43:19 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-21 22:51:05 +01:00
|
|
|
// generates ListPartsResponse from ListPartsInfo.
|
2019-02-24 07:14:24 +01:00
|
|
|
func generateListPartsResponse(partsInfo ListPartsInfo, encodingType string) ListPartsResponse {
|
2015-05-09 20:41:26 +02: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 10:34:20 +02:00
|
|
|
listPartsResponse.Bucket = partsInfo.Bucket
|
2019-02-24 07:14:24 +01: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 10:34:20 +02:00
|
|
|
listPartsResponse.UploadID = partsInfo.UploadID
|
2017-01-18 21:24:34 +01:00
|
|
|
listPartsResponse.StorageClass = globalMinioDefaultStorageClass
|
|
|
|
listPartsResponse.Initiator.ID = globalMinioDefaultOwnerID
|
|
|
|
listPartsResponse.Owner.ID = globalMinioDefaultOwnerID
|
2015-05-09 20:41:26 +02: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 10:34:20 +02:00
|
|
|
listPartsResponse.MaxParts = partsInfo.MaxParts
|
|
|
|
listPartsResponse.PartNumberMarker = partsInfo.PartNumberMarker
|
|
|
|
listPartsResponse.IsTruncated = partsInfo.IsTruncated
|
|
|
|
listPartsResponse.NextPartNumberMarker = partsInfo.NextPartNumberMarker
|
2015-05-09 20:41:26 +02: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 10:34:20 +02:00
|
|
|
listPartsResponse.Parts = make([]Part, len(partsInfo.Parts))
|
|
|
|
for index, part := range partsInfo.Parts {
|
2016-02-20 01:04:29 +01:00
|
|
|
newPart := Part{}
|
2015-05-09 20:41:26 +02:00
|
|
|
newPart.PartNumber = part.PartNumber
|
2015-06-09 10:12:32 +02:00
|
|
|
newPart.ETag = "\"" + part.ETag + "\""
|
2015-05-09 20:41:26 +02:00
|
|
|
newPart.Size = part.Size
|
2016-10-17 17:44:55 +02:00
|
|
|
newPart.LastModified = part.LastModified.UTC().Format(timeFormatAMZLong)
|
2016-03-20 07:44:43 +01:00
|
|
|
listPartsResponse.Parts[index] = newPart
|
2015-05-09 20:41:26 +02:00
|
|
|
}
|
|
|
|
return listPartsResponse
|
|
|
|
}
|
|
|
|
|
2016-11-21 22:51:05 +01:00
|
|
|
// generates ListMultipartUploadsResponse for given bucket and ListMultipartsInfo.
|
2019-02-24 07:14:24 +01:00
|
|
|
func generateListMultipartUploadsResponse(bucket string, multipartsInfo ListMultipartsInfo, encodingType string) ListMultipartUploadsResponse {
|
2015-05-14 23:36:41 +02:00
|
|
|
listMultipartUploadsResponse := ListMultipartUploadsResponse{}
|
|
|
|
listMultipartUploadsResponse.Bucket = bucket
|
2019-02-24 07:14:24 +01: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 10:34:20 +02:00
|
|
|
listMultipartUploadsResponse.IsTruncated = multipartsInfo.IsTruncated
|
2019-02-24 07:14:24 +01: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 10:34:20 +02:00
|
|
|
listMultipartUploadsResponse.MaxUploads = multipartsInfo.MaxUploads
|
|
|
|
listMultipartUploadsResponse.NextUploadIDMarker = multipartsInfo.NextUploadIDMarker
|
|
|
|
listMultipartUploadsResponse.UploadIDMarker = multipartsInfo.UploadIDMarker
|
2016-04-06 00:08:59 +02:00
|
|
|
listMultipartUploadsResponse.CommonPrefixes = make([]CommonPrefix, len(multipartsInfo.CommonPrefixes))
|
|
|
|
for index, commonPrefix := range multipartsInfo.CommonPrefixes {
|
|
|
|
listMultipartUploadsResponse.CommonPrefixes[index] = CommonPrefix{
|
2019-02-24 07:14:24 +01:00
|
|
|
Prefix: s3EncodeName(commonPrefix, encodingType),
|
2016-04-06 00:08:59 +02: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 10:34:20 +02:00
|
|
|
listMultipartUploadsResponse.Uploads = make([]Upload, len(multipartsInfo.Uploads))
|
|
|
|
for index, upload := range multipartsInfo.Uploads {
|
2016-02-20 01:04:29 +01:00
|
|
|
newUpload := Upload{}
|
2015-05-14 23:36:41 +02:00
|
|
|
newUpload.UploadID = upload.UploadID
|
2019-02-24 07:14:24 +01:00
|
|
|
newUpload.Key = s3EncodeName(upload.Object, encodingType)
|
2016-10-17 17:44:55 +02:00
|
|
|
newUpload.Initiated = upload.Initiated.UTC().Format(timeFormatAMZLong)
|
2016-03-20 07:44:43 +01:00
|
|
|
listMultipartUploadsResponse.Uploads[index] = newUpload
|
2015-05-14 23:36:41 +02:00
|
|
|
}
|
|
|
|
return listMultipartUploadsResponse
|
|
|
|
}
|
|
|
|
|
2016-03-06 01:43:48 +01: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 09:37:00 +01:00
|
|
|
func writeResponse(w http.ResponseWriter, statusCode int, response []byte, mType mimeType) {
|
2016-01-08 09:40:06 +01:00
|
|
|
setCommonHeaders(w)
|
2017-01-06 09:37:00 +01:00
|
|
|
if mType != mimeNone {
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.ContentType, string(mType))
|
2017-01-06 09:37:00 +01:00
|
|
|
}
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.ContentLength, strconv.Itoa(len(response)))
|
2016-12-18 22:39:56 +01:00
|
|
|
w.WriteHeader(statusCode)
|
2017-01-06 09:37:00 +01:00
|
|
|
if response != nil {
|
|
|
|
w.Write(response)
|
|
|
|
w.(http.Flusher).Flush()
|
2016-01-08 09:40:06 +01:00
|
|
|
}
|
2015-04-29 19:51:59 +02:00
|
|
|
}
|
|
|
|
|
2017-01-06 09:37:00 +01: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 22:39:56 +01:00
|
|
|
}
|
|
|
|
|
2016-12-20 18:32:17 +01:00
|
|
|
// writeSuccessNoContent writes success headers with http status 204
|
2015-10-17 05:02:37 +02:00
|
|
|
func writeSuccessNoContent(w http.ResponseWriter) {
|
2017-01-06 09:37:00 +01:00
|
|
|
writeResponse(w, http.StatusNoContent, nil, mimeNone)
|
2015-10-17 05:02:37 +02:00
|
|
|
}
|
|
|
|
|
2016-12-20 18:32:17 +01:00
|
|
|
// writeRedirectSeeOther writes Location header with http status 303
|
|
|
|
func writeRedirectSeeOther(w http.ResponseWriter, location string) {
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.Location, location)
|
2017-01-06 09:37:00 +01:00
|
|
|
writeResponse(w, http.StatusSeeOther, nil, mimeNone)
|
2016-12-20 18:32:17 +01:00
|
|
|
}
|
|
|
|
|
2017-01-06 09:37:00 +01:00
|
|
|
func writeSuccessResponseHeadersOnly(w http.ResponseWriter) {
|
|
|
|
writeResponse(w, http.StatusOK, nil, mimeNone)
|
2016-06-16 05:31:06 +02:00
|
|
|
}
|
|
|
|
|
2017-01-06 09:37:00 +01:00
|
|
|
// writeErrorRespone writes error headers
|
2019-02-14 01:07:21 +01:00
|
|
|
func writeErrorResponse(ctx context.Context, w http.ResponseWriter, err APIError, reqURL *url.URL, browser bool) {
|
2019-02-12 10:25:52 +01:00
|
|
|
switch err.Code {
|
|
|
|
case "SlowDown", "XMinioServerNotInitialized", "XMinioReadQuorum", "XMinioWriteQuorum":
|
2017-12-20 09:00:14 +01: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 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.RetryAfter, "120")
|
2019-02-12 10:25:52 +01:00
|
|
|
case "AccessDenied":
|
2018-12-04 08:38:24 +01:00
|
|
|
// The request is from browser and also if browser
|
|
|
|
// is enabled we need to redirect.
|
2019-10-23 07:59:13 +02:00
|
|
|
if browser && globalBrowserEnabled {
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.Location, minioReservedBucketPath+reqURL.Path)
|
2018-11-26 21:15:12 +01:00
|
|
|
w.WriteHeader(http.StatusTemporaryRedirect)
|
|
|
|
return
|
|
|
|
}
|
2017-12-20 09:00:14 +01:00
|
|
|
}
|
2018-11-26 21:15:12 +01:00
|
|
|
|
2016-06-28 23:51:49 +02:00
|
|
|
// Generate error response.
|
2019-02-21 07:20:15 +01:00
|
|
|
errorResponse := getAPIErrorResponse(ctx, err, reqURL.Path,
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Get(xhttp.AmzRequestID), globalDeploymentID)
|
2016-06-16 05:31:06 +02:00
|
|
|
encodedErrorResponse := encodeResponse(errorResponse)
|
2019-02-12 10:25:52 +01:00
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeXML)
|
2017-01-06 09:37:00 +01:00
|
|
|
}
|
|
|
|
|
2019-02-12 10:25:52 +01:00
|
|
|
func writeErrorResponseHeadersOnly(w http.ResponseWriter, err APIError) {
|
|
|
|
writeResponse(w, err.HTTPStatusCode, nil, mimeNone)
|
2015-04-23 01:28:13 +02:00
|
|
|
}
|
2018-01-22 23:54:55 +01:00
|
|
|
|
2019-11-04 18:30:59 +01:00
|
|
|
func writeErrorResponseString(ctx context.Context, w http.ResponseWriter, err APIError, reqURL *url.URL) {
|
|
|
|
// Generate string error response.
|
|
|
|
writeResponse(w, err.HTTPStatusCode, []byte(err.Description), mimeNone)
|
|
|
|
}
|
|
|
|
|
2018-01-22 23:54:55 +01:00
|
|
|
// writeErrorResponseJSON - writes error response in JSON format;
|
|
|
|
// useful for admin APIs.
|
2019-02-14 01:07:21 +01:00
|
|
|
func writeErrorResponseJSON(ctx context.Context, w http.ResponseWriter, err APIError, reqURL *url.URL) {
|
2018-01-22 23:54:55 +01:00
|
|
|
// Generate error response.
|
2019-07-03 07:34:32 +02:00
|
|
|
errorResponse := getAPIErrorResponse(ctx, err, reqURL.Path, w.Header().Get(xhttp.AmzRequestID), globalDeploymentID)
|
2018-01-22 23:54:55 +01:00
|
|
|
encodedErrorResponse := encodeResponseJSON(errorResponse)
|
2019-02-12 10:25:52 +01:00
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeJSON)
|
2018-01-22 23:54:55 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// writeCustomErrorResponseJSON - similar to writeErrorResponseJSON,
|
|
|
|
// but accepts the error message directly (this allows messages to be
|
|
|
|
// dynamically generated.)
|
2019-02-14 01:07:21 +01:00
|
|
|
func writeCustomErrorResponseJSON(ctx context.Context, w http.ResponseWriter, err APIError,
|
2018-01-22 23:54:55 +01:00
|
|
|
errBody string, reqURL *url.URL) {
|
|
|
|
|
2019-02-14 01:07:21 +01:00
|
|
|
reqInfo := logger.GetReqInfo(ctx)
|
2018-01-22 23:54:55 +01:00
|
|
|
errorResponse := APIErrorResponse{
|
2019-02-14 01:07:21 +01:00
|
|
|
Code: err.Code,
|
|
|
|
Message: errBody,
|
|
|
|
Resource: reqURL.Path,
|
|
|
|
BucketName: reqInfo.BucketName,
|
|
|
|
Key: reqInfo.ObjectName,
|
2019-07-03 07:34:32 +02:00
|
|
|
RequestID: w.Header().Get(xhttp.AmzRequestID),
|
2019-07-01 21:22:01 +02:00
|
|
|
HostID: globalDeploymentID,
|
2018-01-22 23:54:55 +01:00
|
|
|
}
|
|
|
|
encodedErrorResponse := encodeResponseJSON(errorResponse)
|
2019-02-12 10:25:52 +01:00
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeJSON)
|
2018-01-22 23:54:55 +01:00
|
|
|
}
|
2019-03-05 21:10:47 +01: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 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.RetryAfter, "120")
|
2019-03-05 21:10:47 +01:00
|
|
|
case "AccessDenied":
|
|
|
|
// The request is from browser and also if browser
|
|
|
|
// is enabled we need to redirect.
|
2019-10-23 07:59:13 +02:00
|
|
|
if browser && globalBrowserEnabled {
|
2019-07-03 07:34:32 +02:00
|
|
|
w.Header().Set(xhttp.Location, minioReservedBucketPath+reqURL.Path)
|
2019-03-05 21:10:47 +01: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 07:34:32 +02:00
|
|
|
RequestID: w.Header().Get(xhttp.AmzRequestID),
|
2019-07-01 21:22:01 +02:00
|
|
|
HostID: globalDeploymentID,
|
2019-03-05 21:10:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
encodedErrorResponse := encodeResponse(errorResponse)
|
|
|
|
writeResponse(w, err.HTTPStatusCode, encodedErrorResponse, mimeXML)
|
|
|
|
}
|