func (c *S3) GetBucketLogging(input *GetBucketLoggingInput) (*GetBucketLoggingOutput, error) {
	req, out := c.GetBucketLoggingRequest(input)
	err := req.Send()
	return out, err
}
Returns the logging status of a bucket and the permissions users have to
view and modify that status. To use GET, you must be the bucket owner.
package s3
import (
	"bytes"
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base64"
	"encoding/json"
	"encoding/xml"
	"errors"
	"fmt"
	mapset "github.com/deckarep/golang-set"
	"github.com/ks3sdklib/aws-sdk-go/aws"
	"github.com/ks3sdklib/aws-sdk-go/aws/awserr"
	"hash"
	"io"
	"io/ioutil"
	"net/http"
	"net/url"
	"sort"
	"strings"
	"sync"
	"time"
)
var oprw sync.Mutex
func (c *S3) AbortMultipartUploadRequest(input *AbortMultipartUploadInput) (req *aws.Request, output *AbortMultipartUploadOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opAbortMultipartUpload == nil {
		opAbortMultipartUpload = &aws.Operation{
			Name:       "AbortMultipartUpload",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}/{Key+}",
		}
	}
	if input == nil {
		input = &AbortMultipartUploadInput{}
	}
	req = c.newRequest(opAbortMultipartUpload, input, output)
	output = &AbortMultipartUploadOutput{}
	req.Data = output
	return
}
func (c *S3) AbortMultipartUpload(input *AbortMultipartUploadInput) (*AbortMultipartUploadOutput, error) {
	req, out := c.AbortMultipartUploadRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) AbortMultipartUploadPresignedUrl(input *AbortMultipartUploadInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.AbortMultipartUploadRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opAbortMultipartUpload *aws.Operation
func (c *S3) CompleteMultipartUploadRequest(input *CompleteMultipartUploadInput) (req *aws.Request, output *CompleteMultipartUploadOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCompleteMultipartUpload == nil {
		opCompleteMultipartUpload = &aws.Operation{
			Name:       "CompleteMultipartUpload",
			HTTPMethod: "POST",
			HTTPPath:   "/{Bucket}/{Key+}",
		}
	}
	if input == nil {
		input = &CompleteMultipartUploadInput{}
	}
	req = c.newRequest(opCompleteMultipartUpload, input, output)
	output = &CompleteMultipartUploadOutput{}
	req.Data = output
	return
}
func (c *S3) CompleteMultipartUpload(input *CompleteMultipartUploadInput) (*CompleteMultipartUploadOutput, error) {
	req, out := c.CompleteMultipartUploadRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) CompleteMultipartUploadPresignedUrl(input *CompleteMultipartUploadInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CompleteMultipartUploadRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCompleteMultipartUpload *aws.Operation
func (c *S3) CopyObjectRequest(input *CopyObjectInput) (req *aws.Request, output *CopyObjectOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCopyObject == nil {
		opCopyObject = &aws.Operation{
			Name:       "CopyObject",
			HTTPMethod: "PUT",
			HTTPPath:   "/{Bucket}/{Key+}",
		}
	}
	if input == nil {
		input = &CopyObjectInput{}
	}
	req = c.newRequest(opCopyObject, input, output)
	output = &CopyObjectOutput{}
	req.Data = output
	return
}
func (c *S3) CopyObject(input *CopyObjectInput) (*CopyObjectOutput, error) {
	req, out := c.CopyObjectRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) CopyObjectPresignedUrl(input *CopyObjectInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CopyObjectRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCopyObject *aws.Operation
func (c *S3) CreateBucketRequest(input *CreateBucketInput) (req *aws.Request, output *CreateBucketOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCreateBucket == nil {
		opCreateBucket = &aws.Operation{
			Name:       "CreateBucket",
			HTTPMethod: "PUT",
			HTTPPath:   "/{Bucket}",
		}
	}
	if input == nil {
		input = &CreateBucketInput{}
	}
	req = c.newRequest(opCreateBucket, input, output)
	output = &CreateBucketOutput{}
	req.Data = output
	return
}
func (c *S3) CreateBucket(input *CreateBucketInput) (*CreateBucketOutput, error) {
	req, out := c.CreateBucketRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) CreateBucketPresignedUrl(input *CreateBucketInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CreateBucketRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCreateBucket *aws.Operation
func (c *S3) CreateMultipartUploadRequest(input *CreateMultipartUploadInput) (req *aws.Request, output *CreateMultipartUploadOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opCreateMultipartUpload == nil {
		opCreateMultipartUpload = &aws.Operation{
			Name:       "CreateMultipartUpload",
			HTTPMethod: "POST",
			HTTPPath:   "/{Bucket}/{Key+}?uploads",
		}
	}
	if input == nil {
		input = &CreateMultipartUploadInput{}
	}
	req = c.newRequest(opCreateMultipartUpload, input, output)
	output = &CreateMultipartUploadOutput{}
	req.Data = output
	return
}
func (c *S3) CreateMultipartUpload(input *CreateMultipartUploadInput) (*CreateMultipartUploadOutput, error) {
	req, out := c.CreateMultipartUploadRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) CreateMultipartUploadPresignedUrl(input *CreateMultipartUploadInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.CreateMultipartUploadRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opCreateMultipartUpload *aws.Operation
func (c *S3) DeleteBucketRequest(input *DeleteBucketInput) (req *aws.Request, output *DeleteBucketOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucket == nil {
		opDeleteBucket = &aws.Operation{
			Name:       "DeleteBucket",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}",
		}
	}
	if input == nil {
		input = &DeleteBucketInput{}
	}
	req = c.newRequest(opDeleteBucket, input, output)
	output = &DeleteBucketOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucket(input *DeleteBucketInput) (*DeleteBucketOutput, error) {
	req, out := c.DeleteBucketRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteBucketPresignedUrl(input *DeleteBucketInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucket *aws.Operation
func (c *S3) DeleteBucketCORSRequest(input *DeleteBucketCORSInput) (req *aws.Request, output *DeleteBucketCORSOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketCORS == nil {
		opDeleteBucketCORS = &aws.Operation{
			Name:       "DeleteBucketCors",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?cors",
		}
	}
	if input == nil {
		input = &DeleteBucketCORSInput{}
	}
	req = c.newRequest(opDeleteBucketCORS, input, output)
	output = &DeleteBucketCORSOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketCORS(input *DeleteBucketCORSInput) (*DeleteBucketCORSOutput, error) {
	req, out := c.DeleteBucketCORSRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteBucketCORSPresignedUrl(input *DeleteBucketCORSInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketCORSRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketCORS *aws.Operation
func (c *S3) DeleteBucketLifecycleRequest(input *DeleteBucketLifecycleInput) (req *aws.Request, output *DeleteBucketLifecycleOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketLifecycle == nil {
		opDeleteBucketLifecycle = &aws.Operation{
			Name:       "DeleteBucketLifecycle",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?lifecycle",
		}
	}
	if input == nil {
		input = &DeleteBucketLifecycleInput{}
	}
	req = c.newRequest(opDeleteBucketLifecycle, input, output)
	output = &DeleteBucketLifecycleOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketLifecycle(input *DeleteBucketLifecycleInput) (*DeleteBucketLifecycleOutput, error) {
	req, out := c.DeleteBucketLifecycleRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteBucketLifecyclePresignedUrl(input *DeleteBucketLifecycleInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketLifecycleRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketLifecycle *aws.Operation
func (c *S3) DeleteBucketPolicyRequest(input *DeleteBucketPolicyInput) (req *aws.Request, output *DeleteBucketPolicyOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketPolicy == nil {
		opDeleteBucketPolicy = &aws.Operation{
			Name:       "DeleteBucketPolicy",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?policy",
		}
	}
	if input == nil {
		input = &DeleteBucketPolicyInput{}
	}
	req = c.newRequest(opDeleteBucketPolicy, input, output)
	output = &DeleteBucketPolicyOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketPolicy(input *DeleteBucketPolicyInput) (*DeleteBucketPolicyOutput, error) {
	req, out := c.DeleteBucketPolicyRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteBucketPolicyPresignedUrl(input *DeleteBucketPolicyInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketPolicyRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketPolicy *aws.Operation
func (c *S3) DeleteBucketReplicationRequest(input *DeleteBucketReplicationInput) (req *aws.Request, output *DeleteBucketReplicationOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketReplication == nil {
		opDeleteBucketReplication = &aws.Operation{
			Name:       "DeleteBucketReplication",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?replication",
		}
	}
	if input == nil {
		input = &DeleteBucketReplicationInput{}
	}
	req = c.newRequest(opDeleteBucketReplication, input, output)
	output = &DeleteBucketReplicationOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketReplication(input *DeleteBucketReplicationInput) (*DeleteBucketReplicationOutput, error) {
	req, out := c.DeleteBucketReplicationRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteBucketReplicationPresignedUrl(input *DeleteBucketReplicationInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketReplicationRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketReplication *aws.Operation
func (c *S3) DeleteBucketTaggingRequest(input *DeleteBucketTaggingInput) (req *aws.Request, output *DeleteBucketTaggingOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketTagging == nil {
		opDeleteBucketTagging = &aws.Operation{
			Name:       "DeleteBucketTagging",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?tagging",
		}
	}
	if input == nil {
		input = &DeleteBucketTaggingInput{}
	}
	req = c.newRequest(opDeleteBucketTagging, input, output)
	output = &DeleteBucketTaggingOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketTagging(input *DeleteBucketTaggingInput) (*DeleteBucketTaggingOutput, error) {
	req, out := c.DeleteBucketTaggingRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteBucketTaggingPresignedUrl(input *DeleteBucketTaggingInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketTaggingRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketTagging *aws.Operation
func (c *S3) DeleteBucketWebsiteRequest(input *DeleteBucketWebsiteInput) (req *aws.Request, output *DeleteBucketWebsiteOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteBucketWebsite == nil {
		opDeleteBucketWebsite = &aws.Operation{
			Name:       "DeleteBucketWebsite",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}?website",
		}
	}
	if input == nil {
		input = &DeleteBucketWebsiteInput{}
	}
	req = c.newRequest(opDeleteBucketWebsite, input, output)
	output = &DeleteBucketWebsiteOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteBucketWebsite(input *DeleteBucketWebsiteInput) (*DeleteBucketWebsiteOutput, error) {
	req, out := c.DeleteBucketWebsiteRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteBucketWebsitePresignedUrl(input *DeleteBucketWebsiteInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteBucketWebsiteRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteBucketWebsite *aws.Operation
func (c *S3) DeleteObjectRequest(input *DeleteObjectInput) (req *aws.Request, output *DeleteObjectOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteObject == nil {
		opDeleteObject = &aws.Operation{
			Name:       "DeleteObject",
			HTTPMethod: "DELETE",
			HTTPPath:   "/{Bucket}/{Key+}",
		}
	}
	if input == nil {
		input = &DeleteObjectInput{}
	}
	req = c.newRequest(opDeleteObject, input, output)
	output = &DeleteObjectOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteObject(input *DeleteObjectInput) (*DeleteObjectOutput, error) {
	req, out := c.DeleteObjectRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) DeleteObjectPresignedUrl(input *DeleteObjectInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteObjectRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteObject *aws.Operation
func (c *S3) DeleteObjectsRequest(input *DeleteObjectsInput) (req *aws.Request, output *DeleteObjectsOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opDeleteObjects == nil {
		opDeleteObjects = &aws.Operation{
			Name:       "DeleteObjects",
			HTTPMethod: "POST",
			HTTPPath:   "/{Bucket}?delete",
		}
	}
	if input == nil {
		input = &DeleteObjectsInput{}
	}
	req = c.newRequest(opDeleteObjects, input, output)
	output = &DeleteObjectsOutput{}
	req.Data = output
	return
}
func (c *S3) DeleteObjects(input *DeleteObjectsInput) *DeleteObjectsOutput {
	var errors []*Error
	var okList []*DeletedObject
	for _, t := range input.Delete.Objects {
		_, err := c.DeleteObject(&DeleteObjectInput{Bucket: input.Bucket, Key: t.Key})
		if err != nil {
			aerr, _ := err.(awserr.Error)
			errors = append(errors, &Error{Key: t.Key, Code: aws.String(aerr.Code()), Message: aws.String(aerr.Message())})
		} else {
			okList = append(okList, &DeletedObject{Key: t.Key})
		}
	}
	output := &DeleteObjectsOutput{
		Deleted: okList,
		Errors:  errors,
	}
	return output
}
func (c *S3) DeleteBucketPrefix(input *DeleteBucketPrefixInput) (*DeleteObjectsOutput, error) {
	var errors []*Error
	var okList []*DeletedObject
	var objects []*Object
	count := 0
	marker := aws.String("")
	prefix := input.Prefix
	var output = &DeleteObjectsOutput{
		Deleted: okList,
		Errors:  errors,
	}
	for {
		resp, err := c.ListObjects(&ListObjectsInput{
			Bucket:  input.Bucket,
			Prefix:  prefix,
			Marker:  marker,
			MaxKeys: aws.Long(1000),
		})
		if err == nil {
			objects = append(objects, resp.Contents...)
			for _, t := range objects {
				_, err := c.DeleteObject(&DeleteObjectInput{Bucket: input.Bucket, Key: t.Key})
				if err != nil {
					aerr, _ := err.(awserr.Error)
					errors = append(errors, &Error{Key: t.Key, Code: aws.String(aerr.Code()), Message: aws.String(aerr.Message())})
					output.Errors = errors
				} else {
					okList = append(okList, &DeletedObject{Key: t.Key})
					output.Deleted = okList
				}
			}
			count += len(objects)
			if *resp.IsTruncated == false {
				break
			}
			marker = objects[999].Key
		} else {
			return output, err
		}
	}
	return output, nil
}
func (c *S3) TryDeleteBucketPrefix(input *DeleteBucketPrefixInput) (*DeleteObjectsOutput, error) {
	params := input
	var output *DeleteObjectsOutput
	err := Do(func(attempt int) (bool, error) {
		var err error
		output, err = c.DeleteBucketPrefix(params)
		if err != nil {
			fmt.Println("DeleteBucketPrefix - ", err)
		}
		return attempt < 3, err  
	})
	if err != nil {
		fmt.Println("error:", err)
	}
	return output, nil
}
func (c *S3) DeleteObjectsPresignedUrl(input *DeleteObjectsInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.DeleteObjectsRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opDeleteObjects *aws.Operation
func (c *S3) GetBucketACLRequest(input *GetBucketACLInput) (req *aws.Request, output *GetBucketACLOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opGetBucketACL == nil {
		opGetBucketACL = &aws.Operation{
			Name:       "GetBucketAcl",
			HTTPMethod: "GET",
			HTTPPath:   "/{Bucket}?acl",
		}
	}
	if input == nil {
		input = &GetBucketACLInput{}
	}
	req = c.newRequest(opGetBucketACL, input, output)
	output = &GetBucketACLOutput{}
	req.Data = output
	return
}
func (c *S3) GetBucketACL(input *GetBucketACLInput) (*GetBucketACLOutput, error) {
	req, out := c.GetBucketACLRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) GetBucketACLPresignedUrl(input *GetBucketACLInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.GetBucketACLRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opGetBucketACL *aws.Operation
func (c *S3) GetBucketCORSRequest(input *GetBucketCORSInput) (req *aws.Request, output *GetBucketCORSOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opGetBucketCORS == nil {
		opGetBucketCORS = &aws.Operation{
			Name:       "GetBucketCors",
			HTTPMethod: "GET",
			HTTPPath:   "/{Bucket}?cors",
		}
	}
	if input == nil {
		input = &GetBucketCORSInput{}
	}
	req = c.newRequest(opGetBucketCORS, input, output)
	output = &GetBucketCORSOutput{}
	req.Data = output
	return
}
func (c *S3) GetBucketCORS(input *GetBucketCORSInput) (*GetBucketCORSOutput, error) {
	req, out := c.GetBucketCORSRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) GetBucketCORSPresignedUrl(input *GetBucketCORSInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.GetBucketCORSRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opGetBucketCORS *aws.Operation
func (c *S3) GetBucketLifecycleRequest(input *GetBucketLifecycleInput) (req *aws.Request, output *GetBucketLifecycleOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opGetBucketLifecycle == nil {
		opGetBucketLifecycle = &aws.Operation{
			Name:       "GetBucketLifecycle",
			HTTPMethod: "GET",
			HTTPPath:   "/{Bucket}?lifecycle",
		}
	}
	if input == nil {
		input = &GetBucketLifecycleInput{}
	}
	req = c.newRequest(opGetBucketLifecycle, input, output)
	output = &GetBucketLifecycleOutput{}
	req.Data = output
	return
}
func (c *S3) GetBucketLifecycle(input *GetBucketLifecycleInput) (*GetBucketLifecycleOutput, error) {
	req, out := c.GetBucketLifecycleRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) GetBucketLifecyclePresignedUrl(input *GetBucketLifecycleInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.GetBucketLifecycleRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opGetBucketLifecycle *aws.Operation
func (c *S3) GetBucketLocationRequest(input *GetBucketLocationInput) (req *aws.Request, output *GetBucketLocationOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opGetBucketLocation == nil {
		opGetBucketLocation = &aws.Operation{
			Name:       "GetBucketLocation",
			HTTPMethod: "GET",
			HTTPPath:   "/{Bucket}?location",
		}
	}
	if input == nil {
		input = &GetBucketLocationInput{}
	}
	req = c.newRequest(opGetBucketLocation, input, output)
	output = &GetBucketLocationOutput{}
	req.Data = output
	return
}
func (c *S3) GetBucketLocation(input *GetBucketLocationInput) (*GetBucketLocationOutput, error) {
	req, out := c.GetBucketLocationRequest(input)
	err := req.Send()
	return out, err
}
func (c *S3) GetBucketLocationPresignedUrl(input *GetBucketLocationInput, expires time.Duration) (*url.URL, error) {
	req, _ := c.GetBucketLocationRequest(input)
	req.ExpireTime = expires
	err := req.Sign()
	return req.HTTPRequest.URL, err
}
var opGetBucketLocation *aws.Operation
func (c *S3) GetBucketLoggingRequest(input *GetBucketLoggingInput) (req *aws.Request, output *GetBucketLoggingOutput) {
	oprw.Lock()
	defer oprw.Unlock()
	if opGetBucketLogging == nil {
		opGetBucketLogging = &aws.Operation{
			Name:       "GetBucketLogging",
			HTTPMethod: "GET",
			HTTPPath:   "/{Bucket}?logging",
		}
	}
	if input == nil {
		input = &GetBucketLoggingInput{}
	}
	req = c.newRequest(opGetBucketLogging, input, output)
	output = &GetBucketLoggingOutput{}
	req.Data = output
	return
}