Documentation

Index

Constants

This section is empty.

Variables

View Source
var DefaultDownloadConcurrency = 5

    The default number of goroutines to spin up when using Download().

    View Source
    var DefaultDownloadOptions = &DownloadOptions{
    	PartSize:    DefaultDownloadPartSize,
    	Concurrency: DefaultDownloadConcurrency,
    }

      The default set of options used when opts is nil in Download().

      View Source
      var DefaultDownloadPartSize int64 = 1024 * 1024 * 5

        The default range of bytes to get at a time when using Download().

        View Source
        var DefaultUploadConcurrency = 5

          The default number of goroutines to spin up when using Upload().

          View Source
          var DefaultUploadOptions = &UploadOptions{
          	PartSize:          DefaultUploadPartSize,
          	Concurrency:       DefaultUploadConcurrency,
          	LeavePartsOnError: false,
          	S3:                nil,
          }

            The default set of options used when opts is nil in Upload().

            View Source
            var DefaultUploadPartSize = MinUploadPartSize

              The default part size to buffer chunks of a payload into.

              View Source
              var MaxUploadParts = 10000

                The maximum allowed number of parts in a multi-part upload on Amazon S3.

                View Source
                var MinUploadPartSize int64 = 1024 * 1024 * 5

                  The minimum allowed part size when uploading a part to Amazon S3.

                  Functions

                  This section is empty.

                  Types

                  type DownloadOptions

                  type DownloadOptions struct {
                  	// The buffer size (in bytes) to use when buffering data into chunks and
                  	// sending them as parts to S3. The minimum allowed part size is 5MB, and
                  	// if this value is set to zero, the DefaultPartSize value will be used.
                  	PartSize int64
                  
                  	// The number of goroutines to spin up in parallel when sending parts.
                  	// If this is set to zero, the DefaultConcurrency value will be used.
                  	Concurrency int
                  
                  	// An S3 client to use when performing downloads. Leave this as nil to use
                  	// a default client.
                  	S3 *s3.S3
                  }

                    DownloadOptions keeps tracks of extra options to pass to an Download() call.

                    type Downloader

                    type Downloader struct {
                    	// contains filtered or unexported fields
                    }

                      The Downloader structure that calls Download(). It is safe to call Download() on this structure for multiple objects and across concurrent goroutines.

                      func NewDownloader

                      func NewDownloader(opts *DownloadOptions) *Downloader

                        NewDownloader creates a new Downloader structure that downloads an object from S3 in concurrent chunks. Pass in an optional DownloadOptions struct to customize the downloader behavior.

                        func (*Downloader) Download

                        func (d *Downloader) Download(w io.WriterAt, input *s3.GetObjectInput) (n int64, err error)

                          Download downloads an object in S3 and writes the payload into w using concurrent GET requests.

                          It is safe to call this method for multiple objects and across concurrent goroutines.

                          type MultiUploadFailure

                          type MultiUploadFailure interface {
                          	awserr.Error
                          
                          	// Returns the upload id for the S3 multipart upload that failed.
                          	UploadID() string
                          }

                            A MultiUploadFailure wraps a failed S3 multipart upload. An error returned will satisfy this interface when a multi part upload failed to upload all chucks to S3. In the case of a failure the UploadID is needed to operate on the chunks, if any, which were uploaded.

                            Example:

                            u := s3manager.NewUploader(opts)
                            output, err := u.upload(input)
                            if err != nil {
                                if multierr, ok := err.(MultiUploadFailure); ok {
                                    // Process error and its associated uploadID
                                    fmt.Println("Error:", multierr.Code(), multierr.Message(), multierr.UploadID())
                                } else {
                                    // Process error generically
                                    fmt.Println("Error:", err.Error())
                                }
                            }
                            

                            type UploadInput

                            type UploadInput struct {
                            	// The canned ACL to apply to the object.
                            	ACL *string `location:"header" locationName:"x-amz-acl" type:"string"`
                            
                            	Bucket *string `location:"uri" locationName:"Bucket" type:"string" required:"true"`
                            
                            	// Specifies caching behavior along the request/reply chain.
                            	CacheControl *string `location:"header" locationName:"Cache-Control" type:"string"`
                            
                            	// Specifies presentational information for the object.
                            	ContentDisposition *string `location:"header" locationName:"Content-Disposition" type:"string"`
                            
                            	// Specifies what content encodings have been applied to the object and thus
                            	// what decoding mechanisms must be applied to obtain the media-type referenced
                            	// by the Content-Type header field.
                            	ContentEncoding *string `location:"header" locationName:"Content-Encoding" type:"string"`
                            
                            	// The language the content is in.
                            	ContentLanguage *string `location:"header" locationName:"Content-Language" type:"string"`
                            
                            	// A standard MIME type describing the format of the object data.
                            	ContentType *string `location:"header" locationName:"Content-Type" type:"string"`
                            
                            	// The date and time at which the object is no longer cacheable.
                            	Expires *time.Time `location:"header" locationName:"Expires" type:"timestamp" timestampFormat:"rfc822"`
                            
                            	// Gives the grantee READ, READ_ACP, and WRITE_ACP permissions on the object.
                            	GrantFullControl *string `location:"header" locationName:"x-amz-grant-full-control" type:"string"`
                            
                            	// Allows grantee to read the object data and its metadata.
                            	GrantRead *string `location:"header" locationName:"x-amz-grant-read" type:"string"`
                            
                            	// Allows grantee to read the object ACL.
                            	GrantReadACP *string `location:"header" locationName:"x-amz-grant-read-acp" type:"string"`
                            
                            	// Allows grantee to write the ACL for the applicable object.
                            	GrantWriteACP *string `location:"header" locationName:"x-amz-grant-write-acp" type:"string"`
                            
                            	Key *string `location:"uri" locationName:"Key" type:"string" required:"true"`
                            
                            	// A map of metadata to store with the object in S3.
                            	Metadata map[string]*string `location:"headers" locationName:"x-amz-meta-" type:"map"`
                            
                            	// Confirms that the requester knows that she or he will be charged for the
                            	// request. Bucket owners need not specify this parameter in their requests.
                            	// Documentation on downloading objects from requester pays buckets can be found
                            	// at http://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html
                            	RequestPayer *string `location:"header" locationName:"x-amz-request-payer" type:"string"`
                            
                            	// Specifies the algorithm to use to when encrypting the object (e.g., AES256,
                            	// aws:kms).
                            	SSECustomerAlgorithm *string `location:"header" locationName:"x-amz-server-side-encryption-customer-algorithm" type:"string"`
                            
                            	// Specifies the customer-provided encryption key for Amazon S3 to use in encrypting
                            	// data. This value is used to store the object and then it is discarded; Amazon
                            	// does not store the encryption key. The key must be appropriate for use with
                            	// the algorithm specified in the x-amz-server-side​-encryption​-customer-algorithm
                            	// header.
                            	SSECustomerKey *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key" type:"string"`
                            
                            	// Specifies the 128-bit MD5 digest of the encryption key according to RFC 1321.
                            	// Amazon S3 uses this header for a message integrity check to ensure the encryption
                            	// key was transmitted without error.
                            	SSECustomerKeyMD5 *string `location:"header" locationName:"x-amz-server-side-encryption-customer-key-MD5" type:"string"`
                            
                            	// Specifies the AWS KMS key ID to use for object encryption. All GET and PUT
                            	// requests for an object protected by AWS KMS will fail if not made via SSL
                            	// or using SigV4. Documentation on configuring any of the officially supported
                            	// AWS SDKs and CLI can be found at http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingAWSSDK.html#specify-signature-version
                            	SSEKMSKeyID *string `location:"header" locationName:"x-amz-server-side-encryption-aws-kms-key-id" type:"string"`
                            
                            	// The Server-side encryption algorithm used when storing this object in S3
                            	// (e.g., AES256, aws:kms).
                            	ServerSideEncryption *string `location:"header" locationName:"x-amz-server-side-encryption" type:"string"`
                            
                            	// The type of storage to use for the object. Defaults to 'STANDARD'.
                            	StorageClass *string `location:"header" locationName:"x-amz-storage-class" type:"string"`
                            
                            	// If the bucket is configured as a website, redirects requests for this object
                            	// to another object in the same bucket or to an external URL. Amazon S3 stores
                            	// the value of this header in the object metadata.
                            	WebsiteRedirectLocation *string `location:"header" locationName:"x-amz-website-redirect-location" type:"string"`
                            
                            	// The readable body payload to send to S3.
                            	Body io.Reader
                            }

                              UploadInput contains all input for upload requests to Amazon S3.

                              type UploadOptions

                              type UploadOptions struct {
                              	// The buffer size (in bytes) to use when buffering data into chunks and
                              	// sending them as parts to S3. The minimum allowed part size is 5MB, and
                              	// if this value is set to zero, the DefaultPartSize value will be used.
                              	PartSize int64
                              
                              	// The number of goroutines to spin up in parallel when sending parts.
                              	// If this is set to zero, the DefaultConcurrency value will be used.
                              	Concurrency int
                              
                              	// Setting this value to true will cause the SDK to avoid calling
                              	// AbortMultipartUpload on a failure, leaving all successfully uploaded
                              	// parts on S3 for manual recovery.
                              	//
                              	// Note that storing parts of an incomplete multipart upload counts towards
                              	// space usage on S3 and will add additional costs if not cleaned up.
                              	LeavePartsOnError bool
                              
                              	// The client to use when uploading to S3. Leave this as nil to use the
                              	// default S3 client.
                              	S3 *s3.S3
                              }

                                UploadOptions keeps tracks of extra options to pass to an Upload() call.

                                type UploadOutput

                                type UploadOutput struct {
                                	// The URL where the object was uploaded to.
                                	Location string
                                
                                	// The ID for a multipart upload to S3. In the case of an error the error
                                	// can be cast to the MultiUploadFailure interface to extract the upload ID.
                                	UploadID string
                                }

                                  UploadOutput represents a response from the Upload() call.

                                  type Uploader

                                  type Uploader struct {
                                  	// contains filtered or unexported fields
                                  }

                                    The Uploader structure that calls Upload(). It is safe to call Upload() on this structure for multiple objects and across concurrent goroutines.

                                    func NewUploader

                                    func NewUploader(opts *UploadOptions) *Uploader

                                      NewUploader creates a new Uploader object to upload data to S3. Pass in an optional opts structure to customize the uploader behavior.

                                      func (*Uploader) Upload

                                      func (u *Uploader) Upload(input *UploadInput) (*UploadOutput, error)

                                        Upload uploads an object to S3, intelligently buffering large files into smaller chunks and sending them in parallel across multiple goroutines. You can configure the buffer size and concurrency through the opts parameter.

                                        If opts is set to nil, DefaultUploadOptions will be used.

                                        It is safe to call this method for multiple objects and across concurrent goroutines.